Merge pull request cerebral#190 from cerebral/refactorEffects

feat(overmind): remove flattening of effects to actions, use effects …

Author: christianalfoni

packages/node_modules/overmind-devtools/src/overmind/actions.ts

@@ -33,15 +33,14 @@ import {
 export const onInitialize: OnInitialize = async ({
   value: app,
   state,
-  storage,
-  connector,
+  effects,
 }) => {
-  const port = await storage.get<string>('currentPort')
+  const port = await effects.storage.get<string>('currentPort')
   if (port) {
     state.port = port
   }
-  connector.onMessage(app.actions.onMessage)
-  connector.connect(state.port)
+  effects.connector.onMessage(app.actions.onMessage)
+  effects.connector.connect(state.port)
 }
 
 const handleClientMessage: Operator<Message, any> = pipe(
@@ -81,12 +80,12 @@ export const setError: Action<string> = ({ value: error, state }) =>
 export const changeNewPortValue: Action<string> = ({ value: port, state }) =>
   (state.newPortValue = String(Number(port)))
 
-export const addConnection: Action = ({ state, connector }) => {
+export const addConnection: Action = ({ state, effects }) => {
   state.error = null
   state.isConnecting = true
   state.port = state.newPortValue
   state.newPortValue = ''
-  connector.connect(state.port)
+  effects.connector.connect(state.port)
 }
 
 export const changeTab: Action<Tab> = ({ value: tab, state }) =>

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

@@ -51,8 +51,8 @@ describe('Config', () => {
     const merged = merge(
       {
         actions: {
-          loadConfigB: ({ lazy }) => {
-            return lazy.loadConfig('configB')
+          loadConfigB: ({ effects }) => {
+            return effects.lazy.loadConfig('configB')
           },
         },
       },

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

@@ -16,10 +16,10 @@ function createDefaultOvermind() {
     context.state.foo = 'bar2'
   }
   const changeFooWithEffect: Action = (context) => {
-    context.state.foo = context.hello()
+    context.state.foo = context.effects.hello()
   }
   const waitAndChangeFoo: Action = (context) => {
-    return context.wait().then(() => {
+    return context.effects.wait().then(() => {
       context.state.foo = 'bar2'
     })
   }

packages/node_modules/overmind/src/index.ts

@@ -295,16 +295,14 @@ export class Overmind<Config extends Configuration> implements Configuration {
     return execution
   }
   private createContext(value, execution, tree) {
-    return Object.assign(
-      {
-        value,
-        state: tree.state,
-        actions: this.actions,
-        execution,
-        proxyStateTree: this.proxyStateTree,
-      },
-      this.trackEffects(this.effects, execution)
-    )
+    return {
+      value,
+      state: tree.state,
+      actions: this.actions,
+      execution,
+      proxyStateTree: this.proxyStateTree,
+      effects: this.trackEffects(this.effects, execution),
+    }
   }
   private scopeValue(value: any, tree: TTree) {
     if (!value) {
@@ -764,14 +762,12 @@ function createContext(context, value, path?) {
     path: path || context.execution.path,
   }
 
-  return Object.assign(
-    {
-      ...context,
-      value,
-      execution: newExecution,
-    },
-    context.execution.trackEffects(newExecution)
-  )
+  return {
+    ...context,
+    value,
+    execution: newExecution,
+    effects: context.execution.trackEffects(newExecution),
+  }
 }
 
 function createNextPath(next) {

packages/node_modules/overmind/src/internalTypes.ts

@@ -137,9 +137,10 @@ export interface Events {
 
 // ============= PRIVATE TYPES FOR APP
 
-export type TBaseContext<Config extends Configuration> = Config['effects'] & {
+export type TBaseContext<Config extends Configuration> = {
   state: ResolveState<Config['state']>
   actions: ResolveActions<Config['actions']>
+  effects: Config['effects']
   execution: any
 }
 

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

@@ -13,8 +13,8 @@ describe('Mock', () => {
     const state: State = {
       foo: 'bar',
     }
-    const test: Action = ({ state, effect, actions }) => {
-      state.foo = effect()
+    const test: Action = ({ state, effects, actions }) => {
+      state.foo = effects.effect()
     }
     const actions = { test }
     const effect = () => 'bar2'

packages/node_modules/overmind/src/types.ts

@@ -33,7 +33,7 @@ export type TStateObject =
 export interface IConfig<Config extends Configuration> {
   state: Config['state']
   actions: Config['actions']
-  effects: Config['effects'] & {}
+  effects: Config['effects']
 }
 
 // This is the type of the `app` argument passed in components.

packages/overmind-website/api/action.md

@@ -4,10 +4,10 @@
 h(Example, { name: "api/action"})
 ```
 
-An action is where you write the logic of the application. Every action receives one argument called the **context**. This context holds: 
+An action is where you write the logic of the application. Every action receives one argument and that is the configuration of your application:
 
-`{ state, actions, ...effects }`
+`{ state, actions, effects }`
 
-This context gives Overmind the primarily the ability to understand what state you are changing and what effects you are running. You can also use other actions defined in your application. Additionally this context makes your actions highly testable as it can easily be mocked.
+This *injected* configuration allows Overmind to understand from where you are chaing state and running effects. You can also use other actions defined in your application. Additionally with *injection* your actions become highly testable as it can easily be mocked.
 
 State changes are restricted to these actions. That means if you try to change the state outside of an action you will get an error. The state changes are also scoped to the action. That means it does not matter if you perform the state change asynchronously, either by defining the action as an **async** function or for example use a **setTimeout**. You can change the state at any time within the action.

packages/overmind-website/api/config.md

@@ -22,7 +22,7 @@ Allows you to namespace configurations by a key.
 h(Example, { name: "api/config_namespaced" })
 ```
 
-## lazy (beta)
+## lazy
 
 You can also lazy load configurations. You do this by giving each configuration a key with a function that returns the config when called. To actually load the configurations you can either call an effect or an action with the key of the configuration to load.