refactor(action-chain): class implementation for ActionChain

Author: Guria

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

@@ -7,11 +7,6 @@ export type ExecutionContext = {
   __path: string[]
 }
 
-export interface ActionChain<Context> extends EventEmitter {
-  getOptions(): ActionChainOptions
-  getContext(executionContext: ExecutionContext): Context & ExecutionContext
-}
-
 export type ActionChainOptions = {
   actionWrapper?: any
   providerExceptions?: string[]
@@ -23,21 +18,24 @@ export type Execution = {
   executionId: number
 }
 
-export function actionChainFactory<Context>(
-  context: Context,
-  options: ActionChainOptions = {}
-): ActionChain<Context> {
-  options.providerExceptions = options.providerExceptions || []
+export class ActionChain<Context> extends EventEmitter {
+  constructor(
+    private context: Context,
+    private options: ActionChainOptions = {}
+  ) {
+    super()
+    this.options.providerExceptions = options.providerExceptions || []
+  }
 
-  return Object.assign(new EventEmitter(), {
-    getOptions() {
-      return options
-    },
-    getContext(executionContext: ExecutionContext) {
-      const instance = this
-      const providers = Object.keys(context).reduce((currentContext, key) => {
-        if (IS_DEVELOPMENT && options.providerExceptions.indexOf(key) === -1) {
-          currentContext[key] = new Proxy(context[key], {
+  getContext(executionContext: ExecutionContext) {
+    const instance = this
+    const providers = Object.keys(this.context).reduce(
+      (currentContext, key) => {
+        if (
+          IS_DEVELOPMENT &&
+          this.options.providerExceptions.indexOf(key) === -1
+        ) {
+          currentContext[key] = new Proxy(this.context[key], {
             get(target, prop) {
               if (typeof target[prop] === 'function') {
                 return (...args) => {
@@ -68,14 +66,20 @@ export function actionChainFactory<Context>(
             },
           })
         } else {
-          currentContext[key] = context[key]
+          currentContext[key] = this.context[key]
         }
 
         return currentContext
-      }, {})
+      },
+      {}
+    )
+    return { ...providers, ...executionContext }
+  }
+}
 
-      return Object.assign({}, providers, executionContext) as Context &
-        ExecutionContext
-    },
-  })
+export function actionChainFactory<Context>(
+  context: Context,
+  options: ActionChainOptions = {}
+): ActionChain<Context> {
+  return new ActionChain(context, options)
 }

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

@@ -134,18 +134,18 @@ describe('CONTEXT', () => {
 
   test('should be able to extend context', () => {
     expect.assertions(1)
-    const foo = action().test((_, { foo }) => {
+    const fn = action().test((_, { foo }) => {
       expect(foo.bar()).toBe('baz')
     })
 
-    foo()
+    fn()
   })
 })
 
 describe('PROVIDER', () => {
   test('should track execution of providers', () => {
     expect.assertions(2)
-    const foo = action().test((_, { foo }) => {
+    const fn = action().test((_, { foo }) => {
       expect(foo.bar()).toBe('baz')
     })
 
@@ -159,11 +159,11 @@ describe('PROVIDER', () => {
         result: 'baz',
       })
     })
-    foo()
+    fn()
   })
   test('should track execution of clas instance providers', () => {
     expect.assertions(2)
-    const foo = action().test((_, { test }) => {
+    const fn = action().test((_, { test }) => {
       expect(test.foo()).toBe('bar')
     })
 
@@ -177,14 +177,14 @@ describe('PROVIDER', () => {
         result: 'bar',
       })
     })
-    foo()
+    fn()
   })
 })
 
 describe('ACTION CHAIN', () => {
   test('should track execution', () => {
     expect.assertions(4)
-    const foo = action().test(() => 'foo')
+    const fn = action().test(() => 'foo')
 
     actionChain.once('action:start', (data) => {
       expect(data).toEqual({
@@ -221,7 +221,7 @@ describe('ACTION CHAIN', () => {
       })
     })
 
-    foo()
+    fn()
   })
   test('should track async execution', () => {
     expect.assertions(2)