refactor(action-chain): move mutation events declaration to overmind

Author: Guria

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

@@ -1,7 +1,7 @@
-import { ActionChain, Execution, ExecutionContext } from './ActionChain'
+import { ActionChain, ExecutionContext } from './ActionChain'
 
 export class StopExecution {
-  constructor(public value) {}
+  constructor(public value: any) {}
 }
 export class ActionBase<Effects> {
   static nextActionId: number = 0
@@ -11,17 +11,15 @@ export class ActionBase<Effects> {
     private initialActionId: number = ActionBase.nextActionId++,
     private runOperators?: (
       value: any,
-      executionContext: {
-        __execution: Execution
-        __path: string[]
-      },
+      executionContext: ExecutionContext,
       newPath?: string
     ) => any | Promise<any>
   ) {
     interface I extends ActionBase<Effects> {
-      (value: string): string
+      (value: any): I
       displayName: string
     }
+    this.getActionChain = this.getActionChain.bind(this)
 
     const instance: I = Object.assign(function(value) {
       const initialOperator = typeof arguments[1] === 'undefined'
@@ -69,8 +67,8 @@ export class ActionBase<Effects> {
 
     return instance
   }
-  getActionChain = () => {
-    return this.actionChain
+  getActionChain<ExtraEvents = {}>() {
+    return this.actionChain as ActionChain<Effects, ExtraEvents>
   }
   createOperatorResult = (
     type: string,

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

@@ -1,32 +1,26 @@
 import { EventEmitter } from 'betsy'
-import { Mutation } from 'proxy-state-tree'
 
 const IS_DEVELOPMENT = process.env.NODE_ENV !== 'production'
 
-export type ExecutionContext = {
-  __execution: Execution
-  __path: string[]
-}
-
-export type ActionChainOptions = {
-  actionWrapper?: any
-  providerExceptions?: string[]
-}
-
 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 = {
+type OperatorExecution = {
   actionId: number
   executionId: number
   operatorId: number
@@ -35,7 +29,7 @@ export type OperatorExecution = {
   path: string
 }
 
-export interface ActionChainEvents {
+interface ActionChainEvents {
   effect: Execution & {
     name: string
     method: string | number | symbol
@@ -52,32 +46,30 @@ export interface ActionChainEvents {
     isAsync: boolean
     result: any
   }
-  mutations: ActionExecution & {
-    mutations: Mutation[]
-  }
 }
 
 function isObject(value) {
   return typeof value === 'object' && !Array.isArray(value) && value !== null
 }
 
-export class ActionChain<Effects> extends EventEmitter<ActionChainEvents> {
+export class ActionChain<Effects, ExtraEvents = {}> extends EventEmitter<
+  ActionChainEvents & ExtraEvents
+> {
   constructor(
     private effects: Effects,
-    private options: ActionChainOptions = {}
+    private options: { providerExceptions?: string[] } = {}
   ) {
     super()
     this.options.providerExceptions = options.providerExceptions || []
   }
-  private createGetHandler(execution, path) {
-    const instance = this
+  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) => {
-              instance.emitAsync('effect', {
+              this.emitAsync('effect', {
                 ...execution,
                 name: path,
                 method: prop,
@@ -86,7 +78,7 @@ export class ActionChain<Effects> extends EventEmitter<ActionChainEvents> {
               })
             })
           } else {
-            instance.emitAsync('effect', {
+            this.emitAsync('effect', {
               ...execution,
               name: path,
               method: prop,
@@ -99,7 +91,7 @@ export class ActionChain<Effects> extends EventEmitter<ActionChainEvents> {
         }
       } else if (isObject(target[prop])) {
         return new Proxy(target[prop], {
-          get: instance.createGetHandler(execution, path + '.' + prop),
+          get: this.createGetHandler(execution, path + '.' + prop),
         })
       }
 
@@ -111,20 +103,23 @@ export class ActionChain<Effects> extends EventEmitter<ActionChainEvents> {
     let effects = this.effects
 
     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]
-        }
+      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 currentEffects
+        },
+        {} as Effects
+      )
     }
 
     return Object.assign({}, effects, executionContext)

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

@@ -1,2 +1,7 @@
 export { ActionBase, StopExecution } from './ActionBase'
-export { ActionChain, Execution, ExecutionContext } from './ActionChain'
+export {
+  ActionChain,
+  ActionExecution,
+  Execution,
+  ExecutionContext,
+} from './ActionChain'

packages/node_modules/overmind/src/Action.ts

@@ -1,5 +1,10 @@
-import ProxyStateTree from 'proxy-state-tree'
-import { ActionBase, StopExecution, ActionChain } from 'action-chain'
+import ProxyStateTree, { Mutation } from 'proxy-state-tree'
+import {
+  ActionBase,
+  ActionExecution,
+  StopExecution,
+  ActionChain,
+} from 'action-chain'
 
 type OperatorCallback<Effects, Value, NewValue = Value> = (
   effects: Effects,
@@ -23,7 +28,11 @@ export interface INoValueAction<
 > extends Action<State, Effects, InitialValue, Value> {
   (): Value
 }
-
+interface MutationsEvents {
+  mutations: ActionExecution & {
+    mutations: Mutation[]
+  }
+}
 export default class Action<
   State,
   Effects,
@@ -71,7 +80,7 @@ export default class Action<
       this.proxyStateTree.startMutationTracking()
       cb(effects.state, value)
       const mutations = this.proxyStateTree.clearMutationTracking()
-      this.getActionChain().emitAsync('mutations', {
+      this.getActionChain<MutationsEvents>().emitAsync('mutations', {
         mutations,
         ...effects.__execution,
       })