fix(overmind): fix managing errors with operators

Author: christianalfoni

packages/node_modules/overmind-devtools/src/components/ActionOperator/index.tsx

@@ -50,24 +50,6 @@ const ActionOperator: FunctionComponent<Props> = ({
           className={styles.operatorBody}
           onClick={(event) => event.stopPropagation()}
         >
-          {operator.error ? (
-            <div className={styles.operatorItem}>
-              <span
-                className={css(
-                  textStyles.description,
-                  textStyles.red,
-                  textStyles.monospace
-                )}
-              >
-                error
-              </span>
-              <span
-                className={css(textStyles.description, textStyles.monospace)}
-              >
-                {operator.error}
-              </span>
-            </div>
-          ) : null}
           {operator.events.map((event, index) => {
             if (event.type === EventType.Effect) {
               const effect = event.data as Effect
@@ -153,6 +135,24 @@ const ActionOperator: FunctionComponent<Props> = ({
               )
             }
           })}
+          {operator.error ? (
+            <div className={styles.operatorItem}>
+              <span
+                className={css(
+                  textStyles.description,
+                  textStyles.red,
+                  textStyles.monospace
+                )}
+              >
+                error
+              </span>
+              <span
+                className={css(textStyles.description, textStyles.monospace)}
+              >
+                {operator.error}
+              </span>
+            </div>
+          ) : null}
         </div>
       </div>
     </div>

packages/node_modules/overmind/src/index.ts

@@ -987,7 +987,7 @@ export function pipe(...operators) {
       const run = (operatorErr, operatorContext) => {
         const operator = operators[operatorIndex++]
 
-        if (operatorContext.value instanceof Promise) {
+        if (!operatorErr && operatorContext.value instanceof Promise) {
           context.execution.emit(EventType.OPERATOR_ASYNC, {
             ...operatorContext.execution,
             isAsync: true,

packages/node_modules/overmind/src/operator.ts

@@ -122,13 +122,13 @@ export function createOperator<ThisConfig extends IConfiguration>(
 ): any {
   const operator = (err, context, next, final) => {
     startDebugOperator(type, name, context)
-    try {
-      let asyncTimeout = setTimeout(() => {
-        context.execution.emit(EventType.OPERATOR_ASYNC, {
-          ...context.execution,
-          isAsync: true,
-        })
+    let asyncTimeout = setTimeout(() => {
+      context.execution.emit(EventType.OPERATOR_ASYNC, {
+        ...context.execution,
+        isAsync: true,
       })
+    })
+    try {
       cb(
         err,
         {
@@ -152,21 +152,23 @@ export function createOperator<ThisConfig extends IConfiguration>(
               nextWithPath(...args)
             })
           } else {
-            stopDebugOperator(context, value, {
-              isSkipped: options.isSkipped,
+            stopDebugOperator(context, err || value, {
+              isSkipped: err ? true : options.isSkipped,
             })
             next(err, createContext(context, value))
           }
         },
         (err, value) => {
           clearTimeout(asyncTimeout)
-          stopDebugOperator(context, value, {
-            isIntercepted: true,
+          stopDebugOperator(context, err || value, {
+            isSkipped: Boolean(err),
+            isIntercepted: !err,
           })
           final(err, createContext(context, value))
         }
       )
     } catch (error) {
+      clearTimeout(asyncTimeout)
       stopDebugOperator(context, context.value, {
         error,
       })
@@ -208,13 +210,13 @@ export function createMutationOperator<ThisConfig extends IConfiguration>(
         })
       })
     }
-    try {
-      let asyncTimeout = setTimeout(() => {
-        context.execution.emit(EventType.OPERATOR_ASYNC, {
-          ...context.execution,
-          isAsync: true,
-        })
+    let asyncTimeout = setTimeout(() => {
+      context.execution.emit(EventType.OPERATOR_ASYNC, {
+        ...context.execution,
+        isAsync: true,
       })
+    })
+    try {
       cb(
         err,
         {
@@ -227,15 +229,16 @@ export function createMutationOperator<ThisConfig extends IConfiguration>(
           : context.execution.scopeValue(context.value, mutationTree),
         (err, value, options = {}) => {
           clearTimeout(asyncTimeout)
-          stopDebugOperator(context, value, {
-            isSkipped: options.isSkipped,
+          stopDebugOperator(context, err || value, {
+            isSkipped: err ? true : options.isSkipped,
           })
           next(err, createContext(context, value))
         },
         (err, value) => {
           clearTimeout(asyncTimeout)
-          stopDebugOperator(context, value, {
-            isIntercepted: true,
+          stopDebugOperator(context, err || value, {
+            isSkipped: Boolean(err),
+            isIntercepted: !err,
           })
           final(err, createContext(context, value))
         }
@@ -264,6 +267,7 @@ export function createMutationOperator<ThisConfig extends IConfiguration>(
         })
       }
     } catch (error) {
+      clearTimeout(asyncTimeout)
       stopDebugOperator(context, context.value, {
         error,
       })