Merge pull request cerebral#29 from cerebral/namespaces

feat(overmind): namespaces as functions for isolated modules

Author: christianalfoni

packages/node_modules/overmind/src/compose.ts

@@ -1,4 +1,4 @@
-import App, { compose } from './'
+import App, { namespaces, Namespace, IAction } from './'
 
 describe('Overmind', () => {
   test('should instantiate app with state', () => {
@@ -19,8 +19,8 @@ describe('Overmind', () => {
     })
     expect(app.actions.foo('bah')).toEqual('bah')
   })
-  test('should instantiate app with composed state and actions', () => {
-    const config = compose({
+  test('should instantiate app with namespaces', () => {
+    const config = namespaces({
       foo: {
         state: {
           foo: 'bar',
@@ -45,6 +45,37 @@ 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: Namespace) => {
+      type State = {
+        foo: string
+      }
+      type NamespacedState = {
+        [namespace]: State
+      }
+      const state: State = {
+        foo: 'bar',
+      }
+
+      type Action = IAction<NamespacedState, { state: NamespacedState }>
+
+      return {
+        state,
+        actions: (action: Action) => ({
+          foo: action<string>().map(
+            (value, { state }) => value + state[namespace].foo
+          ),
+        }),
+      }
+    }
+    const config = namespaces({
+      foo: fooNamespace,
+    })
+    const app = new App(config)
+
+    expect(app.state.foo.foo).toEqual('bar')
+    expect(app.actions.foo.foo('mip')).toEqual('mipbar')
+  })
 })
 
 describe('OPERATORS', () => {

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

@@ -3,7 +3,7 @@ import { EventEmitter } from 'betsy'
 import ProxyStateTree from 'proxy-state-tree'
 import Devtools, { Message, safeValue } from './Devtools'
 import Action, { IValueAction, INoValueAction } from './Action'
-export { default as compose } from './compose'
+export { default as namespaces, Namespace } from './namespaces'
 export { default as derived } from './derived'
 export { default as computed } from './computed'
 
@@ -54,14 +54,14 @@ export default class App<
   Providers extends object,
   Actions extends
     | {
-        [namespace: string]: ActionsCallback<Providers, State>
+        [namespace: string]: ActionsCallback<{}, {}>
       }
     | ActionsCallback<Providers, State>
 > {
   private proxyStateTree: ProxyStateTree
   devtools: Devtools
   actions: Actions extends {
-    [namespace: string]: ActionsCallback<Providers, State>
+    [namespace: string]: ActionsCallback<{}, {}>
   }
     ? { [Namespace in keyof Actions]: ReturnType<Actions[Namespace]> }
     : Actions extends ActionsCallback<Providers, State>

packages/node_modules/overmind/src/index.ts

@@ -0,0 +1,68 @@
+export type Namespace = 'namespace'
+
+type Module = {
+  state?: any
+  providers?: any
+  actions?: any
+}
+
+type ModuleFunction = (namespace: string) => Module
+
+type TNamespaces = {
+  [namespace: string]: Module | ModuleFunction
+}
+
+export default function namespaces<Namespaces extends TNamespaces>(
+  namespaces: Namespaces
+): {
+  state: {
+    [Namespace in keyof Namespaces]: Namespaces[Namespace] extends ModuleFunction
+      ? ReturnType<Namespaces[Namespace]>['state']
+      : Namespaces[Namespace] extends Module
+        ? Namespaces[Namespace]['state']
+        : any
+  }
+  providers: {
+    [Namespace in keyof Namespaces]: Namespaces[Namespace] extends ModuleFunction
+      ? ReturnType<Namespaces[Namespace]>['providers']
+      : Namespaces[Namespace] extends Module
+        ? Namespaces[Namespace]['providers']
+        : any
+  }
+  actions: {
+    [Namespace in keyof Namespaces]: Namespaces[Namespace] extends ModuleFunction
+      ? ReturnType<Namespaces[Namespace]>['actions']
+      : Namespaces[Namespace] extends Module
+        ? Namespaces[Namespace]['actions']
+        : any
+  }
+} {
+  return Object.keys(namespaces).reduce(
+    (aggr, key) => {
+      const namespace =
+        typeof namespaces[key] === 'function'
+          ? (namespaces[key] as ModuleFunction)(key)
+          : (namespaces[key] as Module)
+
+      return Object.assign({
+        state: {
+          ...aggr.state,
+          [key]: namespace.state || {},
+        },
+        providers: {
+          ...aggr.providers,
+          [key]: namespace.providers || {},
+        },
+        actions: {
+          ...aggr.actions,
+          [key]: namespace.actions || {},
+        },
+      })
+    },
+    {
+      state: {},
+      providers: {},
+      actions: {},
+    }
+  )
+}