feat(overmind): make onInitialize a callback with app instance

BREAKING CHANGE:
onInitialize is now a callback with app instance

Author: christianalfoni

.eslintrc.json

@@ -36,7 +36,8 @@
         "no-unused-expressions": "off",
         "no-use-before-define": "off",
         "no-useless-constructor": "off",
-        "typescript/no-unused-vars": "error"
+        "typescript/no-unused-vars": "error",
+        "standard/no-callback-literal": "off"
       }
     }
   ]

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

@@ -14,6 +14,26 @@ describe('Overmind', () => {
 
     expect(app.state.foo).toEqual('bar')
   })
+  test('should instantiate app with onInitialize', () => {
+    const app = new App({
+      onInitialize: (app) => {
+        expect(app.state.foo).toBe('bar')
+        expect(typeof app.actions.doThis === 'function')
+        return 'foo'
+      },
+      state: {
+        foo: 'bar',
+      },
+      actions: {
+        doThis: (action) => action.run(() => {}),
+      },
+      effects: {},
+    })
+
+    return app.initialized.then((value) => {
+      expect(value).toEqual('foo')
+    })
+  })
   test('should instantiate app with modules', () => {
     const fooAction: Action<string> = ({ run }) => run(() => {})
 
@@ -66,9 +86,31 @@ describe('Overmind', () => {
     expect(app.actions.foo.foo('mip')).toEqual('mip')
     expect(app.actions.bar.bar('bop')).toEqual('bop')
   })
+  test('should instantiate modules with onInitialize', () => {
+    const app = new App(
+      modules({
+        modules: {
+          foo: {
+            onInitialize: () => {
+              return 'foo'
+            },
+          },
+          bar: {
+            onInitialize: () => {
+              return 'bar'
+            },
+          },
+        },
+      })
+    )
+
+    return app.initialized.then((values) => {
+      expect(values).toEqual(['foo', 'bar'])
+    })
+  })
 })
 
-describe.only('OPERATORS', () => {
+describe('OPERATORS', () => {
   test('fork', () => {
     expect.assertions(2)
     let calledFoo = false

packages/node_modules/overmind/src/index.ts

@@ -40,6 +40,8 @@ export interface IState {}
 
 export interface IEffects {}
 
+export interface IActions {}
+
 interface IApp {
   effects: IEffects
   state: StateNode<IState>
@@ -49,6 +51,26 @@ interface IOperationArgument<Value> extends IApp {
   value: Value
 }
 
+export type OnInitialize = (
+  app: {
+    state: IState
+    actions: {
+      [T in keyof IActions]: IActions[T] extends (...args: any[]) => any
+        ? ReturnType<IActions[T]>
+        : {
+            [P in keyof IActions[T]]: IActions[T][P] extends (
+              ...args: any[]
+            ) => any
+              ? ReturnType<IActions[T][P]>
+              : undefined
+          }
+    }
+    trackState(): number
+    clearTrackState(id: number, cb?: () => void): Set<string>
+    addMutationListener(paths, cb): () => void
+  }
+) => void
+
 type StateNode<State extends object> = {
   [P in keyof State]: State[P] extends Derive<any>
     ? ReturnType<State[P]>
@@ -61,6 +83,8 @@ export type TState<Config extends Configuration> = Config['state']
 
 export type TEffects<Config extends Configuration> = Config['effects']
 
+export type TActions<Config extends Configuration> = Config['actions']
+
 export type Mutate<Value = any> = (
   arg: { state: IApp['state']; value: Value }
 ) => void
@@ -116,6 +140,7 @@ export type Compute<Input, Output> = (
 ) => (state: IApp['state']) => Output
 
 export type TConfig<Config extends Configuration> = {
+  onInitialize: any
   state: Config['state'] & {}
   effects: Config['effects'] & {}
   actions: Config['actions'] & {}
@@ -143,6 +168,7 @@ export default class App<
   EvalConfig extends TConfig<Config>
 > {
   private proxyStateTree: ProxyStateTree
+  initialized: Promise<any>
   eventHub: EventEmitter<Events>
   devtools: Devtools
   actions: {
@@ -249,12 +275,9 @@ export default class App<
     this.proxyStateTree = proxyStateTree
     this.eventHub = eventHub
 
-    if (configuration.onInitialize) {
-      const onInitialize = operators.compose(configuration.onInitialize)
-      // @ts-ignore
-      onInitialize.displayName = 'onInitialize'
-      onInitialize(undefined)
-    }
+    this.initialized = Promise.resolve(
+      configuration.onInitialize ? configuration.onInitialize(this) : null
+    )
   }
   private initializeDevtools(host, actionChain, eventHub, proxyStateTree) {
     const devtools = new Devtools(

packages/node_modules/overmind/src/modules.ts

@@ -91,8 +91,6 @@ function parseModule(
     result.state[modName] = state
   }
   if (onInitialize) {
-    // @ts-ignore
-    onInitialize.displayName = modName + '.onInitialize'
     result.initializers.push(onInitialize)
   }
 }
@@ -117,12 +115,15 @@ export function modules<T extends ConfigurationWithModules>(
     parseModule(result, modName, modules[modName])
   })
 
-  const onInitialize: Action<undefined> = configWithModules.onInitialize
-    ? configWithModules.onInitialize
-    : (action) => action.parallel(result.initializers)
+  const onInitialize = (app) => {
+    const allInitializers = [
+      configWithModules.onInitialize && configWithModules.onInitialize(app),
+      ...result.initializers.map((initializer) => initializer(app)),
+    ].filter((initializer) => !!initializer)
+
+    return Promise.all(allInitializers)
+  }
 
-  // @ts-ignore
-  onInitialize.displayName = 'onInitialize'
   return {
     onInitialize,
     actions: result.actions,