@craft-ng/dev-tools 0.1.0

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

@@ -0,0 +1,141 @@
+module.exports = {
+  meta: {
+    type: 'problem',
+    docs: {
+      description:
+        'Disallow Angular inject(), @Injectable, and @Service 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) {
+        if (!isAngularModule(node.source.value)) {
+          return;
+        }
+
+        for (const specifier of node.specifiers) {
+          if (
+            specifier.type === 'ImportSpecifier' &&
+            specifier.imported.type === 'Identifier' &&
+            specifier.imported.name === 'inject'
+          ) {
+            context.report({
+              node: specifier,
+              message:
+                'Angular inject() is forbidden. Expose a craftService/toCraftService injector instead.',
+            });
+            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);
+          }
+        }
+      },
+      CallExpression(node) {
+        const callee = node.callee;
+        if (
+          callee.type !== 'MemberExpression' ||
+          callee.computed ||
+          callee.object.type !== 'Identifier' ||
+          !angularNamespaceImports.has(callee.object.name) ||
+          callee.property.type !== 'Identifier' ||
+          callee.property.name !== 'inject'
+        ) {
+          return;
+        }
+
+        context.report({
+          node: callee.property,
+          message:
+            '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.`,
+        });
+      },
+    };
+  },
+};
+
+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;
+}

package/src/eslint-rules/no-direct-angular-class-export.cjs

@@ -0,0 +1,234 @@
+const fs = require('node:fs');
+const path = require('node:path');
+
+const { Project, Node, SyntaxKind } = require('ts-morph');
+const { getAngularKind } = require('../scripts/angular-brand-codemod.js');
+
+const projectCache = new Map();
+
+module.exports = {
+  meta: {
+    type: 'problem',
+    docs: {
+      description:
+        'Disallow direct exports of Angular symbols managed through brandAngularSymbol.',
+    },
+    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();
+        if (!text.includes('export')) {
+          return;
+        }
+
+        const sourceFile = getProjectSourceFile(
+          getProject(getCwd(context)),
+          filePath,
+          text,
+        );
+        const angularClasses = sourceFile
+          .getClasses()
+          .map((classDeclaration) => ({
+            classDeclaration,
+            angularKind: getAngularKind(classDeclaration),
+          }))
+          .filter((entry) => Boolean(entry.angularKind));
+
+        for (const { classDeclaration, angularKind } of angularClasses) {
+          reportDirectClassExport(
+            context,
+            sourceCode,
+            classDeclaration,
+            angularKind,
+          );
+          reportIdentifierExportAssignment(
+            context,
+            sourceCode,
+            sourceFile,
+            classDeclaration,
+            angularKind,
+          );
+          reportNamedExports(
+            context,
+            sourceCode,
+            sourceFile,
+            classDeclaration,
+            angularKind,
+          );
+        }
+      },
+    };
+  },
+};
+
+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 reportDirectClassExport(
+  context,
+  sourceCode,
+  classDeclaration,
+  angularKind,
+) {
+  const hasDirectExportModifier = classDeclaration
+    .getModifiers()
+    .some(
+      (modifier) =>
+        modifier.getKind() === SyntaxKind.ExportKeyword ||
+        modifier.getKind() === SyntaxKind.DefaultKeyword,
+    );
+
+  if (!hasDirectExportModifier) {
+    return;
+  }
+
+  reportNode(
+    context,
+    sourceCode,
+    classDeclaration,
+    `Do not export ${formatAngularKind(angularKind)} classes directly. Keep the class local and export default brandAngularSymbol(...).`,
+  );
+}
+
+function reportIdentifierExportAssignment(
+  context,
+  sourceCode,
+  sourceFile,
+  classDeclaration,
+  angularKind,
+) {
+  const className = classDeclaration.getName();
+  if (!className) {
+    return;
+  }
+
+  for (const exportAssignment of sourceFile.getExportAssignments()) {
+    if (exportAssignment.isExportEquals()) {
+      continue;
+    }
+
+    const expression = exportAssignment.getExpression();
+    if (!Node.isIdentifier(expression) || expression.getText() !== className) {
+      continue;
+    }
+
+    reportNode(
+      context,
+      sourceCode,
+      exportAssignment,
+      `Do not export ${formatAngularKind(angularKind)} classes directly. Use export default brandAngularSymbol(${className}, deps(...)).`,
+    );
+  }
+}
+
+function reportNamedExports(
+  context,
+  sourceCode,
+  sourceFile,
+  classDeclaration,
+  angularKind,
+) {
+  const className = classDeclaration.getName();
+  if (!className) {
+    return;
+  }
+
+  for (const exportDeclaration of sourceFile.getExportDeclarations()) {
+    if (exportDeclaration.getModuleSpecifier()) {
+      continue;
+    }
+
+    for (const namedExport of exportDeclaration.getNamedExports()) {
+      if (namedExport.getName() !== className) {
+        continue;
+      }
+
+      reportNode(
+        context,
+        sourceCode,
+        namedExport,
+        `Do not export ${formatAngularKind(angularKind)} classes directly. Keep ${className} local and export the branded symbol instead.`,
+      );
+    }
+  }
+}
+
+function reportNode(context, sourceCode, node, message) {
+  context.report({
+    loc: {
+      start: sourceCode.getLocFromIndex(node.getStart()),
+      end: sourceCode.getLocFromIndex(node.getEnd()),
+    },
+    message,
+  });
+}
+
+function formatAngularKind(angularKind) {
+  switch (angularKind) {
+    case 'component':
+      return '@Component';
+    case 'directive':
+      return '@Directive';
+    case 'pipe':
+      return '@Pipe';
+    case 'injectable':
+      return '@Injectable';
+    default:
+      return 'Angular';
+  }
+}

package/src/index.d.ts

@@ -0,0 +1 @@
+export * from './scripts/angular-brand-codemod';

package/src/index.js

@@ -0,0 +1,3 @@
+// Export programmatic API for codemod
+export * from './scripts/angular-brand-codemod';
+//# sourceMappingURL=index.js.map

package/src/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../../libs/dev-tools/src/index.ts"],"names":[],"mappings":"AAAA,sCAAsC;AACtC,cAAc,iCAAiC,CAAC"}

package/src/scripts/angular-brand-codemod.d.ts

@@ -0,0 +1,75 @@
+import { ClassDeclaration, Node, SourceFile } from 'ts-morph';
+export type AngularKind = 'component' | 'directive' | 'pipe' | 'injectable';
+export type TransformResult = {
+    changed: boolean;
+    skipped: boolean;
+    warnings: string[];
+    angularKind?: string;
+    className?: string;
+    dependencies: string[];
+    dependencyGroups: DependencyGroups;
+};
+export type AngularBrandCodemodOptions = {
+    helperImportPath?: string;
+    transformOnlyStandaloneDeclarables?: boolean;
+    includeProviders?: boolean;
+    includeViewProviders?: boolean;
+};
+export type AngularClassSearchResult = {
+    classDeclaration?: ClassDeclaration;
+    angularKind?: AngularKind;
+    className?: string;
+    skipped: boolean;
+    warnings: string[];
+};
+export type DependencyExtractionResult = {
+    dependencies: string[];
+    warnings: string[];
+};
+export type DependencyGroups = {
+    injected: string[];
+    importDeps: string[];
+    providers: string[];
+};
+export type DependencyAnalysisResult = Omit<TransformResult, 'changed'> & {
+    classDeclaration?: ClassDeclaration;
+};
+export type ExistingDependencyGroupsResult = {
+    found: boolean;
+    warnings: string[];
+    dependencyGroups: DependencyGroups;
+    exportAssignmentNode?: Node;
+    depsObjectNode?: Node;
+    propertyNodes: Partial<Record<keyof DependencyGroups, Node>>;
+};
+type RunFileReport = TransformResult & {
+    filePath: string;
+};
+export type RunSummary = {
+    transformedFiles: number;
+    skippedFiles: number;
+    warnings: number;
+    countByAngularKind: Record<AngularKind, number>;
+    files: RunFileReport[];
+};
+export declare function transformSourceFile(sourceFile: SourceFile, options?: AngularBrandCodemodOptions): TransformResult;
+export declare function analyzeSourceFileDependencies(sourceFile: SourceFile, options?: AngularBrandCodemodOptions): DependencyAnalysisResult;
+export declare function findAngularDecoratedClass(sourceFile: SourceFile): AngularClassSearchResult;
+export declare function getAngularKind(classDeclaration: ClassDeclaration): AngularKind | undefined;
+export declare function isStandaloneDeclarable(classDeclaration: ClassDeclaration): boolean;
+export declare function extractDecoratorMetadataDeps(classDeclaration: ClassDeclaration, angularKind?: AngularKind | undefined, options?: AngularBrandCodemodOptions): DependencyExtractionResult;
+export declare function extractConstructorDeps(classDeclaration: ClassDeclaration): DependencyExtractionResult;
+export declare function extractInjectCallDeps(classDeclaration: ClassDeclaration): DependencyExtractionResult;
+export declare function mergeDeps(...dependencyGroups: readonly string[][]): string[];
+export declare function ensureHelperImports(sourceFile: SourceFile, helperImportPath: string): void;
+export declare function removeConflictingExports(sourceFile: SourceFile, classDeclaration: ClassDeclaration, className: string): void;
+export declare function writeDefaultBrandExport(sourceFile: SourceFile, className: string, dependencyGroups: DependencyGroups): void;
+export declare function readExistingDependencyGroups(sourceFile: SourceFile, className?: string): ExistingDependencyGroupsResult;
+export declare function formatDependencyGroups(dependencyGroups: DependencyGroups): string;
+export declare function runAngularBrandCodemod(options?: AngularBrandCodemodOptions & {
+    rootDir?: string;
+    tsConfigFilePath?: string;
+    dryRun?: boolean;
+    log?: (message: string) => void;
+}): Promise<RunSummary>;
+export {};