eslint-cdk-plugin 1.0.1 → 1.0.3

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

@@ -0,0 +1,312 @@
+import {
+  AST_NODE_TYPES,
+  ESLintUtils,
+  TSESLint,
+  TSESTree,
+} from "@typescript-eslint/utils";
+
+import { toPascalCase } from "../utils/convertString";
+
+type Context = TSESLint.RuleContext<"noParentNameConstructIdMatch", []>;
+
+type ValidateStatementArgs<T extends TSESTree.Statement> = {
+  node: TSESTree.ClassBody;
+  statement: T;
+  parentClassName: string;
+  context: Context;
+};
+
+type ValidateExpressionArgs<T extends TSESTree.Expression> = {
+  node: TSESTree.ClassBody;
+  expression: T;
+  parentClassName: string;
+  context: Context;
+};
+
+/**
+ * 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: {
+        noParentNameConstructIdMatch:
+          "Construct ID '{{ constructId }}' should not match parent construct name '{{ parentConstructName }}'. Use a more specific identifier.",
+      },
+      schema: [],
+    },
+    defaultOptions: [],
+    create(context) {
+      return {
+        ClassBody(node) {
+          const parent = node.parent;
+          if (parent?.type !== AST_NODE_TYPES.ClassDeclaration) 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({
+              node,
+              expression: body.value,
+              parentClassName,
+              context,
+            });
+          }
+        },
+      };
+    },
+  }
+);
+
+/**
+ * Validate the constructor body for the parent class
+ * - validate each statement in the constructor body
+ */
+const validateConstructorBody = ({
+  node,
+  expression,
+  parentClassName,
+  context,
+}: ValidateExpressionArgs<TSESTree.FunctionExpression>): void => {
+  for (const statement of expression.body.body) {
+    switch (statement.type) {
+      case AST_NODE_TYPES.VariableDeclaration: {
+        const newExpression = statement.declarations[0].init;
+        if (newExpression?.type !== AST_NODE_TYPES.NewExpression) continue;
+        validateConstructId({
+          node,
+          context,
+          expression: newExpression,
+          parentClassName,
+        });
+        break;
+      }
+      case AST_NODE_TYPES.ExpressionStatement: {
+        if (statement.expression?.type !== AST_NODE_TYPES.NewExpression) break;
+        validateStatement({
+          node,
+          statement,
+          parentClassName,
+          context,
+        });
+        break;
+      }
+      case AST_NODE_TYPES.IfStatement: {
+        traverseStatements({
+          node,
+          context,
+          parentClassName,
+          statement: statement.consequent,
+        });
+        break;
+      }
+      case AST_NODE_TYPES.SwitchStatement: {
+        for (const switchCase of statement.cases) {
+          for (const statement of switchCase.consequent) {
+            traverseStatements({
+              node,
+              context,
+              parentClassName,
+              statement,
+            });
+          }
+        }
+        break;
+      }
+    }
+  }
+};
+
+/**
+ * Recursively traverse and validate statements in the AST
+ * - Handles BlockStatement, ExpressionStatement, and VariableDeclaration
+ * - Validates construct IDs against parent class name
+ */
+const traverseStatements = ({
+  node,
+  statement,
+  parentClassName,
+  context,
+}: ValidateStatementArgs<TSESTree.Statement>) => {
+  switch (statement.type) {
+    case AST_NODE_TYPES.BlockStatement: {
+      for (const body of statement.body) {
+        validateStatement({
+          node,
+          statement: body,
+          parentClassName,
+          context,
+        });
+      }
+      break;
+    }
+    case AST_NODE_TYPES.ExpressionStatement: {
+      const newExpression = statement.expression;
+      if (newExpression?.type !== AST_NODE_TYPES.NewExpression) break;
+      validateStatement({
+        node,
+        statement,
+        parentClassName,
+        context,
+      });
+      break;
+    }
+    case AST_NODE_TYPES.VariableDeclaration: {
+      const newExpression = statement.declarations[0].init;
+      if (newExpression?.type !== AST_NODE_TYPES.NewExpression) break;
+      validateConstructId({
+        node,
+        context,
+        expression: newExpression,
+        parentClassName,
+      });
+      break;
+    }
+  }
+};
+
+/**
+ * Validate a single statement in the AST
+ * - Handles different types of statements (Variable, Expression, If, Switch)
+ * - Extracts and validates construct IDs from new expressions
+ */
+const validateStatement = ({
+  node,
+  statement,
+  parentClassName,
+  context,
+}: ValidateStatementArgs<TSESTree.Statement>): void => {
+  switch (statement.type) {
+    case AST_NODE_TYPES.VariableDeclaration: {
+      const newExpression = statement.declarations[0].init;
+      if (newExpression?.type !== AST_NODE_TYPES.NewExpression) break;
+      validateConstructId({
+        node,
+        context,
+        expression: newExpression,
+        parentClassName,
+      });
+      break;
+    }
+    case AST_NODE_TYPES.ExpressionStatement: {
+      const newExpression = statement.expression;
+      if (newExpression?.type !== AST_NODE_TYPES.NewExpression) break;
+      validateConstructId({
+        node,
+        context,
+        expression: newExpression,
+        parentClassName,
+      });
+      break;
+    }
+    case AST_NODE_TYPES.IfStatement: {
+      validateIfStatement({
+        node,
+        statement,
+        parentClassName,
+        context,
+      });
+      break;
+    }
+    case AST_NODE_TYPES.SwitchStatement: {
+      validateSwitchStatement({
+        node,
+        statement,
+        parentClassName,
+        context,
+      });
+      break;
+    }
+  }
+};
+
+/**
+ * Validate the `if` statement
+ * - Validate recursively if `if` statements are nested
+ */
+const validateIfStatement = ({
+  node,
+  statement,
+  parentClassName,
+  context,
+}: ValidateStatementArgs<TSESTree.IfStatement>): void => {
+  traverseStatements({
+    node,
+    context,
+    parentClassName,
+    statement: statement.consequent,
+  });
+};
+
+/**
+ * Validate the `switch` statement
+ * - Validate recursively if `switch` statements are nested
+ */
+const validateSwitchStatement = ({
+  node,
+  statement,
+  parentClassName,
+  context,
+}: ValidateStatementArgs<TSESTree.SwitchStatement>): void => {
+  for (const caseStatement of statement.cases) {
+    for (const _consequent of caseStatement.consequent) {
+      traverseStatements({
+        node,
+        context,
+        parentClassName,
+        statement: _consequent,
+      });
+    }
+  }
+};
+
+/**
+ * Validate that parent construct name and child id do not match
+ */
+const validateConstructId = ({
+  node,
+  context,
+  expression,
+  parentClassName,
+}: ValidateExpressionArgs<TSESTree.NewExpression>): void => {
+  if (expression.arguments.length < 2) return;
+
+  // NOTE: Treat the second argument as ID
+  const secondArg = expression.arguments[1];
+  if (
+    secondArg.type !== AST_NODE_TYPES.Literal ||
+    typeof secondArg.value !== "string"
+  ) {
+    return;
+  }
+
+  const formattedConstructId = toPascalCase(secondArg.value as string);
+  const formattedParentClassName = toPascalCase(parentClassName);
+  if (formattedParentClassName !== formattedConstructId) return;
+
+  context.report({
+    node,
+    messageId: "noParentNameConstructIdMatch",
+    data: {
+      constructId: secondArg.value,
+      parentConstructName: parentClassName,
+    },
+  });
+};

package/src/rules/no-public-class-fields.ts

@@ -0,0 +1,148 @@
+import {
+  AST_NODE_TYPES,
+  ESLintUtils,
+  ParserServicesWithTypeInformation,
+  TSESLint,
+  TSESTree,
+} from "@typescript-eslint/utils";
+
+import { SymbolFlags } from "../types/symbolFlags";
+import { isConstructOrStackType } from "../utils/typeCheck";
+
+type Context = TSESLint.RuleContext<"noPublicClassFields", []>;
+
+/**
+ * Disallow class types in public class fields
+ * @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-public-class-fields} - Documentation
+ */
+export const noPublicClassFields = ESLintUtils.RuleCreator.withoutDocs({
+  meta: {
+    type: "problem",
+    docs: {
+      description: "Disallow class types in public class fields",
+    },
+    messages: {
+      noPublicClassFields:
+        "Public field '{{ propertyName }}' should not use class 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
+        validateClassMember(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 variable of the class
+ * - if it is a class type, report an error
+ */
+const validateClassMember = (
+  node: TSESTree.ClassDeclaration,
+  context: Context,
+  parserServices: ParserServicesWithTypeInformation
+) => {
+  for (const member of node.body.body) {
+    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 fields without type annotation
+    if (!member.typeAnnotation) continue;
+
+    const type = parserServices.getTypeAtLocation(member);
+    if (!type.symbol) continue;
+
+    const isClass = type.symbol.flags === SymbolFlags.Class;
+    if (!isClass) continue;
+
+    context.report({
+      node: member,
+      messageId: "noPublicClassFields",
+      data: {
+        propertyName: member.key.name,
+        typeName: type.symbol.name,
+      },
+    });
+  }
+};
+
+/**
+ * check the constructor parameter property
+ * - if it is a class 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);
+    if (!type.symbol) continue;
+
+    const isClass = type.symbol.flags === SymbolFlags.Class;
+    if (!isClass) continue;
+
+    context.report({
+      node: param,
+      messageId: "noPublicClassFields",
+      data: {
+        propertyName: param.parameter.name,
+        typeName: type.symbol.name,
+      },
+    });
+  }
+};

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

@@ -0,0 +1,101 @@
+import {
+  AST_NODE_TYPES,
+  ESLintUtils,
+  TSESLint,
+  TSESTree,
+} from "@typescript-eslint/utils";
+
+import { isConstructType, isStackType } from "../utils/typeCheck";
+
+type Context = TSESLint.RuleContext<"noVariableConstructId", []>;
+
+/**
+ * Enforce using literal strings for Construct ID.
+ * @param context - The rule context provided by ESLint
+ * @returns An object containing the AST visitor functions
+ */
+export const noVariableConstructId = ESLintUtils.RuleCreator.withoutDocs({
+  meta: {
+    type: "problem",
+    docs: {
+      description: `Enforce using literal strings for Construct ID.`,
+    },
+    messages: {
+      noVariableConstructId: "Shouldn't use a parameter as a Construct ID.",
+    },
+    schema: [],
+  },
+  defaultOptions: [],
+  create(context) {
+    const parserServices = ESLintUtils.getParserServices(context);
+    return {
+      NewExpression(node) {
+        const type = parserServices.getTypeAtLocation(node);
+
+        if (
+          !isConstructType(type) ||
+          isStackType(type) ||
+          node.arguments.length < 2
+        ) {
+          return;
+        }
+
+        validateConstructId(node, context);
+      },
+    };
+  },
+});
+
+/**
+ * Check if the construct ID is a literal string
+ */
+const validateConstructId = (
+  node: TSESTree.NewExpression,
+  context: Context
+) => {
+  if (node.arguments.length < 2 || isInsideLoop(node)) return;
+
+  // NOTE: Treat the second argument as ID
+  const secondArg = node.arguments[1];
+
+  // NOTE: When id is string literal, it's OK
+  if (
+    secondArg.type === AST_NODE_TYPES.Literal &&
+    typeof secondArg.value === "string"
+  ) {
+    return;
+  }
+
+  // NOTE: When id is template literal, only those without expressions are OK
+  if (
+    secondArg.type === AST_NODE_TYPES.TemplateLiteral &&
+    !secondArg.expressions.length
+  ) {
+    return;
+  }
+
+  context.report({
+    node,
+    messageId: "noVariableConstructId",
+  });
+};
+
+/**
+ * Check if the node is inside a loop statement
+ */
+const isInsideLoop = (node: TSESTree.Node): boolean => {
+  let current = node.parent;
+  while (current) {
+    if (
+      current.type === AST_NODE_TYPES.ForStatement ||
+      current.type === AST_NODE_TYPES.ForInStatement ||
+      current.type === AST_NODE_TYPES.ForOfStatement ||
+      current.type === AST_NODE_TYPES.WhileStatement ||
+      current.type === AST_NODE_TYPES.DoWhileStatement
+    ) {
+      return true;
+    }
+    current = current.parent;
+  }
+  return false;
+};

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

@@ -0,0 +1,95 @@
+import {
+  AST_NODE_TYPES,
+  ESLintUtils,
+  TSESLint,
+  TSESTree,
+} from "@typescript-eslint/utils";
+
+import { toPascalCase } from "../utils/convertString";
+import { isConstructOrStackType } from "../utils/typeCheck";
+
+const QUOTE_TYPE = {
+  SINGLE: "'",
+  DOUBLE: '"',
+} as const;
+
+type QuoteType = (typeof QUOTE_TYPE)[keyof typeof QUOTE_TYPE];
+
+type Context = TSESLint.RuleContext<"pascalCaseConstructId", []>;
+
+/**
+/**
+ * Enforce PascalCase for Construct ID.
+ * @param context - The rule context provided by ESLint
+ * @returns An object containing the AST visitor functions
+ * @see {@link https://eslint-cdk-plugin.dev/rules/pascal-case-construct-id} - Documentation
+ */
+export const pascalCaseConstructId = ESLintUtils.RuleCreator.withoutDocs({
+  meta: {
+    type: "problem",
+    docs: {
+      description: "Enforce PascalCase for Construct ID.",
+    },
+    messages: {
+      pascalCaseConstructId: "Construct ID must be PascalCase.",
+    },
+    schema: [],
+    fixable: "code",
+  },
+  defaultOptions: [],
+  create(context) {
+    const parserServices = ESLintUtils.getParserServices(context);
+    return {
+      NewExpression(node) {
+        const type = parserServices.getTypeAtLocation(node);
+        if (!isConstructOrStackType(type) || node.arguments.length < 2) {
+          return;
+        }
+        validateConstructId(node, context);
+      },
+    };
+  },
+});
+
+/**
+ * check if the string is PascalCase
+ * @param str - The string to check
+ * @returns true if the string is PascalCase, false otherwise
+ */
+const isPascalCase = (str: string) => {
+  return /^[A-Z][a-zA-Z0-9]*$/.test(str);
+};
+
+/**
+ * Check the construct ID is PascalCase
+ */
+const validateConstructId = (
+  node: TSESTree.NewExpression,
+  context: Context
+) => {
+  if (node.arguments.length < 2) return;
+
+  // NOTE: Treat the second argument as ID
+  const secondArg = node.arguments[1];
+  if (
+    secondArg.type !== AST_NODE_TYPES.Literal ||
+    typeof secondArg.value !== "string"
+  ) {
+    return;
+  }
+
+  const quote: QuoteType = secondArg.raw?.startsWith('"')
+    ? QUOTE_TYPE.DOUBLE
+    : QUOTE_TYPE.SINGLE;
+
+  if (isPascalCase(secondArg.value)) return;
+
+  context.report({
+    node,
+    messageId: "pascalCaseConstructId",
+    fix: (fixer) => {
+      const pascalCaseValue = toPascalCase(secondArg.value as string);
+      return fixer.replaceText(secondArg, `${quote}${pascalCaseValue}${quote}`);
+    },
+  });
+};

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

@@ -0,0 +1,51 @@
+import { AST_NODE_TYPES, ESLintUtils } from "@typescript-eslint/utils";
+
+import { isConstructType, isStackType } from "../utils/typeCheck";
+
+/**
+ * Enforces that `this` is passed to the constructor
+ * @param context - The rule context provided by ESLint
+ * @returns An object containing the AST visitor functions
+ * @see {@link https://eslint-cdk-plugin.dev/rules/require-passing-this} - Documentation
+ */
+export const requirePassingThis = ESLintUtils.RuleCreator.withoutDocs({
+  meta: {
+    type: "problem",
+    docs: {
+      description: "Require passing `this` in a constructor.",
+    },
+    messages: {
+      requirePassingThis: "Require passing `this` in a constructor.",
+    },
+    schema: [],
+    fixable: "code",
+  },
+  defaultOptions: [],
+  create(context) {
+    const parserServices = ESLintUtils.getParserServices(context);
+    return {
+      NewExpression(node) {
+        const type = parserServices.getTypeAtLocation(node);
+
+        if (
+          !isConstructType(type) ||
+          isStackType(type) ||
+          !node.arguments.length
+        ) {
+          return;
+        }
+
+        const argument = node.arguments[0];
+        if (argument.type === AST_NODE_TYPES.ThisExpression) return;
+
+        context.report({
+          node,
+          messageId: "requirePassingThis",
+          fix: (fixer) => {
+            return fixer.replaceText(argument, "this");
+          },
+        });
+      },
+    };
+  },
+});

package/src/types/symbolFlags.ts

@@ -0,0 +1,6 @@
+/**
+ * Implementing `SymbolFlags` defined in typescript on your own, in order not to include TypeScript in dependencies
+ */
+export enum SymbolFlags {
+  Class = 32,
+}