fix: issue when payload is empty - not calling onDone

package.json

@@ -93,6 +93,6 @@
         "coverageDirectory": "../coverage",
         "testEnvironment": "node",
         "clearMocks": true,
-        "testTimeout": 10000
+        "testTimeout": 3000
     }
 }

src/parallel/parallel.service.spec.ts

@@ -48,6 +48,50 @@ describe('Parallel', () => {
             })
         })
 
+        it('should escape and execute onDone when payload is empty', (done) => {
+            const callFn = jest.fn()
+            const failFn = jest.fn()
+            const payload: any[] = []
+            const length = payload.length
+
+            Parallel.execute({
+                handler: async (item) => {
+                    callFn(item)
+                    return new Promise((resolve) => setTimeout(resolve, 5))
+                },
+                concurrency: 10,
+                payload,
+                onItemFail: failFn,
+                onDone: () => {
+                    expect(callFn).toBeCalledTimes(length)
+                    expect(failFn).toBeCalledTimes(0)
+                    done()
+                },
+            })
+        })
+
+        it('should escape and execute onDone when payload is 1 object', (done) => {
+            const callFn = jest.fn()
+            const failFn = jest.fn()
+            const payload = [1]
+            const length = payload.length
+
+            Parallel.execute({
+                handler: async (item) => {
+                    callFn(item)
+                    return new Promise((resolve) => setTimeout(resolve, 5))
+                },
+                concurrency: 10,
+                payload,
+                onItemFail: failFn,
+                onDone: () => {
+                    expect(callFn).toBeCalledTimes(length)
+                    expect(failFn).toBeCalledTimes(0)
+                    done()
+                },
+            })
+        })
+
         it('should call onItemFail on promise reject', (done) => {
             const callFn = jest.fn()
             const failFn = jest.fn()

src/parallel/parallel.service.ts

@@ -5,6 +5,10 @@ import { DEFAULT_EXECUTION_OPTIONS } from './default'
 
 export class Parallel {
     /**
+     * @description Executes handler for each item in payload
+     * @param options - execution options
+     * @returns subscription of the execution
+     *
      * T - type of payload item
      * K - type of handler return value
      */
@@ -15,20 +19,25 @@ export class Parallel {
             IExecutionOptions<T, K>
         >({}, DEFAULT_EXECUTION_OPTIONS, options)
 
+        const limitedConcurrency: number = Math.min(payload.length, concurrency)
+
         const firstItems =
             processDirection === 'fifo'
-                ? payload.splice(0, concurrency)
-                : payload.splice(payload.length - <number>concurrency, concurrency)
+                ? payload.splice(0, limitedConcurrency)
+                : payload.splice(payload.length - limitedConcurrency, limitedConcurrency)
 
         const executions$: Subscription = new Subscription()
         const isDoneChecker$ = new Subject<boolean>()
 
-        const skipCount: number = concurrency > payload.length ? payload.length : concurrency
+        if (limitedConcurrency === 0) {
+            onDone?.()
+            return executions$
+        }
 
         isDoneChecker$
             .pipe(
                 filter((isDone) => isDone),
-                skip(<number>skipCount - 1),
+                skip(limitedConcurrency - 1),
                 take(1),
                 switchMap(async () => onDone?.()),
             )