eslint-cdk-plugin 1.1.1 → 2.0.1

package/dist/index.mjs

@@ -1,15 +1,103 @@
+import tsParser from '@typescript-eslint/parser';
 import { ESLintUtils, AST_NODE_TYPES, AST_TOKEN_TYPES } from '@typescript-eslint/utils';
 import * as path from 'path';
 
-var SymbolFlags = /* @__PURE__ */ ((SymbolFlags2) => {
-  SymbolFlags2[SymbolFlags2["Class"] = 32] = "Class";
-  return SymbolFlags2;
-})(SymbolFlags || {});
-var SyntaxKind = /* @__PURE__ */ ((SyntaxKind2) => {
-  SyntaxKind2[SyntaxKind2["ClassDeclaration"] = 263] = "ClassDeclaration";
-  SyntaxKind2[SyntaxKind2["Constructor"] = 176] = "Constructor";
-  return SyntaxKind2;
-})(SyntaxKind || {});
+var name = "eslint-cdk-plugin";
+var version = "2.0.0";
+
+const isConstructOrStackType = (type, ignoredClasses = ["App", "Stage"]) => {
+  if (ignoredClasses.includes(type.symbol?.name ?? "")) return false;
+  return isTargetSuperClassType(
+    type,
+    ["Construct", "Stack"],
+    isConstructOrStackType
+  );
+};
+const isConstructType = (type, ignoredClasses = ["App", "Stage", "Stack"]) => {
+  if (ignoredClasses.includes(type.symbol?.name ?? "")) return false;
+  return isTargetSuperClassType(type, ["Construct"], isConstructType);
+};
+const isTargetSuperClassType = (type, targetSuperClasses, typeCheckFunction) => {
+  if (!type.symbol) return false;
+  if (targetSuperClasses.some((suffix) => type.symbol.name.endsWith(suffix))) {
+    return true;
+  }
+  const baseTypes = type.getBaseTypes() ?? [];
+  return baseTypes.some((baseType) => typeCheckFunction(baseType));
+};
+
+const constructConstructorProperty = ESLintUtils.RuleCreator.withoutDocs(
+  {
+    meta: {
+      type: "problem",
+      docs: {
+        description: "Enforces that constructors of classes extending Construct have the property names 'scope, id' or 'scope, id, props'"
+      },
+      messages: {
+        invalidConstructorProperty: "Constructor of a class extending Construct must have the property names 'scope, id' or 'scope, id, props'"
+      },
+      schema: []
+    },
+    defaultOptions: [],
+    create(context) {
+      const parserServices = ESLintUtils.getParserServices(context);
+      return {
+        ClassDeclaration(node) {
+          const type = parserServices.getTypeAtLocation(node);
+          if (!isConstructType(type)) return;
+          const constructor = node.body.body.find(
+            (member) => member.type === AST_NODE_TYPES.MethodDefinition && member.kind === "constructor"
+          );
+          if (!constructor) return;
+          validateConstructorProperty(constructor, context);
+        }
+      };
+    }
+  }
+);
+const validateConstructorProperty = (constructor, context) => {
+  const params = constructor.value.params;
+  if (params.length < 2) {
+    context.report({
+      node: constructor,
+      messageId: "invalidConstructorProperty"
+    });
+    return;
+  }
+  const firstParam = params[0];
+  if (firstParam.type === AST_NODE_TYPES.Identifier && firstParam.name !== "scope") {
+    context.report({
+      node: constructor,
+      messageId: "invalidConstructorProperty"
+    });
+    return;
+  }
+  const secondParam = params[1];
+  if (secondParam.type === AST_NODE_TYPES.Identifier && secondParam.name !== "id") {
+    context.report({
+      node: constructor,
+      messageId: "invalidConstructorProperty"
+    });
+    return;
+  }
+  if (params.length < 3) return;
+  const thirdParam = params[2];
+  if (thirdParam.type === AST_NODE_TYPES.Identifier && thirdParam.name !== "props") {
+    context.report({
+      node: constructor,
+      messageId: "invalidConstructorProperty"
+    });
+    return;
+  }
+};
+
+const SYMBOL_FLAGS = {
+  CLASS: 32
+};
+const SYNTAX_KIND = {
+  CLASS_DECLARATION: 263,
+  CONSTRUCTOR: 176
+};
 
 const noClassInInterface = ESLintUtils.RuleCreator.withoutDocs({
   meta: {
@@ -33,7 +121,7 @@ const noClassInInterface = ESLintUtils.RuleCreator.withoutDocs({
           }
           const type = parserServices.getTypeAtLocation(property);
           if (!type.symbol) continue;
-          const isClass = type.symbol.flags === SymbolFlags.Class;
+          const isClass = type.symbol.flags === SYMBOL_FLAGS.CLASS;
           if (!isClass) continue;
           context.report({
             node: property,
@@ -69,33 +157,16 @@ const getConstructorPropertyNames = (type) => {
   return constructor.parameters.map((param) => param.name.getText());
 };
 const isClassDeclaration = (declaration) => {
-  return declaration.kind === SyntaxKind.ClassDeclaration;
+  return declaration.kind === SYNTAX_KIND.CLASS_DECLARATION;
 };
 const isConstructorDeclaration = (node) => {
-  return node.kind === SyntaxKind.Constructor;
+  return node.kind === SYNTAX_KIND.CONSTRUCTOR;
 };
 
-const isConstructOrStackType = (type, ignoredClasses = ["App", "Stage"]) => {
-  if (ignoredClasses.includes(type.symbol?.name ?? "")) return false;
-  return isTargetSuperClassType(
-    type,
-    ["Construct", "Stack"],
-    isConstructOrStackType
-  );
-};
-const isConstructType = (type, ignoredClasses = ["App", "Stage", "Stack"]) => {
-  if (ignoredClasses.includes(type.symbol?.name ?? "")) return false;
-  return isTargetSuperClassType(type, ["Construct"], isConstructType);
-};
-const isTargetSuperClassType = (type, targetSuperClasses, typeCheckFunction) => {
-  if (!type.symbol) return false;
-  if (targetSuperClasses.some((suffix) => type.symbol.name.endsWith(suffix))) {
-    return true;
-  }
-  const baseTypes = type.getBaseTypes() || [];
-  return baseTypes.some((baseType) => typeCheckFunction(baseType));
+const SUFFIX_TYPE = {
+  CONSTRUCT: "Construct",
+  STACK: "Stack"
 };
-
 const noConstructStackSuffix = ESLintUtils.RuleCreator.withoutDocs({
   meta: {
     type: "problem",
@@ -105,11 +176,33 @@ const noConstructStackSuffix = ESLintUtils.RuleCreator.withoutDocs({
     messages: {
       noConstructStackSuffix: "{{ classType }} ID '{{ id }}' should not include {{ suffix }} suffix."
     },
-    schema: []
+    schema: [
+      {
+        type: "object",
+        properties: {
+          disallowedSuffixes: {
+            type: "array",
+            items: {
+              type: "string",
+              enum: [SUFFIX_TYPE.CONSTRUCT, SUFFIX_TYPE.STACK]
+            },
+            uniqueItems: true
+          }
+        },
+        additionalProperties: false
+      }
+    ]
   },
-  defaultOptions: [],
+  defaultOptions: [
+    {
+      disallowedSuffixes: [SUFFIX_TYPE.CONSTRUCT, SUFFIX_TYPE.STACK]
+    }
+  ],
   create(context) {
     const parserServices = ESLintUtils.getParserServices(context);
+    const options = context.options[0] ?? {
+      disallowedSuffixes: [SUFFIX_TYPE.CONSTRUCT, SUFFIX_TYPE.STACK]
+    };
     return {
       NewExpression(node) {
         const type = parserServices.getTypeAtLocation(node);
@@ -118,35 +211,36 @@ const noConstructStackSuffix = ESLintUtils.RuleCreator.withoutDocs({
         }
         const constructorPropertyNames = getConstructorPropertyNames(type);
         if (constructorPropertyNames[1] !== "id") return;
-        validateConstructId$3(node, context);
+        validateConstructId$3(node, context, options);
       }
     };
   }
 });
-const validateConstructId$3 = (node, context) => {
+const validateConstructId$3 = (node, context, options) => {
   const secondArg = node.arguments[1];
   if (secondArg.type !== AST_NODE_TYPES.Literal || typeof secondArg.value !== "string") {
     return;
   }
   const formattedConstructId = toPascalCase(secondArg.value);
-  if (formattedConstructId.endsWith("Construct")) {
+  const disallowedSuffixes = options.disallowedSuffixes;
+  if (disallowedSuffixes.includes(SUFFIX_TYPE.CONSTRUCT) && formattedConstructId.endsWith(SUFFIX_TYPE.CONSTRUCT)) {
     context.report({
       node,
       messageId: "noConstructStackSuffix",
       data: {
         classType: "Construct",
         id: secondArg.value,
-        suffix: "Construct"
+        suffix: SUFFIX_TYPE.CONSTRUCT
       }
     });
-  } else if (formattedConstructId.endsWith("Stack")) {
+  } else if (disallowedSuffixes.includes(SUFFIX_TYPE.STACK) && formattedConstructId.endsWith(SUFFIX_TYPE.STACK)) {
     context.report({
       node,
       messageId: "noConstructStackSuffix",
       data: {
         classType: "Stack",
         id: secondArg.value,
-        suffix: "Stack"
+        suffix: SUFFIX_TYPE.STACK
       }
     });
   }
@@ -559,7 +653,7 @@ const validateClassMember = (node, context, parserServices) => {
     if (!member.typeAnnotation) continue;
     const type = parserServices.getTypeAtLocation(member);
     if (!type.symbol) continue;
-    const isClass = type.symbol.flags === SymbolFlags.Class;
+    const isClass = type.symbol.flags === SYMBOL_FLAGS.CLASS;
     if (!isClass) continue;
     context.report({
       node: member,
@@ -582,7 +676,7 @@ const validateConstructorParameterProperty = (constructor, context, parserServic
     if (!param.parameter.typeAnnotation) continue;
     const type = parserServices.getTypeAtLocation(param);
     if (!type.symbol) continue;
-    const isClass = type.symbol.flags === SymbolFlags.Class;
+    const isClass = type.symbol.flags === SYMBOL_FLAGS.CLASS;
     if (!isClass) continue;
     context.report({
       node: param,
@@ -640,6 +734,17 @@ const isInsideLoop = (node) => {
     if (current.type === AST_NODE_TYPES.ForStatement || current.type === AST_NODE_TYPES.ForInStatement || current.type === AST_NODE_TYPES.ForOfStatement || current.type === AST_NODE_TYPES.WhileStatement || current.type === AST_NODE_TYPES.DoWhileStatement) {
       return true;
     }
+    if (current.type === AST_NODE_TYPES.CallExpression && current.callee.type === AST_NODE_TYPES.MemberExpression && current.callee.property.type === AST_NODE_TYPES.Identifier && [
+      "forEach",
+      "map",
+      "filter",
+      "reduce",
+      "flatMap",
+      "some",
+      "every"
+    ].includes(current.callee.property.name)) {
+      return true;
+    }
     current = current.parent;
   }
   return false;
@@ -819,11 +924,29 @@ const requirePassingThis = ESLintUtils.RuleCreator.withoutDocs({
     messages: {
       requirePassingThis: "Require passing `this` in a constructor."
     },
-    schema: [],
+    schema: [
+      {
+        type: "object",
+        properties: {
+          allowNonThisAndDisallowScope: {
+            type: "boolean",
+            default: false
+          }
+        },
+        additionalProperties: false
+      }
+    ],
     fixable: "code"
   },
-  defaultOptions: [],
+  defaultOptions: [
+    {
+      allowNonThisAndDisallowScope: false
+    }
+  ],
   create(context) {
+    const options = context.options[0] || {
+      allowNonThisAndDisallowScope: false
+    };
     const parserServices = ESLintUtils.getParserServices(context);
     return {
       NewExpression(node) {
@@ -833,13 +956,25 @@ const requirePassingThis = ESLintUtils.RuleCreator.withoutDocs({
         if (argument.type === AST_NODE_TYPES.ThisExpression) return;
         const constructorPropertyNames = getConstructorPropertyNames(type);
         if (constructorPropertyNames[0] !== "scope") return;
-        context.report({
-          node,
-          messageId: "requirePassingThis",
-          fix: (fixer) => {
-            return fixer.replaceText(argument, "this");
-          }
-        });
+        if (!options.allowNonThisAndDisallowScope) {
+          context.report({
+            node,
+            messageId: "requirePassingThis",
+            fix: (fixer) => {
+              return fixer.replaceText(argument, "this");
+            }
+          });
+          return;
+        }
+        if (argument.type === AST_NODE_TYPES.Identifier && argument.name === "scope") {
+          context.report({
+            node,
+            messageId: "requirePassingThis",
+            fix: (fixer) => {
+              return fixer.replaceText(argument, "this");
+            }
+          });
+        }
       }
     };
   }
@@ -893,49 +1028,65 @@ const rules = {
   "no-parent-name-construct-id-match": noParentNameConstructIdMatch,
   "no-public-class-fields": noPublicClassFields,
   "pascal-case-construct-id": pascalCaseConstructId,
-  "no-mutable-public-fields": noMutablePublicFields,
-  "no-mutable-props-interface": noMutablePropsInterface,
   "require-passing-this": requirePassingThis,
   "no-variable-construct-id": noVariableConstructId,
+  "no-mutable-public-fields": noMutablePublicFields,
+  "no-mutable-props-interface": noMutablePropsInterface,
+  "construct-constructor-property": constructConstructorProperty,
   "require-jsdoc": requireJSDoc,
   "require-props-default-doc": requirePropsDefaultDoc,
   "props-name-convention": propsNameConvention,
   "no-import-private": noImportPrivate
 };
+const cdkPlugin = {
+  meta: { name, version },
+  rules
+};
+const createFlatConfig = (rules2) => {
+  return {
+    languageOptions: {
+      parser: tsParser,
+      parserOptions: {
+        projectService: true
+      }
+    },
+    plugins: {
+      cdk: cdkPlugin
+    },
+    rules: rules2
+  };
+};
+const recommended = createFlatConfig({
+  "cdk/no-class-in-interface": "error",
+  "cdk/no-construct-stack-suffix": "error",
+  "cdk/no-parent-name-construct-id-match": "error",
+  "cdk/no-public-class-fields": "error",
+  "cdk/pascal-case-construct-id": "error",
+  "cdk/require-passing-this": ["error", { allowNonThisAndDisallowScope: true }],
+  "cdk/no-variable-construct-id": "error",
+  "cdk/no-mutable-public-fields": "warn",
+  "cdk/no-mutable-props-interface": "warn",
+  "cdk/construct-constructor-property": "error"
+});
+const strict = createFlatConfig({
+  "cdk/no-class-in-interface": "error",
+  "cdk/no-construct-stack-suffix": "error",
+  "cdk/no-parent-name-construct-id-match": "error",
+  "cdk/no-public-class-fields": "error",
+  "cdk/pascal-case-construct-id": "error",
+  "cdk/require-passing-this": "error",
+  "cdk/no-variable-construct-id": "error",
+  "cdk/no-mutable-public-fields": "error",
+  "cdk/no-mutable-props-interface": "error",
+  "cdk/construct-constructor-property": "error",
+  "cdk/require-jsdoc": "error",
+  "cdk/require-props-default-doc": "error",
+  "cdk/props-name-convention": "error",
+  "cdk/no-import-private": "error"
+});
 const configs = {
-  recommended: {
-    plugins: ["cdk"],
-    rules: {
-      "cdk/no-class-in-interface": "error",
-      "cdk/no-construct-stack-suffix": "error",
-      "cdk/no-parent-name-construct-id-match": "error",
-      "cdk/no-public-class-fields": "error",
-      "cdk/pascal-case-construct-id": "error",
-      "cdk/require-passing-this": "error",
-      "cdk/no-variable-construct-id": "error",
-      "cdk/no-mutable-public-fields": "warn",
-      "cdk/no-mutable-props-interface": "warn",
-      "cdk/props-name-convention": "warn"
-    }
-  },
-  strict: {
-    plugins: ["cdk"],
-    rules: {
-      "cdk/no-class-in-interface": "error",
-      "cdk/no-construct-stack-suffix": "error",
-      "cdk/no-parent-name-construct-id-match": "error",
-      "cdk/no-public-class-fields": "error",
-      "cdk/pascal-case-construct-id": "error",
-      "cdk/require-passing-this": "error",
-      "cdk/no-variable-construct-id": "error",
-      "cdk/no-mutable-public-fields": "error",
-      "cdk/no-mutable-props-interface": "error",
-      "cdk/no-import-private": "error",
-      "cdk/require-props-default-doc": "error",
-      "cdk/props-name-convention": "error",
-      "cdk/require-jsdoc": "error"
-    }
-  }
+  recommended,
+  strict
 };
 const eslintCdkPlugin = {
   rules,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "eslint-cdk-plugin",
-  "version": "1.1.1",
+  "version": "2.0.1",
   "description": "eslint plugin for AWS CDK projects",
   "main": "./dist/index.mjs",
   "types": "./dist/index.d.ts",
@@ -20,7 +20,8 @@
     "build": "sh scripts/build.sh",
     "test": "vitest --run",
     "lint": "eslint --fix --config eslint.config.js",
-    "type-check": "tsc --noEmit",
+    "check": "tsc --noEmit",
+    "pack": "pnpm run build && npm pack",
     "release:minor": "standard-version --release-as minor",
     "release:major": "standard-version --release-as major",
     "release:patch": "standard-version --release-as patch",
@@ -29,23 +30,23 @@
     "docs:preview": "cd ./docs && pnpm install && pnpm run preview"
   },
   "devDependencies": {
-    "@eslint/js": "^9.15.0",
-    "@types/estree": "^1.0.6",
-    "@types/node": "^22.9.0",
-    "@typescript-eslint/rule-tester": "^8.14.0",
-    "eslint": "9.10.0",
+    "@eslint/js": "^9.22.0",
+    "@types/node": "^22.13.10",
+    "@typescript-eslint/rule-tester": "^8.26.0",
+    "eslint": "9.22.0",
     "eslint-plugin-import": "^2.31.0",
-    "pkgroll": "^2.6.0",
+    "pkgroll": "^2.11.2",
     "standard-version": "^9.5.0",
-    "typescript": "^5.6.3",
-    "typescript-eslint": "^8.14.0",
-    "vitest": "^2.1.5"
+    "typescript": "^5.8.2",
+    "typescript-eslint": "^8.26.0",
+    "vitest": "^3.0.8"
   },
   "dependencies": {
-    "@typescript-eslint/utils": "^8.14.0"
+    "@typescript-eslint/parser": "^8.26.0",
+    "@typescript-eslint/utils": "^8.26.0"
   },
   "volta": {
-    "node": "22.11.0"
+    "node": "22.14.0"
   },
   "files": [
     "dist",

package/src/{types/symbolFlags.ts → constants/tsInternalFlags.ts}

@@ -1,14 +1,14 @@
 /**
  * Implementing `SymbolFlags` defined in typescript on your own, in order not to include TypeScript in dependencies
  */
-export enum SymbolFlags {
-  Class = 32,
-}
+export const SYMBOL_FLAGS = {
+  CLASS: 32,
+} as const;
 
 /**
  * Implementing `SyntaxKind` defined in typescript on your own, in order not to include TypeScript in dependencies
  */
-export enum SyntaxKind {
-  ClassDeclaration = 263,
-  Constructor = 176,
-}
+export const SYNTAX_KIND = {
+  CLASS_DECLARATION: 263,
+  CONSTRUCTOR: 176,
+} as const;

package/src/index.ts

@@ -1,3 +1,8 @@
+import tsParser from "@typescript-eslint/parser";
+
+import { name, version } from "../package.json";
+
+import { constructConstructorProperty } from "./rules/construct-constructor-property";
 import { noClassInInterface } from "./rules/no-class-in-interface";
 import { noConstructStackSuffix } from "./rules/no-construct-stack-suffix";
 import { noImportPrivate } from "./rules/no-import-private";
@@ -18,50 +23,70 @@ const rules = {
   "no-parent-name-construct-id-match": noParentNameConstructIdMatch,
   "no-public-class-fields": noPublicClassFields,
   "pascal-case-construct-id": pascalCaseConstructId,
-  "no-mutable-public-fields": noMutablePublicFields,
-  "no-mutable-props-interface": noMutablePropsInterface,
   "require-passing-this": requirePassingThis,
   "no-variable-construct-id": noVariableConstructId,
+  "no-mutable-public-fields": noMutablePublicFields,
+  "no-mutable-props-interface": noMutablePropsInterface,
+  "construct-constructor-property": constructConstructorProperty,
   "require-jsdoc": requireJSDoc,
   "require-props-default-doc": requirePropsDefaultDoc,
   "props-name-convention": propsNameConvention,
   "no-import-private": noImportPrivate,
 };
 
-const configs = {
-  recommended: {
-    plugins: ["cdk"],
-    rules: {
-      "cdk/no-class-in-interface": "error",
-      "cdk/no-construct-stack-suffix": "error",
-      "cdk/no-parent-name-construct-id-match": "error",
-      "cdk/no-public-class-fields": "error",
-      "cdk/pascal-case-construct-id": "error",
-      "cdk/require-passing-this": "error",
-      "cdk/no-variable-construct-id": "error",
-      "cdk/no-mutable-public-fields": "warn",
-      "cdk/no-mutable-props-interface": "warn",
-      "cdk/props-name-convention": "warn",
+const cdkPlugin = {
+  meta: { name, version },
+  rules,
+};
+
+const createFlatConfig = (rules: Record<string, unknown>) => {
+  return {
+    languageOptions: {
+      parser: tsParser,
+      parserOptions: {
+        projectService: true,
+      },
     },
-  },
-  strict: {
-    plugins: ["cdk"],
-    rules: {
-      "cdk/no-class-in-interface": "error",
-      "cdk/no-construct-stack-suffix": "error",
-      "cdk/no-parent-name-construct-id-match": "error",
-      "cdk/no-public-class-fields": "error",
-      "cdk/pascal-case-construct-id": "error",
-      "cdk/require-passing-this": "error",
-      "cdk/no-variable-construct-id": "error",
-      "cdk/no-mutable-public-fields": "error",
-      "cdk/no-mutable-props-interface": "error",
-      "cdk/no-import-private": "error",
-      "cdk/require-props-default-doc": "error",
-      "cdk/props-name-convention": "error",
-      "cdk/require-jsdoc": "error",
+    plugins: {
+      cdk: cdkPlugin,
     },
-  },
+    rules,
+  };
+};
+
+const recommended = createFlatConfig({
+  "cdk/no-class-in-interface": "error",
+  "cdk/no-construct-stack-suffix": "error",
+  "cdk/no-parent-name-construct-id-match": "error",
+  "cdk/no-public-class-fields": "error",
+  "cdk/pascal-case-construct-id": "error",
+  "cdk/require-passing-this": ["error", { allowNonThisAndDisallowScope: true }],
+  "cdk/no-variable-construct-id": "error",
+  "cdk/no-mutable-public-fields": "warn",
+  "cdk/no-mutable-props-interface": "warn",
+  "cdk/construct-constructor-property": "error",
+});
+
+const strict = createFlatConfig({
+  "cdk/no-class-in-interface": "error",
+  "cdk/no-construct-stack-suffix": "error",
+  "cdk/no-parent-name-construct-id-match": "error",
+  "cdk/no-public-class-fields": "error",
+  "cdk/pascal-case-construct-id": "error",
+  "cdk/require-passing-this": "error",
+  "cdk/no-variable-construct-id": "error",
+  "cdk/no-mutable-public-fields": "error",
+  "cdk/no-mutable-props-interface": "error",
+  "cdk/construct-constructor-property": "error",
+  "cdk/require-jsdoc": "error",
+  "cdk/require-props-default-doc": "error",
+  "cdk/props-name-convention": "error",
+  "cdk/no-import-private": "error",
+});
+
+const configs = {
+  recommended,
+  strict,
 };
 
 export { configs, rules };