eslint-cdk-plugin 2.2.0 → 3.0.2

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "eslint-cdk-plugin",
-  "version": "2.2.0",
+  "version": "3.0.2",
   "description": "eslint plugin for AWS CDK projects",
   "main": "./dist/index.mjs",
   "types": "./dist/index.d.ts",
@@ -30,23 +30,24 @@
     "docs:preview": "cd ./docs && pnpm install && pnpm run preview"
   },
   "devDependencies": {
-    "@eslint/js": "^9.22.0",
-    "@types/node": "^22.13.10",
-    "@typescript-eslint/rule-tester": "^8.26.0",
+    "@eslint/js": "^9.26.0",
+    "@types/node": "^22.15.0",
+    "@typescript-eslint/rule-tester": "^8.32.1",
     "eslint": "9.22.0",
     "eslint-plugin-import": "^2.31.0",
-    "pkgroll": "^2.11.2",
+    "pkgroll": "^2.12.2",
     "standard-version": "^9.5.0",
-    "typescript": "^5.8.2",
-    "typescript-eslint": "^8.26.0",
-    "vitest": "^3.0.8"
+    "typescript": "^5.8.3",
+    "typescript-eslint": "^8.32.1",
+    "vitepress-plugin-llms": "^1.1.4",
+    "vitest": "^3.1.3"
   },
   "dependencies": {
-    "@typescript-eslint/parser": "^8.26.0",
-    "@typescript-eslint/utils": "^8.26.0"
+    "@typescript-eslint/parser": "^8.32.1",
+    "@typescript-eslint/utils": "^8.32.1"
   },
   "volta": {
-    "node": "22.14.0"
+    "node": "22.15.0"
   },
   "files": [
     "dist",

package/src/index.ts

@@ -3,13 +3,13 @@ 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 { noConstructInInterface } from "./rules/no-construct-in-interface";
+import { noConstructInPublicPropertyOfConstruct } from "./rules/no-construct-in-public-property-of-construct";
 import { noConstructStackSuffix } from "./rules/no-construct-stack-suffix";
 import { noImportPrivate } from "./rules/no-import-private";
-import { noMutablePropsInterface } from "./rules/no-mutable-props-interface";
-import { noMutablePublicFields } from "./rules/no-mutable-public-fields";
+import { noMutablePropertyOfPropsInterface } from "./rules/no-mutable-property-of-props-interface";
+import { noMutablePublicPropertyOfConstruct } from "./rules/no-mutable-public-property-of-construct";
 import { noParentNameConstructIdMatch } from "./rules/no-parent-name-construct-id-match";
-import { noPublicClassFields } from "./rules/no-public-class-fields";
 import { noVariableConstructId } from "./rules/no-variable-construct-id";
 import { pascalCaseConstructId } from "./rules/pascal-case-construct-id";
 import { propsNameConvention } from "./rules/props-name-convention";
@@ -18,20 +18,21 @@ import { requirePassingThis } from "./rules/require-passing-this";
 import { requirePropsDefaultDoc } from "./rules/require-props-default-doc";
 
 const rules = {
-  "no-class-in-interface": noClassInInterface,
+  "construct-constructor-property": constructConstructorProperty,
+  "no-construct-in-interface": noConstructInInterface,
+  "no-construct-in-public-property-of-construct":
+    noConstructInPublicPropertyOfConstruct,
   "no-construct-stack-suffix": noConstructStackSuffix,
+  "no-import-private": noImportPrivate,
+  "no-mutable-property-of-props-interface": noMutablePropertyOfPropsInterface,
+  "no-mutable-public-property-of-construct": noMutablePublicPropertyOfConstruct,
   "no-parent-name-construct-id-match": noParentNameConstructIdMatch,
-  "no-public-class-fields": noPublicClassFields,
-  "pascal-case-construct-id": pascalCaseConstructId,
-  "require-passing-this": requirePassingThis,
   "no-variable-construct-id": noVariableConstructId,
-  "no-mutable-public-fields": noMutablePublicFields,
-  "no-mutable-props-interface": noMutablePropsInterface,
-  "construct-constructor-property": constructConstructorProperty,
+  "pascal-case-construct-id": pascalCaseConstructId,
+  "props-name-convention": propsNameConvention,
   "require-jsdoc": requireJSDoc,
+  "require-passing-this": requirePassingThis,
   "require-props-default-doc": requirePropsDefaultDoc,
-  "props-name-convention": propsNameConvention,
-  "no-import-private": noImportPrivate,
 };
 
 const cdkPlugin = {
@@ -55,39 +56,39 @@ const createFlatConfig = (rules: Record<string, unknown>) => {
 };
 
 const recommended = createFlatConfig({
-  "cdk/no-class-in-interface": "error",
+  "cdk/construct-constructor-property": "error",
+  "cdk/no-construct-in-interface": "error",
+  "cdk/no-construct-in-public-property-of-construct": "error",
   "cdk/no-construct-stack-suffix": "error",
+  "cdk/no-mutable-property-of-props-interface": "warn",
+  "cdk/no-mutable-public-property-of-construct": "warn",
   "cdk/no-parent-name-construct-id-match": [
     "error",
     { disallowContainingParentName: false },
   ],
-  "cdk/no-public-class-fields": "error",
+  "cdk/no-variable-construct-id": "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/construct-constructor-property": "error",
+  "cdk/no-construct-in-interface": "error",
+  "cdk/no-construct-in-public-property-of-construct": "error",
   "cdk/no-construct-stack-suffix": "error",
+  "cdk/no-import-private": "error",
+  "cdk/no-mutable-property-of-props-interface": "error",
+  "cdk/no-mutable-public-property-of-construct": "error",
   "cdk/no-parent-name-construct-id-match": [
     "error",
     { disallowContainingParentName: true },
   ],
-  "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/pascal-case-construct-id": "error",
+  "cdk/props-name-convention": "error",
   "cdk/require-jsdoc": "error",
+  "cdk/require-passing-this": "error",
   "cdk/require-props-default-doc": "error",
-  "cdk/props-name-convention": "error",
-  "cdk/no-import-private": "error",
 });
 
 const configs = {

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

@@ -67,7 +67,7 @@ const validateConstructorProperty = (
   // NOTE: Check if the constructor has at least 2 parameters
   if (params.length < 2) {
     context.report({
-      node: constructor,
+      node: constructor.value,
       messageId: "invalidConstructorProperty",
     });
     return;
@@ -80,7 +80,7 @@ const validateConstructorProperty = (
     firstParam.name !== "scope"
   ) {
     context.report({
-      node: constructor,
+      node: firstParam,
       messageId: "invalidConstructorProperty",
     });
     return;
@@ -93,7 +93,7 @@ const validateConstructorProperty = (
     secondParam.name !== "id"
   ) {
     context.report({
-      node: constructor,
+      node: secondParam,
       messageId: "invalidConstructorProperty",
     });
     return;
@@ -109,7 +109,7 @@ const validateConstructorProperty = (
     thirdParam.name !== "props"
   ) {
     context.report({
-      node: constructor,
+      node: thirdParam,
       messageId: "invalidConstructorProperty",
     });
     return;

package/src/rules/{no-class-in-interface.ts → no-construct-in-interface.ts}

@@ -1,22 +1,23 @@
 import { AST_NODE_TYPES, ESLintUtils } from "@typescript-eslint/utils";
 
 import { SYMBOL_FLAGS } from "../constants/tsInternalFlags";
+import { isConstructOrStackType } from "../utils/typeCheck";
 
 /**
- * Enforces the use of interface types instead of class in interface properties
+ * Enforces the use of interface types instead of CDK Construct types in interface properties
  * @param context - The rule context provided by ESLint
  * @returns An object containing the AST visitor functions
  * @see {@link https://eslint-cdk-plugin.dev/rules/no-class-in-interface} - Documentation
  */
-export const noClassInInterface = ESLintUtils.RuleCreator.withoutDocs({
+export const noConstructInInterface = ESLintUtils.RuleCreator.withoutDocs({
   meta: {
     type: "problem",
     docs: {
-      description: "Disallow class types in interface properties",
+      description: "Disallow CDK Construct types in interface properties",
     },
     messages: {
-      noClassInInterfaceProps:
-        "Interface property '{{ propertyName }}' should not use class type '{{ typeName }}'. Consider using an interface or type alias instead.",
+      invalidInterfaceProperty:
+        "Interface property '{{ propertyName }}' should not use CDK Construct type '{{ typeName }}'. Consider using an interface or type alias instead.",
     },
     schema: [],
   },
@@ -35,7 +36,7 @@ export const noClassInInterface = ESLintUtils.RuleCreator.withoutDocs({
           }
 
           const type = parserServices.getTypeAtLocation(property);
-          if (!type.symbol) continue;
+          if (!isConstructOrStackType(type)) continue;
 
           // 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.
@@ -45,7 +46,7 @@ export const noClassInInterface = ESLintUtils.RuleCreator.withoutDocs({
 
           context.report({
             node: property,
-            messageId: "noClassInInterfaceProps",
+            messageId: "invalidInterfaceProperty",
             data: {
               propertyName: property.key.name,
               typeName: type.symbol.name,

package/src/rules/no-construct-in-public-property-of-construct.ts

@@ -0,0 +1,155 @@
+import {
+  AST_NODE_TYPES,
+  ESLintUtils,
+  ParserServicesWithTypeInformation,
+  TSESLint,
+  TSESTree,
+} from "@typescript-eslint/utils";
+
+import { SYMBOL_FLAGS } from "../constants/tsInternalFlags";
+import { isConstructOrStackType } from "../utils/typeCheck";
+
+type Context = TSESLint.RuleContext<"invalidPublicPropertyOfConstruct", []>;
+
+/**
+ * Disallow Construct types in public property of Construct
+ * @param context - The rule context provided by ESLint
+ * @returns An object containing the AST visitor functions
+ * @see {@link https://eslint-cdk-plugin.dev/rules/no-construct-in-public-property-of-construct} - Documentation
+ */
+export const noConstructInPublicPropertyOfConstruct =
+  ESLintUtils.RuleCreator.withoutDocs({
+    meta: {
+      type: "problem",
+      docs: {
+        description: "Disallow Construct types in public property of Construct",
+      },
+      messages: {
+        invalidPublicPropertyOfConstruct:
+          "Public property '{{ propertyName }}' of Construct should not use Construct type '{{ typeName }}'. Consider using an interface or type alias instead.",
+      },
+      schema: [],
+    },
+    defaultOptions: [],
+    create(context) {
+      const parserServices = ESLintUtils.getParserServices(context);
+      return {
+        ClassDeclaration(node) {
+          const type = parserServices.getTypeAtLocation(node);
+          if (!isConstructOrStackType(type)) return;
+
+          // NOTE: Check class members
+          validatePublicPropertyOfConstruct(node, context, parserServices);
+
+          // NOTE: Check constructor parameter properties
+          const constructor = node.body.body.find(
+            (member): member is TSESTree.MethodDefinition =>
+              member.type === AST_NODE_TYPES.MethodDefinition &&
+              member.kind === "constructor"
+          );
+          if (
+            !constructor ||
+            constructor.value.type !== AST_NODE_TYPES.FunctionExpression
+          ) {
+            return;
+          }
+
+          validateConstructorParameterProperty(
+            constructor,
+            context,
+            parserServices
+          );
+        },
+      };
+    },
+  });
+
+/**
+ * check the public property of Construct
+ * - if it is a Construct type, report an error
+ */
+const validatePublicPropertyOfConstruct = (
+  node: TSESTree.ClassDeclaration,
+  context: Context,
+  parserServices: ParserServicesWithTypeInformation
+) => {
+  for (const property of node.body.body) {
+    if (
+      property.type !== AST_NODE_TYPES.PropertyDefinition ||
+      property.key.type !== AST_NODE_TYPES.Identifier
+    ) {
+      continue;
+    }
+
+    // NOTE: Skip private and protected fields
+    if (["private", "protected"].includes(property.accessibility ?? "")) {
+      continue;
+    }
+
+    // NOTE: Skip fields without type annotation
+    if (!property.typeAnnotation) continue;
+
+    const type = parserServices.getTypeAtLocation(property);
+    if (!isConstructOrStackType(type)) continue;
+
+    // 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({
+      node: property,
+      messageId: "invalidPublicPropertyOfConstruct",
+      data: {
+        propertyName: property.key.name,
+        typeName: type.symbol.name,
+      },
+    });
+  }
+};
+
+/**
+ * check the constructor parameter property
+ * - if it is a Construct type, report an error
+ */
+const validateConstructorParameterProperty = (
+  constructor: TSESTree.MethodDefinition,
+  context: Context,
+  parserServices: ParserServicesWithTypeInformation
+) => {
+  for (const param of constructor.value.params) {
+    if (
+      param.type !== AST_NODE_TYPES.TSParameterProperty ||
+      param.parameter.type !== AST_NODE_TYPES.Identifier
+    ) {
+      continue;
+    }
+
+    // NOTE: Skip private and protected parameters
+    if (["private", "protected"].includes(param.accessibility ?? "")) {
+      continue;
+    }
+
+    // NOTE: Skip parameters without type annotation
+    if (!param.parameter.typeAnnotation) continue;
+
+    const type = parserServices.getTypeAtLocation(param);
+    if (!isConstructOrStackType(type)) continue;
+
+    // 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({
+      node: param,
+      messageId: "invalidPublicPropertyOfConstruct",
+      data: {
+        propertyName: param.parameter.name,
+        typeName: type.symbol.name,
+      },
+    });
+  }
+};

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

@@ -22,7 +22,7 @@ type Options = [
   }
 ];
 
-type Context = TSESLint.RuleContext<"noConstructStackSuffix", Options>;
+type Context = TSESLint.RuleContext<"invalidConstructId", Options>;
 
 /**
  * Enforces that Construct IDs do not end with 'Construct' or 'Stack' suffix
@@ -38,7 +38,7 @@ export const noConstructStackSuffix = ESLintUtils.RuleCreator.withoutDocs({
         "Effort to avoid using 'Construct' and 'Stack' suffix in construct id.",
     },
     messages: {
-      noConstructStackSuffix:
+      invalidConstructId:
         "{{ classType }} ID '{{ id }}' should not include {{ suffix }} suffix.",
     },
     schema: [
@@ -110,8 +110,8 @@ const validateConstructId = (
     formattedConstructId.endsWith(SUFFIX_TYPE.CONSTRUCT)
   ) {
     context.report({
-      node,
-      messageId: "noConstructStackSuffix",
+      node: secondArg,
+      messageId: "invalidConstructId",
       data: {
         classType: "Construct",
         id: secondArg.value,
@@ -123,8 +123,8 @@ const validateConstructId = (
     formattedConstructId.endsWith(SUFFIX_TYPE.STACK)
   ) {
     context.report({
-      node,
-      messageId: "noConstructStackSuffix",
+      node: secondArg,
+      messageId: "invalidConstructId",
       data: {
         classType: "Stack",
         id: secondArg.value,

package/src/rules/no-import-private.ts

@@ -16,7 +16,7 @@ export const noImportPrivate: Rule.RuleModule = {
         "Cannot import modules from private dir at different levels of the hierarchy.",
     },
     messages: {
-      noImportPrivate:
+      invalidImportPath:
         "Cannot import modules from private dir at different levels of the hierarchy.",
     },
     schema: [],
@@ -43,7 +43,7 @@ export const noImportPrivate: Rule.RuleModule = {
             (segment, index) => segment !== importDirSegments[index]
           )
         ) {
-          context.report({ node, messageId: "noImportPrivate" });
+          context.report({ node, messageId: "invalidImportPath" });
         }
       },
     };

package/src/rules/no-mutable-property-of-props-interface.ts

@@ -0,0 +1,60 @@
+import { AST_NODE_TYPES, ESLintUtils } from "@typescript-eslint/utils";
+
+/**
+ * Disallow mutable properties of Construct Props (interface)
+ * @param context - The rule context provided by ESLint
+ * @returns An object containing the AST visitor functions
+ * @see {@link https://eslint-cdk-plugin.dev/rules/no-mutable-property-of-props-interface} - Documentation
+ */
+export const noMutablePropertyOfPropsInterface =
+  ESLintUtils.RuleCreator.withoutDocs({
+    meta: {
+      type: "problem",
+      docs: {
+        description:
+          "Disallow mutable properties of Construct Props (interface)",
+      },
+      fixable: "code",
+      messages: {
+        invalidPropertyOfPropsInterface:
+          "Property '{{ propertyName }}' of Construct Props should be readonly.",
+      },
+      schema: [],
+    },
+    defaultOptions: [],
+    create(context) {
+      return {
+        TSInterfaceDeclaration(node) {
+          const sourceCode = context.sourceCode;
+
+          // NOTE: Interface name check for "Props"
+          if (!node.id.name.endsWith("Props")) return;
+
+          for (const property of node.body.body) {
+            // NOTE: check property signature
+            if (
+              property.type !== AST_NODE_TYPES.TSPropertySignature ||
+              property.key.type !== AST_NODE_TYPES.Identifier
+            ) {
+              continue;
+            }
+
+            // NOTE: Skip if already readonly
+            if (property.readonly) continue;
+
+            context.report({
+              node: property,
+              messageId: "invalidPropertyOfPropsInterface",
+              data: {
+                propertyName: property.key.name,
+              },
+              fix: (fixer) => {
+                const propertyText = sourceCode.getText(property);
+                return fixer.replaceText(property, `readonly ${propertyText}`);
+              },
+            });
+          }
+        },
+      };
+    },
+  });

package/src/rules/no-mutable-public-property-of-construct.ts

@@ -0,0 +1,76 @@
+import { AST_NODE_TYPES, ESLintUtils } from "@typescript-eslint/utils";
+
+import { isConstructOrStackType } from "../utils/typeCheck";
+
+/**
+ * Disallow mutable public properties of Construct
+ * @param context - The rule context provided by ESLint
+ * @returns An object containing the AST visitor functions
+ * @see {@link https://eslint-cdk-plugin.dev/rules/no-mutable-public-property-of-construct} - Documentation
+ */
+export const noMutablePublicPropertyOfConstruct =
+  ESLintUtils.RuleCreator.withoutDocs({
+    meta: {
+      type: "problem",
+      docs: {
+        description: "Disallow mutable public properties of Construct",
+      },
+      fixable: "code",
+      messages: {
+        invalidPublicPropertyOfConstruct:
+          "Public property '{{ propertyName }}' should be readonly. Consider adding the 'readonly' modifier.",
+      },
+      schema: [],
+    },
+    defaultOptions: [],
+    create(context) {
+      const parserServices = ESLintUtils.getParserServices(context);
+
+      return {
+        ClassDeclaration(node) {
+          const sourceCode = context.sourceCode;
+          const type = parserServices.getTypeAtLocation(node);
+          if (!isConstructOrStackType(type)) return;
+
+          for (const member of node.body.body) {
+            // NOTE: check property definition
+            if (
+              member.type !== AST_NODE_TYPES.PropertyDefinition ||
+              member.key.type !== AST_NODE_TYPES.Identifier
+            ) {
+              continue;
+            }
+
+            // NOTE: Skip private and protected fields
+            if (["private", "protected"].includes(member.accessibility ?? "")) {
+              continue;
+            }
+
+            // NOTE: Skip if readonly is present
+            if (member.readonly) continue;
+
+            context.report({
+              node: member,
+              messageId: "invalidPublicPropertyOfConstruct",
+              data: {
+                propertyName: member.key.name,
+              },
+              fix: (fixer) => {
+                const accessibility = member.accessibility ? "public " : "";
+                const paramText = sourceCode.getText(member);
+                const [key, value] = paramText.split(":");
+                const replacedKey = key.startsWith("public ")
+                  ? key.replace("public ", "")
+                  : key;
+
+                return fixer.replaceText(
+                  member,
+                  `${accessibility}readonly ${replacedKey}:${value}`
+                );
+              },
+            });
+          }
+        },
+      };
+    },
+  });