fix: preserve any upload worker error

Author: goanpeca

__tests__/commands/upload-download.test.ts

@@ -193,6 +193,42 @@ describe('upload + download commands (B2Simulator)', () => {
     expect(completed).toEqual(expect.arrayContaining(['a.txt', 'b.txt']))
   })
 
+  it('rethrows undefined glob upload failures', async () => {
+    const srcDir = join(fx.workDir, 'undefined-failure-bundle')
+    await mkdir(srcDir)
+    for (const name of ['a.txt', 'b.txt', 'c.txt']) {
+      await writeFile(join(srcDir, name), `payload-${name}`)
+    }
+
+    const started: string[] = []
+    const originalUpload = fx.bucket.upload.bind(fx.bucket)
+    fx.bucket.upload = async (...args: Parameters<typeof fx.bucket.upload>) => {
+      const fileName = args[0].fileName
+      started.push(fileName)
+      if (fileName === 'a.txt') {
+        throw undefined
+      }
+      await new Promise((resolve) => setTimeout(resolve, 25))
+      return await originalUpload(...args)
+    }
+
+    let rejected = false
+    try {
+      await uploadCommand(fx.bucket, {
+        ...baseInputs(),
+        source: srcDir,
+        concurrency: 2,
+      })
+    } catch (error) {
+      rejected = true
+      expect(error).toBeUndefined()
+    }
+
+    expect(rejected).toBe(true)
+    expect(started).toHaveLength(2)
+    expect(started).toEqual(expect.arrayContaining(['a.txt', 'b.txt']))
+  })
+
   it('fails when an upload glob matches no files and fail-on-empty is true', async () => {
     await expect(
       uploadCommand(fx.bucket, {

dist/index.js

@@ -40706,9 +40706,10 @@ async function mapWithConcurrency(items, concurrency, mapper) {
     const results = new Array(items.length);
     let next = 0;
     let firstError;
+    let failed = false;
     async function worker() {
         while (true) {
-            if (firstError !== undefined)
+            if (failed)
                 return;
             const index = next++;
             if (index >= items.length)
@@ -40717,14 +40718,17 @@ async function mapWithConcurrency(items, concurrency, mapper) {
                 results[index] = await mapper(items[index]);
             }
             catch (error) {
-                firstError ??= error;
+                if (!failed) {
+                    failed = true;
+                    firstError = error;
+                }
                 return;
             }
         }
     }
     const workerCount = Math.min(concurrency, items.length);
     await Promise.all(Array.from({ length: workerCount }, () => worker()));
-    if (firstError !== undefined)
+    if (failed)
         throw firstError;
     return results;
 }

dist/index.js.map

@@ -96,24 +96,28 @@ async function mapWithConcurrency<T, U>(
   const results = new Array<U>(items.length)
   let next = 0
   let firstError: unknown
+  let failed = false
 
   async function worker(): Promise<void> {
     while (true) {
-      if (firstError !== undefined) return
+      if (failed) return
       const index = next++
       if (index >= items.length) return
       try {
         results[index] = await mapper(items[index] as T)
       } catch (error) {
-        firstError ??= error
+        if (!failed) {
+          failed = true
+          firstError = error
+        }
         return
       }
     }
   }
 
   const workerCount = Math.min(concurrency, items.length)
   await Promise.all(Array.from({ length: workerCount }, () => worker()))
-  if (firstError !== undefined) throw firstError
+  if (failed) throw firstError
   return results
 }