feat(store): add runtime check for action type uniqueness

modules/effects/spec/types/utils.ts

@@ -1,6 +1,6 @@
 export const compilerOptions = () => ({
   moduleResolution: 'node',
-  target: 'es2015',
+  target: 'es2017',
   baseUrl: '.',
   experimentalDecorators: true,
   paths: {

modules/router-store/spec/types/utils.ts

@@ -1,6 +1,6 @@
 export const compilerOptions = () => ({
   moduleResolution: 'node',
-  target: 'es2015',
+  target: 'es2017',
   baseUrl: '.',
   experimentalDecorators: true,
   paths: {

modules/store/spec/runtime_checks.spec.ts

@@ -1,9 +1,19 @@
 import * as ngCore from '@angular/core';
 import { TestBed, fakeAsync, flush } from '@angular/core/testing';
-import { Store, StoreModule, META_REDUCERS, USER_RUNTIME_CHECKS } from '..';
+import {
+  Store,
+  StoreModule,
+  META_REDUCERS,
+  USER_RUNTIME_CHECKS,
+  createAction,
+} from '..';
 import { createActiveRuntimeChecks } from '../src/runtime_checks';
 import { RuntimeChecks, Action } from '../src/models';
 import * as metaReducers from '../src/meta-reducers';
+import {
+  REGISTERED_ACTION_TYPES,
+  resetRegisteredActionTypes,
+} from '../src/globals';
 
 describe('Runtime checks:', () => {
   describe('createActiveRuntimeChecks:', () => {
@@ -14,6 +24,7 @@ describe('Runtime checks:', () => {
         strictActionImmutability: true,
         strictStateImmutability: true,
         strictActionWithinNgZone: false,
+        strictActionTypeUniqueness: false,
       });
     });
 
@@ -25,13 +36,15 @@ describe('Runtime checks:', () => {
           strictActionImmutability: false,
           strictStateImmutability: false,
           strictActionWithinNgZone: true,
+          strictActionTypeUniqueness: true,
         })
       ).toEqual({
         strictStateSerializability: true,
         strictActionSerializability: true,
         strictActionImmutability: false,
         strictStateImmutability: false,
         strictActionWithinNgZone: true,
+        strictActionTypeUniqueness: true,
       });
     });
 
@@ -44,6 +57,7 @@ describe('Runtime checks:', () => {
         strictActionImmutability: false,
         strictStateImmutability: false,
         strictActionWithinNgZone: false,
+        strictActionTypeUniqueness: false,
       });
     });
 
@@ -55,13 +69,15 @@ describe('Runtime checks:', () => {
           strictStateSerializability: true,
           strictActionSerializability: true,
           strictActionWithinNgZone: true,
+          strictActionTypeUniqueness: true,
         })
       ).toEqual({
         strictStateSerializability: false,
         strictActionSerializability: false,
         strictActionImmutability: false,
         strictStateImmutability: false,
         strictActionWithinNgZone: false,
+        strictActionTypeUniqueness: false,
       });
     });
   });
@@ -384,6 +400,39 @@ describe('Runtime checks:', () => {
   });
 });
 
+describe('ActionType uniqueness', () => {
+  beforeEach(() => {
+    resetRegisteredActionTypes();
+  });
+
+  it('should throw when having no duplicate action types', () => {
+    createAction('action 1');
+    createAction('action 1');
+
+    expect(() => {
+      setupStore({ strictActionTypeUniqueness: true });
+    }).toThrowError(/Action types are registered more than once/);
+  });
+
+  it('should not throw when having no duplicate action types', () => {
+    createAction('action 1');
+    createAction('action 2');
+
+    expect(() => {
+      setupStore({ strictActionTypeUniqueness: true });
+    }).not.toThrowError();
+  });
+
+  it('should not throw when disabled', () => {
+    createAction('action 1');
+    createAction('action 1');
+
+    expect(() => {
+      setupStore({ strictActionTypeUniqueness: false });
+    }).not.toThrowError();
+  });
+});
+
 function setupStore(runtimeChecks?: Partial<RuntimeChecks>): Store<any> {
   TestBed.configureTestingModule({
     imports: [

modules/store/spec/types/utils.ts

@@ -1,6 +1,6 @@
 export const compilerOptions = () => ({
   moduleResolution: 'node',
-  target: 'es2015',
+  target: 'es2017',
   baseUrl: '.',
   experimentalDecorators: true,
   paths: {

modules/store/src/action_creator.ts

@@ -6,6 +6,7 @@ import {
   NotAllowedCheck,
   Props,
 } from './models';
+import { REGISTERED_ACTION_TYPES } from './globals';
 
 // Action creators taken from ts-action library and modified a bit to better
 // fit current NgRx usage. Thank you Nicholas Jamieson (@cartant).
@@ -101,6 +102,8 @@ export function createAction<T extends string, C extends Creator>(
   type: T,
   config?: { _as: 'props' } | C
 ): ActionCreator<T> {
+  REGISTERED_ACTION_TYPES[type] = (REGISTERED_ACTION_TYPES[type] || 0) + 1;
+
   if (typeof config === 'function') {
     return defineType(type, (...args: any[]) => ({
       ...config(...args),

modules/store/src/globals.ts

@@ -0,0 +1,5 @@
+export let REGISTERED_ACTION_TYPES: { [actionType: string]: number } = {};
+
+export function resetRegisteredActionTypes() {
+  REGISTERED_ACTION_TYPES = {};
+}

modules/store/src/models.ts

@@ -120,4 +120,9 @@ export interface RuntimeChecks {
    * Verifies that actions are dispatched within NgZone
    */
   strictActionWithinNgZone: boolean;
+
+  /**
+   * Verifies that action types are not registered more than once
+   */
+  strictActionTypeUniqueness: boolean;
 }

modules/store/src/runtime_checks.ts

@@ -10,7 +10,10 @@ import {
   _ACTIVE_RUNTIME_CHECKS,
   META_REDUCERS,
   USER_RUNTIME_CHECKS,
+  _ACTION_TYPE_UNIQUENESS_CHECK,
 } from './tokens';
+import { REGISTERED_ACTION_TYPES } from './globals';
+import { RUNTIME_CHECK_URL } from './meta-reducers/utils';
 
 export function createActiveRuntimeChecks(
   runtimeChecks?: Partial<RuntimeChecks>
@@ -22,6 +25,7 @@ export function createActiveRuntimeChecks(
       strictStateImmutability: true,
       strictActionImmutability: true,
       strictActionWithinNgZone: false,
+      strictActionTypeUniqueness: false,
       ...runtimeChecks,
     };
   }
@@ -32,6 +36,7 @@ export function createActiveRuntimeChecks(
     strictStateImmutability: false,
     strictActionImmutability: false,
     strictActionWithinNgZone: false,
+    strictActionTypeUniqueness: false,
   };
 }
 
@@ -118,8 +123,37 @@ export function provideRuntimeChecks(
   ];
 }
 
+export function checkForActionTypeUniqueness(): Provider[] {
+  return [
+    {
+      provide: _ACTION_TYPE_UNIQUENESS_CHECK,
+      multi: true,
+      deps: [_ACTIVE_RUNTIME_CHECKS],
+      useFactory: _actionTypeUniquenessCheck,
+    },
+  ];
+}
+
 export function _runtimeChecksFactory(
   runtimeChecks: RuntimeChecks
 ): RuntimeChecks {
   return runtimeChecks;
 }
+
+export function _actionTypeUniquenessCheck(config: RuntimeChecks) {
+  if (!config.strictActionTypeUniqueness) {
+    return;
+  }
+
+  const duplicates = Object.entries(REGISTERED_ACTION_TYPES)
+    .filter(([_type, registrations]) => registrations > 1)
+    .map(([type]) => type);
+
+  if (duplicates.length) {
+    throw new Error(
+      `Action types are registered more than once, ${duplicates
+        .map(type => `"${type}"`)
+        .join(', ')}. ${RUNTIME_CHECK_URL}#strictactiontypeuniqueness`
+    );
+  }
+}

modules/store/src/store_module.ts

@@ -37,6 +37,8 @@ import {
   USER_PROVIDED_META_REDUCERS,
   _RESOLVED_META_REDUCERS,
   _ROOT_STORE_GUARD,
+  _ACTIVE_RUNTIME_CHECKS,
+  _ACTION_TYPE_UNIQUENESS_CHECK,
 } from './tokens';
 import { ACTIONS_SUBJECT_PROVIDERS, ActionsSubject } from './actions_subject';
 import {
@@ -50,7 +52,10 @@ import {
 } from './scanned_actions_subject';
 import { STATE_PROVIDERS } from './state';
 import { STORE_PROVIDERS, Store } from './store';
-import { provideRuntimeChecks } from './runtime_checks';
+import {
+  provideRuntimeChecks,
+  checkForActionTypeUniqueness,
+} from './runtime_checks';
 
 @NgModule({})
 export class StoreRootModule {
@@ -61,7 +66,10 @@ export class StoreRootModule {
     store: Store<any>,
     @Optional()
     @Inject(_ROOT_STORE_GUARD)
-    guard: any
+    guard: any,
+    @Optional()
+    @Inject(_ACTION_TYPE_UNIQUENESS_CHECK)
+    actionCheck: any
   ) {}
 }
 
@@ -71,7 +79,10 @@ export class StoreFeatureModule implements OnDestroy {
     @Inject(_STORE_FEATURES) private features: StoreFeature<any, any>[],
     @Inject(FEATURE_REDUCERS) private featureReducers: ActionReducerMap<any>[],
     private reducerManager: ReducerManager,
-    root: StoreRootModule
+    root: StoreRootModule,
+    @Optional()
+    @Inject(_ACTION_TYPE_UNIQUENESS_CHECK)
+    actionCheck: any
   ) {
     const feats = features.map((feature, index) => {
       const featureReducerCollection = featureReducers.shift();
@@ -166,6 +177,7 @@ export class StoreModule {
         STATE_PROVIDERS,
         STORE_PROVIDERS,
         provideRuntimeChecks(config.runtimeChecks),
+        checkForActionTypeUniqueness(),
       ],
     };
   }
@@ -238,6 +250,7 @@ export class StoreModule {
           ],
           useFactory: _createFeatureReducers,
         },
+        checkForActionTypeUniqueness(),
       ],
     };
   }

modules/store/src/tokens.ts

@@ -86,3 +86,7 @@ export const _USER_RUNTIME_CHECKS = new InjectionToken<RuntimeChecks>(
 export const _ACTIVE_RUNTIME_CHECKS = new InjectionToken<RuntimeChecks>(
   '@ngrx/store Internal Runtime Checks'
 );
+
+export const _ACTION_TYPE_UNIQUENESS_CHECK = new InjectionToken<void>(
+  '@ngrx/store Check if Action types are unique'
+);

projects/example-app/src/app/app.module.ts

@@ -41,6 +41,7 @@ import { AppComponent } from '@example-app/core/containers';
         strictStateSerializability: true,
         strictActionSerializability: true,
         strictActionWithinNgZone: true,
+        strictActionTypeUniqueness: true,
       },
     }),