feat(overmind): statemachines now has explicit effects and state callback

Author: christianalfoni

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

@@ -456,4 +456,42 @@ describe('Statemachine', () => {
 
     expect(() => overmind.actions.transition()).not.toThrow()
   })
+  test('should deal with transition effects', async () => {
+    type States = {
+      current: 'FOO'
+    } | {
+      current: 'BAR',
+      number: number
+    }
+
+    const state = statemachine<States>({
+      FOO: ['BAR'],
+      BAR: ['FOO']
+    }, {
+      current: 'FOO',
+    })
+    const transition: Action = ({ state }) => {
+      return state.transition('BAR', { number: 123 }, () => {
+        return Promise.resolve(4321)
+      }, (barState, value) => {
+          barState.number = value
+      })
+    }
+
+    const config = {
+      state,
+      actions: {
+        transition
+      }
+    } 
+
+    interface Action extends IAction<typeof config, void, Promise<void>> {}
+
+    const overmind = createOvermindMock(config)
+    // @ts-ignore
+    overmind.isStrict = true
+    
+    await overmind.actions.transition()
+    expect(overmind.state.current === 'BAR' && overmind.state.number === 4321).toBe(true)
+  })
 })

packages/node_modules/overmind/src/statemachine.ts

@@ -34,15 +34,18 @@ export interface MachineMethods<States extends TStates, Base extends IState = {}
   matches<T extends States["current"], O = void>(state: T | T[], cb: (current: Statemachine<Base, States, States extends {
     current: T
   } ? States : never>) => O): O;
-  transition<T extends States["current"], O = void>(
+  transition<T extends States["current"], O = void, O2 = O>(
     state: T,
     newState: States extends {
       current: T  
     } ? Exact<Omit<States, 'current'>, {}> extends never ?  Omit<States, 'current'> & Partial<Base> : Exact<Partial<Base>, {}> extends never ? Partial<Base> : { [NO_PROP]?: true} : never,
-    callback?: ((current: Statemachine<Base, States, States extends {
+    effectsCallback?: ((current: Statemachine<Base, States, States extends {
       current: T
-    } ? States : never>) => O)
-  ): O;
+    } ? States : never>) => O),
+    stateCallback?: ((current: Statemachine<Base, States, States extends {
+      current: T
+    } ? States : never>, value: O extends Promise<infer V> ? V : O) => O2)
+  ): O extends Promise<any> ? Promise<O2> : O2;
 }
 
 export type Statemachine<Base extends IState, States extends TStates, State extends TStates = States> = Base extends never ? State & MachineMethods<States> : Base & State & MachineMethods<States, Base>
@@ -86,7 +89,7 @@ export class StateMachine<Base extends IState, States extends TStates, State ext
       return result
     }
   }
-  transition(state, newState, callback) {
+  transition(state, newState, effectsCallback, stateCallback) {
     const transitions = this[VALUE][TRANSITIONS] 
 
     if (transitions[this.current].includes(state)) {
@@ -108,8 +111,20 @@ export class StateMachine<Base extends IState, States extends TStates, State ext
       tree.blockMutations()
 
       let result
-      if (callback) {
-        result = callback(this)
+      if (effectsCallback) {
+        result = effectsCallback(this)
+      }
+
+      if (stateCallback && result instanceof Promise) {
+        return result.then((value) => {
+          if (this.current !== state) {
+            return value
+          }
+          tree.enableMutations()
+          const result = stateCallback(this, value)
+          tree.blockMutations()
+          return result
+        })
       }
 
       return result