feat(overmind): add dynamic module as experimental feature

Author: christianalfoni

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

@@ -1,4 +1,4 @@
-import App, { TAction, TConfig } from './'
+import App, { TAction, TConfig, DynamicAction, dynamicModule } from './'
 
 describe('Overmind', () => {
   test('should instantiate app with state', () => {
@@ -35,7 +35,6 @@ describe('Overmind', () => {
         bar: fooAction,
       },
     }
-
     type Config = TConfig<{
       modules: {
         foo: typeof foo
@@ -59,52 +58,33 @@ describe('Overmind', () => {
     expect(app.actions.foo.foo('mip')).toEqual('mip')
     expect(app.actions.bar.bar('bop')).toEqual('bop')
   })
-  /*
   test('should allow namespaced modules to be functions', () => {
-    const fooNamespace = (namespace: string) => {
-      type Action<InitialValue = void> = TAction<InitialValue, Namespace>
-      type Map<InValue = void, OutValue = InValue> = TOperation.Map<
-        InValue,
-        OutValue,
-        Namespace
-      >
-
-      type State = {
-        foo: string
-      }
-
-      const state: State = {
-        foo: 'bar',
-      }
-
-      const effects = {
-        hello: () => 'hello',
-      }
-
-      const mapFoo: Map<string> = ({ state }, value) =>
-        value + (state[namespace] as State).foo
-
-      const foo: Action<string> = (action) => action<string>().map(mapFoo)
+    const foo = dynamicModule((namespace) => {
+      const fooAction: DynamicAction<string> = (action) =>
+        action().mutate((state) => (state[namespace].foo = 'bar2'))
 
       return {
-        state,
+        state: {
+          foo: 'bar',
+        },
         actions: {
-          foo,
+          foo: fooAction,
         },
-        effects,
       }
-    }
-
-    const config = namespaces({
-      foo: fooNamespace,
     })
 
+    const config = {
+      modules: {
+        foo,
+      },
+    }
+
     const app = new App(config)
 
     expect(app.state.foo.foo).toEqual('bar')
-    expect(app.actions.foo.foo('mip')).toEqual('mipbar')
+    expect(app.actions.foo.foo('mip')).toEqual('mip')
+    expect(app.state.foo.foo).toEqual('bar2')
   })
-  */
 })
 
 describe('OPERATORS', () => {

packages/node_modules/overmind/src/index.ts

@@ -12,9 +12,24 @@ export { IValueAction, Compose }
 export const log = (...objects: any[]) =>
   console.log(...objects.map((obj) => JSON.parse(JSON.stringify(obj))))
 
+export const dynamicModule = ((cb) => (namespace) =>
+  cb(namespace)) as DynamicModule
+
 /*
   BASE TYPES
 */
+type DynamicModule = <
+  T extends {
+    onInitialize?: any
+    state?: any
+    effects?: any
+    actions?: any
+    reactions?: any
+  }
+>(
+  cb: (namespace: string) => T
+) => ReturnType<typeof cb>
+
 export type Configuration = {
   onInitialize?: any
   state?: any
@@ -106,6 +121,13 @@ export type Action<InitialValue = void, ReturnValue = any> = Compose<
   ReturnValue
 >
 
+export type DynamicAction<InitialValue = void, ReturnValue = any> = Compose<
+  any,
+  any,
+  InitialValue,
+  ReturnValue
+>
+
 export type Reaction = (
   reaction: (
     getState: (state: IApp['state']) => any,
@@ -338,6 +360,10 @@ export default class App<
   }
   state: EvalConfig['state']
   constructor(configuration: Config, options: Options = {}) {
+    /*
+      Mutate module functions into module objects
+    */
+    this.mutateModuleFunctionsIntoModules(configuration)
     /*
       Set up an eventHub to trigger information from derived, computed and reactions
     */
@@ -453,6 +479,13 @@ export default class App<
     onInitialize.displayName = 'onInitialize'
     onInitialize(undefined)
   }
+  private mutateModuleFunctionsIntoModules(config: Configuration) {
+    if (config.modules) {
+      Object.keys(config.modules).forEach((key) => {
+        config.modules[key] = (config.modules[key] as any)(key)
+      })
+    }
+  }
   private initializeDevtools(host, actionChain, eventHub, proxyStateTree) {
     const devtools = new Devtools()
     devtools.connect(