Make it work with inheritance

Author: keenondrums

README.md

@@ -22,6 +22,7 @@ Consider using it with [flux-action-class](https://github.com/keenondrums/flux-a
   - [Step 1](#step-1)
   - [Step 2](#step-2)
   - [How can I make shared reducer's logic dynamic?](#how-can-i-make-shared-reducers-logic-dynamic)
+- [Reducer inheritance](#reducer-inheritance)
 - [In depth](#in-depth)
   - [When can we omit list of actions for `@Action`?](#when-can-we-omit-list-of-actions-for-action)
   - [Running several reducers for the same action](#running-several-reducers-for-the-same-action)
@@ -669,9 +670,6 @@ const reducer = ReducerCat.create()
 ```js
 import { Action, Extend, ReducerClass } from 'reducer-class'
 
-interface IHungryState {
-  hungry: boolean;
-}
 export const makeReducerHungry = (actionHungry, actionFull) =>
   class {
     @Action(actionHungry)
@@ -717,6 +715,76 @@ const reducer = ReducerCat.create()
 
 </details>
 
+## Reducer inheritance
+
+Any reducer class is still a class, therefore it can be inherited. It's different way to share some common logic and alter the final behavior for children. There's no runtime information about method visibility (`private`, `protected`, `public`), so if you want to share some common logic without wrapping it with `@Action` decorator prefix the shared method with `_`.
+
+```ts
+interface ICatState {
+  enegry: number
+}
+class CatReducer extends ReducerClass<ICatState> {
+  initialState = {
+    energy: 10,
+  }
+
+  @Action
+  addEnergy(state: ICatState, action: ActionCatEat) {
+    return this._addEnergy(state, action)
+  }
+
+  // DO NOT FORGET TO PREFIX IT WITH "_"
+  protected _addEnergy(state: ICatState, action: ActionCatEat): ICatState {
+    return {
+      energy: state.energy + action.payload,
+    }
+  }
+}
+
+class KittenReducer extends CatReducer {
+  // DO NOT FORGET TO PREFIX IT WITH "_"
+  protected _addEnergy(state: ICatState, action: ActionCatEat): ICatState {
+    return {
+      energy: state.energy + action.payload * 10,
+    }
+  }
+}
+```
+
+<details>
+<summary>JavaScript version</summary>
+
+```js
+class CatReducer extends ReducerClass {
+  initialState = {
+    energy: 10,
+  }
+
+  @Action(ActionCatEat)
+  addEnergy(state, action) {
+    return this._addEnergy(state, action)
+  }
+
+  // DO NOT FORGET TO PREFIX IT WITH "_"
+  protected _addEnergy(state, action) {
+    return {
+      energy: state.energy + action.payload,
+    }
+  }
+}
+
+class KittenReducer extends CatReducer {
+  // DO NOT FORGET TO PREFIX IT WITH "_"
+  protected _addEnergy(state, action) {
+    return {
+      energy: state.energy + action.payload * 10,
+    }
+  }
+}
+```
+
+</details>
+
 ## In depth
 
 ### When can we omit list of actions for `@Action`?

package.json

@@ -1,6 +1,6 @@
 {
   "name": "reducer-class",
-  "version": "1.3.2",
+  "version": "1.4.0",
   "description": "Boilerplate free class-based reducer creator. Built with TypeScript. Works with Redux and NGRX. Has integration with immer.",
   "main": "dist/index.js",
   "scripts": {

src/constants.ts

@@ -1,2 +1,3 @@
 export const METADATA_KEY_METHOD_PARAMS = 'design:paramtypes'
 export const METADATA_KEY_ACTION = Symbol()
+export const PREFIX_OMIT_METHOD = '_'

src/reducer-class-helpers.test.ts

@@ -52,6 +52,45 @@ describe(ReducerClassHelpers.name, () => {
       expect(methodWithActionTypes2.actionType).toBe(Action2.type)
       expect(methodWithActionTypes2.method).toBe(mockAddImmerIfNeededResImmer)
     })
+    test('returns action types for the whole inheritance chain', () => {
+      class Action1 extends ActionStandard {}
+      class Action2 extends ActionStandard {}
+      class Test extends ReducerClass<undefined> {
+        public initialState = undefined
+
+        @Action(Action1)
+        public reducerPure(): undefined {
+          return undefined
+        }
+      }
+      class TestChild extends Test {
+        @Action(Action2)
+        public reducerImmer(state: undefined, draft: undefined, action: any) {
+          return undefined
+        }
+      }
+      const test = new TestChild()
+      const keys = reducerClassHelpers.getClassInstanceMethodNames(test)
+      const spyGetMetadata = jest.spyOn(Reflect, 'getMetadata')
+      const mockAddImmerIfNeededResPure = Symbol()
+      const mockAddImmerIfNeededResImmer = Symbol()
+      jest.spyOn(ReducerClassHelpers.prototype, 'addImmerIfNeeded').mockImplementation(
+        (reducer: any): any => {
+          if (reducerClassHelpers.typeGuardReducerPure(reducer)) {
+            return mockAddImmerIfNeededResPure
+          }
+          return mockAddImmerIfNeededResImmer
+        },
+      )
+      const methodsWithActionTypes = reducerClassHelpers.getReducerClassMethodsWthActionTypes(test as any, keys)
+      expect(spyGetMetadata).toBeCalledTimes(2)
+      expect(methodsWithActionTypes.length).toBe(2)
+      const [methodWithActionTypes1, methodWithActionTypes2] = methodsWithActionTypes
+      expect(methodWithActionTypes1.actionType).toBe(Action1.type)
+      expect(methodWithActionTypes1.method).toBe(mockAddImmerIfNeededResPure)
+      expect(methodWithActionTypes2.actionType).toBe(Action2.type)
+      expect(methodWithActionTypes2.method).toBe(mockAddImmerIfNeededResImmer)
+    })
     test('throws if no actions passed', () => {
       class Test extends ReducerClass<undefined> {
         public initialState = undefined
@@ -65,6 +104,25 @@ describe(ReducerClassHelpers.name, () => {
         MetadataActionMissingError,
       )
     })
+    test("doesn't throw on methods prefixed with '_' if no actions passed", () => {
+      class Test extends ReducerClass<undefined> {
+        public initialState = undefined
+        public _test3() {
+          return undefined
+        }
+        protected _test2() {
+          return undefined
+        }
+
+        // @ts-ignore
+        private _test() {
+          return undefined
+        }
+      }
+      const test = new Test()
+      const keys = reducerClassHelpers.getClassInstanceMethodNames(test)
+      expect(keys).toEqual([])
+    })
   })
 
   describe(ReducerClassHelpers.prototype.getReducerMap.name, () => {

src/reducer-class-helpers.ts

@@ -1,8 +1,9 @@
 import { produce } from 'immer'
 import { DeepReadonlyArray, DeepReadonlyObject } from 'typelevel-ts'
 
-import { METADATA_KEY_ACTION } from './constants'
+import { METADATA_KEY_ACTION, PREFIX_OMIT_METHOD } from './constants'
 import { MetadataActionMissingError } from './errors'
+import { ReducerClass } from './reducer-class'
 
 export type Immutable<T> = T extends object ? DeepReadonlyObject<T> : T extends any[] ? DeepReadonlyArray<T> : T
 export interface IReducerMap<T> {
@@ -65,8 +66,14 @@ export class ReducerClassHelpers {
       return accum
     }, {})
   }
-  public getClassInstanceMethodNames(obj: object) {
+  public getClassInstanceMethodNames(obj: object): string[] {
     const proto = Object.getPrototypeOf(obj)
-    return Object.getOwnPropertyNames(proto).filter((name) => name !== 'constructor')
+    if (!(proto instanceof ReducerClass)) {
+      return []
+    }
+    const protoMethodNames = Object.getOwnPropertyNames(proto).filter(
+      (name) => name !== 'constructor' && !name.startsWith(PREFIX_OMIT_METHOD),
+    )
+    return [...this.getClassInstanceMethodNames(proto), ...protoMethodNames]
   }
 }

src/reducer-class.test.ts

@@ -47,4 +47,38 @@ describe(ReducerClass.name, () => {
       sum: 20,
     })
   })
+  test('can be inherited', () => {
+    interface ITestState {
+      sum: number
+    }
+    class Action1 extends ActionStandard {}
+    class Test extends ReducerClass<ITestState> {
+      public initialState = { sum: 10 }
+
+      @Action
+      public test1(state: ITestState, action: Action1) {
+        return this._sum(state)
+      }
+
+      protected _sum(state: ITestState): ITestState {
+        return {
+          sum: state.sum + 1,
+        }
+      }
+    }
+
+    class TestChild extends Test {
+      protected _sum(state: ITestState): ITestState {
+        return {
+          sum: state.sum + 100,
+        }
+      }
+    }
+
+    const testReducer = TestChild.create()
+    const res11 = testReducer(undefined, new Action1())
+    expect(res11).toEqual({
+      sum: 110,
+    })
+  })
 })