eslint-cdk-plugin 1.1.0 → 2.0.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "eslint-cdk-plugin",
-  "version": "1.1.0",
+  "version": "2.0.0",
   "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/constants/tsInternalFlags.ts

@@ -0,0 +1,14 @@
+/**
+ * Implementing `SymbolFlags` defined in typescript on your own, in order not to include TypeScript in dependencies
+ */
+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 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,71 @@ 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: {
+      parserOptions: {
+        projectService: true,
+        parser: tsParser,
+        sourceType: "module",
+      },
     },
-  },
-  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 };

package/src/rules/construct-constructor-property.ts

@@ -0,0 +1,117 @@
+import {
+  AST_NODE_TYPES,
+  ESLintUtils,
+  TSESLint,
+  TSESTree,
+} from "@typescript-eslint/utils";
+
+import { isConstructType } from "../utils/typeCheck";
+
+type Context = TSESLint.RuleContext<"invalidConstructorProperty", []>;
+
+/**
+ * Enforces that constructors of classes extending Construct have the property names 'scope, id' or 'scope, id, props'
+ * @param context - The rule context provided by ESLint
+ * @returns An object containing the AST visitor functions
+ * @see {@link https://eslint-cdk-plugin.dev/rules/construct-constructor-property} - Documentation
+ */
+export 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;
+
+          // NOTE: Find the constructor method
+          const constructor = node.body.body.find(
+            (member): member is TSESTree.MethodDefinition =>
+              member.type === AST_NODE_TYPES.MethodDefinition &&
+              member.kind === "constructor"
+          );
+
+          // NOTE: Skip if there's no constructor
+          if (!constructor) return;
+
+          validateConstructorProperty(constructor, context);
+        },
+      };
+    },
+  }
+);
+
+/**
+ * Validates that the constructor has the property names "scope, id" or "scope, id, props"
+ */
+const validateConstructorProperty = (
+  constructor: TSESTree.MethodDefinition,
+  context: Context
+): void => {
+  const params = constructor.value.params;
+
+  // NOTE: Check if the constructor has at least 2 parameters
+  if (params.length < 2) {
+    context.report({
+      node: constructor,
+      messageId: "invalidConstructorProperty",
+    });
+    return;
+  }
+
+  // NOTE: Check if the first parameter is named "scope"
+  const firstParam = params[0];
+  if (
+    firstParam.type === AST_NODE_TYPES.Identifier &&
+    firstParam.name !== "scope"
+  ) {
+    context.report({
+      node: constructor,
+      messageId: "invalidConstructorProperty",
+    });
+    return;
+  }
+
+  // NOTE: Check if the second parameter is named "id"
+  const secondParam = params[1];
+  if (
+    secondParam.type === AST_NODE_TYPES.Identifier &&
+    secondParam.name !== "id"
+  ) {
+    context.report({
+      node: constructor,
+      messageId: "invalidConstructorProperty",
+    });
+    return;
+  }
+
+  // NOTE: If there's no third parameter, return
+  if (params.length < 3) return;
+
+  // NOTE: Check if the third parameter is named "props"
+  const thirdParam = params[2];
+  if (
+    thirdParam.type === AST_NODE_TYPES.Identifier &&
+    thirdParam.name !== "props"
+  ) {
+    context.report({
+      node: constructor,
+      messageId: "invalidConstructorProperty",
+    });
+    return;
+  }
+};

package/src/rules/no-class-in-interface.ts

@@ -1,6 +1,6 @@
 import { AST_NODE_TYPES, ESLintUtils } from "@typescript-eslint/utils";
 
-import { SymbolFlags } from "../types/symbolFlags";
+import { SYMBOL_FLAGS } from "../constants/tsInternalFlags";
 
 /**
  * Enforces the use of interface types instead of class in interface properties
@@ -37,8 +37,10 @@ export const noClassInInterface = ESLintUtils.RuleCreator.withoutDocs({
           const type = parserServices.getTypeAtLocation(property);
           if (!type.symbol) continue;
 
-          // NOTE: check class type
-          const isClass = type.symbol.flags === SymbolFlags.Class;
+          // NOTE: In order not to make it dependent on the typescript library, it defines its own unions.
+          //       Therefore, the type information structures do not match.
+          // eslint-disable-next-line @typescript-eslint/no-unsafe-enum-comparison
+          const isClass = type.symbol.flags === SYMBOL_FLAGS.CLASS;
           if (!isClass) continue;
 
           context.report({

package/src/rules/no-construct-stack-suffix.ts

@@ -9,7 +9,20 @@ import { toPascalCase } from "../utils/convertString";
 import { getConstructorPropertyNames } from "../utils/parseType";
 import { isConstructOrStackType } from "../utils/typeCheck";
 
-type Context = TSESLint.RuleContext<"noConstructStackSuffix", []>;
+const SUFFIX_TYPE = {
+  CONSTRUCT: "Construct",
+  STACK: "Stack",
+} as const;
+
+type SuffixType = (typeof SUFFIX_TYPE)[keyof typeof SUFFIX_TYPE];
+
+type Options = [
+  {
+    disallowedSuffixes?: SuffixType[];
+  }
+];
+
+type Context = TSESLint.RuleContext<"noConstructStackSuffix", Options>;
 
 /**
  * Enforces that Construct IDs do not end with 'Construct' or 'Stack' suffix
@@ -28,11 +41,34 @@ export const noConstructStackSuffix = ESLintUtils.RuleCreator.withoutDocs({
       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);
@@ -43,7 +79,7 @@ export const noConstructStackSuffix = ESLintUtils.RuleCreator.withoutDocs({
         const constructorPropertyNames = getConstructorPropertyNames(type);
         if (constructorPropertyNames[1] !== "id") return;
 
-        validateConstructId(node, context);
+        validateConstructId(node, context, options);
       },
     };
   },
@@ -54,7 +90,8 @@ export const noConstructStackSuffix = ESLintUtils.RuleCreator.withoutDocs({
  */
 const validateConstructId = (
   node: TSESTree.NewExpression,
-  context: Context
+  context: Context,
+  options: { disallowedSuffixes: SuffixType[] }
 ): void => {
   // NOTE: Treat the second argument as ID
   const secondArg = node.arguments[1];
@@ -66,25 +103,32 @@ const validateConstructId = (
   }
 
   const formattedConstructId = toPascalCase(secondArg.value);
+  const disallowedSuffixes = options.disallowedSuffixes;
 
-  if (formattedConstructId.endsWith("Construct")) {
+  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,
       },
     });
   }

package/src/rules/no-parent-name-construct-id-match.ts

@@ -297,7 +297,7 @@ const validateConstructId = ({
     return;
   }
 
-  const formattedConstructId = toPascalCase(secondArg.value as string);
+  const formattedConstructId = toPascalCase(secondArg.value);
   const formattedParentClassName = toPascalCase(parentClassName);
   if (formattedParentClassName !== formattedConstructId) return;
 

package/src/rules/no-public-class-fields.ts

@@ -6,7 +6,7 @@ import {
   TSESTree,
 } from "@typescript-eslint/utils";
 
-import { SymbolFlags } from "../types/symbolFlags";
+import { SYMBOL_FLAGS } from "../constants/tsInternalFlags";
 import { isConstructOrStackType } from "../utils/typeCheck";
 
 type Context = TSESLint.RuleContext<"noPublicClassFields", []>;
@@ -91,7 +91,10 @@ const validateClassMember = (
     const type = parserServices.getTypeAtLocation(member);
     if (!type.symbol) continue;
 
-    const isClass = type.symbol.flags === SymbolFlags.Class;
+    // NOTE: In order not to make it dependent on the typescript library, it defines its own unions.
+    //       Therefore, the type information structures do not match.
+    // eslint-disable-next-line @typescript-eslint/no-unsafe-enum-comparison
+    const isClass = type.symbol.flags === SYMBOL_FLAGS.CLASS;
     if (!isClass) continue;
 
     context.report({
@@ -133,7 +136,10 @@ const validateConstructorParameterProperty = (
     const type = parserServices.getTypeAtLocation(param);
     if (!type.symbol) continue;
 
-    const isClass = type.symbol.flags === SymbolFlags.Class;
+    // NOTE: In order not to make it dependent on the typescript library, it defines its own unions.
+    //       Therefore, the type information structures do not match.
+    // eslint-disable-next-line @typescript-eslint/no-unsafe-enum-comparison
+    const isClass = type.symbol.flags === SYMBOL_FLAGS.CLASS;
     if (!isClass) continue;
 
     context.report({

package/src/rules/no-variable-construct-id.ts

@@ -93,6 +93,25 @@ const isInsideLoop = (node: TSESTree.Node): boolean => {
     ) {
       return true;
     }
+
+    // NOTE: Check for array methods like forEach, map, etc.
+    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;

package/src/rules/pascal-case-construct-id.ts

@@ -93,7 +93,7 @@ const validateConstructId = (
     node,
     messageId: "pascalCaseConstructId",
     fix: (fixer) => {
-      const pascalCaseValue = toPascalCase(secondArg.value as string);
+      const pascalCaseValue = toPascalCase(secondArg.value);
       return fixer.replaceText(secondArg, `${quote}${pascalCaseValue}${quote}`);
     },
   });

package/src/rules/require-passing-this.ts

@@ -1,8 +1,20 @@
-import { AST_NODE_TYPES, ESLintUtils } from "@typescript-eslint/utils";
+import {
+  AST_NODE_TYPES,
+  ESLintUtils,
+  TSESLint,
+} from "@typescript-eslint/utils";
 
 import { getConstructorPropertyNames } from "../utils/parseType";
 import { isConstructType } from "../utils/typeCheck";
 
+type Options = [
+  {
+    allowNonThisAndDisallowScope?: boolean;
+  }
+];
+
+type Context = TSESLint.RuleContext<"requirePassingThis", Options>;
+
 /**
  * Enforces that `this` is passed to the constructor
  * @param context - The rule context provided by ESLint
@@ -18,11 +30,29 @@ export 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: [],
-  create(context) {
+  defaultOptions: [
+    {
+      allowNonThisAndDisallowScope: false,
+    },
+  ],
+  create(context: Context) {
+    const options = context.options[0] || {
+      allowNonThisAndDisallowScope: false,
+    };
     const parserServices = ESLintUtils.getParserServices(context);
     return {
       NewExpression(node) {
@@ -31,18 +61,39 @@ export const requirePassingThis = ESLintUtils.RuleCreator.withoutDocs({
         if (!isConstructType(type) || !node.arguments.length) return;
 
         const argument = node.arguments[0];
+
+        // NOTE: If the first argument is already `this`, it's valid
         if (argument.type === AST_NODE_TYPES.ThisExpression) return;
 
+        // NOTE: If the first argument is not `scope`, it's valid
         const constructorPropertyNames = getConstructorPropertyNames(type);
         if (constructorPropertyNames[0] !== "scope") return;
 
-        context.report({
-          node,
-          messageId: "requirePassingThis",
-          fix: (fixer) => {
-            return fixer.replaceText(argument, "this");
-          },
-        });
+        // NOTE: If `allowNonThisAndDisallowScope` is false, require `this` for all cases
+        if (!options.allowNonThisAndDisallowScope) {
+          context.report({
+            node,
+            messageId: "requirePassingThis",
+            fix: (fixer) => {
+              return fixer.replaceText(argument, "this");
+            },
+          });
+          return;
+        }
+        // NOTE: If `allowNonThisAndDisallowScope` is true, allow non-`this` values except `scope` variable
+        // Check if the argument is the `scope` variable
+        if (
+          argument.type === AST_NODE_TYPES.Identifier &&
+          argument.name === "scope"
+        ) {
+          context.report({
+            node,
+            messageId: "requirePassingThis",
+            fix: (fixer) => {
+              return fixer.replaceText(argument, "this");
+            },
+          });
+        }
       },
     };
   },

package/src/utils/parseType.ts

@@ -1,4 +1,12 @@
-import { isClassDeclaration, isConstructorDeclaration, Type } from "typescript";
+import {
+  ClassDeclaration,
+  ConstructorDeclaration,
+  Declaration,
+  Node,
+  Type,
+} from "typescript";
+
+import { SYNTAX_KIND } from "../constants/tsInternalFlags";
 
 /**
  * Parses type to get the property names of the class constructor.
@@ -18,3 +26,27 @@ export const getConstructorPropertyNames = (type: Type): string[] => {
 
   return constructor.parameters.map((param) => param.name.getText());
 };
+
+/**
+ * Implementing `isClassDeclaration` defined in typescript on your own, in order not to include TypeScript in dependencies
+ */
+const isClassDeclaration = (
+  declaration: Declaration
+): declaration is ClassDeclaration => {
+  // NOTE: In order not to make it dependent on the typescript library, it defines its own unions.
+  //       Therefore, the type information structures do not match.
+  // eslint-disable-next-line @typescript-eslint/no-unsafe-enum-comparison
+  return declaration.kind === SYNTAX_KIND.CLASS_DECLARATION;
+};
+
+/**
+ * Implementing `isConstructorDeclaration` defined in typescript on your own, in order not to include TypeScript in dependencies
+ */
+const isConstructorDeclaration = (
+  node: Node
+): node is ConstructorDeclaration => {
+  // NOTE: In order not to make it dependent on the typescript library, it defines its own unions.
+  //       Therefore, the type information structures do not match.
+  // eslint-disable-next-line @typescript-eslint/no-unsafe-enum-comparison
+  return node.kind === SYNTAX_KIND.CONSTRUCTOR;
+};

package/src/utils/typeCheck.ts

@@ -53,6 +53,6 @@ const isTargetSuperClassType = (
   }
 
   // NOTE: Check the base type
-  const baseTypes = type.getBaseTypes() || [];
+  const baseTypes = type.getBaseTypes() ?? [];
   return baseTypes.some((baseType) => typeCheckFunction(baseType));
 };

package/src/types/symbolFlags.ts

@@ -1,6 +0,0 @@
-/**
- * Implementing `SymbolFlags` defined in typescript on your own, in order not to include TypeScript in dependencies
- */
-export enum SymbolFlags {
-  Class = 32,
-}