feat(schematics): add support for minimal setup option for store and effects

Author: brandonroberts

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

@@ -48,6 +48,12 @@
       "default": false,
       "description": "Group effects file within 'effects' folder",
       "aliases": ["g"]
+    },
+    "minimal": {
+      "type": "boolean",
+      "default": false,
+      "description":
+        "Setup root effects module without registering initial effects."
     }
   },
   "required": []

modules/schematics/src/effect/index.spec.ts

@@ -126,6 +126,39 @@ describe('Effect Schematic', () => {
     expect(content).toMatch(/EffectsModule\.forRoot\(\[FooEffects\]\)/);
   });
 
+  it('should register the root effect module without effect with the minimal flag', () => {
+    const options = {
+      ...defaultOptions,
+      root: true,
+      name: undefined,
+      module: 'app.module.ts',
+      minimal: true,
+    };
+
+    const tree = schematicRunner.runSchematic('effect', options, appTree);
+    const content = tree.readContent(`${projectPath}/src/app/app.module.ts`);
+
+    expect(content).toMatch(/EffectsModule\.forRoot\(\[\]\)/);
+    expect(content).not.toMatch(/FooEffects/);
+  });
+
+  it('should still register the feature effect module with an effect with the minimal flag', () => {
+    const options = {
+      ...defaultOptions,
+      root: false,
+      module: 'app.module.ts',
+      minimal: true,
+    };
+
+    const tree = schematicRunner.runSchematic('effect', options, appTree);
+    const content = tree.readContent(`${projectPath}/src/app/app.module.ts`);
+
+    expect(content).toMatch(/EffectsModule\.forFeature\(\[FooEffects\]\)/);
+    expect(
+      tree.files.indexOf(`${projectPath}/src/app/foo/foo.effects.ts`)
+    ).toBeGreaterThanOrEqual(0);
+  });
+
   it('should register the feature effect in the provided module', () => {
     const options = { ...defaultOptions, module: 'app.module.ts' };
 

modules/schematics/src/effect/index.ts

@@ -11,7 +11,6 @@ import {
   mergeWith,
   move,
   noop,
-  template,
   url,
 } from '@angular-devkit/schematics';
 import {
@@ -74,13 +73,22 @@ function addImportToNgModule(options: EffectOptions): Rule {
       effectsName,
       relativePath
     );
+
+    const effectsSetup =
+      options.root && options.minimal ? `[]` : `[${effectsName}]`;
     const [effectsNgModuleImport] = addImportToModule(
       source,
       modulePath,
-      `EffectsModule.for${options.root ? 'Root' : 'Feature'}([${effectsName}])`,
+      `EffectsModule.for${options.root ? 'Root' : 'Feature'}(${effectsSetup})`,
       relativePath
     );
-    const changes = [effectsModuleImport, effectsImport, effectsNgModuleImport];
+
+    let changes = [effectsModuleImport, effectsNgModuleImport];
+
+    if (!options.root || (options.root && !options.minimal)) {
+      changes = changes.concat([effectsImport]);
+    }
+
     const recorder = host.beginUpdate(modulePath);
     for (const change of changes) {
       if (change instanceof InsertChange) {
@@ -116,14 +124,15 @@ export default function(options: EffectOptions): Rule {
       options.module = findModuleFromOptions(host, options);
     }
 
-    const parsedPath = parseName(options.path, options.name);
+    const parsedPath = parseName(options.path, options.name || '');
     options.name = parsedPath.name;
     options.path = parsedPath.path;
 
     const templateSource = apply(url('./files'), [
       options.spec
         ? noop()
         : filter(path => !path.endsWith('.spec.ts.template')),
+      options.root && options.minimal ? filter(_ => false) : noop(),
       applyTemplates({
         ...stringUtils,
         'if-flat': (s: string) =>

modules/schematics/src/effect/schema.json

@@ -70,6 +70,12 @@
       "description":
         "Specifies whether to use creator functions for handling actions, reducers, and effects.",
       "aliases": ["c"]
+    },
+    "minimal": {
+      "type": "boolean",
+      "default": false,
+      "description":
+        "Setup root effects module without registering initial effects."
     }
   },
   "required": []

modules/schematics/src/effect/schema.ts

@@ -54,4 +54,9 @@ export interface Schema {
    * handling actions, reducers, and effects.
    */
   creators?: boolean;
+
+  /**
+   * Setup root effects module without registering initial effects.
+   */
+  minimal?: boolean;
 }

modules/schematics/src/store/index.spec.ts

@@ -45,6 +45,48 @@ describe('Store Schematic', () => {
     ).toBeGreaterThanOrEqual(0);
   });
 
+  it('should skip the initial store setup files if the minimal flag is provided', async () => {
+    const options = {
+      ...defaultOptions,
+      module: 'app.module.ts',
+      minimal: true,
+    };
+
+    const tree = await schematicRunner
+      .runSchematicAsync('store', options, appTree)
+      .toPromise();
+    const content = tree.readContent(`${projectPath}/src/app/app.module.ts`);
+    const files = tree.files;
+
+    expect(content).not.toMatch(
+      /import { reducers, metaReducers } from '\.\/reducers';/
+    );
+    expect(content).toMatch(/StoreModule.forRoot\({}/);
+
+    expect(files.indexOf(`${projectPath}/src/app/reducers/index.ts`)).toBe(-1);
+  });
+
+  it('should not skip the initial store setup files if the minimal flag is provided with a feature', async () => {
+    const options = {
+      ...defaultOptions,
+      root: false,
+      module: 'app.module.ts',
+      minimal: true,
+    };
+
+    const tree = await schematicRunner
+      .runSchematicAsync('store', options, appTree)
+      .toPromise();
+    const content = tree.readContent(`${projectPath}/src/app/app.module.ts`);
+
+    expect(content).toMatch(
+      /StoreModule\.forFeature\('foo', fromFoo\.reducers, { metaReducers: fromFoo.metaReducers }\)/
+    );
+    expect(
+      tree.files.indexOf(`${projectPath}/src/app/reducers/index.ts`)
+    ).toBeGreaterThanOrEqual(0);
+  });
+
   it('should create the initial store to specified project if provided', () => {
     const options = {
       ...defaultOptions,
@@ -154,6 +196,7 @@ describe('Store Schematic', () => {
 
     const tree = schematicRunner.runSchematic('store', options, appTree);
     const content = tree.readContent(`${projectPath}/src/app/app.module.ts`);
+
     expect(content).toMatch(
       /StoreModule\.forFeature\('foo', fromFoo\.reducers, { metaReducers: fromFoo.metaReducers }\)/
     );
@@ -244,7 +287,7 @@ describe('Store Schematic', () => {
 
     const tree = schematicRunner.runSchematic('store', options, appTree);
     const content = tree.readContent(`${projectPath}/src/app/app.module.ts`);
-    expect(content).toMatch(/, runtimeChecks: {/);
+    expect(content).toMatch(/runtimeChecks: {/);
     expect(content).toMatch(/strictStateImmutability: true,/);
     expect(content).toMatch(/strictActionImmutability: true/);
   });

modules/schematics/src/store/index.ts

@@ -11,6 +11,8 @@ import {
   template,
   url,
   move,
+  filter,
+  noop,
 } from '@angular-devkit/schematics';
 import { Path, dirname } from '@angular-devkit/core';
 import * as ts from 'typescript';
@@ -61,16 +63,25 @@ function addImportToNgModule(options: StoreOptions): Rule {
       `${options.path}/environments/environment`
     );
 
-    const runtimeChecks = `runtimeChecks: {
+    const runtimeChecks = `
+      runtimeChecks: {
         strictStateImmutability: true,
         strictActionImmutability: true,
-    }`;
+      }
+   `;
+
+    const rootStoreReducers = options.minimal ? `{}` : `reducers`;
+
+    const rootStoreConfig = options.minimal
+      ? `{ ${runtimeChecks} }`
+      : `{
+      metaReducers, ${runtimeChecks} }`;
 
     const storeNgModuleImport = addImportToModule(
       source,
       modulePath,
       options.root
-        ? `StoreModule.forRoot(reducers, { metaReducers, ${runtimeChecks} })`
+        ? `StoreModule.forRoot(${rootStoreReducers}, ${rootStoreConfig})`
         : `StoreModule.forFeature('${stringUtils.camelize(
             options.name
           )}', from${stringUtils.classify(
@@ -83,22 +94,30 @@ function addImportToNgModule(options: StoreOptions): Rule {
 
     let commonImports = [
       insertImport(source, modulePath, 'StoreModule', '@ngrx/store'),
-      options.root
-        ? insertImport(
-            source,
-            modulePath,
-            'reducers, metaReducers',
-            relativePath
-          )
-        : insertImport(
-            source,
-            modulePath,
-            `* as from${stringUtils.classify(options.name)}`,
-            relativePath,
-            true
-          ),
       storeNgModuleImport,
     ];
+
+    if (options.root && !options.minimal) {
+      commonImports = commonImports.concat([
+        insertImport(
+          source,
+          modulePath,
+          'reducers, metaReducers',
+          relativePath
+        ),
+      ]);
+    } else if (!options.root) {
+      commonImports = commonImports.concat([
+        insertImport(
+          source,
+          modulePath,
+          `* as from${stringUtils.classify(options.name)}`,
+          relativePath,
+          true
+        ),
+      ]);
+    }
+
     let rootImports: (Change | undefined)[] = [];
 
     if (options.root) {
@@ -166,6 +185,7 @@ export default function(options: StoreOptions): Rule {
     }
 
     const templateSource = apply(url('./files'), [
+      options.root && options.minimal ? filter(_ => false) : noop(),
       applyTemplates({
         ...stringUtils,
         ...(options as object),

modules/schematics/src/store/schema.json

@@ -54,6 +54,12 @@
       "default": "State",
       "description": "Specifies the interface for the state.",
       "alias": "si"
+    },
+    "minimal": {
+      "type": "boolean",
+      "default": false,
+      "description":
+        "Setup root state management without registering initial reducers."
     }
   },
   "required": []

modules/schematics/src/store/schema.ts

@@ -39,4 +39,8 @@ export interface Schema {
    * Specifies the interface for the state
    */
   stateInterface?: string;
+  /**
+   * Setup state management without registering initial reducers.
+   */
+  minimal?: boolean;
 }