fix(overmind): remove support for modules

modules add a lot of complexity and should be handled in user space

BREAKING CHANGE:

modules are no longer supported

Author: gaspard

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

@@ -1,4 +1,4 @@
-import App, { TAction, TConfig, DynamicAction, dynamicModule } from './'
+import App, { DynamicAction, TAction, TConfig, dynamicModule } from './'
 
 describe('Overmind', () => {
   test('should instantiate app with state', () => {
@@ -14,78 +14,6 @@ describe('Overmind', () => {
 
     expect(app.state.foo).toEqual('bar')
   })
-  test('should instantiate app with namespaces', () => {
-    const fooAction: Action<string> = ({ run }) => run(() => {})
-
-    const foo = {
-      state: {
-        foo: 'bar',
-      },
-      actions: {
-        foo: fooAction,
-      },
-    }
-    const bar = {
-      state: {
-        bar: 'baz',
-      },
-      effects: {
-        hello: () => 'hello',
-      },
-      actions: {
-        bar: fooAction,
-      },
-    }
-    type Config = TConfig<{
-      modules: {
-        foo: typeof foo
-        bar: typeof bar
-      }
-    }>
-
-    type Action<Input = void, Output = any> = TAction<Input, Output, Config>
-
-    const config = {
-      modules: {
-        foo,
-        bar,
-      },
-    }
-
-    const app = new App(config)
-
-    expect(app.state.foo.foo).toEqual('bar')
-    expect(app.state.bar.bar).toEqual('baz')
-    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 foo = dynamicModule((namespace) => {
-      const fooAction: DynamicAction<string> = ({ mutate }) =>
-        mutate((state) => (state[namespace].foo = 'bar2'))
-
-      return {
-        state: {
-          foo: 'bar',
-        },
-        actions: {
-          foo: fooAction,
-        },
-      }
-    })
-
-    const config = {
-      modules: {
-        foo,
-      },
-    }
-
-    const app = new App(config)
-
-    expect(app.state.foo.foo).toEqual('bar')
-    expect(app.actions.foo.foo('mip')).toEqual('mip')
-    expect(app.state.foo.foo).toEqual('bar2')
-  })
 })
 
 describe('OPERATORS', () => {

packages/node_modules/overmind/src/index.ts

@@ -1,21 +1,23 @@
-import { ActionChain } from 'action-chain'
-import { EventEmitter } from 'betsy'
-import ProxyStateTree from 'proxy-state-tree'
-import Devtools, { Message, safeValue } from './Devtools'
 import ActionClass, {
-  IValueAction,
-  INoValueAction,
   Compose,
+  INoValueAction,
+  IValueAction,
   createOperators,
 } from './Action'
-import Reaction from './reaction'
+import Devtools, { Message, safeValue } from './Devtools'
 import {
   DynamicModule,
-  SubType,
-  Events,
   EventType,
+  Events,
   Options,
+  SubType,
 } from './internalTypes'
+
+import { ActionChain } from 'action-chain'
+import { EventEmitter } from 'betsy'
+import ProxyStateTree from 'proxy-state-tree'
+import Reaction from './reaction'
+
 export { default as derive } from './derived'
 export { default as compute } from './computed'
 
@@ -37,15 +39,6 @@ export type Configuration = {
   effects?: any
   actions?: any
   reactions?: any
-  modules?: {
-    [namespace: string]: {
-      onInitialize?: any
-      state?: any
-      effects?: any
-      actions?: any
-      reactions?: any
-    }
-  }
 }
 
 /*
@@ -59,43 +52,9 @@ interface IApp extends IEffects {
   state: IState
 }
 
-export type TState<Config extends Configuration> = [Config['state']] extends [
-  undefined
-]
-  ? {
-      [P in keyof SubType<Config['modules'], { state: {} }>]: SubType<
-        Config['modules'],
-        { state: {} }
-      >[P]['state']
-    }
-  : [Config['modules']] extends [undefined]
-    ? Config['state']
-    : Config['state'] &
-        {
-          [P in keyof SubType<Config['modules'], { state: {} }>]: SubType<
-            Config['modules'],
-            { state: {} }
-          >[P]['state']
-        }
+export type TState<Config extends Configuration> = Config['state']
 
-export type TEffects<Config extends Configuration> = [
-  Config['effects']
-] extends [undefined]
-  ? {
-      [P in keyof SubType<Config['modules'], { effects: object }>]: SubType<
-        Config['modules'],
-        { effects: object }
-      >[P]['effects']
-    }
-  : [Config['modules']] extends [undefined]
-    ? Config['effects']
-    : Config['effects'] &
-        {
-          [P in keyof SubType<Config['modules'], { effects: object }>]: SubType<
-            Config['modules'],
-            { effects: object }
-          >[P]['effects']
-        }
+export type TEffects<Config extends Configuration> = Config['effects']
 
 export type Mutate<Value = any> = (state: IApp['state'], value: Value) => void
 
@@ -162,54 +121,9 @@ export type Compute<Input, Output> = (
 ) => (state: IApp['state']) => Output
 
 export type TConfig<Config extends Configuration> = {
-  state: [Config['state']] extends [undefined]
-    ? {
-        [P in keyof SubType<Config['modules'], { state: {} }>]: SubType<
-          Config['modules'],
-          { state: {} }
-        >[P]['state']
-      }
-    : [Config['modules']] extends [undefined]
-      ? Config['state']
-      : Config['state'] &
-          {
-            [P in keyof SubType<Config['modules'], { state: {} }>]: SubType<
-              Config['modules'],
-              { state: {} }
-            >[P]['state']
-          }
-  effects: [Config['effects']] extends [undefined]
-    ? {
-        [P in keyof SubType<Config['modules'], { effects: object }>]: SubType<
-          Config['modules'],
-          { effects: object }
-        >[P]['effects']
-      }
-    : [Config['modules']] extends [undefined]
-      ? Config['effects']
-      : Config['effects'] &
-          {
-            [P in keyof SubType<
-              Config['modules'],
-              { effects: object }
-            >]: SubType<Config['modules'], { effects: object }>[P]['effects']
-          }
-  actions: [Config['actions']] extends [undefined]
-    ? {
-        [P in keyof SubType<Config['modules'], { actions: object }>]: SubType<
-          Config['modules'],
-          { actions: object }
-        >[P]['actions']
-      }
-    : [Config['modules']] extends [undefined]
-      ? Config['actions']
-      : Config['actions'] &
-          {
-            [P in keyof SubType<
-              Config['modules'],
-              { actions: object }
-            >]: SubType<Config['modules'], { actions: object }>[P]['actions']
-          }
+  state: Config['state'] & {}
+  effects: Config['effects'] & {}
+  actions: Config['actions'] & {}
   reactions: any
   namespaces: any
 }
@@ -258,10 +172,6 @@ export default class App<
       }
     }
 
-    /*
-      Mutate module functions into module objects
-    */
-    this.mutateModuleFunctionsIntoModules(configuration)
     /*
       Set up an eventHub to trigger information from derived, computed and reactions
     */
@@ -342,36 +252,11 @@ export default class App<
     this.proxyStateTree = proxyStateTree
     this.eventHub = eventHub
 
-    const initializers = this.getInitializers(configuration)
-
-    if (!initializers.length) {
-      return
-    }
-
-    const rootInitializer =
-      initializers[0].name === 'onInitialize' ? initializers.shift() : null
-
-    let onInitialize
-
-    if (initializers.length) {
-      onInitialize = operators.parallel(initializers)
-    }
-
-    if (rootInitializer) {
-      onInitialize = operators.compose(rootInitializer)
-    }
-
-    // @ts-ignore
-    onInitialize.displayName = 'onInitialize'
-    onInitialize(undefined)
-  }
-  private mutateModuleFunctionsIntoModules(config: Configuration) {
-    if (config.modules) {
-      Object.keys(config.modules).forEach((key) => {
-        if (typeof config.modules[key] === 'function') {
-          config.modules[key] = (config.modules[key] as any)(key)
-        }
-      })
+    if (configuration.onInitialize) {
+      const onInitialize = operators.compose(configuration.onInitialize)
+      // @ts-ignore
+      onInitialize.displayName = 'onInitialize'
+      onInitialize(undefined)
     }
   }
   private initializeDevtools(host, actionChain, eventHub, proxyStateTree) {
@@ -485,41 +370,9 @@ export default class App<
     if (configuration.state) {
       state = this.transformStateToPlainObject(configuration.state)
     }
-    if (configuration.modules) {
-      Object.keys(configuration.modules).reduce((aggr, key) => {
-        if (configuration.modules[key].state) {
-          return Object.assign(aggr, {
-            [key]: this.transformStateToPlainObject(
-              configuration.modules[key].state
-            ),
-          })
-        }
-
-        return aggr
-      }, state)
-    }
 
     return state
   }
-  private getInitializers(configuration) {
-    let initializers = []
-    if (configuration.onInitialize) {
-      initializers.push(configuration.onInitialize)
-    }
-    if (configuration.modules) {
-      initializers = Object.keys(configuration.modules).reduce((aggr, key) => {
-        if (configuration.modules[key].onInitialize) {
-          configuration.modules[key].onInitialize.displayName =
-            key + '.onInitialize'
-          return aggr.concat(configuration.modules[key].onInitialize)
-        }
-
-        return aggr
-      }, initializers)
-    }
-
-    return initializers
-  }
   private transformStateToPlainObject(state: {}) {
     return Object.keys(state).reduce((aggr, key) => {
       aggr[key] = state[key]
@@ -532,17 +385,6 @@ export default class App<
     if (configuration.actions) {
       actions = configuration.actions
     }
-    if (configuration.modules) {
-      Object.keys(configuration.modules).reduce((aggr, key) => {
-        if (configuration.modules[key].actions) {
-          return Object.assign(aggr, {
-            [key]: configuration.modules[key].actions,
-          })
-        }
-
-        return aggr
-      }, actions)
-    }
 
     const evaluatedActions = Object.keys(actions).reduce((aggr, name) => {
       if (typeof actions[name] === 'function') {