@craft-ng/dev-tools 0.1.9 → 0.4.0-beta.1

package/src/eslint-rules/brand-angular-deps-match.cjs

@@ -1,27 +1,62 @@
 const fs = require('node:fs');
+const moduleApi = require('node:module');
 const path = require('node:path');
+const vm = require('node:vm');
+const ts = require('typescript');
 
-process.env.TS_NODE_PROJECT ??= path.resolve(
-  __dirname,
-  '../tsconfig.codemod.json',
-);
-require('ts-node/register/transpile-only');
-
-const { Project } = require('ts-morph');
+const { Node, Project } = require('ts-morph');
 const {
   analyzeSourceFileDependencies,
-  readExistingDependencyGroups,
-} = require('../scripts/angular-brand-codemod.ts');
+  discoverAngularBrandConfigFilePath,
+  transformSourceFile,
+} = loadAngularBrandCodemod();
 
 const projectCache = new Map();
+const typePrinter = ts.createPrinter({ removeComments: true });
+
+function loadAngularBrandCodemod() {
+  const filePath = path.resolve(
+    __dirname,
+    '../scripts/angular-brand-codemod.ts',
+  );
+  const compiledFilePath = `${filePath}.cjs`;
+  const sourceText = fs.readFileSync(filePath, 'utf8');
+  const librarySourceText = sourceText.replace(
+    /\n\/\/ Check if this module is being run directly[\s\S]*$/,
+    '\n',
+  );
+  const transpiled = ts.transpileModule(librarySourceText, {
+    compilerOptions: {
+      module: ts.ModuleKind.CommonJS,
+      target: ts.ScriptTarget.ES2022,
+      esModuleInterop: true,
+      moduleResolution: ts.ModuleResolutionKind.NodeJs,
+    },
+    fileName: filePath,
+  });
+  const wrappedSource = module.constructor.wrap(transpiled.outputText);
+  const evaluate = vm.runInThisContext(wrappedSource, {
+    filename: compiledFilePath,
+  });
+  const loadedModule = { exports: {} };
+  evaluate(
+    loadedModule.exports,
+    moduleApi.createRequire(compiledFilePath),
+    loadedModule,
+    compiledFilePath,
+    path.dirname(filePath),
+  );
+  return loadedModule.exports;
+}
 
 module.exports = {
   meta: {
     type: 'problem',
     docs: {
       description:
-        'Ensure deps({ injected, importDeps, providers }) matches the Angular symbol dependencies.',
+        'Ensure generated GenDeps aliases match the Angular symbol dependencies.',
     },
+    fixable: 'code',
     schema: [],
   },
   create(context) {
@@ -34,7 +69,10 @@ module.exports = {
         }
 
         const text = sourceCode.getText();
-        if (!text.includes('brandAngularSymbol') || !text.includes('deps(')) {
+        if (
+          !text.includes('export type GenDeps_') ||
+          !text.includes('GetDeps<')
+        ) {
           return;
         }
 
@@ -43,59 +81,64 @@ module.exports = {
           filePath,
           text,
         );
-        const analysis = analyzeSourceFileDependencies(sourceFile);
+        const configFilePath = discoverAngularBrandConfigFilePath(
+          path.dirname(filePath),
+          getCwd(context),
+        );
+        const analysis = analyzeSourceFileDependencies(sourceFile, {
+          configFilePath,
+        });
         if (
           !analysis.classDeclaration ||
           analysis.skipped ||
-          !analysis.className
+          !analysis.className ||
+          !analysis.generatedTypeName
         ) {
           return;
         }
 
-        const existing = readExistingDependencyGroups(
-          sourceFile,
-          analysis.className,
+        const currentGeneratedType = sourceFile.getTypeAlias(
+          analysis.generatedTypeName,
         );
-        if (!existing.found) {
+        if (!currentGeneratedType) {
           return;
         }
 
-        if (existing.warnings.length > 0) {
-          for (const warning of existing.warnings) {
-            reportNode(
-              context,
-              sourceCode,
-              existing.depsObjectNode ?? existing.exportAssignmentNode,
-              warning,
-            );
-          }
+        const currentRange = getNodeRange(currentGeneratedType);
+        const currentSnapshot = readGeneratedDepsSnapshot(currentGeneratedType);
+
+        transformSourceFile(sourceFile, { configFilePath });
+
+        const refreshedGeneratedType = sourceFile.getTypeAlias(
+          analysis.generatedTypeName,
+        );
+        if (!refreshedGeneratedType) {
           return;
         }
 
-        reportIfMismatch(
-          context,
-          sourceCode,
-          existing,
-          'injected',
-          analysis.dependencyGroups.injected,
-          existing.dependencyGroups.injected,
+        const refreshedSnapshot = readGeneratedDepsSnapshot(
+          refreshedGeneratedType,
         );
-        reportIfMismatch(
-          context,
-          sourceCode,
-          existing,
-          'importDeps',
-          analysis.dependencyGroups.importDeps,
-          existing.dependencyGroups.importDeps,
-        );
-        reportIfMismatch(
-          context,
-          sourceCode,
-          existing,
-          'providers',
-          analysis.dependencyGroups.providers,
-          existing.dependencyGroups.providers,
+        if (currentSnapshot.typeText === refreshedSnapshot.typeText) {
+          return;
+        }
+
+        const staleSections = getStaleSections(
+          currentSnapshot.sections,
+          refreshedSnapshot.sections,
         );
+        const fixedText = sourceFile.getFullText();
+
+        context.report({
+          loc: getRangeLoc(sourceCode, currentRange),
+          message: formatOutOfDateMessage(
+            analysis.generatedTypeName,
+            staleSections,
+          ),
+          fix(fixer) {
+            return fixer.replaceTextRange([0, text.length], fixedText);
+          },
+        });
       },
     };
   },
@@ -151,49 +194,140 @@ function getCwd(context) {
   return context.cwd ?? process.cwd();
 }
 
-function reportIfMismatch(
-  context,
-  sourceCode,
-  existing,
-  propertyName,
-  expected,
-  actual,
-) {
-  if (isSameDependencyList(expected, actual)) {
-    return;
+function readGeneratedDepsSnapshot(typeAlias) {
+  const typeNode = typeAlias.getTypeNode();
+  const snapshot = {
+    typeText: normalizeText(typeNode?.getText() ?? ''),
+    sections: undefined,
+  };
+
+  if (!typeNode || !Node.isTypeReference(typeNode)) {
+    return snapshot;
   }
 
-  reportNode(
-    context,
-    sourceCode,
-    existing.propertyNodes[propertyName] ??
-      existing.depsObjectNode ??
-      existing.exportAssignmentNode,
-    `deps.${propertyName} does not match the Angular symbol. Expected ${formatDependencyList(expected)} but found ${formatDependencyList(actual)}.`,
-  );
+  if (typeNode.getTypeName().getText() !== 'GetDeps') {
+    return snapshot;
+  }
+
+  const [inputType] = typeNode.getTypeArguments();
+  if (!inputType || !Node.isTypeLiteral(inputType)) {
+    return snapshot;
+  }
+
+  snapshot.sections = {
+    deps: normalizeText(readTypeLiteralPropertyTypeText(inputType, 'deps')),
+    propertiesDeps: normalizeText(
+      readTypeLiteralPropertyTypeText(inputType, 'propertiesDeps'),
+    ),
+    provided: normalizeText(
+      readTypeLiteralPropertyTypeText(inputType, 'provided'),
+    ),
+    missingProvider: normalizeText(
+      readTypeLiteralPropertyTypeText(inputType, 'missingProvider'),
+    ),
+  };
+
+  return snapshot;
 }
 
-function reportNode(context, sourceCode, node, message) {
-  context.report({
-    loc: node ? getNodeLoc(sourceCode, node) : undefined,
-    message,
-  });
+function getNodeRange(node) {
+  return [node.getStart(), node.getEnd()];
 }
 
-function getNodeLoc(sourceCode, node) {
+function getRangeLoc(sourceCode, [start, end]) {
   return {
-    start: sourceCode.getLocFromIndex(node.getStart()),
-    end: sourceCode.getLocFromIndex(node.getEnd()),
+    start: sourceCode.getLocFromIndex(start),
+    end: sourceCode.getLocFromIndex(end),
   };
 }
 
-function isSameDependencyList(left, right) {
-  return (
-    left.length === right.length &&
-    left.every((value, index) => value === right[index])
+function readTypeLiteralPropertyTypeText(typeLiteral, propertyName) {
+  const property = typeLiteral
+    .getMembers()
+    .find(
+      (member) =>
+        Node.isPropertySignature(member) && member.getName() === propertyName,
+    );
+
+  return property?.getTypeNode()?.getText() ?? '';
+}
+
+function getStaleSections(currentSections, refreshedSections) {
+  if (!currentSections || !refreshedSections) {
+    return [];
+  }
+
+  return ['deps', 'propertiesDeps', 'provided', 'missingProvider'].filter(
+    (sectionName) =>
+      currentSections[sectionName] !== refreshedSections[sectionName],
   );
 }
 
-function formatDependencyList(dependencies) {
-  return `[${dependencies.join(', ')}]`;
+function formatOutOfDateMessage(generatedTypeName, staleSections) {
+  if (staleSections.length === 0) {
+    return `${generatedTypeName} is out of date. Run ESLint --fix on this file or craft-brand --root <source-root> to refresh it.`;
+  }
+
+  return `${generatedTypeName} is out of date for ${formatSectionList(staleSections)}. Run ESLint --fix on this file or craft-brand --root <source-root> to refresh it.`;
+}
+
+function formatSectionList(sectionNames) {
+  if (sectionNames.length === 1) {
+    return sectionNames[0];
+  }
+
+  if (sectionNames.length === 2) {
+    return `${sectionNames[0]} and ${sectionNames[1]}`;
+  }
+
+  return `${sectionNames.slice(0, -1).join(', ')}, and ${
+    sectionNames[sectionNames.length - 1]
+  }`;
+}
+
+function normalizeText(text) {
+  const collapsedText = text.replace(/\s+/g, ' ').trim();
+  if (collapsedText === '') {
+    return '';
+  }
+
+  try {
+    const sourceFile = ts.createSourceFile(
+      '__brand_angular_deps_match__.ts',
+      `type __BrandAngularDepsMatch = ${text};`,
+      ts.ScriptTarget.Latest,
+      true,
+      ts.ScriptKind.TS,
+    );
+    const [statement] = sourceFile.statements;
+
+    if (!statement || !ts.isTypeAliasDeclaration(statement)) {
+      return collapsedText;
+    }
+
+    const transformedType = ts.transform(statement.type, [
+      (transformationContext) => (rootNode) =>
+        ts.visitNode(rootNode, function visit(node) {
+          if (ts.isStringLiteral(node)) {
+            return ts.factory.createStringLiteral(node.text);
+          }
+
+          return ts.visitEachChild(node, visit, transformationContext);
+        }),
+    ]);
+
+    const [canonicalTypeNode] = transformedType.transformed;
+    const normalizedText = typePrinter
+      .printNode(
+        ts.EmitHint.Unspecified,
+        canonicalTypeNode ?? statement.type,
+        sourceFile,
+      )
+      .replace(/\s+/g, ' ')
+      .trim();
+    transformedType.dispose();
+    return normalizedText;
+  } catch {
+    return collapsedText;
+  }
 }

package/src/eslint-rules/brand-angular-gen-deps-required.cjs

@@ -0,0 +1,175 @@
+const fs = require('node:fs');
+const moduleApi = require('node:module');
+const path = require('node:path');
+const vm = require('node:vm');
+const ts = require('typescript');
+
+const { Project } = require('ts-morph');
+const {
+  analyzeSourceFileDependencies,
+  discoverAngularBrandConfigFilePath,
+  transformSourceFile,
+} = loadAngularBrandCodemod();
+
+const projectCache = new Map();
+
+function loadAngularBrandCodemod() {
+  const filePath = path.resolve(
+    __dirname,
+    '../scripts/angular-brand-codemod.ts',
+  );
+  const compiledFilePath = `${filePath}.cjs`;
+  const sourceText = fs.readFileSync(filePath, 'utf8');
+  const librarySourceText = sourceText.replace(
+    /\n\/\/ Check if this module is being run directly[\s\S]*$/,
+    '\n',
+  );
+  const transpiled = ts.transpileModule(librarySourceText, {
+    compilerOptions: {
+      module: ts.ModuleKind.CommonJS,
+      target: ts.ScriptTarget.ES2022,
+      esModuleInterop: true,
+      moduleResolution: ts.ModuleResolutionKind.NodeJs,
+    },
+    fileName: filePath,
+  });
+  const wrappedSource = module.constructor.wrap(transpiled.outputText);
+  const evaluate = vm.runInThisContext(wrappedSource, {
+    filename: compiledFilePath,
+  });
+  const loadedModule = { exports: {} };
+  evaluate(
+    loadedModule.exports,
+    moduleApi.createRequire(compiledFilePath),
+    loadedModule,
+    compiledFilePath,
+    path.dirname(filePath),
+  );
+  return loadedModule.exports;
+}
+
+module.exports = {
+  meta: {
+    type: 'problem',
+    docs: {
+      description:
+        'Ensure Angular components, directives, and pipes expose a generated GenDeps alias.',
+    },
+    fixable: 'code',
+    schema: [],
+  },
+  create(context) {
+    return {
+      'Program:exit'() {
+        const sourceCode = context.sourceCode ?? context.getSourceCode();
+        const filePath = getFilePath(context);
+        if (!filePath || !filePath.endsWith('.ts')) {
+          return;
+        }
+
+        const text = sourceCode.getText();
+        const sourceFile = getProjectSourceFile(
+          getProject(getCwd(context)),
+          filePath,
+          text,
+        );
+        const configFilePath = discoverAngularBrandConfigFilePath(
+          path.dirname(filePath),
+          getCwd(context),
+        );
+        const analysis = analyzeSourceFileDependencies(sourceFile, {
+          configFilePath,
+        });
+        if (
+          !analysis.classDeclaration ||
+          analysis.skipped ||
+          !analysis.generatedTypeName
+        ) {
+          return;
+        }
+
+        if (sourceFile.getTypeAlias(analysis.generatedTypeName)) {
+          return;
+        }
+
+        const reportLoc = getNodeLoc(sourceCode, analysis.classDeclaration);
+
+        transformSourceFile(sourceFile, { configFilePath });
+
+        if (!sourceFile.getTypeAlias(analysis.generatedTypeName)) {
+          return;
+        }
+
+        const fixedText = sourceFile.getFullText();
+        if (fixedText === text) {
+          return;
+        }
+
+        context.report({
+          loc: reportLoc,
+          message: `${analysis.generatedTypeName} is missing. Run ESLint --fix on this file or craft-brand --root <source-root> to generate it.`,
+          fix(fixer) {
+            return fixer.replaceTextRange([0, text.length], fixedText);
+          },
+        });
+      },
+    };
+  },
+};
+
+function getProject(cwd) {
+  let project = projectCache.get(cwd);
+  if (project) {
+    return project;
+  }
+
+  const tsConfigFilePath = path.join(cwd, 'tsconfig.json');
+  project = fs.existsSync(tsConfigFilePath)
+    ? new Project({ tsConfigFilePath })
+    : new Project({
+        compilerOptions: {
+          experimentalDecorators: true,
+          target: 9,
+        },
+      });
+
+  projectCache.set(cwd, project);
+  return project;
+}
+
+function getProjectSourceFile(project, filePath, text) {
+  const normalizedPath = path.resolve(filePath);
+  const existingSourceFile = project.getSourceFile(normalizedPath);
+  if (existingSourceFile) {
+    existingSourceFile.replaceWithText(text);
+    return existingSourceFile;
+  }
+
+  const sourceFile = project.addSourceFileAtPathIfExists(normalizedPath);
+  if (sourceFile) {
+    sourceFile.replaceWithText(text);
+    return sourceFile;
+  }
+
+  return project.createSourceFile(normalizedPath, text, { overwrite: true });
+}
+
+function getFilePath(context) {
+  const filePath = context.filename ?? context.getFilename();
+  if (!filePath || filePath === '<input>') {
+    return undefined;
+  }
+
+  return filePath;
+}
+
+function getCwd(context) {
+  return context.cwd ?? process.cwd();
+}
+
+function getNodeLoc(sourceCode, node) {
+  return {
+    start: sourceCode.getLocFromIndex(node.getStart()),
+    end: sourceCode.getLocFromIndex(node.getEnd()),
+  };
+}

package/src/eslint-rules/index.cjs

@@ -1,11 +1,19 @@
+const brandAngularGenDepsRequired = require('./brand-angular-gen-deps-required.cjs');
 const brandAngularDepsMatch = require('./brand-angular-deps-match.cjs');
+const appStartRegistryMatch = require('./app-start-registry-match.cjs');
 const noAngularInject = require('./no-angular-inject.cjs');
-const noDirectAngularClassExport = require('./no-direct-angular-class-export.cjs');
+const preferCraftHttpClient = require('./prefer-craft-http-client.cjs');
+const preferCraftService = require('./prefer-craft-service.cjs');
+const preferBrowserBoundaries = require('./prefer-browser-boundaries.cjs');
 
 module.exports = {
   rules: {
+    'app-start-registry-match': appStartRegistryMatch,
+    'brand-angular-gen-deps-required': brandAngularGenDepsRequired,
     'brand-angular-deps-match': brandAngularDepsMatch,
     'no-angular-inject': noAngularInject,
-    'no-direct-angular-class-export': noDirectAngularClassExport,
+    'prefer-craft-http-client': preferCraftHttpClient,
+    'prefer-craft-service': preferCraftService,
+    'prefer-browser-boundaries': preferBrowserBoundaries,
   },
 };

package/src/eslint-rules/no-angular-inject.cjs

@@ -3,14 +3,12 @@ module.exports = {
     type: 'problem',
     docs: {
       description:
-        'Disallow Angular inject(), @Injectable, and @Service usage so dependencies go through craftService or toCraftService.',
+        'Disallow Angular inject() usage so dependencies go through craftService or toCraftService.',
     },
     schema: [],
   },
   create(context) {
     const angularNamespaceImports = new Set();
-    const angularInjectableImports = new Set();
-    const angularServiceImports = new Set();
 
     return {
       ImportDeclaration(node) {
@@ -32,24 +30,6 @@ module.exports = {
             continue;
           }
 
-          if (
-            specifier.type === 'ImportSpecifier' &&
-            specifier.imported.type === 'Identifier' &&
-            specifier.imported.name === 'Injectable'
-          ) {
-            angularInjectableImports.add(specifier.local.name);
-            continue;
-          }
-
-          if (
-            specifier.type === 'ImportSpecifier' &&
-            specifier.imported.type === 'Identifier' &&
-            specifier.imported.name === 'Service'
-          ) {
-            angularServiceImports.add(specifier.local.name);
-            continue;
-          }
-
           if (specifier.type === 'ImportNamespaceSpecifier') {
             angularNamespaceImports.add(specifier.local.name);
           }
@@ -74,22 +54,6 @@ module.exports = {
             'Angular inject() is forbidden. Expose a craftService/toCraftService injector instead.',
         });
       },
-      Decorator(node) {
-        const decoratorName = getAngularBlockedDecoratorName(
-          node.expression,
-          angularInjectableImports,
-          angularServiceImports,
-          angularNamespaceImports,
-        );
-        if (!decoratorName) {
-          return;
-        }
-
-        context.report({
-          node,
-          message: `Angular @${decoratorName} is forbidden. Expose the dependency through craftService or toCraftService instead.`,
-        });
-      },
     };
   },
 };
@@ -97,44 +61,3 @@ module.exports = {
 function isAngularModule(sourceValue) {
   return typeof sourceValue === 'string' && sourceValue.startsWith('@angular/');
 }
-
-function getAngularBlockedDecoratorName(
-  expression,
-  angularInjectableImports,
-  angularServiceImports,
-  angularNamespaceImports,
-) {
-  if (expression.type === 'Identifier') {
-    if (angularInjectableImports.has(expression.name)) {
-      return 'Injectable';
-    }
-
-    if (angularServiceImports.has(expression.name)) {
-      return 'Service';
-    }
-
-    return undefined;
-  }
-
-  if (expression.type === 'CallExpression') {
-    return getAngularBlockedDecoratorName(
-      expression.callee,
-      angularInjectableImports,
-      angularServiceImports,
-      angularNamespaceImports,
-    );
-  }
-
-  if (
-    expression.type === 'MemberExpression' &&
-    !expression.computed &&
-    expression.object.type === 'Identifier' &&
-    angularNamespaceImports.has(expression.object.name) &&
-    expression.property.type === 'Identifier' &&
-    (expression.property.name === 'Injectable' || expression.property.name === 'Service')
-  ) {
-    return expression.property.name;
-  }
-
-  return undefined;
-}