@craft-ng/dev-tools 0.5.0-beta.3 → 0.5.0-beta.4

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@craft-ng/dev-tools",
-  "version": "0.5.0-beta.3",
+  "version": "0.5.0-beta.4",
   "description": "Development tools for ng-craft: ESLint configs, ESLint rules, and codemods",
   "type": "module",
   "main": "./src/index.js",

package/src/eslint-rules/global-exception-registry-match.cjs

@@ -30,8 +30,8 @@ module.exports = {
         }
 
         const text = sourceCode.getText();
-        // Cheap pre-filter: both the trigger and the delegated outcome must appear.
-        if (!text.includes('handleExceptions') || !text.includes('globalError')) {
+        // Cheap pre-filter: the delegated outcome must appear.
+        if (!text.includes('globalError')) {
           return;
         }
 
@@ -208,8 +208,8 @@ function resolveCollectionVar(craftRoutesCall) {
   return undefined;
 }
 
-// A route array element is either `route('path', { … })` (optionally followed by
-// `.withProviders(…)`) or a plain `{ path: '…', handleExceptions: { … } }`.
+// A route array element is either `route('path', { … }, { … })` (optionally
+// followed by `.withProviders(…)`) or a plain `{ path: '…', handleExceptions: { … } }`.
 function extractRouteDefinition(element) {
   if (Node.isObjectLiteralExpression(element)) {
     const pathValue = readStringProperty(element, 'path');
@@ -225,23 +225,19 @@ function extractRouteDefinition(element) {
     if (!routeCall) {
       return undefined;
     }
-    const [pathArg, defArg] = routeCall.getArguments();
+    const [pathArg, , handlersArg] = routeCall.getArguments();
     if (
       !pathArg ||
-      !defArg ||
-      !Node.isObjectLiteralExpression(defArg) ||
+      !handlersArg ||
+      !Node.isObjectLiteralExpression(handlersArg) ||
       (!Node.isStringLiteral(pathArg) &&
         !Node.isNoSubstitutionTemplateLiteral(pathArg))
     ) {
       return undefined;
     }
-    const handleExceptions = readObjectProperty(defArg, 'handleExceptions');
-    if (!handleExceptions) {
-      return undefined;
-    }
     return {
       path: pathArg.getLiteralText(),
-      handleExceptions,
+      handleExceptions: handlersArg,
       reportNode: routeCall,
     };
   }

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

@@ -5,10 +5,14 @@ module.exports = {
       description:
         'Disallow Angular inject() usage so dependencies go through craftService or toCraftService.',
     },
+    hasSuggestions: true,
     schema: [],
   },
   create(context) {
     const angularNamespaceImports = new Set();
+    const angularInjectImports = new Map();
+    const reportedInjectImports = new Set();
+    const sourceCode = context.sourceCode ?? context.getSourceCode();
 
     return {
       ImportDeclaration(node) {
@@ -22,11 +26,7 @@ module.exports = {
             specifier.imported.type === 'Identifier' &&
             specifier.imported.name === 'inject'
           ) {
-            context.report({
-              node: specifier,
-              message:
-                'Angular inject() is forbidden. Expose a craftService/toCraftService injector instead.',
-            });
+            angularInjectImports.set(specifier.local.name, specifier);
             continue;
           }
 
@@ -36,24 +36,50 @@ module.exports = {
         }
       },
       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'
-        ) {
+        const angularInjectNode = getAngularInjectCallee(
+          node.callee,
+          angularInjectImports,
+          angularNamespaceImports,
+        );
+        if (!angularInjectNode) {
           return;
         }
 
+        if (node.callee.type === 'Identifier') {
+          reportedInjectImports.add(node.callee.name);
+        }
+
+        const tokenText = getInjectTokenText(node.arguments[0], sourceCode);
+        const helperName = getRecommendedInjectorName(node.arguments[0]);
+
         context.report({
-          node: callee.property,
-          message:
-            'Angular inject() is forbidden. Expose a craftService/toCraftService injector instead.',
+          node: angularInjectNode,
+          message: createInjectMessage(tokenText, helperName),
+          suggest: [
+            createTemporaryDisableSuggestion(
+              sourceCode,
+              angularInjectNode,
+              'no-angular-inject',
+              helperName
+                ? `replace this Angular inject(${tokenText}) call with ${helperName} from a craftService/toCraftService adapter`
+                : 'replace this Angular inject() call with a craftService/toCraftService injector',
+            ),
+          ],
         });
       },
+      'Program:exit'() {
+        for (const [localName, specifier] of angularInjectImports) {
+          if (reportedInjectImports.has(localName)) {
+            continue;
+          }
+
+          context.report({
+            node: specifier,
+            message:
+              'Angular inject() is forbidden. Import and use the injectX helper exposed by a craftService/toCraftService adapter instead.',
+          });
+        }
+      },
     };
   },
 };
@@ -61,3 +87,101 @@ module.exports = {
 function isAngularModule(sourceValue) {
   return typeof sourceValue === 'string' && sourceValue.startsWith('@angular/');
 }
+
+function getAngularInjectCallee(
+  callee,
+  angularInjectImports,
+  angularNamespaceImports,
+) {
+  if (callee.type === 'Identifier' && angularInjectImports.has(callee.name)) {
+    return 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 callee.property;
+  }
+
+  return undefined;
+}
+
+function createInjectMessage(tokenText, helperName) {
+  if (!helperName) {
+    return 'Angular inject() is forbidden. Use the injectX helper exposed by a craftService/toCraftService adapter instead.';
+  }
+
+  return `Angular inject(${tokenText}) is forbidden. Use ${helperName} from a craftService/toCraftService adapter instead.`;
+}
+
+function getInjectTokenText(argument, sourceCode) {
+  if (!argument) {
+    return '';
+  }
+
+  return sourceCode.getText(argument);
+}
+
+function getRecommendedInjectorName(argument) {
+  const tokenName = getTokenName(argument);
+  if (!tokenName) {
+    return undefined;
+  }
+
+  return `inject${toPascalCase(tokenName)}`;
+}
+
+function getTokenName(argument) {
+  if (!argument) {
+    return undefined;
+  }
+
+  if (argument.type === 'Identifier') {
+    return argument.name;
+  }
+
+  if (
+    argument.type === 'MemberExpression' &&
+    !argument.computed &&
+    argument.property.type === 'Identifier'
+  ) {
+    return argument.property.name;
+  }
+
+  return undefined;
+}
+
+function toPascalCase(value) {
+  return value
+    .replace(/^[^A-Za-z$]+/, '')
+    .split(/[^A-Za-z0-9$]+|(?<=[a-z0-9])(?=[A-Z])/)
+    .filter(Boolean)
+    .map((part) => part.charAt(0).toUpperCase() + part.slice(1).toLowerCase())
+    .join('');
+}
+
+function createTemporaryDisableSuggestion(
+  sourceCode,
+  node,
+  ruleName,
+  migrationNote,
+) {
+  return {
+    desc: 'Insert a temporary eslint-disable-next-line comment with a migration note.',
+    fix(fixer) {
+      const lineStart = sourceCode.getIndexFromLoc({
+        line: node.loc.start.line,
+        column: 0,
+      });
+      return fixer.insertTextBeforeRange(
+        [lineStart, lineStart],
+        `// eslint-disable-next-line craft-ng/${ruleName} -- ${migrationNote}\n`,
+      );
+    },
+  };
+}