feat(overmind): allow run operator to run async with returned promise

Author: christianalfoni

packages/node_modules/overmind-devtools/src/app/state.ts

@@ -20,15 +20,15 @@ type State = {
   expandedStatePaths: string[]
   expandAllActionDetails: boolean
   expandedComponents: string[]
-  currentAction: Derive<Action>
-  currentApp: Derive<App>
-  componentsMounted: Derive<Component[]>
-  componentsUpdateCount: Derive<number>
-  componentsStatePathCount: Derive<number>
-  flushes: Derive<Flush[]>
-  flushesMutationsCount: Derive<number>
-  flushesStatePathCount: Derive<number>
-  groupedComponents: Derive<GroupedComponents>
+  currentAction: Derive<Action, State>
+  currentApp: Derive<App, State>
+  componentsMounted: Derive<Component[], State>
+  componentsUpdateCount: Derive<number, State>
+  componentsStatePathCount: Derive<number, State>
+  flushes: Derive<Flush[], State>
+  flushesMutationsCount: Derive<number, State>
+  flushesStatePathCount: Derive<number, State>
+  groupedComponents: Derive<GroupedComponents, State>
 }
 
 const state: State = {

packages/node_modules/overmind/src/index.ts

@@ -37,11 +37,7 @@ export type Action<Value = void> = TAction<App, Value>
 
 export type Context = TContext<App>
 
-export type Derive<Value, Parent extends object = {}> = TDerive<
-  App,
-  Value,
-  Parent
->
+export type Derive<Value, Parent extends object> = TDerive<App, Value, Parent>
 
 export type Reaction = TReaction<App>
 
@@ -646,16 +642,23 @@ export function map<Input, Output, BaseContext = Context>(
 }
 
 export function run<Input, BaseContext = Context>(
-  operation: (input: TValueContext<BaseContext, Input>) => void
+  operation: (input: TValueContext<BaseContext, Input>) => any
 ): TOperator<Input, Input, BaseContext> {
   const instance = (err, context, next) => {
     if (err) next(err)
     else {
       startDebugOperator('run', operation, context)
-      operation(context)
-      const newContext = createContext(context, context.value)
-      stopDebugOperator(newContext)
-      next(null, newContext)
+      const runNext = () => {
+        const newContext = createContext(context, context.value)
+        stopDebugOperator(newContext)
+        next(null, newContext)
+      }
+      const result = operation(context)
+      if (result instanceof Promise) {
+        result.then(runNext).catch(next)
+      } else {
+        runNext()
+      }
     }
   }
   instance[IS_PIPE] = true

packages/node_modules/overmind/src/pipe.test.ts

@@ -180,5 +180,19 @@ describe('PIPE', () => {
         expect(value).toEqual('foo')
       })
     })
+    test('run (async)', () => {
+      expect.assertions(2)
+      let hasRun = false
+      const test: Operator<string, string> = pipe(
+        run(({ value }) => Promise.resolve(value + '!!!')),
+        run(() => (hasRun = true))
+      )
+      const action = createMockAction(test)
+      const actionRun = action('foo')
+      expect(hasRun).toBe(false)
+      return actionRun.then((value) => {
+        expect(value).toEqual('foo')
+      })
+    })
   })
 })