eslint-cdk-plugin 3.4.4 → 3.4.6

package/src/index.ts

@@ -1,112 +1,7 @@
-import tsParser from "@typescript-eslint/parser";
 import { FlatConfig } from "@typescript-eslint/utils/ts-eslint";
 
-import { name, version } from "../package.json";
-
-import { constructConstructorProperty } from "./rules/construct-constructor-property";
-import { noConstructInInterface } from "./rules/no-construct-in-interface";
-import { noConstructInPublicPropertyOfConstruct } from "./rules/no-construct-in-public-property-of-construct";
-import { noConstructStackSuffix } from "./rules/no-construct-stack-suffix";
-import { noImportPrivate } from "./rules/no-import-private";
-import { noMutablePropertyOfPropsInterface } from "./rules/no-mutable-property-of-props-interface";
-import { noMutablePublicPropertyOfConstruct } from "./rules/no-mutable-public-property-of-construct";
-import { noParentNameConstructIdMatch } from "./rules/no-parent-name-construct-id-match";
-import { noUnusedProps } from "./rules/no-unused-props";
-import { noVariableConstructId } from "./rules/no-variable-construct-id";
-import { pascalCaseConstructId } from "./rules/pascal-case-construct-id";
-import { propsNameConvention } from "./rules/props-name-convention";
-import { requireJSDoc } from "./rules/require-jsdoc";
-import { requirePassingThis } from "./rules/require-passing-this";
-import { requirePropsDefaultDoc } from "./rules/require-props-default-doc";
-
-const rules = {
-  "construct-constructor-property": constructConstructorProperty,
-  "no-construct-in-interface": noConstructInInterface,
-  "no-construct-in-public-property-of-construct":
-    noConstructInPublicPropertyOfConstruct,
-  "no-construct-stack-suffix": noConstructStackSuffix,
-  "no-import-private": noImportPrivate,
-  "no-mutable-property-of-props-interface": noMutablePropertyOfPropsInterface,
-  "no-mutable-public-property-of-construct": noMutablePublicPropertyOfConstruct,
-  "no-parent-name-construct-id-match": noParentNameConstructIdMatch,
-  "no-unused-props": noUnusedProps,
-  "no-variable-construct-id": noVariableConstructId,
-  "pascal-case-construct-id": pascalCaseConstructId,
-  "props-name-convention": propsNameConvention,
-  "require-jsdoc": requireJSDoc,
-  "require-passing-this": requirePassingThis,
-  "require-props-default-doc": requirePropsDefaultDoc,
-};
-
-const cdkPlugin = {
-  meta: { name, version },
-  rules,
-};
-
-const createFlatConfig = (
-  rules: FlatConfig.Rules
-): {
-  languageOptions: FlatConfig.LanguageOptions;
-  plugins: FlatConfig.Plugins;
-  rules: FlatConfig.Rules;
-} => {
-  return {
-    languageOptions: {
-      parser: tsParser,
-      parserOptions: {
-        projectService: true,
-      },
-    },
-    plugins: {
-      cdk: cdkPlugin,
-    },
-    rules,
-  };
-};
-
-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 },
-  ],
-  // TODO: Enable this rule at v4.0.0
-  // "cdk/no-unused-props": "error",
-  "cdk/no-variable-construct-id": "error",
-  "cdk/pascal-case-construct-id": "error",
-  "cdk/require-passing-this": ["error", { allowNonThisAndDisallowScope: true }],
-});
-
-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",
-});
-
-const configs = {
-  recommended,
-  strict,
-};
+import { configs } from "./configs";
+import { rules } from "./rules";
 
 export { configs, rules };
 
@@ -120,7 +15,10 @@ export interface EslintCdkPlugin {
 
 const eslintCdkPlugin: EslintCdkPlugin = {
   rules,
-  configs,
+  configs: {
+    recommended: configs.recommended,
+    strict: configs.strict,
+  },
 };
 
 export default eslintCdkPlugin;

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

@@ -6,9 +6,9 @@ import {
   TSESTree,
 } from "@typescript-eslint/utils";
 
-import { createRule } from "../utils/createRule";
-import { getConstructor } from "../utils/getConstructor";
-import { isConstructType } from "../utils/typecheck/cdk";
+import { findConstructor } from "../core/ast-node/finder/constructor";
+import { isConstructType } from "../core/cdk-construct/type-checker/is-construct";
+import { createRule } from "../shared/create-rule";
 
 type Context = TSESLint.RuleContext<
   | "invalidConstructorProperty"
@@ -17,6 +17,12 @@ type Context = TSESLint.RuleContext<
   []
 >;
 
+type ConstructorProperties = [
+  TSESTree.Parameter,
+  TSESTree.Parameter,
+  TSESTree.Parameter | undefined
+];
+
 /**
  * Enforces that constructors of classes extending Construct have the property names 'scope, id' or 'scope, id, props'
  * @param context - The rule context provided by ESLint
@@ -48,36 +54,46 @@ export const constructConstructorProperty = createRule({
         const type = parserServices.getTypeAtLocation(node);
         if (!isConstructType(type)) return;
 
-        const constructor = getConstructor(node);
+        const constructor = findConstructor(node);
         if (!constructor) return;
 
-        validateConstructorProperty(constructor, context, parserServices);
+        const params = checkNumOfConstructorProperty(constructor, context);
+        if (params) {
+          checkFirstParamIsScope(params[0], context, parserServices);
+          checkSecondParamIsId(params[1], context);
+          checkThirdParamIsProps(params[2], context);
+        }
       },
     };
   },
 });
 
 /**
- * Validates that the constructor has the property names "scope, id" or "scope, id, props"
+ * Checks if the number of constructor properties is valid (at least 2)
  */
-const validateConstructorProperty = (
+const checkNumOfConstructorProperty = (
   constructor: TSESTree.MethodDefinition,
-  context: Context,
-  parserServices: ParserServicesWithTypeInformation
-): void => {
+  context: Context
+): ConstructorProperties | undefined => {
   const params = constructor.value.params;
-
-  // NOTE: Check if the constructor has at least 2 parameters
   if (params.length < 2) {
     context.report({
       node: constructor.value,
       messageId: "invalidConstructorProperty",
     });
-    return;
+    return undefined;
   }
+  return [params[0], params[1], params[2]];
+};
 
-  // NOTE: Check if the first parameter is named "scope"
-  const firstParam = params[0];
+/**
+ * Checks if the first parameter is named "scope" and of type Construct
+ */
+const checkFirstParamIsScope = (
+  firstParam: ConstructorProperties[0],
+  context: Context,
+  parserServices: ParserServicesWithTypeInformation
+) => {
   if (
     firstParam.type !== AST_NODE_TYPES.Identifier ||
     firstParam.name !== "scope"
@@ -92,9 +108,15 @@ const validateConstructorProperty = (
       messageId: "invalidConstructorType",
     });
   }
+};
 
-  // NOTE: Check if the second parameter is named "id"
-  const secondParam = params[1];
+/**
+ * Checks if the second parameter is named "id" and of type string
+ */
+const checkSecondParamIsId = (
+  secondParam: ConstructorProperties[1],
+  context: Context
+) => {
   if (
     secondParam.type !== AST_NODE_TYPES.Identifier ||
     secondParam.name !== "id"
@@ -103,7 +125,6 @@ const validateConstructorProperty = (
       node: secondParam,
       messageId: "invalidConstructorProperty",
     });
-    return;
   } else if (
     secondParam.typeAnnotation?.typeAnnotation.type !==
     AST_NODE_TYPES.TSStringKeyword
@@ -112,15 +133,17 @@ const validateConstructorProperty = (
       node: secondParam,
       messageId: "invalidConstructorIdType",
     });
-    return;
   }
+};
 
-  if (params.length < 3)
-    // NOTE: If there's no third parameter, return
-    return;
-
-  // NOTE: Check if the third parameter is named "props"
-  const thirdParam = params[2];
+/**
+ * Checks if the third parameter is named "props"
+ */
+const checkThirdParamIsProps = (
+  thirdParam: ConstructorProperties[2],
+  context: Context
+) => {
+  if (!thirdParam) return;
   if (
     thirdParam.type !== AST_NODE_TYPES.Identifier ||
     thirdParam.name !== "props"
@@ -129,6 +152,5 @@ const validateConstructorProperty = (
       node: thirdParam,
       messageId: "invalidConstructorProperty",
     });
-    return;
   }
 };

package/src/rules/index.ts

@@ -0,0 +1,34 @@
+import { constructConstructorProperty } from "./construct-constructor-property";
+import { noConstructInInterface } from "./no-construct-in-interface";
+import { noConstructInPublicPropertyOfConstruct } from "./no-construct-in-public-property-of-construct";
+import { noConstructStackSuffix } from "./no-construct-stack-suffix";
+import { noImportPrivate } from "./no-import-private";
+import { noMutablePropertyOfPropsInterface } from "./no-mutable-property-of-props-interface";
+import { noMutablePublicPropertyOfConstruct } from "./no-mutable-public-property-of-construct";
+import { noParentNameConstructIdMatch } from "./no-parent-name-construct-id-match";
+import { noUnusedProps } from "./no-unused-props";
+import { noVariableConstructId } from "./no-variable-construct-id";
+import { pascalCaseConstructId } from "./pascal-case-construct-id";
+import { propsNameConvention } from "./props-name-convention";
+import { requireJSDoc } from "./require-jsdoc";
+import { requirePassingThis } from "./require-passing-this";
+import { requirePropsDefaultDoc } from "./require-props-default-doc";
+
+export const rules = {
+  "construct-constructor-property": constructConstructorProperty,
+  "no-construct-in-interface": noConstructInInterface,
+  "no-construct-in-public-property-of-construct":
+    noConstructInPublicPropertyOfConstruct,
+  "no-construct-stack-suffix": noConstructStackSuffix,
+  "no-import-private": noImportPrivate,
+  "no-mutable-property-of-props-interface": noMutablePropertyOfPropsInterface,
+  "no-mutable-public-property-of-construct": noMutablePublicPropertyOfConstruct,
+  "no-parent-name-construct-id-match": noParentNameConstructIdMatch,
+  "no-unused-props": noUnusedProps,
+  "no-variable-construct-id": noVariableConstructId,
+  "pascal-case-construct-id": pascalCaseConstructId,
+  "props-name-convention": propsNameConvention,
+  "require-jsdoc": requireJSDoc,
+  "require-passing-this": requirePassingThis,
+  "require-props-default-doc": requirePropsDefaultDoc,
+};

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

@@ -1,10 +1,7 @@
 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";
+import { findTypeOfCdkConstruct } from "../core/cdk-construct/type-finder";
+import { createRule } from "../shared/create-rule";
 
 /**
  * Enforces the use of interface types instead of CDK Construct types in interface properties
@@ -38,58 +35,15 @@ export const noConstructInInterface = createRule({
           }
 
           const type = parserServices.getTypeAtLocation(property);
+          const result = findTypeOfCdkConstruct(type);
 
-          // NOTE: Check if it's a direct class type
-          if (isClassType(type) && isResourceWithReadonlyInterface(type)) {
+          if (result) {
             context.report({
               node: property,
               messageId: "invalidInterfaceProperty",
               data: {
                 propertyName: property.key.name,
-                typeName: type.symbol.name,
-              },
-            });
-            continue;
-          }
-
-          // 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,
+                typeName: result.symbol.name,
               },
             });
           }

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

@@ -1,22 +1,22 @@
 import {
-  AST_NODE_TYPES,
   ESLintUtils,
   ParserServicesWithTypeInformation,
   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";
+import { findPublicPropertiesInClass } from "../core/ast-node/finder/public-property";
+import { isConstructOrStackType } from "../core/cdk-construct/type-checker/is-construct-or-stack";
+import { findTypeOfCdkConstruct } from "../core/cdk-construct/type-finder";
+import { createRule } from "../shared/create-rule";
 
 type Context = TSESLint.RuleContext<"invalidPublicPropertyOfConstruct", []>;
 
+type PublicProperty = {
+  name: string;
+  node: TSESTree.Parameter | TSESTree.ClassElement;
+};
+
 /**
  * Disallow Construct types in public property of Construct
  * @param context - The rule context provided by ESLint
@@ -42,152 +42,29 @@ export const noConstructInPublicPropertyOfConstruct = createRule({
       ClassDeclaration(node) {
         const type = parserServices.getTypeAtLocation(node);
         if (!isConstructOrStackType(type)) return;
-
-        // NOTE: Check class members
-        validatePublicPropertyOfConstruct(node, context, parserServices);
-
-        // NOTE: Check constructor parameter properties
-        const constructor = getConstructor(node);
-        if (
-          !constructor ||
-          constructor.value.type !== AST_NODE_TYPES.FunctionExpression
-        ) {
-          return;
+        const publicProperties = findPublicPropertiesInClass(node);
+        for (const publicProperty of publicProperties) {
+          validatePublicProperty(publicProperty, context, parserServices);
         }
-
-        validateConstructorParameterProperty(
-          constructor,
-          context,
-          parserServices
-        );
       },
     };
   },
 });
 
-/**
- * check the public property of Construct
- * - if it is a Construct type, report an error
- */
-const validatePublicPropertyOfConstruct = (
-  node: TSESTree.ClassDeclaration,
+const validatePublicProperty = (
+  publicProperty: PublicProperty,
   context: Context,
   parserServices: ParserServicesWithTypeInformation
 ) => {
-  for (const property of node.body.body) {
-    if (
-      property.type !== AST_NODE_TYPES.PropertyDefinition ||
-      property.key.type !== AST_NODE_TYPES.Identifier
-    ) {
-      continue;
-    }
-
-    // NOTE: Skip private and protected fields
-    if (["private", "protected"].includes(property.accessibility ?? "")) {
-      continue;
-    }
-
-    // NOTE: Skip fields without type annotation
-    if (!property.typeAnnotation) continue;
-
-    const type = parserServices.getTypeAtLocation(property);
-    checkAndReportConstructType(type, property, property.key.name, context);
-  }
-};
-
-/**
- * check the constructor parameter property
- * - if it is a Construct type, report an error
- */
-const validateConstructorParameterProperty = (
-  constructor: TSESTree.MethodDefinition,
-  context: Context,
-  parserServices: ParserServicesWithTypeInformation
-) => {
-  for (const param of constructor.value.params) {
-    if (
-      param.type !== AST_NODE_TYPES.TSParameterProperty ||
-      param.parameter.type !== AST_NODE_TYPES.Identifier
-    ) {
-      continue;
-    }
-
-    // NOTE: Skip private and protected parameters
-    if (["private", "protected"].includes(param.accessibility ?? "")) {
-      continue;
-    }
-
-    // NOTE: Skip parameters without type annotation
-    if (!param.parameter.typeAnnotation) continue;
-
-    const type = parserServices.getTypeAtLocation(param);
-    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,
-      messageId: "invalidPublicPropertyOfConstruct",
-      data: {
-        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;
-    })();
-
+  const type = parserServices.getTypeAtLocation(publicProperty.node);
+  const constructType = findTypeOfCdkConstruct(type);
+  if (constructType) {
     context.report({
-      node,
+      node: publicProperty.node,
       messageId: "invalidPublicPropertyOfConstruct",
       data: {
-        propertyName,
-        typeName: wrapperName
-          ? `${wrapperName}<${genericArgument.symbol.name}>`
-          : genericArgument.symbol.name,
+        propertyName: publicProperty.name,
+        typeName: constructType.symbol.name,
       },
     });
   }

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

@@ -5,10 +5,10 @@ import {
   TSESTree,
 } from "@typescript-eslint/utils";
 
-import { toPascalCase } from "../utils/convertString";
-import { createRule } from "../utils/createRule";
-import { getConstructorPropertyNames } from "../utils/getPropertyNames";
-import { isConstructOrStackType } from "../utils/typecheck/cdk";
+import { isConstructOrStackType } from "../core/cdk-construct/type-checker/is-construct-or-stack";
+import { findConstructorPropertyNames } from "../core/ts-type/finder/constructor-property-name";
+import { toPascalCase } from "../shared/converter/to-pascal-case";
+import { createRule } from "../shared/create-rule";
 
 const SUFFIX_TYPE = {
   CONSTRUCT: "Construct",
@@ -72,7 +72,7 @@ export const noConstructStackSuffix = createRule({
           return;
         }
 
-        const constructorPropertyNames = getConstructorPropertyNames(type);
+        const constructorPropertyNames = findConstructorPropertyNames(type);
         if (constructorPropertyNames[1] !== "id") return;
 
         validateConstructId(node, context);

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

@@ -1,6 +1,6 @@
 import { AST_NODE_TYPES } from "@typescript-eslint/utils";
 
-import { createRule } from "../utils/createRule";
+import { createRule } from "../shared/create-rule";
 
 /**
  * Disallow mutable properties of Construct Props (interface)