eslint-cdk-plugin 3.4.4 → 3.4.6

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "eslint-cdk-plugin",
-  "version": "3.4.4",
+  "version": "3.4.6",
   "description": "eslint plugin for AWS CDK projects",
   "main": "./dist/index.mjs",
   "types": "./dist/index.d.ts",
@@ -20,44 +20,42 @@
     "migrate-cdk-plugin": "./bin/migration.mjs"
   },
   "scripts": {
-    "build": "sh scripts/build.sh",
+    "build": "tsdown",
     "test": "vitest --run",
-    "lint": "eslint --fix --config eslint.config.js",
+    "test:integration": "sh scripts/integration-test.sh",
+    "lint": "eslint --fix",
     "check": "tsc --noEmit",
     "pack": "pnpm run build && npm pack",
     "docs": "pnpm run --filter=@eslint-cdk-plugin/docs",
-    "example:flat-config": "pnpm run --filter=@eslint-cdk-plugin/example-flat-config",
-    "prebuild": "rolldown -c"
+    "example:flat-config": "pnpm run --filter=@eslint-cdk-plugin/example-flat-config"
   },
   "devDependencies": {
-    "@eslint/js": "^9.36.0",
-    "@secretlint/secretlint-rule-preset-recommend": "^11.2.4",
-    "@types/node": "^24.9.2",
-    "@typescript-eslint/rule-tester": "^8.46.2",
-    "@vitest/coverage-v8": "3.2.4",
-    "commander": "^14.0.1",
+    "@eslint/js": "^9.39.1",
+    "@secretlint/secretlint-rule-preset-recommend": "^11.2.5",
+    "@types/node": "^24.10.0",
+    "@typescript-eslint/parser": "^8.48.1",
+    "@typescript-eslint/rule-tester": "^8.48.1",
+    "@typescript-eslint/utils": "^8.48.1",
+    "commander": "^14.0.2",
     "consola": "^3.4.2",
-    "eslint": "^9.38.0",
+    "eslint": "^9.39.1",
     "eslint-plugin-import": "^2.32.0",
-    "pkgroll": "^2.20.1",
-    "rolldown": "1.0.0-beta.45",
-    "secretlint": "^11.2.4",
+    "secretlint": "^11.2.5",
+    "tsdown": "^0.17.0",
     "typescript": "^5.9.3",
-    "typescript-eslint": "^8.46.2",
-    "vitest": "^3.2.4"
-  },
-  "dependencies": {
-    "@typescript-eslint/parser": "^8.46.2",
-    "@typescript-eslint/utils": "^8.46.2"
+    "typescript-eslint": "^8.48.1",
+    "vitest": "^4.0.6"
   },
   "peerDependencies": {
-    "typescript": ">=5.0.0"
+    "eslint": "^8.57.0 || ^9.0.0",
+    "typescript": ">=4.8.4 <6.0.0"
   },
   "engines": {
     "node": "^18.18.0 || ^20.9.0 || >=21.1.0"
   },
   "packageManager": "pnpm@10.10.0",
   "files": [
+    "bin",
     "dist",
     "src",
     "!src/__tests__",

package/src/configs/flat-config.ts

@@ -0,0 +1,69 @@
+import tsParser from "@typescript-eslint/parser";
+import { FlatConfig } from "@typescript-eslint/utils/ts-eslint";
+
+import { name, version } from "../../package.json";
+import { rules } from "../rules";
+
+const cdk = {
+  meta: { name, version },
+  rules,
+};
+
+const createFlatConfig = (
+  rules: FlatConfig.Rules
+): {
+  languageOptions: FlatConfig.LanguageOptions;
+  plugins: FlatConfig.Plugins;
+  rules: FlatConfig.Rules;
+} => {
+  return {
+    plugins: {
+      cdk,
+    },
+    languageOptions: {
+      parser: tsParser,
+      parserOptions: {
+        projectService: true,
+      },
+    },
+    rules,
+  };
+};
+
+export const recommended = createFlatConfig({
+  "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-unused-props": "error",
+  "cdk/no-variable-construct-id": "error",
+  "cdk/pascal-case-construct-id": "error",
+  "cdk/require-passing-this": ["error", { allowNonThisAndDisallowScope: true }],
+});
+
+export const strict = createFlatConfig({
+  "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-unused-props": "error",
+  "cdk/no-variable-construct-id": "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",
+});

package/src/configs/index.ts

@@ -0,0 +1,6 @@
+import { recommended, strict } from "./flat-config";
+
+export const configs = {
+  recommended,
+  strict,
+};

package/src/{utils/get-child-nodes.ts → core/ast-node/finder/child-nodes.ts}

@@ -1,9 +1,9 @@
 import { TSESTree } from "@typescript-eslint/utils";
 
 /**
- * Safely gets child nodes from a TSESTree.Node
+ * find child nodes from a TSESTree.Node
  */
-export const getChildNodes = (node: TSESTree.Node): TSESTree.Node[] => {
+export const findChildNodes = (node: TSESTree.Node): TSESTree.Node[] => {
   return Object.entries(node).reduce<TSESTree.Node[]>((acc, [key, value]) => {
     if (["parent", "range", "loc"].includes(key)) return acc; // Keys to skip to avoid circular references and unnecessary properties
     if (isESTreeNode(value)) return [...acc, value];

package/src/{utils/getConstructor.ts → core/ast-node/finder/constructor.ts}

@@ -5,7 +5,7 @@ import { AST_NODE_TYPES, TSESTree } from "@typescript-eslint/utils";
  * @param node The class declaration
  * @returns The constructor method definition or undefined if not found
  */
-export const getConstructor = (
+export const findConstructor = (
   node: TSESTree.ClassDeclaration
 ): TSESTree.MethodDefinition | undefined => {
   return node.body.body.find(

package/src/core/ast-node/finder/property-name.ts

@@ -0,0 +1,20 @@
+import { AST_NODE_TYPES, TSESTree } from "@typescript-eslint/utils";
+
+/**
+ * Retrieves the property names from an array of properties.
+ *
+ * @param properties An array of properties to extract names from.
+ * @returns An array of property names.
+ */
+export const findPropertyNames = (
+  properties: (TSESTree.Property | TSESTree.RestElement)[]
+): string[] => {
+  return properties.reduce<string[]>(
+    (acc, prop) =>
+      prop.type === AST_NODE_TYPES.Property &&
+      prop.key.type === AST_NODE_TYPES.Identifier
+        ? [...acc, prop.key.name]
+        : acc,
+    []
+  );
+};

package/src/core/ast-node/finder/public-property.ts

@@ -0,0 +1,76 @@
+import { AST_NODE_TYPES, TSESTree } from "@typescript-eslint/utils";
+
+import { findConstructor } from "./constructor";
+
+export type PublicProperty = {
+  /**
+   * Name of the public property
+   */
+  name: string;
+  /**
+   * AST node representing the public property
+   */
+  node:
+    | TSESTree.PropertyDefinitionComputedName
+    | TSESTree.PropertyDefinitionNonComputedName
+    | TSESTree.TSParameterProperty;
+};
+
+export const findPublicPropertiesInClass = (
+  node: TSESTree.ClassDeclaration
+): PublicProperty[] => {
+  const constructorProperties = findPropertiesInConstructor(node);
+  const classElementProperties = findPropertiesInClassElement(node);
+  return [...constructorProperties, ...classElementProperties];
+}
+
+const findPropertiesInConstructor = (
+  node: TSESTree.ClassDeclaration
+) => {
+  const constructor = findConstructor(node);
+  if (!constructor) return [];
+  return constructor.value.params.flatMap(
+    (property) => findPublicProperty(property) ?? []
+  );
+}
+
+const findPropertiesInClassElement = (node: TSESTree.ClassDeclaration): PublicProperty[] => {
+  return node.body.body.flatMap(
+    (property) => findPublicProperty(property) ?? []
+  );
+};
+
+const findPublicProperty = (
+  property: TSESTree.Parameter | TSESTree.ClassElement
+): PublicProperty | undefined => {
+  switch (property.type) {
+    // NOTE: get from constructor
+    case AST_NODE_TYPES.TSParameterProperty: {
+      if (property.parameter.type !== AST_NODE_TYPES.Identifier) {
+        return;
+      }
+      if (["private", "protected"].includes(property.accessibility ?? "")) {
+        return;
+      }
+      if (!property.parameter.typeAnnotation) return;
+      return {
+        name: property.parameter.name,
+        node: property,
+      };
+    }
+    // NOTE: get from class element
+    case AST_NODE_TYPES.PropertyDefinition: {
+      if (property.key.type !== AST_NODE_TYPES.Identifier) {
+        return;
+      }
+      if (["private", "protected"].includes(property.accessibility ?? "")) {
+        return;
+      }
+      if (!property.typeAnnotation) return;
+      return {
+        name: property.key.name,
+        node: property,
+      };
+    }
+  }
+};

package/src/core/cdk-construct/type-checker/is-construct-or-stack.ts

@@ -0,0 +1,21 @@
+import { Type } from "typescript";
+
+import { isExtendsFromTargetSuperClass } from "../../ts-type/checker/is-extends-target-super-class";
+
+/**
+ * Check if the type extends Construct or Stack
+ * @param type - The type to check
+ * @param ignoredClasses - Classes that inherit from Construct Class or Stack Class but do not want to be treated as Construct Class or Stack Class
+ * @returns True if the type extends Construct or Stack, otherwise false
+ */
+export const isConstructOrStackType = (
+  type: Type,
+  ignoredClasses: readonly string[] = ["App", "Stage", "CfnOutput"] as const
+): boolean => {
+  if (ignoredClasses.includes(type.symbol?.name ?? "")) return false;
+  return isExtendsFromTargetSuperClass(
+    type,
+    ["Construct", "Stack"],
+    isConstructOrStackType
+  );
+};

package/src/core/cdk-construct/type-checker/is-construct.ts

@@ -0,0 +1,22 @@
+import { Type } from "typescript";
+
+import { isExtendsFromTargetSuperClass } from "../../ts-type/checker/is-extends-target-super-class";
+
+/**
+ * Check if the type extends Construct
+ * @param type - The type to check
+ * @param ignoredClasses - Classes that inherit from Construct Class but do not want to be treated as Construct Class
+ * @returns True if the type extends Construct, otherwise false
+ */
+export const isConstructType = (
+  type: Type,
+  ignoredClasses: readonly string[] = [
+    "App",
+    "Stage",
+    "CfnOutput",
+    "Stack",
+  ] as const
+): boolean => {
+  if (ignoredClasses.includes(type.symbol?.name ?? "")) return false;
+  return isExtendsFromTargetSuperClass(type, ["Construct"], isConstructType);
+};

package/src/{utils → core/cdk-construct/type-checker}/is-resource-with-readonly-interface.ts

@@ -2,12 +2,13 @@ import {
   isClassDeclaration,
   isIdentifier,
   isPropertyAccessExpression,
+  SyntaxKind,
   Type,
 } from "typescript";
 
-import { isResourceType } from "./typecheck/cdk";
-import { checkHeritageClauseIsImplements } from "./typecheck/ts-node";
-import { isClassType } from "./typecheck/ts-type";
+import { isClassType } from "../../ts-type/checker/is-class";
+
+import { isResourceType } from "./is-resource";
 
 /**
  * Checks if the type is an AWS resource Construct that implements a read-only resource interface
@@ -140,7 +141,7 @@ const getDirectImplementedInterfaceNames = (type: Type): string[] => {
     if (!heritageClauses) return acc;
 
     return heritageClauses.reduce<string[]>((hcAcc, hc) => {
-      if (!checkHeritageClauseIsImplements(hc)) return hcAcc;
+      if (hc.token !== SyntaxKind.ImplementsKeyword) return hcAcc;
 
       return hc.types.reduce<string[]>((typeAcc, type) => {
         const expression = type.expression;

package/src/core/cdk-construct/type-checker/is-resource.ts

@@ -0,0 +1,17 @@
+import { Type } from "typescript";
+
+import { isExtendsFromTargetSuperClass } from "../../ts-type/checker/is-extends-target-super-class";
+
+/**
+ * Check if the type extends Resource
+ * @param type - The type to check
+ * @param ignoredClasses - Classes that inherit from Resource Class but do not want to be treated as Resource Class
+ * @returns True if the type extends Resource, otherwise false
+ */
+export const isResourceType = (
+  type: Type,
+  ignoredClasses: readonly string[] = [] // App, Stage, CfnOutput, Stack are not extended Resource, so no need to ignore them
+): boolean => {
+  if (ignoredClasses.includes(type.symbol?.name ?? "")) return false;
+  return isExtendsFromTargetSuperClass(type, ["Resource"], isResourceType);
+};

package/src/core/cdk-construct/type-finder/index.ts

@@ -0,0 +1,73 @@
+import { Type } from "typescript";
+
+import { findArrayElementType } from "../../../core/ts-type/finder/array-element";
+import { findGenericsTypeArgument } from "../../../core/ts-type/finder/generics-type-argument";
+import { isClassType } from "../../ts-type/checker/is-class";
+import { isResourceWithReadonlyInterface } from "../type-checker/is-resource-with-readonly-interface";
+
+/**
+ * Recursively find the ts.Type to obtain type of CDK Construct class
+ */
+export const findTypeOfCdkConstruct = (type: Type): Type | undefined => {
+  if (isClassType(type) && isResourceWithReadonlyInterface(type)) {
+    return type;
+  }
+  return (
+    findFromArray(type) ??
+    findFromGenerics(type) ??
+    findFromUnion(type) ??
+    findFromIntersection(type)
+  );
+};
+
+/**
+ * Find Construct type from an array type (e.g. s3.Bucket[])
+ */
+const findFromArray = (
+  type: Type
+): Type | undefined => {
+  const arrElementType = findArrayElementType(type);
+  if (!arrElementType) return undefined;
+
+  return findTypeOfCdkConstruct(arrElementType);
+};
+
+/**
+ * Find Construct type from a generics type (e.g. Array<s3.Bucket>, Promise<s3.Bucket[]>)
+ */
+const findFromGenerics = (
+  type: Type
+): Type | undefined => {
+  const genericsArgument = findGenericsTypeArgument(type);
+  if (!genericsArgument) return undefined;
+
+  return findTypeOfCdkConstruct(genericsArgument);
+};
+
+/**
+ * Find Construct type from a union type (e.g. s3.Bucket | string)
+ */
+const findFromUnion = (
+  type: Type
+): Type | undefined => {
+  if (!type.isUnion()) return undefined;
+
+  for (const unionType of type.types) {
+    const foundType = findTypeOfCdkConstruct(unionType);
+    if (foundType) return foundType;
+  }
+};
+
+/**
+ * Find Construct type from an intersection type (e.g. s3.Bucket & { customProp: string })
+ */
+const findFromIntersection = (
+  type: Type
+): Type | undefined => {
+  if (!type.isIntersection()) return undefined;
+
+  for (const intersectionType of type.types) {
+    const foundType = findTypeOfCdkConstruct(intersectionType);
+    if (foundType) return foundType;
+  }
+};

package/src/{utils/typecheck/ts-type.ts → core/ts-type/checker/is-array.ts}

@@ -1,12 +1,6 @@
-import { Symbol, SymbolFlags, Type } from "typescript";
+import { Type } from "typescript";
 
-const getSymbol = (type: Type): Symbol | undefined => {
-  return type.getSymbol?.() ?? type.symbol;
-};
-
-export const isClassType = (type: Type): boolean => {
-  return getSymbol(type)?.flags === SymbolFlags.Class;
-};
+import { getSymbol } from "./private/get-symbol";
 
 export const isArrayType = (type: Type): boolean => {
   const symbol = getSymbol(type);

package/src/core/ts-type/checker/is-class.ts

@@ -0,0 +1,7 @@
+import { SymbolFlags, Type } from "typescript";
+
+import { getSymbol } from "./private/get-symbol";
+
+export const isClassType = (type: Type): boolean => {
+  return getSymbol(type)?.flags === SymbolFlags.Class;
+};

package/src/core/ts-type/checker/is-extends-target-super-class.ts

@@ -0,0 +1,24 @@
+import { Type } from "typescript";
+
+/**
+ * Check if the type extends target super class
+ * @param type - The type to check
+ * @param targetSuperClasses - The target super classes
+ * @returns True if the type extends target super class, otherwise false
+ */
+export const isExtendsFromTargetSuperClass = (
+  type: Type,
+  targetSuperClasses: string[],
+  typeCheckFunction: (type: Type) => boolean
+): boolean => {
+  if (!type.symbol) return false;
+
+  // NOTE: Check if the current type ends in target super class
+  if (targetSuperClasses.some((suffix) => type.symbol.name === suffix)) {
+    return true;
+  }
+
+  // NOTE: Check the base type
+  const baseTypes = type.getBaseTypes() ?? [];
+  return baseTypes.some((baseType) => typeCheckFunction(baseType));
+};

package/src/core/ts-type/checker/private/get-symbol.ts

@@ -0,0 +1,5 @@
+import { Symbol, Type } from "typescript";
+
+export const getSymbol = (type: Type): Symbol | undefined => {
+  return type.getSymbol?.() ?? type.symbol;
+};

package/src/core/ts-type/finder/array-element.ts

@@ -0,0 +1,20 @@
+import { Type } from "typescript";
+
+import { isArrayType } from "../checker/is-array";
+
+
+/**
+ * Find the element type of an array type (e.g. for s3.Bucket[], returns s3.Bucket)
+ * @param type - The type to check
+ * @returns The element type if the type is an array, undefined otherwise
+ */
+export const findArrayElementType = (type: Type): Type | undefined => {
+  if (!isArrayType(type)) return undefined;
+
+  // Get type arguments for Array<T>
+  if ("typeArguments" in type && Array.isArray(type.typeArguments)) {
+    return (type.typeArguments as Type[])[0];
+  }
+
+  return undefined;
+};

package/src/core/ts-type/finder/constructor-property-name.ts

@@ -0,0 +1,21 @@
+import { isClassDeclaration, isConstructorDeclaration, Type } from "typescript";
+
+
+/**
+ * Parses type to get the property names of the class constructor.
+ * @returns The property names of the class constructor.
+ */
+export const findConstructorPropertyNames = (type: Type): string[] => {
+  const declarations = type.symbol?.declarations;
+  if (!declarations?.length) return [];
+
+  const classDeclaration = declarations[0];
+  if (!isClassDeclaration(classDeclaration)) return [];
+
+  const constructor = classDeclaration.members.find((member) =>
+    isConstructorDeclaration(member)
+  );
+  if (!constructor?.parameters.length) return [];
+
+  return constructor.parameters.map((param) => param.name.getText());
+};

package/src/{utils/getGenericTypeArgument.ts → core/ts-type/finder/generics-type-argument.ts}

@@ -1,11 +1,11 @@
 import { Type } from "typescript";
 
 /**
- * Extracts the type argument from a generic type reference
+ * Extracts the type argument from a generics type reference (e.g. Array<s3.Bucket>, returns s3.Bucket)
  * @param type - The type to check
- * @returns The first type argument if it's a generic type reference, undefined otherwise
+ * @returns The first type argument if it's a generics type reference, undefined otherwise
  */
-export const getGenericTypeArgument = (type: Type): Type | undefined => {
+export const findGenericsTypeArgument = (type: Type): Type | undefined => {
   // NOTE: Check for type alias (e.g. Readonly<T>, Partial<T>)
   if (
     "aliasSymbol" in type &&
@@ -16,7 +16,7 @@ export const getGenericTypeArgument = (type: Type): Type | undefined => {
     return type.aliasTypeArguments[0];
   }
 
-  // NOTE: Check if type has typeArguments (generic types like Array<T>, etc.)
+  // NOTE: Check if type has typeArguments (generics types like Array<T>, etc.)
   //       This works for TypeReference types
   if (
     "typeArguments" in type &&
@@ -26,7 +26,7 @@ export const getGenericTypeArgument = (type: Type): Type | undefined => {
     return type.typeArguments[0] as Type;
   }
 
-  // NOTE: Alternative approach: check for target property (some generic types have this)
+  // NOTE: Alternative approach: check for target property (some generics types have this)
   if (
     "target" in type &&
     type.target &&