feat(core): add injectable reducer factory (#4631)

Author: griest024

…e/state/src/reducers/create-meta.spec.ts …/core/state/src/reducers/compose.spec.tslibs/core/state/src/reducers/create-meta.spec.ts renamed to libs/core/state/src/reducers/compose.spec.ts libs/core/state/src/reducers/create-meta.spec.ts renamed to libs/core/state/src/reducers/compose.spec.ts

@@ -1,6 +1,6 @@
 import { ActionReducer } from '@ngrx/store';
 
-import { daffComposeReducers } from './create-meta';
+import { daffComposeReducers } from './compose';
 
 interface MockState {
   foo: string;

…s/core/state/src/reducers/create-meta.ts libs/core/state/src/reducers/compose.tslibs/core/state/src/reducers/create-meta.ts renamed to libs/core/state/src/reducers/compose.ts libs/core/state/src/reducers/create-meta.ts renamed to libs/core/state/src/reducers/compose.ts

@@ -0,0 +1,77 @@
+import { TestBed } from '@angular/core/testing';
+import {
+  ActionReducer,
+  MetaReducer,
+  StoreConfig,
+  StoreModule,
+} from '@ngrx/store';
+
+import { daffComposeReducers } from './compose';
+import { createInjectableReducersTokens } from './injectable-reducers.factory';
+import { InjectableReducersTokens } from './injectable-reducers.type';
+
+interface State {
+  test: string;
+}
+
+describe('@daffodil/core/state | createInjectableReducersTokens', () => {
+  let metaReducers: Array<MetaReducer<State>>;
+  let config: StoreConfig<State>;
+  let tokens: InjectableReducersTokens<State>;
+  let reducers: ActionReducer<State>;
+  let extraReducer: ActionReducer<State>;
+  let reducer: ActionReducer<State>;
+  let result: State;
+
+  beforeEach(() => {
+    const initialState: State = {
+      test: 'test',
+    };
+    extraReducer = (state, action) => ({
+      ...state,
+      test: `${state?.test} extra`,
+    });
+    metaReducers = [
+      r => r,
+      r => r,
+    ];
+    reducers = daffComposeReducers([
+      (state = initialState, action) => state,
+      (state = initialState, action) => state,
+    ]);
+    tokens = createInjectableReducersTokens<State>('TEST', () => reducers);
+
+    TestBed.configureTestingModule({
+      imports: [
+        StoreModule.forRoot(),
+        StoreModule.forFeature('test', tokens.reducers.token, tokens.config.token),
+      ],
+      providers: [
+        ...tokens.meta.provider(...metaReducers),
+        ...tokens.extra.provider(extraReducer),
+      ],
+    });
+
+    reducer = TestBed.inject(tokens.reducers.token);
+    config = TestBed.inject(tokens.config.token);
+    result = reducer(initialState, { type: '' });
+  });
+
+  it('should return the meta-reducers', () => {
+    expect(TestBed.inject(tokens.config.token).metaReducers).toEqual(jasmine.arrayContaining(metaReducers));
+  });
+
+  it('should run the extra reducer after the daffodil reducers', () => {
+    expect(result.test).toEqual('test extra');
+  });
+
+  it('should provide the extra reducers to the token', () => {
+    expect(TestBed.inject(tokens.extra.token)).toContain(extraReducer);
+  });
+
+  it('should provide the meta-reducers to the token', () => {
+    metaReducers.forEach(metaReducer => {
+      expect(TestBed.inject(tokens.meta.token)).toContain(metaReducer);
+    });
+  });
+});

libs/core/state/src/reducers/injectable-reducers.factory.spec.ts

@@ -0,0 +1,51 @@
+import {
+  inject,
+  Injector,
+  runInInjectionContext,
+} from '@angular/core';
+import {
+  ActionReducer,
+  MetaReducer,
+  StoreConfig,
+} from '@ngrx/store';
+
+import {
+  createMultiInjectionToken,
+  createSingleInjectionToken,
+} from '@daffodil/core';
+
+import { daffComposeReducers } from './compose';
+import { InjectableReducersTokens } from './injectable-reducers.type';
+
+export const createInjectableReducersTokens = <T>(
+  feature: string,
+  createReducers: () => ActionReducer<T>,
+): InjectableReducersTokens<T> => {
+  const extra = createMultiInjectionToken<ActionReducer<T>>(`${feature}_EXTRA_REDUCERS`);
+  const reducers = createSingleInjectionToken<ActionReducer<T>>(
+    `${feature}_REDUCERS`,
+    {
+      factory: () => daffComposeReducers([
+        runInInjectionContext(inject(Injector), createReducers),
+        ...inject(extra.token),
+      ]),
+    },
+  );
+  const meta = createMultiInjectionToken<MetaReducer<T>>(`${feature}_META_REDUCERS`);
+  const config = createSingleInjectionToken<StoreConfig<T>>(
+    `${feature}_STORE_CONFIG`,
+    {
+      providedIn: 'any',
+      factory: () => ({
+        metaReducers: inject(meta.token),
+      }),
+    },
+  );
+
+  return {
+    extra,
+    reducers,
+    meta,
+    config,
+  };
+};

libs/core/state/src/reducers/injectable-reducers.factory.ts

@@ -0,0 +1,17 @@
+import {
+  ActionReducer,
+  MetaReducer,
+  StoreConfig,
+} from '@ngrx/store';
+
+import {
+  DaffMultiInjectionToken,
+  DaffSingleInjectionToken,
+} from '@daffodil/core';
+
+export interface InjectableReducersTokens<T> {
+  extra: DaffMultiInjectionToken<ActionReducer<T>>;
+  reducers: DaffSingleInjectionToken<ActionReducer<T>>;
+  meta: DaffMultiInjectionToken<MetaReducer<T>>;
+  config: DaffSingleInjectionToken<StoreConfig<T>>;
+}

libs/core/state/src/reducers/injectable-reducers.type.ts

@@ -1,2 +1,4 @@
-export { daffComposeReducers } from './create-meta';
+export { daffComposeReducers } from './compose';
 export { daffIdentityReducer } from './identity';
+export { createInjectableReducersTokens } from './injectable-reducers.factory';
+export { InjectableReducersTokens } from './injectable-reducers.type';