eslint-cdk-plugin 3.0.2 → 3.0.3

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

@@ -5,6 +5,7 @@ import {
   TSESTree,
 } from "@typescript-eslint/utils";
 
+import { createRule } from "../utils/createRule";
 import { isConstructType } from "../utils/typeCheck";
 
 type Context = TSESLint.RuleContext<"invalidConstructorProperty", []>;
@@ -13,47 +14,44 @@ type Context = TSESLint.RuleContext<"invalidConstructorProperty", []>;
  * 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
  * @returns An object containing the AST visitor functions
- * @see {@link https://eslint-cdk-plugin.dev/rules/construct-constructor-property} - Documentation
  */
-export const constructConstructorProperty = ESLintUtils.RuleCreator.withoutDocs(
-  {
-    meta: {
-      type: "problem",
-      docs: {
-        description:
-          "Enforces that constructors of classes extending Construct have the property names 'scope, id' or 'scope, id, props'",
-      },
-      messages: {
-        invalidConstructorProperty:
-          "Constructor of a class extending Construct must have the property names 'scope, id' or 'scope, id, props'",
-      },
-      schema: [],
+export const constructConstructorProperty = createRule({
+  name: "construct-constructor-property",
+  meta: {
+    type: "problem",
+    docs: {
+      description:
+        "Enforces that constructors of classes extending Construct have the property names 'scope, id' or 'scope, id, props'",
     },
-    defaultOptions: [],
-    create(context) {
-      const parserServices = ESLintUtils.getParserServices(context);
-
-      return {
-        ClassDeclaration(node) {
-          const type = parserServices.getTypeAtLocation(node);
-          if (!isConstructType(type)) return;
+    messages: {
+      invalidConstructorProperty:
+        "Constructor of a class extending Construct must have the property names 'scope, id' or 'scope, id, props'",
+    },
+    schema: [],
+  },
+  defaultOptions: [],
+  create(context) {
+    const parserServices = ESLintUtils.getParserServices(context);
+    return {
+      ClassDeclaration(node) {
+        const type = parserServices.getTypeAtLocation(node);
+        if (!isConstructType(type)) return;
 
-          // NOTE: Find the constructor method
-          const constructor = node.body.body.find(
-            (member): member is TSESTree.MethodDefinition =>
-              member.type === AST_NODE_TYPES.MethodDefinition &&
-              member.kind === "constructor"
-          );
+        // NOTE: Find the constructor method
+        const constructor = node.body.body.find(
+          (member): member is TSESTree.MethodDefinition =>
+            member.type === AST_NODE_TYPES.MethodDefinition &&
+            member.kind === "constructor"
+        );
 
-          // NOTE: Skip if there's no constructor
-          if (!constructor) return;
+        // NOTE: Skip if there's no constructor
+        if (!constructor) return;
 
-          validateConstructorProperty(constructor, context);
-        },
-      };
-    },
-  }
-);
+        validateConstructorProperty(constructor, context);
+      },
+    };
+  },
+});
 
 /**
  * Validates that the constructor has the property names "scope, id" or "scope, id, props"

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

@@ -1,15 +1,16 @@
 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";
 
 /**
  * Enforces the use of interface types instead of CDK Construct types in interface properties
  * @param context - The rule context provided by ESLint
  * @returns An object containing the AST visitor functions
- * @see {@link https://eslint-cdk-plugin.dev/rules/no-class-in-interface} - Documentation
  */
-export const noConstructInInterface = ESLintUtils.RuleCreator.withoutDocs({
+export const noConstructInInterface = createRule({
+  name: "no-construct-in-interface",
   meta: {
     type: "problem",
     docs: {

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

@@ -7,6 +7,7 @@ import {
 } from "@typescript-eslint/utils";
 
 import { SYMBOL_FLAGS } from "../constants/tsInternalFlags";
+import { createRule } from "../utils/createRule";
 import { isConstructOrStackType } from "../utils/typeCheck";
 
 type Context = TSESLint.RuleContext<"invalidPublicPropertyOfConstruct", []>;
@@ -15,54 +16,53 @@ type Context = TSESLint.RuleContext<"invalidPublicPropertyOfConstruct", []>;
  * Disallow Construct types in public property of Construct
  * @param context - The rule context provided by ESLint
  * @returns An object containing the AST visitor functions
- * @see {@link https://eslint-cdk-plugin.dev/rules/no-construct-in-public-property-of-construct} - Documentation
  */
-export const noConstructInPublicPropertyOfConstruct =
-  ESLintUtils.RuleCreator.withoutDocs({
-    meta: {
-      type: "problem",
-      docs: {
-        description: "Disallow Construct types in public property of Construct",
-      },
-      messages: {
-        invalidPublicPropertyOfConstruct:
-          "Public property '{{ propertyName }}' of Construct should not use Construct type '{{ typeName }}'. Consider using an interface or type alias instead.",
-      },
-      schema: [],
+export const noConstructInPublicPropertyOfConstruct = createRule({
+  name: "no-construct-in-public-property-of-construct",
+  meta: {
+    type: "problem",
+    docs: {
+      description: "Disallow Construct types in public property of Construct",
     },
-    defaultOptions: [],
-    create(context) {
-      const parserServices = ESLintUtils.getParserServices(context);
-      return {
-        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 = node.body.body.find(
-            (member): member is TSESTree.MethodDefinition =>
-              member.type === AST_NODE_TYPES.MethodDefinition &&
-              member.kind === "constructor"
-          );
-          if (
-            !constructor ||
-            constructor.value.type !== AST_NODE_TYPES.FunctionExpression
-          ) {
-            return;
-          }
-
-          validateConstructorParameterProperty(
-            constructor,
-            context,
-            parserServices
-          );
-        },
-      };
+    messages: {
+      invalidPublicPropertyOfConstruct:
+        "Public property '{{ propertyName }}' of Construct should not use Construct type '{{ typeName }}'. Consider using an interface or type alias instead.",
     },
-  });
+    schema: [],
+  },
+  defaultOptions: [],
+  create(context) {
+    const parserServices = ESLintUtils.getParserServices(context);
+    return {
+      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 = node.body.body.find(
+          (member): member is TSESTree.MethodDefinition =>
+            member.type === AST_NODE_TYPES.MethodDefinition &&
+            member.kind === "constructor"
+        );
+        if (
+          !constructor ||
+          constructor.value.type !== AST_NODE_TYPES.FunctionExpression
+        ) {
+          return;
+        }
+
+        validateConstructorParameterProperty(
+          constructor,
+          context,
+          parserServices
+        );
+      },
+    };
+  },
+});
 
 /**
  * check the public property of Construct

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

@@ -6,6 +6,7 @@ import {
 } from "@typescript-eslint/utils";
 
 import { toPascalCase } from "../utils/convertString";
+import { createRule } from "../utils/createRule";
 import { getConstructorPropertyNames } from "../utils/parseType";
 import { isConstructOrStackType } from "../utils/typeCheck";
 
@@ -28,9 +29,9 @@ type Context = TSESLint.RuleContext<"invalidConstructId", Options>;
  * Enforces that Construct IDs do not end with 'Construct' or 'Stack' suffix
  * @param context - The rule context provided by ESLint
  * @returns An object containing the AST visitor functions
- * @see {@link https://eslint-cdk-plugin.dev/rules/no-construct-stack-suffix} - Documentation
  */
-export const noConstructStackSuffix = ESLintUtils.RuleCreator.withoutDocs({
+export const noConstructStackSuffix = createRule({
+  name: "no-construct-stack-suffix",
   meta: {
     type: "problem",
     docs: {

package/src/rules/no-import-private.ts

@@ -6,12 +6,12 @@ import { Rule } from "eslint";
  * Disallow importing modules from private directories at different levels of the hierarchy.
  * @param context - The rule context provided by ESLint
  * @returns An object containing the AST visitor functions
- * @see {@link https://eslint-cdk-plugin.dev/rules/no-import-private} - Documentation
  */
 export const noImportPrivate: Rule.RuleModule = {
   meta: {
     type: "problem",
     docs: {
+      url: "https://eslint-cdk-plugin.dev/rules/no-import-private",
       description:
         "Cannot import modules from private dir at different levels of the hierarchy.",
     },

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

@@ -1,60 +1,60 @@
-import { AST_NODE_TYPES, ESLintUtils } from "@typescript-eslint/utils";
+import { AST_NODE_TYPES } from "@typescript-eslint/utils";
+
+import { createRule } from "../utils/createRule";
 
 /**
  * Disallow mutable properties of Construct Props (interface)
  * @param context - The rule context provided by ESLint
  * @returns An object containing the AST visitor functions
- * @see {@link https://eslint-cdk-plugin.dev/rules/no-mutable-property-of-props-interface} - Documentation
  */
-export const noMutablePropertyOfPropsInterface =
-  ESLintUtils.RuleCreator.withoutDocs({
-    meta: {
-      type: "problem",
-      docs: {
-        description:
-          "Disallow mutable properties of Construct Props (interface)",
-      },
-      fixable: "code",
-      messages: {
-        invalidPropertyOfPropsInterface:
-          "Property '{{ propertyName }}' of Construct Props should be readonly.",
-      },
-      schema: [],
+export const noMutablePropertyOfPropsInterface = createRule({
+  name: "no-mutable-property-of-props-interface",
+  meta: {
+    type: "problem",
+    docs: {
+      description: "Disallow mutable properties of Construct Props (interface)",
+    },
+    fixable: "code",
+    messages: {
+      invalidPropertyOfPropsInterface:
+        "Property '{{ propertyName }}' of Construct Props should be readonly.",
     },
-    defaultOptions: [],
-    create(context) {
-      return {
-        TSInterfaceDeclaration(node) {
-          const sourceCode = context.sourceCode;
+    schema: [],
+  },
+  defaultOptions: [],
+  create(context) {
+    return {
+      TSInterfaceDeclaration(node) {
+        const sourceCode = context.sourceCode;
 
-          // NOTE: Interface name check for "Props"
-          if (!node.id.name.endsWith("Props")) return;
+        // NOTE: Interface name check for "Props"
+        if (!node.id.name.endsWith("Props")) return;
 
-          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
-            ) {
-              continue;
-            }
+        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
+          ) {
+            continue;
+          }
 
-            // NOTE: Skip if already readonly
-            if (property.readonly) continue;
+          // NOTE: Skip if already readonly
+          if (property.readonly) continue;
 
-            context.report({
-              node: property,
-              messageId: "invalidPropertyOfPropsInterface",
-              data: {
-                propertyName: property.key.name,
-              },
-              fix: (fixer) => {
-                const propertyText = sourceCode.getText(property);
-                return fixer.replaceText(property, `readonly ${propertyText}`);
-              },
-            });
-          }
-        },
-      };
-    },
-  });
+          context.report({
+            node: property,
+            messageId: "invalidPropertyOfPropsInterface",
+            data: {
+              propertyName: property.key.name,
+            },
+            fix: (fixer) => {
+              const propertyText = sourceCode.getText(property);
+              return fixer.replaceText(property, `readonly ${propertyText}`);
+            },
+          });
+        }
+      },
+    };
+  },
+});

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

@@ -1,76 +1,76 @@
 import { AST_NODE_TYPES, ESLintUtils } from "@typescript-eslint/utils";
 
+import { createRule } from "../utils/createRule";
 import { isConstructOrStackType } from "../utils/typeCheck";
 
 /**
  * Disallow mutable public properties of Construct
  * @param context - The rule context provided by ESLint
  * @returns An object containing the AST visitor functions
- * @see {@link https://eslint-cdk-plugin.dev/rules/no-mutable-public-property-of-construct} - Documentation
  */
-export const noMutablePublicPropertyOfConstruct =
-  ESLintUtils.RuleCreator.withoutDocs({
-    meta: {
-      type: "problem",
-      docs: {
-        description: "Disallow mutable public properties of Construct",
-      },
-      fixable: "code",
-      messages: {
-        invalidPublicPropertyOfConstruct:
-          "Public property '{{ propertyName }}' should be readonly. Consider adding the 'readonly' modifier.",
-      },
-      schema: [],
+export const noMutablePublicPropertyOfConstruct = createRule({
+  name: "no-mutable-public-property-of-construct",
+  meta: {
+    type: "problem",
+    docs: {
+      description: "Disallow mutable public properties of Construct",
     },
-    defaultOptions: [],
-    create(context) {
-      const parserServices = ESLintUtils.getParserServices(context);
+    fixable: "code",
+    messages: {
+      invalidPublicPropertyOfConstruct:
+        "Public property '{{ propertyName }}' should be readonly. Consider adding the 'readonly' modifier.",
+    },
+    schema: [],
+  },
+  defaultOptions: [],
+  create(context) {
+    const parserServices = ESLintUtils.getParserServices(context);
 
-      return {
-        ClassDeclaration(node) {
-          const sourceCode = context.sourceCode;
-          const type = parserServices.getTypeAtLocation(node);
-          if (!isConstructOrStackType(type)) return;
+    return {
+      ClassDeclaration(node) {
+        const sourceCode = context.sourceCode;
+        const type = parserServices.getTypeAtLocation(node);
+        if (!isConstructOrStackType(type)) return;
 
-          for (const member of node.body.body) {
-            // NOTE: check property definition
-            if (
-              member.type !== AST_NODE_TYPES.PropertyDefinition ||
-              member.key.type !== AST_NODE_TYPES.Identifier
-            ) {
-              continue;
-            }
+        for (const member of node.body.body) {
+          // NOTE: check property definition
+          if (
+            member.type !== AST_NODE_TYPES.PropertyDefinition ||
+            member.key.type !== AST_NODE_TYPES.Identifier
+          ) {
+            continue;
+          }
 
-            // NOTE: Skip private and protected fields
-            if (["private", "protected"].includes(member.accessibility ?? "")) {
-              continue;
-            }
+          // NOTE: Skip private and protected fields
+          if (["private", "protected"].includes(member.accessibility ?? "")) {
+            continue;
+          }
 
-            // NOTE: Skip if readonly is present
-            if (member.readonly) continue;
+          // NOTE: Skip if readonly is present
+          if (member.readonly) continue;
 
-            context.report({
-              node: member,
-              messageId: "invalidPublicPropertyOfConstruct",
-              data: {
-                propertyName: member.key.name,
-              },
-              fix: (fixer) => {
-                const accessibility = member.accessibility ? "public " : "";
-                const paramText = sourceCode.getText(member);
-                const [key, value] = paramText.split(":");
-                const replacedKey = key.startsWith("public ")
-                  ? key.replace("public ", "")
-                  : key;
+          context.report({
+            node: member,
+            messageId: "invalidPublicPropertyOfConstruct",
+            data: {
+              propertyName: member.key.name,
+            },
+            fix: (fixer) => {
+              const accessibility = member.accessibility ? "public " : "";
+              const paramText = sourceCode.getText(member);
+              const [key, value] = paramText.split(":");
+              const replacedKey = key.startsWith("public ")
+                ? key.replace("public ", "")
+                : key;
 
-                return fixer.replaceText(
-                  member,
-                  `${accessibility}readonly ${replacedKey}:${value}`
-                );
-              },
-            });
-          }
-        },
-      };
-    },
-  });
+              return fixer.replaceText(
+                member,
+                `${accessibility}readonly ${replacedKey}:${value}`
+              );
+            },
+          });
+        }
+      },
+    };
+  },
+});

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

@@ -7,6 +7,7 @@ import {
 } from "@typescript-eslint/utils";
 
 import { toPascalCase } from "../utils/convertString";
+import { createRule } from "../utils/createRule";
 import { isConstructOrStackType, isConstructType } from "../utils/typeCheck";
 
 type Options = [
@@ -37,78 +38,76 @@ type ValidateExpressionArgs<T extends TSESTree.Expression> = {
  * Enforce that construct IDs does not match the parent construct name.
  * @param context - The rule context provided by ESLint
  * @returns An object containing the AST visitor functions
- * @see {@link https://eslint-cdk-plugin.dev/rules/no-parent-name-construct-id-match} - Documentation
  */
-export const noParentNameConstructIdMatch = ESLintUtils.RuleCreator.withoutDocs(
-  {
-    meta: {
-      type: "problem",
-      docs: {
-        description:
-          "Enforce that construct IDs does not match the parent construct name.",
-      },
-      messages: {
-        invalidConstructId:
-          "Construct ID '{{ constructId }}' should not match parent construct name '{{ parentConstructName }}'. Use a more specific identifier.",
-      },
-      schema: [
-        {
-          type: "object",
-          properties: {
-            disallowContainingParentName: {
-              type: "boolean",
-              default: false,
-            },
-          },
-          additionalProperties: false,
-        },
-      ],
+export const noParentNameConstructIdMatch = createRule({
+  name: "no-parent-name-construct-id-match",
+  meta: {
+    type: "problem",
+    docs: {
+      description:
+        "Enforce that construct IDs does not match the parent construct name.",
     },
-    defaultOptions: [
+    messages: {
+      invalidConstructId:
+        "Construct ID '{{ constructId }}' should not match parent construct name '{{ parentConstructName }}'. Use a more specific identifier.",
+    },
+    schema: [
       {
-        disallowContainingParentName: false,
+        type: "object",
+        properties: {
+          disallowContainingParentName: {
+            type: "boolean",
+            default: false,
+          },
+        },
+        additionalProperties: false,
       },
     ],
+  },
+  defaultOptions: [
+    {
+      disallowContainingParentName: false,
+    },
+  ],
 
-    create(context: Context) {
-      const option = context.options[0] || {
-        disallowContainingParentName: false,
-      };
-      const parserServices = ESLintUtils.getParserServices(context);
-      return {
-        ClassBody(node) {
-          const type = parserServices.getTypeAtLocation(node);
+  create(context: Context) {
+    const option = context.options[0] || {
+      disallowContainingParentName: false,
+    };
+    const parserServices = ESLintUtils.getParserServices(context);
+    return {
+      ClassBody(node) {
+        const type = parserServices.getTypeAtLocation(node);
 
-          if (!isConstructOrStackType(type)) return;
+        if (!isConstructOrStackType(type)) return;
 
-          const parent = node.parent;
-          if (parent?.type !== AST_NODE_TYPES.ClassDeclaration) return;
+        const parent = node.parent;
+        if (parent?.type !== AST_NODE_TYPES.ClassDeclaration) return;
 
-          const parentClassName = parent.id?.name;
-          if (!parentClassName) return;
+        const parentClassName = parent.id?.name;
+        if (!parentClassName) return;
 
-          for (const body of node.body) {
-            // NOTE: Ignore if neither method nor constructor.
-            if (
-              body.type !== AST_NODE_TYPES.MethodDefinition ||
-              !["method", "constructor"].includes(body.kind) ||
-              body.value.type !== AST_NODE_TYPES.FunctionExpression
-            ) {
-              continue;
-            }
-            validateConstructorBody({
-              expression: body.value,
-              parentClassName,
-              context,
-              parserServices,
-              option,
-            });
+        for (const body of node.body) {
+          // NOTE: Ignore if neither method nor constructor.
+          if (
+            body.type !== AST_NODE_TYPES.MethodDefinition ||
+            !["method", "constructor"].includes(body.kind) ||
+            body.value.type !== AST_NODE_TYPES.FunctionExpression
+          ) {
+            continue;
           }
-        },
-      };
-    },
-  }
-);
+          validateConstructorBody({
+            expression: body.value,
+            parentClassName,
+            context,
+            parserServices,
+            option,
+          });
+        }
+      },
+    };
+  },
+});
 
 /**
  * Validate the constructor body for the parent class

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

@@ -5,6 +5,7 @@ import {
   TSESTree,
 } from "@typescript-eslint/utils";
 
+import { createRule } from "../utils/createRule";
 import { getConstructorPropertyNames } from "../utils/parseType";
 import { isConstructType } from "../utils/typeCheck";
 
@@ -15,7 +16,8 @@ type Context = TSESLint.RuleContext<"invalidConstructId", []>;
  * @param context - The rule context provided by ESLint
  * @returns An object containing the AST visitor functions
  */
-export const noVariableConstructId = ESLintUtils.RuleCreator.withoutDocs({
+export const noVariableConstructId = createRule({
+  name: "no-variable-construct-id",
   meta: {
     type: "problem",
     docs: {