eslint-cdk-plugin 3.4.0 → 3.4.1

package/dist/index.cjs

@@ -26,7 +26,7 @@ function _interopNamespaceDefault(e) {
 var path__namespace = /*#__PURE__*/_interopNamespaceDefault(path);
 
 var name = "eslint-cdk-plugin";
-var version = "3.4.0";
+var version = "3.4.1";
 
 const createRule = utils.ESLintUtils.RuleCreator(
   (name) => `https://eslint-cdk-plugin.dev/rules/${name}`
@@ -153,6 +153,46 @@ const SYNTAX_KIND = {
   PROPERTY_ACCESS_EXPRESSION: 211
 };
 
+const getSymbol = (type) => {
+  return type.getSymbol?.() ?? type.symbol;
+};
+const isClassType = (type) => {
+  return getSymbol(type)?.flags === SYMBOL_FLAGS.CLASS;
+};
+const isArrayType = (type) => {
+  const symbol = getSymbol(type);
+  if (symbol?.name === "Array") return true;
+  if ("target" in type && type.target) {
+    const targetSymbol = getSymbol(type.target);
+    return targetSymbol?.name === "Array";
+  }
+  return false;
+};
+
+const getArrayElementType = (type) => {
+  if (!isArrayType(type)) return void 0;
+  if ("typeArguments" in type && Array.isArray(type.typeArguments)) {
+    return type.typeArguments[0];
+  }
+  return void 0;
+};
+
+const getGenericTypeArgument = (type) => {
+  if ("aliasSymbol" in type && type.aliasSymbol && "aliasTypeArguments" in type && type.aliasTypeArguments?.length) {
+    return type.aliasTypeArguments[0];
+  }
+  if ("typeArguments" in type && Array.isArray(type.typeArguments) && type.typeArguments?.length) {
+    return type.typeArguments[0];
+  }
+  if ("target" in type && type.target && "typeArguments" in type && Array.isArray(type.typeArguments) && type.typeArguments?.length) {
+    return type.typeArguments[0];
+  }
+  if ("modifiersType" in type && type.modifiersType) {
+    return type.modifiersType;
+  }
+  return void 0;
+};
+
 const isClassDeclaration = (node) => {
   return node.kind === SYNTAX_KIND.CLASS_DECLARATION;
 };
@@ -169,13 +209,6 @@ const isConstructorDeclaration = (node) => {
   return node.kind === SYNTAX_KIND.CONSTRUCTOR;
 };
 
-const getSymbol = (type) => {
-  return type.getSymbol?.() ?? type.symbol;
-};
-const isClassType = (type) => {
-  return getSymbol(type)?.flags === SYMBOL_FLAGS.CLASS;
-};
-
 const isResourceWithReadonlyInterface = (type) => {
   if (!isResourceType(type) || !type.symbol?.name) return false;
   if (isIgnoreClass(type.symbol.name)) return false;
@@ -267,17 +300,45 @@ const noConstructInInterface = createRule({
             continue;
           }
           const type = parserServices.getTypeAtLocation(property);
-          if (!isClassType(type) || !isResourceWithReadonlyInterface(type)) {
+          if (isClassType(type) && isResourceWithReadonlyInterface(type)) {
+            context.report({
+              node: property,
+              messageId: "invalidInterfaceProperty",
+              data: {
+                propertyName: property.key.name,
+                typeName: type.symbol.name
+              }
+            });
             continue;
           }
-          context.report({
-            node: property,
-            messageId: "invalidInterfaceProperty",
-            data: {
-              propertyName: property.key.name,
-              typeName: type.symbol.name
-            }
-          });
+          const elementType = getArrayElementType(type);
+          if (elementType && isClassType(elementType) && isResourceWithReadonlyInterface(elementType)) {
+            context.report({
+              node: property,
+              messageId: "invalidInterfaceProperty",
+              data: {
+                propertyName: property.key.name,
+                typeName: `${elementType.symbol.name}[]`
+              }
+            });
+            continue;
+          }
+          const genericArgument = getGenericTypeArgument(type);
+          if (genericArgument && isClassType(genericArgument) && isResourceWithReadonlyInterface(genericArgument)) {
+            const wrapperName = (() => {
+              if (type.aliasSymbol) return type.aliasSymbol.name;
+              if (type.symbol?.name) return type.symbol.name;
+              return void 0;
+            })();
+            context.report({
+              node: property,
+              messageId: "invalidInterfaceProperty",
+              data: {
+                propertyName: property.key.name,
+                typeName: wrapperName ? `${wrapperName}<${genericArgument.symbol.name}>` : genericArgument.symbol.name
+              }
+            });
+          }
         }
       }
     };
@@ -327,15 +388,7 @@ const validatePublicPropertyOfConstruct = (node, context, parserServices) => {
     }
     if (!property.typeAnnotation) continue;
     const type = parserServices.getTypeAtLocation(property);
-    if (!isClassType(type) || !isResourceWithReadonlyInterface(type)) continue;
-    context.report({
-      node: property,
-      messageId: "invalidPublicPropertyOfConstruct",
-      data: {
-        propertyName: property.key.name,
-        typeName: type.symbol.name
-      }
-    });
+    checkAndReportConstructType(type, property, property.key.name, context);
   }
 };
 const validateConstructorParameterProperty = (constructor, context, parserServices) => {
@@ -348,15 +401,50 @@ const validateConstructorParameterProperty = (constructor, context, parserServic
     }
     if (!param.parameter.typeAnnotation) continue;
     const type = parserServices.getTypeAtLocation(param);
-    if (!isClassType(type) || !isResourceWithReadonlyInterface(type)) continue;
+    checkAndReportConstructType(type, param, param.parameter.name, context);
+  }
+};
+const checkAndReportConstructType = (type, node, propertyName, context) => {
+  if (isClassType(type) && isResourceWithReadonlyInterface(type)) {
     context.report({
-      node: param,
+      node,
       messageId: "invalidPublicPropertyOfConstruct",
       data: {
-        propertyName: param.parameter.name,
+        propertyName,
         typeName: type.symbol.name
       }
     });
+    return;
+  }
+  const elementType = getArrayElementType(type);
+  if (elementType && isClassType(elementType) && isResourceWithReadonlyInterface(elementType)) {
+    context.report({
+      node,
+      messageId: "invalidPublicPropertyOfConstruct",
+      data: {
+        propertyName,
+        typeName: `${elementType.symbol.name}[]`
+      }
+    });
+    return;
+  }
+  const genericArgument = getGenericTypeArgument(type);
+  if (genericArgument && isClassType(genericArgument) && isResourceWithReadonlyInterface(genericArgument)) {
+    const wrapperName = (() => {
+      if ("aliasSymbol" in type && type.aliasSymbol) {
+        return type.aliasSymbol.name;
+      }
+      if (type.symbol?.name) return type.symbol.name;
+      return void 0;
+    })();
+    context.report({
+      node,
+      messageId: "invalidPublicPropertyOfConstruct",
+      data: {
+        propertyName,
+        typeName: wrapperName ? `${wrapperName}<${genericArgument.symbol.name}>` : genericArgument.symbol.name
+      }
+    });
   }
 };
 

package/dist/index.mjs

@@ -3,7 +3,7 @@ import { ESLintUtils, AST_NODE_TYPES, AST_TOKEN_TYPES } from '@typescript-eslint
 import * as path from 'path';
 
 var name = "eslint-cdk-plugin";
-var version = "3.4.0";
+var version = "3.4.1";
 
 const createRule = ESLintUtils.RuleCreator(
   (name) => `https://eslint-cdk-plugin.dev/rules/${name}`
@@ -130,6 +130,46 @@ const SYNTAX_KIND = {
   PROPERTY_ACCESS_EXPRESSION: 211
 };
 
+const getSymbol = (type) => {
+  return type.getSymbol?.() ?? type.symbol;
+};
+const isClassType = (type) => {
+  return getSymbol(type)?.flags === SYMBOL_FLAGS.CLASS;
+};
+const isArrayType = (type) => {
+  const symbol = getSymbol(type);
+  if (symbol?.name === "Array") return true;
+  if ("target" in type && type.target) {
+    const targetSymbol = getSymbol(type.target);
+    return targetSymbol?.name === "Array";
+  }
+  return false;
+};
+
+const getArrayElementType = (type) => {
+  if (!isArrayType(type)) return void 0;
+  if ("typeArguments" in type && Array.isArray(type.typeArguments)) {
+    return type.typeArguments[0];
+  }
+  return void 0;
+};
+
+const getGenericTypeArgument = (type) => {
+  if ("aliasSymbol" in type && type.aliasSymbol && "aliasTypeArguments" in type && type.aliasTypeArguments?.length) {
+    return type.aliasTypeArguments[0];
+  }
+  if ("typeArguments" in type && Array.isArray(type.typeArguments) && type.typeArguments?.length) {
+    return type.typeArguments[0];
+  }
+  if ("target" in type && type.target && "typeArguments" in type && Array.isArray(type.typeArguments) && type.typeArguments?.length) {
+    return type.typeArguments[0];
+  }
+  if ("modifiersType" in type && type.modifiersType) {
+    return type.modifiersType;
+  }
+  return void 0;
+};
+
 const isClassDeclaration = (node) => {
   return node.kind === SYNTAX_KIND.CLASS_DECLARATION;
 };
@@ -146,13 +186,6 @@ const isConstructorDeclaration = (node) => {
   return node.kind === SYNTAX_KIND.CONSTRUCTOR;
 };
 
-const getSymbol = (type) => {
-  return type.getSymbol?.() ?? type.symbol;
-};
-const isClassType = (type) => {
-  return getSymbol(type)?.flags === SYMBOL_FLAGS.CLASS;
-};
-
 const isResourceWithReadonlyInterface = (type) => {
   if (!isResourceType(type) || !type.symbol?.name) return false;
   if (isIgnoreClass(type.symbol.name)) return false;
@@ -244,17 +277,45 @@ const noConstructInInterface = createRule({
             continue;
           }
           const type = parserServices.getTypeAtLocation(property);
-          if (!isClassType(type) || !isResourceWithReadonlyInterface(type)) {
+          if (isClassType(type) && isResourceWithReadonlyInterface(type)) {
+            context.report({
+              node: property,
+              messageId: "invalidInterfaceProperty",
+              data: {
+                propertyName: property.key.name,
+                typeName: type.symbol.name
+              }
+            });
             continue;
           }
-          context.report({
-            node: property,
-            messageId: "invalidInterfaceProperty",
-            data: {
-              propertyName: property.key.name,
-              typeName: type.symbol.name
-            }
-          });
+          const elementType = getArrayElementType(type);
+          if (elementType && isClassType(elementType) && isResourceWithReadonlyInterface(elementType)) {
+            context.report({
+              node: property,
+              messageId: "invalidInterfaceProperty",
+              data: {
+                propertyName: property.key.name,
+                typeName: `${elementType.symbol.name}[]`
+              }
+            });
+            continue;
+          }
+          const genericArgument = getGenericTypeArgument(type);
+          if (genericArgument && isClassType(genericArgument) && isResourceWithReadonlyInterface(genericArgument)) {
+            const wrapperName = (() => {
+              if (type.aliasSymbol) return type.aliasSymbol.name;
+              if (type.symbol?.name) return type.symbol.name;
+              return void 0;
+            })();
+            context.report({
+              node: property,
+              messageId: "invalidInterfaceProperty",
+              data: {
+                propertyName: property.key.name,
+                typeName: wrapperName ? `${wrapperName}<${genericArgument.symbol.name}>` : genericArgument.symbol.name
+              }
+            });
+          }
         }
       }
     };
@@ -304,15 +365,7 @@ const validatePublicPropertyOfConstruct = (node, context, parserServices) => {
     }
     if (!property.typeAnnotation) continue;
     const type = parserServices.getTypeAtLocation(property);
-    if (!isClassType(type) || !isResourceWithReadonlyInterface(type)) continue;
-    context.report({
-      node: property,
-      messageId: "invalidPublicPropertyOfConstruct",
-      data: {
-        propertyName: property.key.name,
-        typeName: type.symbol.name
-      }
-    });
+    checkAndReportConstructType(type, property, property.key.name, context);
   }
 };
 const validateConstructorParameterProperty = (constructor, context, parserServices) => {
@@ -325,15 +378,50 @@ const validateConstructorParameterProperty = (constructor, context, parserServic
     }
     if (!param.parameter.typeAnnotation) continue;
     const type = parserServices.getTypeAtLocation(param);
-    if (!isClassType(type) || !isResourceWithReadonlyInterface(type)) continue;
+    checkAndReportConstructType(type, param, param.parameter.name, context);
+  }
+};
+const checkAndReportConstructType = (type, node, propertyName, context) => {
+  if (isClassType(type) && isResourceWithReadonlyInterface(type)) {
     context.report({
-      node: param,
+      node,
       messageId: "invalidPublicPropertyOfConstruct",
       data: {
-        propertyName: param.parameter.name,
+        propertyName,
         typeName: type.symbol.name
       }
     });
+    return;
+  }
+  const elementType = getArrayElementType(type);
+  if (elementType && isClassType(elementType) && isResourceWithReadonlyInterface(elementType)) {
+    context.report({
+      node,
+      messageId: "invalidPublicPropertyOfConstruct",
+      data: {
+        propertyName,
+        typeName: `${elementType.symbol.name}[]`
+      }
+    });
+    return;
+  }
+  const genericArgument = getGenericTypeArgument(type);
+  if (genericArgument && isClassType(genericArgument) && isResourceWithReadonlyInterface(genericArgument)) {
+    const wrapperName = (() => {
+      if ("aliasSymbol" in type && type.aliasSymbol) {
+        return type.aliasSymbol.name;
+      }
+      if (type.symbol?.name) return type.symbol.name;
+      return void 0;
+    })();
+    context.report({
+      node,
+      messageId: "invalidPublicPropertyOfConstruct",
+      data: {
+        propertyName,
+        typeName: wrapperName ? `${wrapperName}<${genericArgument.symbol.name}>` : genericArgument.symbol.name
+      }
+    });
   }
 };
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "eslint-cdk-plugin",
-  "version": "3.4.0",
+  "version": "3.4.1",
   "description": "eslint plugin for AWS CDK projects",
   "main": "./dist/index.mjs",
   "types": "./dist/index.d.ts",
@@ -22,24 +22,22 @@
     "lint": "eslint --fix --config eslint.config.js",
     "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",
     "docs:dev": "cd ./docs && pnpm install && pnpm run dev",
     "docs:build": "cd ./docs && pnpm install && pnpm run build",
     "docs:preview": "cd ./docs && pnpm install && pnpm run preview"
   },
   "devDependencies": {
     "@eslint/js": "^9.26.0",
+    "@secretlint/secretlint-rule-preset-recommend": "^11.2.4",
     "@types/node": "^22.15.0",
     "@typescript-eslint/rule-tester": "^8.32.1",
-    "eslint": "9.22.0",
-    "eslint-plugin-import": "^2.31.0",
+    "eslint": "9.36.0",
+    "eslint-plugin-import": "^2.32.0",
     "pkgroll": "^2.12.2",
-    "standard-version": "^9.5.0",
+    "secretlint": "^11.2.4",
     "typescript": "^5.8.3",
     "typescript-eslint": "^8.32.1",
-    "vitest": "^3.1.3"
+    "vitest": "^3.2.4"
   },
   "dependencies": {
     "@typescript-eslint/parser": "^8.32.1",

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

@@ -1,6 +1,8 @@
 import { AST_NODE_TYPES, ESLintUtils } from "@typescript-eslint/utils";
 
 import { createRule } from "../utils/createRule";
+import { getArrayElementType } from "../utils/getArrayElementType";
+import { getGenericTypeArgument } from "../utils/getGenericTypeArgument";
 import { isResourceWithReadonlyInterface } from "../utils/is-resource-with-readonly-interface";
 import { isClassType } from "../utils/typecheck/ts-type";
 
@@ -36,18 +38,61 @@ export const noConstructInInterface = createRule({
           }
 
           const type = parserServices.getTypeAtLocation(property);
-          if (!isClassType(type) || !isResourceWithReadonlyInterface(type)) {
+
+          // NOTE: Check if it's a direct class type
+          if (isClassType(type) && isResourceWithReadonlyInterface(type)) {
+            context.report({
+              node: property,
+              messageId: "invalidInterfaceProperty",
+              data: {
+                propertyName: property.key.name,
+                typeName: type.symbol.name,
+              },
+            });
             continue;
           }
 
-          context.report({
-            node: property,
-            messageId: "invalidInterfaceProperty",
-            data: {
-              propertyName: property.key.name,
-              typeName: type.symbol.name,
-            },
-          });
+          // NOTE: Check if it's an array of class types
+          const elementType = getArrayElementType(type);
+          if (
+            elementType &&
+            isClassType(elementType) &&
+            isResourceWithReadonlyInterface(elementType)
+          ) {
+            context.report({
+              node: property,
+              messageId: "invalidInterfaceProperty",
+              data: {
+                propertyName: property.key.name,
+                typeName: `${elementType.symbol.name}[]`,
+              },
+            });
+            continue;
+          }
+
+          // NOTE: Check if it's a generic type wrapping a class type
+          const genericArgument = getGenericTypeArgument(type);
+          if (
+            genericArgument &&
+            isClassType(genericArgument) &&
+            isResourceWithReadonlyInterface(genericArgument)
+          ) {
+            const wrapperName = (() => {
+              if (type.aliasSymbol) return type.aliasSymbol.name; // For type aliases like Readonly<T>, Partial<T>
+              if (type.symbol?.name) return type.symbol.name; // For other generic types like Array<T>
+              return undefined;
+            })();
+            context.report({
+              node: property,
+              messageId: "invalidInterfaceProperty",
+              data: {
+                propertyName: property.key.name,
+                typeName: wrapperName
+                  ? `${wrapperName}<${genericArgument.symbol.name}>`
+                  : genericArgument.symbol.name,
+              },
+            });
+          }
         }
       },
     };

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

@@ -5,9 +5,12 @@ import {
   TSESLint,
   TSESTree,
 } from "@typescript-eslint/utils";
+import { Type } from "typescript";
 
 import { createRule } from "../utils/createRule";
+import { getArrayElementType } from "../utils/getArrayElementType";
 import { getConstructor } from "../utils/getConstructor";
+import { getGenericTypeArgument } from "../utils/getGenericTypeArgument";
 import { isResourceWithReadonlyInterface } from "../utils/is-resource-with-readonly-interface";
 import { isConstructOrStackType } from "../utils/typecheck/cdk";
 import { isClassType } from "../utils/typecheck/ts-type";
@@ -88,16 +91,7 @@ const validatePublicPropertyOfConstruct = (
     if (!property.typeAnnotation) continue;
 
     const type = parserServices.getTypeAtLocation(property);
-    if (!isClassType(type) || !isResourceWithReadonlyInterface(type)) continue;
-
-    context.report({
-      node: property,
-      messageId: "invalidPublicPropertyOfConstruct",
-      data: {
-        propertyName: property.key.name,
-        typeName: type.symbol.name,
-      },
-    });
+    checkAndReportConstructType(type, property, property.key.name, context);
   }
 };
 
@@ -127,15 +121,74 @@ const validateConstructorParameterProperty = (
     if (!param.parameter.typeAnnotation) continue;
 
     const type = parserServices.getTypeAtLocation(param);
-    if (!isClassType(type) || !isResourceWithReadonlyInterface(type)) continue;
+    checkAndReportConstructType(type, param, param.parameter.name, context);
+  }
+};
 
+/**
+ * Common validation logic for checking if a type is a Construct type
+ */
+const checkAndReportConstructType = (
+  type: Type,
+  node: TSESTree.Node,
+  propertyName: string,
+  context: Context
+): void => {
+  // NOTE: Check if it's a direct class type
+  if (isClassType(type) && isResourceWithReadonlyInterface(type)) {
     context.report({
-      node: param,
+      node,
       messageId: "invalidPublicPropertyOfConstruct",
       data: {
-        propertyName: param.parameter.name,
+        propertyName,
         typeName: type.symbol.name,
       },
     });
+    return;
+  }
+
+  // NOTE: Check if it's an array of class types
+  const elementType = getArrayElementType(type);
+  if (
+    elementType &&
+    isClassType(elementType) &&
+    isResourceWithReadonlyInterface(elementType)
+  ) {
+    context.report({
+      node,
+      messageId: "invalidPublicPropertyOfConstruct",
+      data: {
+        propertyName,
+        typeName: `${elementType.symbol.name}[]`,
+      },
+    });
+    return;
+  }
+
+  // NOTE: Check if it's a generic type wrapping a class type
+  const genericArgument = getGenericTypeArgument(type);
+  if (
+    genericArgument &&
+    isClassType(genericArgument) &&
+    isResourceWithReadonlyInterface(genericArgument)
+  ) {
+    const wrapperName = (() => {
+      if ("aliasSymbol" in type && type.aliasSymbol) {
+        return type.aliasSymbol.name; // For type aliases like Readonly<T>, Partial<T>
+      }
+      if (type.symbol?.name) return type.symbol.name; // For other generic types like Array<T>
+      return undefined;
+    })();
+
+    context.report({
+      node,
+      messageId: "invalidPublicPropertyOfConstruct",
+      data: {
+        propertyName,
+        typeName: wrapperName
+          ? `${wrapperName}<${genericArgument.symbol.name}>`
+          : genericArgument.symbol.name,
+      },
+    });
   }
 };

package/src/utils/getArrayElementType.ts

@@ -0,0 +1,14 @@
+import { Type } from "typescript";
+
+import { isArrayType } from "./typecheck/ts-type";
+
+export const getArrayElementType = (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/utils/getGenericTypeArgument.ts

@@ -0,0 +1,47 @@
+import { Type } from "typescript";
+
+/**
+ * Extracts the type argument from a generic type reference
+ * @param type - The type to check
+ * @returns The first type argument if it's a generic type reference, undefined otherwise
+ */
+export const getGenericTypeArgument = (type: Type): Type | undefined => {
+  // NOTE: Check for type alias (e.g. Readonly<T>, Partial<T>)
+  if (
+    "aliasSymbol" in type &&
+    type.aliasSymbol &&
+    "aliasTypeArguments" in type &&
+    type.aliasTypeArguments?.length
+  ) {
+    return type.aliasTypeArguments[0];
+  }
+
+  // NOTE: Check if type has typeArguments (generic types like Array<T>, etc.)
+  //       This works for TypeReference types
+  if (
+    "typeArguments" in type &&
+    Array.isArray(type.typeArguments) &&
+    type.typeArguments?.length
+  ) {
+    return type.typeArguments[0] as Type;
+  }
+
+  // NOTE: Alternative approach: check for target property (some generic types have this)
+  if (
+    "target" in type &&
+    type.target &&
+    "typeArguments" in type &&
+    Array.isArray(type.typeArguments) &&
+    type.typeArguments?.length
+  ) {
+    return type.typeArguments[0] as Type;
+  }
+
+  // NOTE: For mapped types like Readonly<T> and Partial<T>
+  //       These are represented differently in TypeScript's type system
+  if ("modifiersType" in type && type.modifiersType) {
+    return type.modifiersType as Type;
+  }
+
+  return undefined;
+};

package/src/utils/typecheck/ts-type.ts

@@ -13,3 +13,15 @@ const getSymbol = (type: Type): Symbol | undefined => {
 export const isClassType = (type: Type): boolean => {
   return getSymbol(type)?.flags === SYMBOL_FLAGS.CLASS;
 };
+
+export const isArrayType = (type: Type): boolean => {
+  const symbol = getSymbol(type);
+  if (symbol?.name === "Array") return true;
+
+  if ("target" in type && type.target) {
+    const targetSymbol = getSymbol(type.target as Type);
+    return targetSymbol?.name === "Array";
+  }
+
+  return false;
+};