feat(component): add migration for replacing ReactiveComponentModule

modules/component/migrations/14_1_0/index.spec.ts

@@ -0,0 +1,95 @@
+import { Tree } from '@angular-devkit/schematics';
+import {
+  SchematicTestRunner,
+  UnitTestTree,
+} from '@angular-devkit/schematics/testing';
+import * as path from 'path';
+import { createPackageJson } from '@ngrx/schematics-core/testing/create-package';
+import { waitForAsync } from '@angular/core/testing';
+
+describe('Component Store Migration 14_1_0', () => {
+  let appTree: UnitTestTree;
+  const collectionPath = path.join(__dirname, '../migration.json');
+  const pkgName = 'component';
+
+  beforeEach(() => {
+    appTree = new UnitTestTree(Tree.empty());
+    appTree.create(
+      '/tsconfig.json',
+      `
+        {
+          "include": [**./*.ts"]
+        }
+       `
+    );
+    createPackageJson('', pkgName, appTree);
+  });
+
+  describe('Replace ReactiveComponentModule', () => {
+    it(
+      `should replace the ReactiveComponentModule with LetModule and PushModule`,
+      waitForAsync(async () => {
+        const input = `
+      import { ReactiveComponentModule } from '@ngrx/component';
+
+      const reactiveComponentModule: ReactiveComponentModule;
+
+      @NgModule({
+        imports: [
+          AuthModule,
+          AppRoutingModule,
+          ReactiveComponentModule,
+          CoreModule,
+        ],
+        exports: [ReactiveComponentModule]
+        bootstrap: [AppComponent],
+      })
+      export class AppModule {}
+
+      @Component({
+        imports: [
+          AuthModule,
+          ReactiveComponentModule
+        ]
+      })
+      export class SomeStandaloneComponent {}
+    `;
+        const expected = `
+      import { LetModule, PushModule } from '@ngrx/component';
+
+      const reactiveComponentModule: ReactiveComponentModule;
+
+      @NgModule({
+        imports: [
+          AuthModule,
+          AppRoutingModule,
+          LetModule, PushModule,
+          CoreModule,
+        ],
+        exports: [LetModule, PushModule]
+        bootstrap: [AppComponent],
+      })
+      export class AppModule {}
+
+      @Component({
+        imports: [
+          AuthModule,
+          LetModule, PushModule
+        ]
+      })
+      export class SomeStandaloneComponent {}
+    `;
+
+        appTree.create('./app.module.ts', input);
+        const runner = new SchematicTestRunner('schematics', collectionPath);
+
+        const newTree = await runner
+          .runSchematicAsync(`ngrx-${pkgName}-migration-14-1`, {}, appTree)
+          .toPromise();
+        const file = newTree.readContent('app.module.ts');
+
+        expect(file).toBe(expected);
+      })
+    );
+  });
+});

modules/component/migrations/14_1_0/index.ts

@@ -0,0 +1,143 @@
+import * as ts from 'typescript';
+import { Rule, chain, Tree } from '@angular-devkit/schematics';
+import {
+  visitTSSourceFiles,
+  commitChanges,
+  createReplaceChange,
+  ReplaceChange,
+} from '../../schematics-core';
+
+const reactiveComponentModuleText = 'ReactiveComponentModule';
+const reactiveComponentModuleReplacement = 'LetModule, PushModule';
+const moduleLocations = {
+  imports: ['NgModule', 'Component'],
+  exports: ['NgModule'],
+};
+
+function migrateReactiveComponentModule() {
+  return (tree: Tree) => {
+    visitTSSourceFiles(tree, (sourceFile) => {
+      const componentImports = sourceFile.statements
+        .filter(ts.isImportDeclaration)
+        .filter(({ moduleSpecifier }) =>
+          moduleSpecifier.getText(sourceFile).includes('@ngrx/component')
+        );
+
+      if (componentImports.length === 0) {
+        return;
+      }
+
+      const changes = [
+        ...findReactiveComponentModuleImportDeclarations(
+          sourceFile,
+          componentImports
+        ),
+        ...findReactiveComponentModuleImportReplacements(sourceFile),
+      ];
+
+      commitChanges(tree, sourceFile.fileName, changes);
+    });
+  };
+}
+
+function findReactiveComponentModuleImportDeclarations(
+  sourceFile: ts.SourceFile,
+  imports: ts.ImportDeclaration[]
+) {
+  const changes = imports
+    .map((p) => (p?.importClause?.namedBindings as ts.NamedImports)?.elements)
+    .reduce(
+      (imports, curr) => imports.concat(curr ?? []),
+      [] as ts.ImportSpecifier[]
+    )
+    .map((specifier) => {
+      if (!ts.isImportSpecifier(specifier)) {
+        return { hit: false };
+      }
+
+      if (specifier.name.text === reactiveComponentModuleText) {
+        return { hit: true, specifier, text: specifier.name.text };
+      }
+
+      // if import is renamed
+      if (
+        specifier.propertyName &&
+        specifier.propertyName.text === reactiveComponentModuleText
+      ) {
+        return { hit: true, specifier, text: specifier.propertyName.text };
+      }
+
+      return { hit: false };
+    })
+    .filter(({ hit }) => hit)
+    .map(({ specifier, text }) =>
+      !!specifier && !!text
+        ? createReplaceChange(
+            sourceFile,
+            specifier,
+            text,
+            reactiveComponentModuleReplacement
+          )
+        : undefined
+    )
+    .filter((change) => !!change) as Array<ReplaceChange>;
+
+  return changes;
+}
+
+function findReactiveComponentModuleImportReplacements(
+  sourceFile: ts.SourceFile
+) {
+  const changes: ReplaceChange[] = [];
+  ts.forEachChild(sourceFile, (node) => find(node, changes));
+  return changes;
+
+  function find(node: ts.Node, changes: ReplaceChange[]) {
+    let change = undefined;
+
+    if (
+      ts.isIdentifier(node) &&
+      node.text === reactiveComponentModuleText &&
+      ts.isArrayLiteralExpression(node.parent) &&
+      ts.isPropertyAssignment(node.parent.parent)
+    ) {
+      const property = node.parent.parent;
+      if (ts.isIdentifier(property.name)) {
+        const propertyName = String(property.name.escapedText);
+        if (Object.keys(moduleLocations).includes(propertyName)) {
+          const decorator = property.parent.parent.parent;
+          if (
+            ts.isDecorator(decorator) &&
+            ts.isCallExpression(decorator.expression) &&
+            ts.isIdentifier(decorator.expression.expression) &&
+            moduleLocations[propertyName as 'imports' | 'exports'].includes(
+              String(decorator.expression.expression.escapedText)
+            )
+          ) {
+            change = {
+              node: node,
+              text: node.text,
+            };
+          }
+        }
+      }
+    }
+
+    if (change) {
+      changes.push(
+        createReplaceChange(
+          sourceFile,
+          change.node,
+          change.text,
+          reactiveComponentModuleReplacement
+        )
+      );
+    }
+
+    ts.forEachChild(node, (childNode) => find(childNode, changes));
+  }
+}
+
+export default function (): Rule {
+  return chain([migrateReactiveComponentModule()]);
+}

modules/component/migrations/migration.json

@@ -1,4 +1,10 @@
 {
   "$schema": "../../../node_modules/@angular-devkit/schematics/collection-schema.json",
-  "schematics": {}
+  "schematics": {
+    "ngrx-component-migration-14-1": {
+      "description": "Version 14.1",
+      "version": "14.1",
+      "factory": "./14_1_0/index"
+    }
+  }
 }