fix(overmind): fix lazy loading namespacePath and typing

Author: christianalfoni

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

@@ -1,4 +1,4 @@
-import { Overmind } from '../'
+import { Overmind, createOvermindMock } from '../'
 import { lazy, merge, namespaced } from './'
 
 describe('Config', () => {
@@ -94,4 +94,29 @@ describe('Config', () => {
     expect(merged.state.foo).toEqual('bar')
     expect(merged.state.configB.bar).toEqual('baz')
   })
+
+  test('should keep context when lazy loading namespaces', async () => {
+    const config = {
+      state: {
+        foo: 'bar',
+      },
+      actions: {
+        changeFoo(context) {
+          context.state.config.foo = 'bar2'
+        }
+      }
+    }
+    
+    const overmind = createOvermindMock(lazy({
+      config: () => Promise.resolve(config)
+    }))
+
+    await overmind.onInitialize()
+
+    await overmind.actions.lazy.loadConfig('config')
+    // @ts-ignore
+    overmind.actions.config.changeFoo()
+    expect(overmind.state.config!.foo).toEqual('bar2')
+    
+  })
 })

packages/node_modules/overmind/src/config/lazy.ts

@@ -13,7 +13,7 @@ interface LazyConfiguration {
   }>
 }
 
-export function lazy<T extends LazyConfiguration, B = T>(
+export function lazy<T extends LazyConfiguration>(
   configurations: T
 ): {
   onInitialize?: any
@@ -70,24 +70,28 @@ export function lazy<T extends LazyConfiguration, B = T>(
     },
     actions: {
       lazy: {
-        loadConfig({ state, ...rest }, key) {
+        loadConfig({ state, execution, ...rest }, key) {
           const configToLoad = configurations[key]
-
+          const namespacePath = execution.namespacePath.slice(0, execution.namespacePath.length - 1).concat(key)
           return configToLoad().then((loadedConfig) => {
             const newConfig = namespaced({
               [key]: loadedConfig,
             })
 
             if (newConfig.state && newConfig.state[key])
-              state[key] = processState(newConfig.state[key])
+              state[key] = processState(newConfig.state[key]!)
             if (newConfig.effects && newConfig.effects[key])
               app.effects[key] = newConfig.effects[key]
             if (newConfig.actions && newConfig.actions[key])
-              app.actions[key] = app.getActions(newConfig.actions[key])
+              app.actions[key] = app.getActions(newConfig.actions[key], namespacePath)
             if (newConfig.onInitialize)
               newConfig.onInitialize(
                 {
                   state,
+                  execution: {
+                    ...execution,
+                    namespacePath
+                  },
                   ...rest,
                 },
                 app

packages/node_modules/overmind/src/internalTypes.ts

@@ -5,11 +5,11 @@ import {
   ITrackStateTree,
 } from 'proxy-state-tree'
 
-import { IAction,  IOperator, IState } from './types'
+import { IAction,  IOperator } from './types'
 
 export type SubType<Base, Condition> = Pick<
   Base,
-  { [Key in keyof Base]: Base[Key] extends Condition ? Key : never }[keyof Base]
+  { [Key in keyof Base]: Base[Key] extends Condition | undefined ? Key : never }[keyof Base]
 >
 
 export type NestedPartial<T> = T extends Function