eslint-cdk-plugin 3.3.0 → 3.4.0

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.0";
 
 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,105 @@ 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 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 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;
+  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,9 +267,9 @@ const noConstructInInterface = createRule({
             continue;
           }
           const type = parserServices.getTypeAtLocation(property);
-          if (!isConstructOrStackType(type)) continue;
-          const isClass = type.symbol.flags === SYMBOL_FLAGS.CLASS;
-          if (!isClass) continue;
+          if (!isClassType(type) || !isResourceWithReadonlyInterface(type)) {
+            continue;
+          }
           context.report({
             node: property,
             messageId: "invalidInterfaceProperty",
@@ -229,9 +327,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;
+    if (!isClassType(type) || !isResourceWithReadonlyInterface(type)) continue;
     context.report({
       node: property,
       messageId: "invalidPublicPropertyOfConstruct",
@@ -252,9 +348,7 @@ 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;
+    if (!isClassType(type) || !isResourceWithReadonlyInterface(type)) continue;
     context.report({
       node: param,
       messageId: "invalidPublicPropertyOfConstruct",
@@ -291,12 +385,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.0";
 
 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,105 @@ 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 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 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;
+  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,9 +244,9 @@ const noConstructInInterface = createRule({
             continue;
           }
           const type = parserServices.getTypeAtLocation(property);
-          if (!isConstructOrStackType(type)) continue;
-          const isClass = type.symbol.flags === SYMBOL_FLAGS.CLASS;
-          if (!isClass) continue;
+          if (!isClassType(type) || !isResourceWithReadonlyInterface(type)) {
+            continue;
+          }
           context.report({
             node: property,
             messageId: "invalidInterfaceProperty",
@@ -206,9 +304,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;
+    if (!isClassType(type) || !isResourceWithReadonlyInterface(type)) continue;
     context.report({
       node: property,
       messageId: "invalidPublicPropertyOfConstruct",
@@ -229,9 +325,7 @@ 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;
+    if (!isClassType(type) || !isResourceWithReadonlyInterface(type)) continue;
     context.report({
       node: param,
       messageId: "invalidPublicPropertyOfConstruct",
@@ -268,12 +362,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.0",
   "description": "eslint plugin for AWS CDK projects",
   "main": "./dist/index.mjs",
   "types": "./dist/index.d.ts",

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"

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

@@ -1,8 +1,8 @@
 import { AST_NODE_TYPES, ESLintUtils } from "@typescript-eslint/utils";
 
-import { SYMBOL_FLAGS } from "../constants/tsInternalFlags";
 import { createRule } from "../utils/createRule";
-import { isConstructOrStackType } from "../utils/typeCheck";
+import { isResourceWithReadonlyInterface } from "../utils/is-resource-with-readonly-interface";
+import { isClassType } from "../utils/typecheck/ts-type";
 
 /**
  * Enforces the use of interface types instead of CDK Construct types in interface properties
@@ -28,7 +28,6 @@ export const noConstructInInterface = createRule({
     return {
       TSInterfaceDeclaration(node) {
         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
@@ -37,13 +36,9 @@ export const noConstructInInterface = createRule({
           }
 
           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;
+          if (!isClassType(type) || !isResourceWithReadonlyInterface(type)) {
+            continue;
+          }
 
           context.report({
             node: property,

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

@@ -6,10 +6,11 @@ import {
   TSESTree,
 } from "@typescript-eslint/utils";
 
-import { SYMBOL_FLAGS } from "../constants/tsInternalFlags";
 import { createRule } from "../utils/createRule";
 import { getConstructor } from "../utils/getConstructor";
-import { isConstructOrStackType } from "../utils/typeCheck";
+import { isResourceWithReadonlyInterface } from "../utils/is-resource-with-readonly-interface";
+import { isConstructOrStackType } from "../utils/typecheck/cdk";
+import { isClassType } from "../utils/typecheck/ts-type";
 
 type Context = TSESLint.RuleContext<"invalidPublicPropertyOfConstruct", []>;
 
@@ -87,13 +88,7 @@ const validatePublicPropertyOfConstruct = (
     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;
+    if (!isClassType(type) || !isResourceWithReadonlyInterface(type)) continue;
 
     context.report({
       node: property,
@@ -132,13 +127,7 @@ const validateConstructorParameterProperty = (
     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;
+    if (!isClassType(type) || !isResourceWithReadonlyInterface(type)) continue;
 
     context.report({
       node: param,

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

@@ -8,7 +8,7 @@ import {
 import { toPascalCase } from "../utils/convertString";
 import { createRule } from "../utils/createRule";
 import { getConstructorPropertyNames } from "../utils/getPropertyNames";
-import { isConstructOrStackType } from "../utils/typeCheck";
+import { isConstructOrStackType } from "../utils/typecheck/cdk";
 
 const SUFFIX_TYPE = {
   CONSTRUCT: "Construct",

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

@@ -1,7 +1,7 @@
 import { AST_NODE_TYPES, ESLintUtils } from "@typescript-eslint/utils";
 
 import { createRule } from "../utils/createRule";
-import { isConstructOrStackType } from "../utils/typeCheck";
+import { isConstructOrStackType } from "../utils/typecheck/cdk";
 
 /**
  * Disallow mutable public properties of Construct

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

@@ -8,7 +8,10 @@ import {
 
 import { toPascalCase } from "../utils/convertString";
 import { createRule } from "../utils/createRule";
-import { isConstructOrStackType, isConstructType } from "../utils/typeCheck";
+import {
+  isConstructOrStackType,
+  isConstructType,
+} from "../utils/typecheck/cdk";
 
 type Options = [
   {

package/src/rules/no-unused-props.ts

@@ -12,7 +12,7 @@ import {
   IPropsUsageTracker,
   propsUsageTrackerFactory,
 } from "../utils/propsUsageTracker";
-import { isConstructType } from "../utils/typeCheck";
+import { isConstructType } from "../utils/typecheck/cdk";
 
 type Context = TSESLint.RuleContext<"unusedProp", []>;
 

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

@@ -7,7 +7,7 @@ import {
 
 import { createRule } from "../utils/createRule";
 import { getConstructorPropertyNames } from "../utils/getPropertyNames";
-import { isConstructType } from "../utils/typeCheck";
+import { isConstructType } from "../utils/typecheck/cdk";
 
 type Context = TSESLint.RuleContext<"invalidConstructId", []>;
 

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

@@ -8,7 +8,7 @@ import {
 import { toPascalCase } from "../utils/convertString";
 import { createRule } from "../utils/createRule";
 import { getConstructorPropertyNames } from "../utils/getPropertyNames";
-import { isConstructOrStackType } from "../utils/typeCheck";
+import { isConstructOrStackType } from "../utils/typecheck/cdk";
 
 const QUOTE_TYPE = {
   SINGLE: "'",

package/src/rules/props-name-convention.ts

@@ -2,7 +2,7 @@ import { AST_NODE_TYPES, ESLintUtils } from "@typescript-eslint/utils";
 
 import { createRule } from "../utils/createRule";
 import { getConstructor } from "../utils/getConstructor";
-import { isConstructType } from "../utils/typeCheck";
+import { isConstructType } from "../utils/typecheck/cdk";
 
 /**
  * Enforces a naming convention for props interfaces in Construct classes

package/src/rules/require-jsdoc.ts

@@ -5,7 +5,7 @@ import {
 } from "@typescript-eslint/utils";
 
 import { createRule } from "../utils/createRule";
-import { isConstructType } from "../utils/typeCheck";
+import { isConstructType } from "../utils/typecheck/cdk";
 
 /**
  * Require JSDoc comments for interface properties and public properties in Construct classes

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

@@ -6,7 +6,7 @@ import {
 
 import { createRule } from "../utils/createRule";
 import { getConstructorPropertyNames } from "../utils/getPropertyNames";
-import { isConstructType } from "../utils/typeCheck";
+import { isConstructType } from "../utils/typecheck/cdk";
 
 type Options = [
   {

package/src/utils/getPropertyNames.ts

@@ -1,13 +1,10 @@
 import { AST_NODE_TYPES, TSESTree } from "@typescript-eslint/utils";
-import {
-  ClassDeclaration,
-  ConstructorDeclaration,
-  Declaration,
-  Node,
-  Type,
-} from "typescript";
+import { Type } from "typescript";
 
-import { SYNTAX_KIND } from "../constants/tsInternalFlags";
+import {
+  isClassDeclaration,
+  isConstructorDeclaration,
+} from "./typecheck/ts-node";
 
 /**
  * Retrieves the property names from an array of properties.
@@ -46,27 +43,3 @@ 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/is-resource-with-readonly-interface.ts

@@ -0,0 +1,165 @@
+import { Type } from "typescript";
+
+import { isResourceType } from "./typecheck/cdk";
+import {
+  checkHeritageClauseIsImplements,
+  isClassDeclaration,
+  isIdentifier,
+  isPropertyAccessExpression,
+} from "./typecheck/ts-node";
+import { isClassType } from "./typecheck/ts-type";
+
+/**
+ * Checks if the type is an AWS resource Construct that implements a read-only resource interface
+ *
+ * This function validates that:
+ * 1. The type extends from Resource (AWS CDK resource)
+ * 2. The type or any of its base classes implements an interface following CDK's read-only interface naming convention
+ *    - Pattern 1: Class name with I prefix (e.g., Bucket -> IBucket)
+ *    - Pattern 2: Class name without Base suffix/prefix with I prefix (e.g., BucketBase -> IBucket, BaseService -> IService)
+ *
+ * @param type - The TypeScript type to check
+ * @returns true if the type is a resource Construct with a matching read-only interface, false otherwise
+ *
+ * @example
+ * // Returns true for:
+ * class Bucket extends Resource implements IBucket { ... }
+ * class BucketBase extends Resource implements IBucket { ... }
+ * class BaseService extends Resource implements IService { ... }
+ * class TableBaseV2 extends Resource implements ITableV2 { ... }
+ * class S3OriginAccessControl extends OriginAccessControlBase { ... } // where OriginAccessControlBase implements IOriginAccessControl
+ *
+ * // Returns false for:
+ * class CustomResource extends Resource { ... } // No matching interface
+ * class EdgeFunction extends Resource implements IVersion { ... } // Interface doesn't match naming pattern
+ */
+export const isResourceWithReadonlyInterface = (type: Type): boolean => {
+  if (!isResourceType(type) || !type.symbol?.name) return false;
+  if (isIgnoreClass(type.symbol.name)) return false;
+  return hasMatchingInterfaceInHierarchy(type);
+};
+
+/**
+ * Checks if a type or any of its base classes implements an interface matching its class name
+ * @param type - The TypeScript type to check
+ * @returns true if any class in the hierarchy implements a matching interface
+ * @private
+ */
+const hasMatchingInterfaceInHierarchy = (type: Type): boolean => {
+  const processedTypes = new Set<string>();
+
+  const checkTypeAndBases = (currentType: Type): boolean => {
+    const symbol = currentType.getSymbol?.() ?? currentType.symbol;
+    if (!symbol?.name) return false;
+
+    // Skip if already processed
+    if (processedTypes.has(symbol.name)) return false;
+    processedTypes.add(symbol.name);
+
+    const currentClassName = symbol.name;
+    if (isIgnoreClass(currentClassName)) return false;
+
+    const directInterfaces = getDirectImplementedInterfaceNames(currentType);
+
+    // NOTE: Check if any interface matches this class name
+    if (
+      directInterfaces.some((interfaceName) =>
+        checkInterfaceMatchClassName(interfaceName, currentClassName)
+      )
+    ) {
+      return true;
+    }
+
+    const baseTypes = currentType.getBaseTypes?.() ?? [];
+    return baseTypes.some(
+      (baseType) => isClassType(baseType) && checkTypeAndBases(baseType)
+    );
+  };
+
+  return checkTypeAndBases(type);
+};
+
+/**
+ * Checks if the provided interface name matches the class name according to specific patterns
+ *
+ * Patterns:
+ * 1. Class name with I prefix (e.g., Bucket -> IBucket)
+ * 2. Class name without Base suffix/prefix with I prefix (e.g., BucketBase -> IBucket, BaseService -> IService)
+ * 3. Class name with BaseV{number} suffix with I prefix (e.g., TableBaseV2 -> ITableV2)
+ *
+ * @param interfaceName - The name of the interface to check
+ * @param classname - The name of the class to compare against
+ * @returns boolean - true if the interface name matches the class name patterns, false otherwise
+ */
+const checkInterfaceMatchClassName = (
+  interfaceName: string,
+  classname: string
+) => {
+  const simpleInterfaceName = interfaceName.includes(".")
+    ? interfaceName.split(".").pop() ?? interfaceName
+    : interfaceName;
+
+  // Pattern 1: Class name with I prefix
+  if (simpleInterfaceName === `I${classname}`) return true;
+
+  // Pattern 2: Class name without Base suffix/prefix with I prefix
+  const classNameWithoutBase = classname.replace(/^Base|Base$/g, "");
+  if (
+    classNameWithoutBase &&
+    simpleInterfaceName === `I${classNameWithoutBase}`
+  ) {
+    return true;
+  }
+
+  // Pattern 3: Class name with BaseV{number} suffix with I prefix (e.g., TableBaseV2 -> ITableV2)
+  const baseVMatch = /^(.+)BaseV(\d+)$/.exec(classname);
+  if (!baseVMatch) return false;
+  const [, baseName, version] = baseVMatch;
+  return simpleInterfaceName === `I${baseName}V${version}`;
+};
+
+/**
+ * Retrieves interface names directly implemented by a type (not including inherited interfaces)
+ * @param type - The TypeScript type to analyze
+ * @returns Array of interface names directly implemented by this type
+ * @private
+ */
+const getDirectImplementedInterfaceNames = (type: Type): string[] => {
+  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<string[]>((acc, decl) => {
+    if (!isClassDeclaration(decl)) return acc;
+
+    const heritageClauses = decl.heritageClauses;
+    if (!heritageClauses) return acc;
+
+    return heritageClauses.reduce<string[]>((hcAcc, hc) => {
+      if (!checkHeritageClauseIsImplements(hc)) return hcAcc;
+
+      return hc.types.reduce<string[]>((typeAcc, type) => {
+        const expression = type.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: string): boolean => {
+  return className === "Resource" || className === "Construct";
+};

package/src/utils/{typeCheck.ts → typecheck/cdk.ts}

@@ -1,6 +1,6 @@
 import { Type } from "typescript";
 
-type SuperClassType = "Construct" | "Stack";
+type SuperClassType = "Construct" | "Stack" | "Resource";
 
 /**
  * Check if the type extends Construct or Stack
@@ -39,6 +39,14 @@ export const isConstructType = (
   return isTargetSuperClassType(type, ["Construct"], isConstructType);
 };
 
+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 isTargetSuperClassType(type, ["Resource"], isResourceType);
+};
+
 /**
  * Check if the type extends target super class
  * @param type - The type to check

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

@@ -0,0 +1,42 @@
+import {
+  ClassDeclaration,
+  ConstructorDeclaration,
+  HeritageClause,
+  Identifier,
+  Node,
+  PropertyAccessExpression,
+} from "typescript";
+
+import { SYNTAX_KIND } from "../../constants/tsInternalFlags";
+
+// 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 @typescript-eslint/no-unsafe-enum-comparison */
+
+// NOTE: Implementing type check method defined in typescript on your own, in order not to include TypeScript in dependencies
+
+export const isClassDeclaration = (node: Node): node is ClassDeclaration => {
+  return node.kind === SYNTAX_KIND.CLASS_DECLARATION;
+};
+
+export const isIdentifier = (node: Node): node is Identifier => {
+  return node.kind === SYNTAX_KIND.IDENTIFIER;
+};
+
+export const isPropertyAccessExpression = (
+  node: Node
+): node is PropertyAccessExpression => {
+  return node.kind === SYNTAX_KIND.PROPERTY_ACCESS_EXPRESSION;
+};
+
+export const checkHeritageClauseIsImplements = (
+  node: HeritageClause
+): boolean => {
+  return node.token === SYNTAX_KIND.IMPLEMENTS_KEYWORD;
+};
+
+export const isConstructorDeclaration = (
+  node: Node
+): node is ConstructorDeclaration => {
+  return node.kind === SYNTAX_KIND.CONSTRUCTOR;
+};

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

@@ -0,0 +1,15 @@
+import { Symbol, Type } from "typescript";
+
+import { SYMBOL_FLAGS } from "../../constants/tsInternalFlags";
+
+// 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 @typescript-eslint/no-unsafe-enum-comparison */
+
+const getSymbol = (type: Type): Symbol | undefined => {
+  return type.getSymbol?.() ?? type.symbol;
+};
+
+export const isClassType = (type: Type): boolean => {
+  return getSymbol(type)?.flags === SYMBOL_FLAGS.CLASS;
+};