eslint-cdk-plugin 3.3.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.3.0";
+var version = "3.4.1";
 
 const createRule = utils.ESLintUtils.RuleCreator(
   (name) => `https://eslint-cdk-plugin.dev/rules/${name}`
@@ -55,6 +55,10 @@ const isConstructType = (type, ignoredClasses = [
   if (ignoredClasses.includes(type.symbol?.name ?? "")) return false;
   return isTargetSuperClassType(type, ["Construct"], isConstructType);
 };
+const isResourceType = (type, ignoredClasses = []) => {
+  if (ignoredClasses.includes(type.symbol?.name ?? "")) return false;
+  return isTargetSuperClassType(type, ["Resource"], isResourceType);
+};
 const isTargetSuperClassType = (type, targetSuperClasses, typeCheckFunction) => {
   if (!type.symbol) return false;
   if (targetSuperClasses.some((suffix) => type.symbol.name === suffix)) {
@@ -140,11 +144,138 @@ const validateConstructorProperty = (constructor, context, parserServices) => {
 };
 
 const SYMBOL_FLAGS = {
-  CLASS: 32
-};
+  CLASS: 32};
 const SYNTAX_KIND = {
   CLASS_DECLARATION: 263,
-  CONSTRUCTOR: 176
+  CONSTRUCTOR: 176,
+  IMPLEMENTS_KEYWORD: 119,
+  IDENTIFIER: 80,
+  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;
+};
+const isIdentifier = (node) => {
+  return node.kind === SYNTAX_KIND.IDENTIFIER;
+};
+const isPropertyAccessExpression = (node) => {
+  return node.kind === SYNTAX_KIND.PROPERTY_ACCESS_EXPRESSION;
+};
+const checkHeritageClauseIsImplements = (node) => {
+  return node.token === SYNTAX_KIND.IMPLEMENTS_KEYWORD;
+};
+const isConstructorDeclaration = (node) => {
+  return node.kind === SYNTAX_KIND.CONSTRUCTOR;
+};
+
+const isResourceWithReadonlyInterface = (type) => {
+  if (!isResourceType(type) || !type.symbol?.name) return false;
+  if (isIgnoreClass(type.symbol.name)) return false;
+  return hasMatchingInterfaceInHierarchy(type);
+};
+const hasMatchingInterfaceInHierarchy = (type) => {
+  const processedTypes = /* @__PURE__ */ new Set();
+  const checkTypeAndBases = (currentType) => {
+    const symbol = currentType.getSymbol?.() ?? currentType.symbol;
+    if (!symbol?.name) return false;
+    if (processedTypes.has(symbol.name)) return false;
+    processedTypes.add(symbol.name);
+    const currentClassName = symbol.name;
+    if (isIgnoreClass(currentClassName)) return false;
+    const directInterfaces = getDirectImplementedInterfaceNames(currentType);
+    if (directInterfaces.some(
+      (interfaceName) => checkInterfaceMatchClassName(interfaceName, currentClassName)
+    )) {
+      return true;
+    }
+    const baseTypes = currentType.getBaseTypes?.() ?? [];
+    return baseTypes.some(
+      (baseType) => isClassType(baseType) && checkTypeAndBases(baseType)
+    );
+  };
+  return checkTypeAndBases(type);
+};
+const checkInterfaceMatchClassName = (interfaceName, classname) => {
+  const simpleInterfaceName = interfaceName.includes(".") ? interfaceName.split(".").pop() ?? interfaceName : interfaceName;
+  if (simpleInterfaceName === `I${classname}`) return true;
+  const classNameWithoutBase = classname.replace(/^Base|Base$/g, "");
+  if (classNameWithoutBase && simpleInterfaceName === `I${classNameWithoutBase}`) {
+    return true;
+  }
+  const baseVMatch = /^(.+)BaseV(\d+)$/.exec(classname);
+  if (!baseVMatch) return false;
+  const [, baseName, version] = baseVMatch;
+  return simpleInterfaceName === `I${baseName}V${version}`;
+};
+const getDirectImplementedInterfaceNames = (type) => {
+  const symbol = type.getSymbol?.() ?? type.symbol;
+  if (!symbol?.name) return [];
+  const declarations = symbol.getDeclarations ? symbol.getDeclarations() : symbol.declarations;
+  if (!declarations?.length) return [];
+  return declarations.reduce((acc, decl) => {
+    if (!isClassDeclaration(decl)) return acc;
+    const heritageClauses = decl.heritageClauses;
+    if (!heritageClauses) return acc;
+    return heritageClauses.reduce((hcAcc, hc) => {
+      if (!checkHeritageClauseIsImplements(hc)) return hcAcc;
+      return hc.types.reduce((typeAcc, type2) => {
+        const expression = type2.expression;
+        if (!expression) return typeAcc;
+        if (isIdentifier(expression)) return [...typeAcc, expression.text];
+        if (!isPropertyAccessExpression(expression)) return typeAcc;
+        const namespace = expression.expression;
+        const interfaceName = expression.name;
+        if (isIdentifier(namespace) && isIdentifier(interfaceName)) {
+          return [...typeAcc, `${namespace.text}.${interfaceName.text}`];
+        }
+        return typeAcc;
+      }, []);
+    }, []);
+  }, []);
+};
+const isIgnoreClass = (className) => {
+  return className === "Resource" || className === "Construct";
 };
 
 const noConstructInInterface = createRule({
@@ -169,17 +300,45 @@ const noConstructInInterface = createRule({
             continue;
           }
           const type = parserServices.getTypeAtLocation(property);
-          if (!isConstructOrStackType(type)) continue;
-          const isClass = type.symbol.flags === SYMBOL_FLAGS.CLASS;
-          if (!isClass) continue;
-          context.report({
-            node: property,
-            messageId: "invalidInterfaceProperty",
-            data: {
-              propertyName: property.key.name,
-              typeName: type.symbol.name
-            }
-          });
+          if (isClassType(type) && isResourceWithReadonlyInterface(type)) {
+            context.report({
+              node: property,
+              messageId: "invalidInterfaceProperty",
+              data: {
+                propertyName: property.key.name,
+                typeName: type.symbol.name
+              }
+            });
+            continue;
+          }
+          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
+              }
+            });
+          }
         }
       }
     };
@@ -229,17 +388,7 @@ const validatePublicPropertyOfConstruct = (node, context, parserServices) => {
     }
     if (!property.typeAnnotation) continue;
     const type = parserServices.getTypeAtLocation(property);
-    if (!isConstructOrStackType(type)) continue;
-    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
-      }
-    });
+    checkAndReportConstructType(type, property, property.key.name, context);
   }
 };
 const validateConstructorParameterProperty = (constructor, context, parserServices) => {
@@ -252,17 +401,50 @@ const validateConstructorParameterProperty = (constructor, context, parserServic
     }
     if (!param.parameter.typeAnnotation) continue;
     const type = parserServices.getTypeAtLocation(param);
-    if (!isConstructOrStackType(type)) continue;
-    const isClass = type.symbol.flags === SYMBOL_FLAGS.CLASS;
-    if (!isClass) 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
+      }
+    });
   }
 };
 
@@ -291,12 +473,6 @@ const getConstructorPropertyNames = (type) => {
   if (!constructor?.parameters.length) return [];
   return constructor.parameters.map((param) => param.name.getText());
 };
-const isClassDeclaration = (declaration) => {
-  return declaration.kind === SYNTAX_KIND.CLASS_DECLARATION;
-};
-const isConstructorDeclaration = (node) => {
-  return node.kind === SYNTAX_KIND.CONSTRUCTOR;
-};
 
 const SUFFIX_TYPE = {
   CONSTRUCT: "Construct",

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.3.0";
+var version = "3.4.1";
 
 const createRule = ESLintUtils.RuleCreator(
   (name) => `https://eslint-cdk-plugin.dev/rules/${name}`
@@ -32,6 +32,10 @@ const isConstructType = (type, ignoredClasses = [
   if (ignoredClasses.includes(type.symbol?.name ?? "")) return false;
   return isTargetSuperClassType(type, ["Construct"], isConstructType);
 };
+const isResourceType = (type, ignoredClasses = []) => {
+  if (ignoredClasses.includes(type.symbol?.name ?? "")) return false;
+  return isTargetSuperClassType(type, ["Resource"], isResourceType);
+};
 const isTargetSuperClassType = (type, targetSuperClasses, typeCheckFunction) => {
   if (!type.symbol) return false;
   if (targetSuperClasses.some((suffix) => type.symbol.name === suffix)) {
@@ -117,11 +121,138 @@ const validateConstructorProperty = (constructor, context, parserServices) => {
 };
 
 const SYMBOL_FLAGS = {
-  CLASS: 32
-};
+  CLASS: 32};
 const SYNTAX_KIND = {
   CLASS_DECLARATION: 263,
-  CONSTRUCTOR: 176
+  CONSTRUCTOR: 176,
+  IMPLEMENTS_KEYWORD: 119,
+  IDENTIFIER: 80,
+  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;
+};
+const isIdentifier = (node) => {
+  return node.kind === SYNTAX_KIND.IDENTIFIER;
+};
+const isPropertyAccessExpression = (node) => {
+  return node.kind === SYNTAX_KIND.PROPERTY_ACCESS_EXPRESSION;
+};
+const checkHeritageClauseIsImplements = (node) => {
+  return node.token === SYNTAX_KIND.IMPLEMENTS_KEYWORD;
+};
+const isConstructorDeclaration = (node) => {
+  return node.kind === SYNTAX_KIND.CONSTRUCTOR;
+};
+
+const isResourceWithReadonlyInterface = (type) => {
+  if (!isResourceType(type) || !type.symbol?.name) return false;
+  if (isIgnoreClass(type.symbol.name)) return false;
+  return hasMatchingInterfaceInHierarchy(type);
+};
+const hasMatchingInterfaceInHierarchy = (type) => {
+  const processedTypes = /* @__PURE__ */ new Set();
+  const checkTypeAndBases = (currentType) => {
+    const symbol = currentType.getSymbol?.() ?? currentType.symbol;
+    if (!symbol?.name) return false;
+    if (processedTypes.has(symbol.name)) return false;
+    processedTypes.add(symbol.name);
+    const currentClassName = symbol.name;
+    if (isIgnoreClass(currentClassName)) return false;
+    const directInterfaces = getDirectImplementedInterfaceNames(currentType);
+    if (directInterfaces.some(
+      (interfaceName) => checkInterfaceMatchClassName(interfaceName, currentClassName)
+    )) {
+      return true;
+    }
+    const baseTypes = currentType.getBaseTypes?.() ?? [];
+    return baseTypes.some(
+      (baseType) => isClassType(baseType) && checkTypeAndBases(baseType)
+    );
+  };
+  return checkTypeAndBases(type);
+};
+const checkInterfaceMatchClassName = (interfaceName, classname) => {
+  const simpleInterfaceName = interfaceName.includes(".") ? interfaceName.split(".").pop() ?? interfaceName : interfaceName;
+  if (simpleInterfaceName === `I${classname}`) return true;
+  const classNameWithoutBase = classname.replace(/^Base|Base$/g, "");
+  if (classNameWithoutBase && simpleInterfaceName === `I${classNameWithoutBase}`) {
+    return true;
+  }
+  const baseVMatch = /^(.+)BaseV(\d+)$/.exec(classname);
+  if (!baseVMatch) return false;
+  const [, baseName, version] = baseVMatch;
+  return simpleInterfaceName === `I${baseName}V${version}`;
+};
+const getDirectImplementedInterfaceNames = (type) => {
+  const symbol = type.getSymbol?.() ?? type.symbol;
+  if (!symbol?.name) return [];
+  const declarations = symbol.getDeclarations ? symbol.getDeclarations() : symbol.declarations;
+  if (!declarations?.length) return [];
+  return declarations.reduce((acc, decl) => {
+    if (!isClassDeclaration(decl)) return acc;
+    const heritageClauses = decl.heritageClauses;
+    if (!heritageClauses) return acc;
+    return heritageClauses.reduce((hcAcc, hc) => {
+      if (!checkHeritageClauseIsImplements(hc)) return hcAcc;
+      return hc.types.reduce((typeAcc, type2) => {
+        const expression = type2.expression;
+        if (!expression) return typeAcc;
+        if (isIdentifier(expression)) return [...typeAcc, expression.text];
+        if (!isPropertyAccessExpression(expression)) return typeAcc;
+        const namespace = expression.expression;
+        const interfaceName = expression.name;
+        if (isIdentifier(namespace) && isIdentifier(interfaceName)) {
+          return [...typeAcc, `${namespace.text}.${interfaceName.text}`];
+        }
+        return typeAcc;
+      }, []);
+    }, []);
+  }, []);
+};
+const isIgnoreClass = (className) => {
+  return className === "Resource" || className === "Construct";
 };
 
 const noConstructInInterface = createRule({
@@ -146,17 +277,45 @@ const noConstructInInterface = createRule({
             continue;
           }
           const type = parserServices.getTypeAtLocation(property);
-          if (!isConstructOrStackType(type)) continue;
-          const isClass = type.symbol.flags === SYMBOL_FLAGS.CLASS;
-          if (!isClass) continue;
-          context.report({
-            node: property,
-            messageId: "invalidInterfaceProperty",
-            data: {
-              propertyName: property.key.name,
-              typeName: type.symbol.name
-            }
-          });
+          if (isClassType(type) && isResourceWithReadonlyInterface(type)) {
+            context.report({
+              node: property,
+              messageId: "invalidInterfaceProperty",
+              data: {
+                propertyName: property.key.name,
+                typeName: type.symbol.name
+              }
+            });
+            continue;
+          }
+          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
+              }
+            });
+          }
         }
       }
     };
@@ -206,17 +365,7 @@ const validatePublicPropertyOfConstruct = (node, context, parserServices) => {
     }
     if (!property.typeAnnotation) continue;
     const type = parserServices.getTypeAtLocation(property);
-    if (!isConstructOrStackType(type)) continue;
-    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
-      }
-    });
+    checkAndReportConstructType(type, property, property.key.name, context);
   }
 };
 const validateConstructorParameterProperty = (constructor, context, parserServices) => {
@@ -229,17 +378,50 @@ const validateConstructorParameterProperty = (constructor, context, parserServic
     }
     if (!param.parameter.typeAnnotation) continue;
     const type = parserServices.getTypeAtLocation(param);
-    if (!isConstructOrStackType(type)) continue;
-    const isClass = type.symbol.flags === SYMBOL_FLAGS.CLASS;
-    if (!isClass) 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
+      }
+    });
   }
 };
 
@@ -268,12 +450,6 @@ const getConstructorPropertyNames = (type) => {
   if (!constructor?.parameters.length) return [];
   return constructor.parameters.map((param) => param.name.getText());
 };
-const isClassDeclaration = (declaration) => {
-  return declaration.kind === SYNTAX_KIND.CLASS_DECLARATION;
-};
-const isConstructorDeclaration = (node) => {
-  return node.kind === SYNTAX_KIND.CONSTRUCTOR;
-};
 
 const SUFFIX_TYPE = {
   CONSTRUCT: "Construct",

package/package.json

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

@@ -3,6 +3,7 @@
  */
 export const SYMBOL_FLAGS = {
   CLASS: 32,
+  Interface: 64,
 } as const;
 
 /**
@@ -11,4 +12,7 @@ export const SYMBOL_FLAGS = {
 export const SYNTAX_KIND = {
   CLASS_DECLARATION: 263,
   CONSTRUCTOR: 176,
+  IMPLEMENTS_KEYWORD: 119,
+  IDENTIFIER: 80,
+  PROPERTY_ACCESS_EXPRESSION: 211,
 } as const;

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

@@ -8,7 +8,7 @@ import {
 
 import { createRule } from "../utils/createRule";
 import { getConstructor } from "../utils/getConstructor";
-import { isConstructType } from "../utils/typeCheck";
+import { isConstructType } from "../utils/typecheck/cdk";
 
 type Context = TSESLint.RuleContext<
   | "invalidConstructorProperty"