fix(overmind): refactor pipe to handle async and errors better

Author: christianalfoni

packages/node_modules/overmind/src/index.ts

@@ -813,32 +813,14 @@ export function pipe(...operators) {
     if (err) next(err)
     else {
       let operatorIndex = 0
-      let asyncTimeout
-      const finalClearingAsync = (...args) => {
-        clearTimeout(asyncTimeout)
-        final(...args)
-      }
-      const run = (runErr, runContext) => {
-        asyncTimeout = setTimeout(() => {
-          context.execution.emit(EventType.OPERATOR_ASYNC, {
-            ...runContext.execution,
-            isAsync: true,
-          })
-        })
 
-        operators[operatorIndex++](
-          runErr,
-          runContext,
-          runNextOperator,
-          finalClearingAsync
-        )
-      }
+      const run = (operatorErr, operatorContext) => {
+        const operator = operators[operatorIndex++]
+
+        if (!operator) return next(operatorErr, operatorContext)
 
-      const runNextOperator = (operatorError, operatorContext) => {
-        clearTimeout(asyncTimeout)
-        if (operatorIndex >= operators.length)
-          return next(operatorError, operatorContext)
-        if (operatorError) return run(operatorError, operatorContext)
+        if (operatorErr)
+          return operator(operatorErr, operatorContext, run, final)
 
         if (operatorContext.value instanceof Promise) {
           context.execution.emit(EventType.OPERATOR_ASYNC, {
@@ -847,21 +829,26 @@ export function pipe(...operators) {
           })
           operatorContext.value
             .then((promiseValue) =>
-              run(null, { ...operatorContext, value: promiseValue })
+              operator(
+                null,
+                { ...operatorContext, value: promiseValue },
+                run,
+                final
+              )
             )
             .catch((promiseError) =>
-              runNextOperator(promiseError, operatorContext)
+              operator(promiseError, operatorContext, run, final)
             )
         } else {
           try {
-            run(null, operatorContext)
+            operator(null, operatorContext, run, final)
           } catch (operatorError) {
-            runNextOperator(operatorError, operatorContext)
+            operator(operatorError, operatorContext, run, final)
           }
         }
       }
 
-      runNextOperator(null, context)
+      run(null, context)
     }
   }
   instance[IS_OPERATOR] = true