feat(action-chain): extract ActionChain methods as static utilities

Author: Guria

packages/node_modules/action-chain/src/ActionBase.ts

@@ -1,4 +1,5 @@
-import { ActionChain, ExecutionContext } from './ActionChain'
+import { ActionChain } from './ActionChain'
+import { ExecutionContext } from './types'
 
 export class StopExecution {
   constructor(public value: any) {}
@@ -103,8 +104,9 @@ export class ActionBase<Effects> {
 
           const path = executionContextWithPath.__path
 
-          const effects = this.actionChain.getEffects(
-            thisExecution,
+          const effects = Object.assign(
+            {},
+            this.actionChain.getEffects(thisExecution),
             executionContextWithPath
           )
 

packages/node_modules/action-chain/src/ActionChain.ts

@@ -1,57 +1,9 @@
 import { EventEmitter } from 'betsy'
+import { proxifyEffects } from './utils'
+import { ActionChainEvents, Execution } from './types'
 
 const IS_DEVELOPMENT = process.env.NODE_ENV !== 'production'
 
-export type Execution = {
-  operatorId: number
-  actionId: number
-  executionId: number
-}
-
-export type ExecutionContext = {
-  __execution: Execution
-  __path: string[]
-}
-
-export type ActionExecution = {
-  actionId: number
-  executionId: number
-  actionName: string
-  value?: any
-}
-
-type OperatorExecution = {
-  actionId: number
-  executionId: number
-  operatorId: number
-  type: string
-  name: string
-  path: string
-}
-
-interface ActionChainEvents {
-  effect: Execution & {
-    name: string
-    method: string | number | symbol
-    result: any
-    args: any[]
-  }
-  'action:start': ActionExecution
-  'action:end': ActionExecution
-  'operator:start': OperatorExecution
-  'operator:async': OperatorExecution & {
-    isAsync: boolean
-  }
-  'operator:end': OperatorExecution & {
-    isAsync: boolean
-    result: any
-  }
-}
-
-function isObject(value) {
-  return typeof value === 'object' && !Array.isArray(value) && value !== null
-}
-
 export class ActionChain<Effects, ExtraEvents = {}> extends EventEmitter<
   ActionChainEvents & ExtraEvents
 > {
@@ -60,68 +12,17 @@ export class ActionChain<Effects, ExtraEvents = {}> extends EventEmitter<
     private options: { providerExceptions?: string[] } = {}
   ) {
     super()
-    this.options.providerExceptions = options.providerExceptions || []
-  }
-  private createGetHandler(execution: Execution, path: string) {
-    return (target, prop) => {
-      if (typeof target[prop] === 'function') {
-        return (...args) => {
-          const result = target[prop](...args)
-          if (result instanceof Promise) {
-            result.then((promisedResult) => {
-              this.emitAsync('effect', {
-                ...execution,
-                name: path,
-                method: prop,
-                args,
-                result: promisedResult,
-              })
-            })
-          } else {
-            this.emitAsync('effect', {
-              ...execution,
-              name: path,
-              method: prop,
-              args,
-              result,
-            })
-          }
-
-          return result
-        }
-      } else if (isObject(target[prop])) {
-        return new Proxy(target[prop], {
-          get: this.createGetHandler(execution, path + '.' + prop),
-        })
-      }
-
-      return target[prop]
-    }
   }
 
-  getEffects(thisExecution: Execution, executionContext: ExecutionContext) {
-    let effects = this.effects
-
+  getEffects(thisExecution: Execution) {
     if (IS_DEVELOPMENT) {
-      effects = Object.keys(this.effects).reduce(
-        (currentEffects, key) => {
-          if (
-            this.options.providerExceptions.indexOf(key) === -1 &&
-            isObject(this.effects[key])
-          ) {
-            currentEffects[key] = new Proxy(this.effects[key], {
-              get: this.createGetHandler(thisExecution, key),
-            })
-          } else {
-            currentEffects[key] = this.effects[key]
-          }
-
-          return currentEffects
-        },
-        {} as Effects
+      return proxifyEffects(
+        this.effects,
+        this.options.providerExceptions,
+        (effect) => this.emitAsync('effect', { ...thisExecution, ...effect })
       )
     }
 
-    return Object.assign({}, effects, executionContext)
+    return this.effects
   }
 }

packages/node_modules/action-chain/src/index.ts

@@ -1,7 +1,4 @@
 export { ActionBase, StopExecution } from './ActionBase'
-export {
-  ActionChain,
-  ActionExecution,
-  Execution,
-  ExecutionContext,
-} from './ActionChain'
+export { ActionChain } from './ActionChain'
+export { ActionExecution, Execution, ExecutionContext } from './types'
+export { doNotProxy } from './utils'

packages/node_modules/action-chain/src/types.ts

@@ -0,0 +1,42 @@
+export type Execution = {
+  operatorId: number
+  actionId: number
+  executionId: number
+}
+
+export type ExecutionContext = {
+  __execution: Execution
+  __path: string[]
+}
+
+export type ActionExecution = {
+  actionId: number
+  executionId: number
+  actionName: string
+  value?: any
+}
+
+export type OperatorExecution = {
+  actionId: number
+  executionId: number
+  operatorId: number
+  type: string
+  name: string
+  path: string
+}
+
+export type EffectResult = {
+  name: string
+  method: string | number | symbol
+  result: any
+  args: any[]
+}
+
+export interface ActionChainEvents {
+  effect: Execution & EffectResult
+  'action:start': ActionExecution
+  'action:end': ActionExecution
+  'operator:start': OperatorExecution
+  'operator:async': OperatorExecution & { isAsync: true }
+  'operator:end': OperatorExecution & { isAsync: boolean; result: any }
+}

packages/node_modules/action-chain/src/utils.ts

@@ -0,0 +1,65 @@
+import { EffectResult } from './types'
+
+export const doNotProxy = Symbol('doNotProxy')
+
+function isObject(value) {
+  return typeof value === 'object' && !Array.isArray(value) && value !== null
+}
+
+function createProxyGetHandler(
+  path: string,
+  cb: (effect: EffectResult) => void
+): ProxyHandler<any>['get'] {
+  return (target, prop) => {
+    if (typeof target[prop] === 'function') {
+      return (...args) => {
+        const result = target[prop](...args)
+        if (result instanceof Promise) {
+          result.then((promisedResult) => {
+            // eslint-disable-next-line standard/no-callback-literal
+            cb({
+              name: path,
+              method: prop,
+              args,
+              result: promisedResult,
+            })
+          })
+        } else {
+          // eslint-disable-next-line standard/no-callback-literal
+          cb({
+            name: path,
+            method: prop,
+            args,
+            result,
+          })
+        }
+        return result
+      }
+    } else if (isObject(target[prop])) {
+      return new Proxy(target[prop], {
+        get: createProxyGetHandler(path + '.' + prop.toString(), cb),
+      })
+    }
+  }
+}
+
+export function proxifyEffects<Effects>(
+  effects: Effects,
+  skipKeys: string[] = [],
+  cb: (effect: EffectResult) => void
+): Effects {
+  return Object.keys(effects).reduce(
+    (currentEffects, key) => {
+      const effect = effects[key]
+      if (skipKeys.indexOf(key) === -1 && isObject(effect)) {
+        currentEffects[key] = new Proxy(effect, {
+          get: createProxyGetHandler(key, cb),
+        })
+      } else {
+        currentEffects[key] = effect
+      }
+      return currentEffects
+    },
+    {} as Effects
+  )
+}

packages/node_modules/overmind/src/index.ts

@@ -1,4 +1,4 @@
-import { ActionChain } from 'action-chain'
+import { ActionChain, doNotProxy } from 'action-chain'
 import { EventEmitter } from 'betsy'
 import ProxyStateTree from 'proxy-state-tree'
 import Devtools, { Message, safeValue } from './Devtools'
@@ -280,15 +280,8 @@ export default class App<
       The action chain with the context configuration
     */
     const actionChain = new ActionChain(
-      Object.assign(
-        {
-          state: proxyStateTree.get(),
-        },
-        configuration.effects || {}
-      ),
-      {
-        providerExceptions: ['state'],
-      }
+      Object.assign({ state: proxyStateTree.get() }, configuration.effects),
+      { providerExceptions: ['state'] }
     )
 
     /*