Merge branch 'master' of https://github.com/ngrx/platform

refactor(effects): refactor types in effects, expose metadata key for createEffect

refactor(example): close sidenav when logoutConfirmation is dispatched (ngrx#2189)

Closes ngrx#2186

docs: remove github link from navigation (ngrx#2188)

Closes ngrx#2185

feat(schematics): add message prompts for individual schematics (ngrx#2143)

test(store): fix flaky integration test (ngrx#2209)

Author: Jordan Powell

modules/data/schematics/ng-add/files/entity-metadata.ts.template

@@ -0,0 +1,10 @@
+import { EntityMetadataMap, EntityDataModuleConfig } from '@ngrx/data';
+
+const entityMetadata: EntityMetadataMap = {};
+
+const pluralNames = {  };
+
+export const entityConfig: EntityDataModuleConfig = {
+  entityMetadata,
+  pluralNames
+};

modules/data/schematics/ng-add/index.spec.ts

@@ -68,11 +68,45 @@ describe('Data ng-add Schematic', () => {
     expect(thrownError).toBeDefined();
   });
 
+  it('should add entity-metadata config to EntityDataModule', () => {
+    const options = { ...defaultOptions, effects: false, entityConfig: true };
+
+    const tree = schematicRunner.runSchematic('ng-add', options, appTree);
+    const content = tree.readContent(`${projectPath}/src/app/app.module.ts`);
+    expect(content).toMatch(
+      /import { entityConfig } from '.\/entity-metadata'/
+    );
+    expect(content).toMatch(
+      /EntityDataModuleWithoutEffects.forRoot\(entityConfig\)/
+    );
+  });
+
+  it('should add entity-metadata config file', () => {
+    const options = { ...defaultOptions, entityConfig: true };
+
+    const tree = schematicRunner.runSchematic('ng-add', options, appTree);
+    expect(
+      tree.files.indexOf(`${projectPath}/src/app/entity-metadata.ts`)
+    ).toBeGreaterThanOrEqual(0);
+  });
+
+  it('should add entity-metadata config to EntityDataModule', () => {
+    const options = { ...defaultOptions, entityConfig: true };
+
+    const tree = schematicRunner.runSchematic('ng-add', options, appTree);
+    const content = tree.readContent(`${projectPath}/src/app/app.module.ts`);
+    expect(content).toMatch(
+      /import { entityConfig } from '.\/entity-metadata'/
+    );
+    expect(content).toMatch(/EntityDataModule.forRoot\(entityConfig\)/);
+  });
+
   it('should import EntityDataModuleWithoutEffects into a specified module', () => {
     const options = {
       ...defaultOptions,
       module: 'app.module.ts',
       effects: false,
+      entityConfig: false,
     };
 
     const tree = schematicRunner.runSchematic('ng-add', options, appTree);
@@ -83,15 +117,15 @@ describe('Data ng-add Schematic', () => {
   });
 
   it('should register EntityDataModule in the provided module', () => {
-    const options = { ...defaultOptions };
+    const options = { ...defaultOptions, entityConfig: false };
 
     const tree = schematicRunner.runSchematic('ng-add', options, appTree);
     const content = tree.readContent(`${projectPath}/src/app/app.module.ts`);
     expect(content).toMatch(/EntityDataModule\n/);
   });
 
   it('should register EntityDataModuleWithoutEffects in the provided module', () => {
-    const options = { ...defaultOptions, effects: false };
+    const options = { ...defaultOptions, effects: false, entityConfig: false };
 
     const tree = schematicRunner.runSchematic('ng-add', options, appTree);
     const content = tree.readContent(`${projectPath}/src/app/app.module.ts`);

modules/data/schematics/ng-add/index.ts

@@ -1,26 +1,33 @@
-import * as ts from 'typescript';
+import { Path } from '@angular-devkit/core';
 import {
-  Rule,
-  SchematicContext,
-  Tree,
+  apply,
+  applyTemplates,
   chain,
+  mergeWith,
+  move,
   noop,
+  Rule,
+  SchematicContext,
   SchematicsException,
+  Tree,
+  url,
 } from '@angular-devkit/schematics';
 import { NodePackageInstallTask } from '@angular-devkit/schematics/tasks';
 import {
+  addImportToModule,
   addPackageToPackageJson,
-  platformVersion,
+  commitChanges,
+  createReplaceChange,
   findModuleFromOptions,
-  insertImport,
   getProjectPath,
+  insertImport,
   parseName,
-  addImportToModule,
-  createReplaceChange,
+  platformVersion,
   ReplaceChange,
+  stringUtils,
   visitTSSourceFiles,
-  commitChanges,
 } from '@ngrx/data/schematics-core';
+import * as ts from 'typescript';
 import { Schema as EntityDataOptions } from './schema';
 
 function addNgRxDataToPackageJson() {
@@ -53,6 +60,7 @@ function addEntityDataToNgModule(options: EntityDataOptions): Rule {
     const moduleToImport = options.effects
       ? 'EntityDataModule'
       : 'EntityDataModuleWithoutEffects';
+
     const effectsModuleImport = insertImport(
       source,
       modulePath,
@@ -63,11 +71,24 @@ function addEntityDataToNgModule(options: EntityDataOptions): Rule {
     const [dateEntityNgModuleImport] = addImportToModule(
       source,
       modulePath,
-      moduleToImport,
+      options.entityConfig
+        ? [moduleToImport, 'forRoot(entityConfig)'].join('.')
+        : moduleToImport,
       ''
     );
 
     const changes = [effectsModuleImport, dateEntityNgModuleImport];
+
+    if (options.entityConfig) {
+      const entityConfigImport = insertImport(
+        source,
+        modulePath,
+        'entityConfig',
+        './entity-metadata'
+      );
+      changes.push(entityConfigImport);
+    }
+
     commitChanges(host, source.fileName, changes);
 
     return host;
@@ -248,6 +269,18 @@ function throwIfModuleNotSpecified(host: Tree, module?: string) {
   }
 }
 
+function createEntityConfigFile(options: EntityDataOptions, path: Path) {
+  return mergeWith(
+    apply(url('./files'), [
+      applyTemplates({
+        ...stringUtils,
+        ...options,
+      }),
+      move(path),
+    ])
+  );
+}
+
 export default function(options: EntityDataOptions): Rule {
   return (host: Tree, context: SchematicContext) => {
     (options as any).name = '';
@@ -268,6 +301,9 @@ export default function(options: EntityDataOptions): Rule {
             renameNgrxDataModule(),
           ])
         : addEntityDataToNgModule(options),
+      options.entityConfig
+        ? createEntityConfigFile(options, parsedPath.path)
+        : noop(),
     ])(host, context);
   };
 }

modules/data/schematics/ng-add/schema.json

@@ -39,6 +39,11 @@
       "default": false,
       "description": "Migrate from ngrx-data, will rename modules.",
       "alias": "migrate"
+    },
+    "entityConfig": {
+      "type": "boolean",
+      "default": true,
+      "description": "Create the Entity config file"
     }
   },
   "required": []

modules/data/schematics/ng-add/schema.ts

@@ -5,4 +5,5 @@ export interface Schema {
   project?: string;
   module?: string;
   migrateNgrxData?: boolean;
+  entityConfig?: boolean;
 }

modules/effects/spec/effect_creator.spec.ts

@@ -9,15 +9,15 @@ describe('createEffect()', () => {
   });
 
   it('should dispatch by default', () => {
-    const effect: any = createEffect(() => of({ type: 'a' }));
+    const effect = createEffect(() => of({ type: 'a' }));
 
     expect(effect['__@ngrx/effects_create__']).toEqual(
       jasmine.objectContaining({ dispatch: true })
     );
   });
 
   it('should be possible to explicitly create a dispatching effect', () => {
-    const effect: any = createEffect(() => of({ type: 'a' }), {
+    const effect = createEffect(() => of({ type: 'a' }), {
       dispatch: true,
     });
 
@@ -27,7 +27,7 @@ describe('createEffect()', () => {
   });
 
   it('should be possible to create a non-dispatching effect', () => {
-    const effect: any = createEffect(() => of({ type: 'a' }), {
+    const effect = createEffect(() => of({ someProp: 'a' }), {
       dispatch: false,
     });
 
@@ -37,7 +37,7 @@ describe('createEffect()', () => {
   });
 
   it('should be possible to create a non-dispatching effect returning a non-action', () => {
-    const effect: any = createEffect(() => of('foo'), {
+    const effect = createEffect(() => of('foo'), {
       dispatch: false,
     });
 

modules/effects/src/effect_creator.ts

@@ -1,9 +1,13 @@
 import { Observable } from 'rxjs';
 import { Action } from '@ngrx/store';
-import { EffectMetadata, EffectConfig } from './models';
+import { EffectMetadata, EffectConfig, DEFAULT_EFFECT_CONFIG } from './models';
 
 const CREATE_EFFECT_METADATA_KEY = '__@ngrx/effects_create__';
 
+interface CreateEffectMetadata {
+  [CREATE_EFFECT_METADATA_KEY]: EffectConfig;
+}
+
 type DispatchType<T> = T extends { dispatch: infer U } ? U : unknown;
 type ObservableReturnType<T> = T extends false
   ? Observable<unknown>
@@ -45,27 +49,22 @@ export function createEffect<
   T extends DispatchType<C>,
   O extends ObservableReturnType<T>,
   R extends O | ((...args: any[]) => O)
->(source: () => R, config?: Partial<C>): R {
+>(source: () => R, config?: Partial<C>): R & CreateEffectMetadata {
   const effect = source();
-  // Right now both createEffect and @Effect decorator set default values.
-  // Ideally that should only be done in one place that aggregates that info,
-  // for example in mergeEffects().
   const value: EffectConfig = {
-    dispatch: true,
-    resubscribeOnError: true,
+    ...DEFAULT_EFFECT_CONFIG,
     ...config, // Overrides any defaults if values are provided
   };
   Object.defineProperty(effect, CREATE_EFFECT_METADATA_KEY, {
     value,
   });
-  return effect;
+  return effect as typeof effect & CreateEffectMetadata;
 }
 
-export function getCreateEffectMetadata<T>(instance: T): EffectMetadata<T>[] {
-  const propertyNames = Object.getOwnPropertyNames(instance) as Extract<
-    keyof T,
-    string
-  >[];
+export function getCreateEffectMetadata<
+  T extends { [props in keyof T]: Object }
+>(instance: T): EffectMetadata<T>[] {
+  const propertyNames = Object.getOwnPropertyNames(instance) as Array<keyof T>;
 
   const metadata: EffectMetadata<T>[] = propertyNames
     .filter(

modules/effects/src/effect_decorator.ts

@@ -1,27 +1,27 @@
 import { compose } from '@ngrx/store';
-import { EffectMetadata, EffectConfig } from './models';
+
+import {
+  DEFAULT_EFFECT_CONFIG,
+  EffectConfig,
+  EffectMetadata,
+  EffectPropertyKey,
+} from './models';
 import { getSourceForInstance } from './utils';
 
 const METADATA_KEY = '__@ngrx/effects__';
 
-export function Effect<T>({
-  dispatch = true,
-  resubscribeOnError = true,
-}: EffectConfig = {}): PropertyDecorator {
-  return function<K extends Extract<keyof T, string>>(
+export function Effect(config: EffectConfig = {}) {
+  return function<T extends Object, K extends EffectPropertyKey<T>>(
     target: T,
     propertyName: K
   ) {
-    // Right now both createEffect and @Effect decorator set default values.
-    // Ideally that should only be done in one place that aggregates that info,
-    // for example in mergeEffects().
     const metadata: EffectMetadata<T> = {
+      ...DEFAULT_EFFECT_CONFIG,
+      ...config, // Overrides any defaults if values are provided
       propertyName,
-      dispatch,
-      resubscribeOnError,
     };
-    setEffectMetadataEntries<T>(target, [metadata]);
-  } as (target: {}, propertyName: string | symbol) => void;
+    addEffectMetadataEntry<T>(target, metadata);
+  };
 }
 
 export function getEffectDecoratorMetadata<T>(
@@ -35,23 +35,38 @@ export function getEffectDecoratorMetadata<T>(
   return effectsDecorators;
 }
 
-function setEffectMetadataEntries<T>(
+/**
+ * Type guard to detemine whether METADATA_KEY is already present on the Class
+ * constructor
+ */
+function hasMetadataEntries<T extends Object>(
+  sourceProto: T
+): sourceProto is typeof sourceProto & {
+  constructor: typeof sourceProto.constructor & {
+    [METADATA_KEY]: EffectMetadata<T>[];
+  };
+} {
+  return sourceProto.constructor.hasOwnProperty(METADATA_KEY);
+}
+
+/** Add Effect Metadata to the Effect Class constructor under specific key */
+function addEffectMetadataEntry<T extends object>(
   sourceProto: T,
-  entries: EffectMetadata<T>[]
+  metadata: EffectMetadata<T>
 ) {
-  const constructor = sourceProto.constructor;
-  const meta: Array<EffectMetadata<T>> = constructor.hasOwnProperty(
-    METADATA_KEY
-  )
-    ? (constructor as any)[METADATA_KEY]
-    : Object.defineProperty(constructor, METADATA_KEY, { value: [] })[
-        METADATA_KEY
-      ];
-  Array.prototype.push.apply(meta, entries);
+  if (hasMetadataEntries(sourceProto)) {
+    sourceProto.constructor[METADATA_KEY].push(metadata);
+  } else {
+    Object.defineProperty(sourceProto.constructor, METADATA_KEY, {
+      value: [metadata],
+    });
+  }
 }
 
-function getEffectMetadataEntries<T>(sourceProto: T): EffectMetadata<T>[] {
-  return sourceProto.constructor.hasOwnProperty(METADATA_KEY)
-    ? (sourceProto.constructor as any)[METADATA_KEY]
+function getEffectMetadataEntries<T extends object>(
+  sourceProto: T
+): EffectMetadata<T>[] {
+  return hasMetadataEntries(sourceProto)
+    ? sourceProto.constructor[METADATA_KEY]
     : [];
 }

modules/effects/src/effect_notification.ts

@@ -4,7 +4,7 @@ import { Notification, Observable } from 'rxjs';
 
 export interface EffectNotification {
   effect: Observable<any> | (() => Observable<any>);
-  propertyName: string;
+  propertyName: PropertyKey;
   sourceName: string;
   sourceInstance: any;
   notification: Notification<Action | null | undefined>;
@@ -46,7 +46,7 @@ function getEffectName({
 }: EffectNotification) {
   const isMethod = typeof sourceInstance[propertyName] === 'function';
 
-  return `"${sourceName}.${propertyName}${isMethod ? '()' : ''}"`;
+  return `"${sourceName}.${String(propertyName)}${isMethod ? '()' : ''}"`;
 }
 
 function stringify(action: Action | null | undefined) {