eslint-cdk-plugin 1.0.1 → 1.0.3

package/package.json

@@ -1,13 +1,26 @@
 {
   "name": "eslint-cdk-plugin",
-  "version": "1.0.1",
+  "version": "1.0.3",
   "description": "eslint plugin for AWS CDK projects",
-  "main": "dist/index.mjs",
+  "main": "./dist/index.mjs",
+  "types": "./dist/index.d.ts",
   "type": "module",
+  "exports": {
+    "types": "./dist/index.d.ts",
+    "require": {
+      "types": "./dist/index.d.ts",
+      "default": "./dist/index.cjs"
+    },
+    "import": {
+      "types": "./dist/index.d.ts",
+      "default": "./dist/index.mjs"
+    }
+  },
   "scripts": {
-    "build": "rm -rf dist && tsc -p tsconfig.build.json",
+    "build": "sh scripts/build.sh",
     "test": "vitest --run",
-    "lint": "eslint --fix --config eslint.config.mjs",
+    "lint": "eslint --fix --config eslint.config.js",
+    "type-check": "tsc --noEmit",
     "release:minor": "standard-version --release-as minor",
     "release:major": "standard-version --release-as major",
     "release:patch": "standard-version --release-as patch",
@@ -20,21 +33,24 @@
     "@types/estree": "^1.0.6",
     "@types/node": "^22.9.0",
     "@typescript-eslint/rule-tester": "^8.14.0",
+    "eslint": "9.10.0",
     "eslint-plugin-import": "^2.31.0",
+    "pkgroll": "^2.6.0",
     "standard-version": "^9.5.0",
     "typescript": "^5.6.3",
     "typescript-eslint": "^8.14.0",
     "vitest": "^2.1.5"
   },
   "dependencies": {
-    "@typescript-eslint/utils": "^8.14.0",
-    "eslint": "9.10.0"
+    "@typescript-eslint/utils": "^8.14.0"
   },
   "volta": {
     "node": "22.11.0"
   },
   "files": [
     "dist",
+    "src",
+    "!src/__tests__",
     "README.md",
     "LICENSE"
   ],
@@ -50,9 +66,6 @@
     "type": "git",
     "url": "https://github.com/ren-yamanashi/eslint-cdk-plugin.git"
   },
-  "engines": {
-    "node": "^18.18.0 || ^20.9.0 || >=21.1.0"
-  },
   "author": {
     "name": "ren-yamanashi"
   },

package/src/index.ts

@@ -0,0 +1,69 @@
+import { noClassInInterface } from "./rules/no-class-in-interface";
+import { noConstructStackSuffix } from "./rules/no-construct-stack-suffix";
+import { noImportPrivate } from "./rules/no-import-private";
+import { noMutablePropsInterface } from "./rules/no-mutable-props-interface";
+import { noMutablePublicFields } from "./rules/no-mutable-public-fields";
+import { noParentNameConstructIdMatch } from "./rules/no-parent-name-construct-id-match";
+import { noPublicClassFields } from "./rules/no-public-class-fields";
+import { noVariableConstructId } from "./rules/no-variable-construct-id";
+import { pascalCaseConstructId } from "./rules/pascal-case-construct-id";
+import { requirePassingThis } from "./rules/require-passing-this";
+
+const rules = {
+  "no-class-in-interface": noClassInInterface,
+  "no-construct-stack-suffix": noConstructStackSuffix,
+  "no-parent-name-construct-id-match": noParentNameConstructIdMatch,
+  "no-public-class-fields": noPublicClassFields,
+  "pascal-case-construct-id": pascalCaseConstructId,
+  "no-mutable-public-fields": noMutablePublicFields,
+  "no-mutable-props-interface": noMutablePropsInterface,
+  "require-passing-this": requirePassingThis,
+  "no-variable-construct-id": noVariableConstructId,
+  "no-import-private": noImportPrivate,
+};
+
+const configs = {
+  recommended: {
+    plugins: ["cdk"],
+    rules: {
+      "cdk/no-class-in-interface": "error",
+      "cdk/no-construct-stack-suffix": "error",
+      "cdk/no-parent-name-construct-id-match": "error",
+      "cdk/no-public-class-fields": "error",
+      "cdk/pascal-case-construct-id": "error",
+      "cdk/require-passing-this": "error",
+      "cdk/no-variable-construct-id": "error",
+      "cdk/no-mutable-public-fields": "warn",
+      "cdk/no-mutable-props-interface": "warn",
+    },
+  },
+  strict: {
+    plugins: ["cdk"],
+    rules: {
+      "cdk/no-class-in-interface": "error",
+      "cdk/no-construct-stack-suffix": "error",
+      "cdk/no-parent-name-construct-id-match": "error",
+      "cdk/no-public-class-fields": "error",
+      "cdk/pascal-case-construct-id": "error",
+      "cdk/require-passing-this": "error",
+      "cdk/no-variable-construct-id": "error",
+      "cdk/no-mutable-public-fields": "error",
+      "cdk/no-mutable-props-interface": "error",
+      "cdk/no-import-private": "error",
+    },
+  },
+};
+
+export { configs, rules };
+
+export interface EslintCdkPlugin {
+  rules: typeof rules;
+  configs: typeof configs;
+}
+
+const eslintCdkPlugin: EslintCdkPlugin = {
+  rules,
+  configs,
+};
+
+export default eslintCdkPlugin;

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

@@ -0,0 +1,56 @@
+import { AST_NODE_TYPES, ESLintUtils } from "@typescript-eslint/utils";
+
+import { SymbolFlags } from "../types/symbolFlags";
+
+/**
+ * Enforces the use of interface types instead of class 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 noClassInInterface = ESLintUtils.RuleCreator.withoutDocs({
+  meta: {
+    type: "problem",
+    docs: {
+      description: "Disallow class types in interface properties",
+    },
+    messages: {
+      noClassInInterfaceProps:
+        "Interface property '{{ 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 {
+      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
+          ) {
+            continue;
+          }
+
+          const type = parserServices.getTypeAtLocation(property);
+          if (!type.symbol) continue;
+
+          // NOTE: check class type
+          const isClass = type.symbol.flags === SymbolFlags.Class;
+          if (!isClass) continue;
+
+          context.report({
+            node: property,
+            messageId: "noClassInInterfaceProps",
+            data: {
+              propertyName: property.key.name,
+              typeName: type.symbol.name,
+            },
+          });
+        }
+      },
+    };
+  },
+});

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

@@ -0,0 +1,86 @@
+import {
+  AST_NODE_TYPES,
+  ESLintUtils,
+  TSESLint,
+  TSESTree,
+} from "@typescript-eslint/utils";
+
+import { toPascalCase } from "../utils/convertString";
+import { isConstructOrStackType } from "../utils/typeCheck";
+
+type Context = TSESLint.RuleContext<"noConstructStackSuffix", []>;
+
+/**
+ * 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({
+  meta: {
+    type: "problem",
+    docs: {
+      description:
+        "Effort to avoid using 'Construct' and 'Stack' suffix in construct id.",
+    },
+    messages: {
+      noConstructStackSuffix:
+        "{{ classType }} ID '{{ id }}' should not include {{ suffix }} suffix.",
+    },
+    schema: [],
+  },
+  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);
+      },
+    };
+  },
+});
+
+/**
+ * Validate that construct ID does not end with "Construct" or "Stack"
+ */
+const validateConstructId = (
+  node: TSESTree.NewExpression,
+  context: Context
+): void => {
+  // 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 formattedConstructId = toPascalCase(secondArg.value);
+
+  if (formattedConstructId.endsWith("Construct")) {
+    context.report({
+      node,
+      messageId: "noConstructStackSuffix",
+      data: {
+        classType: "Construct",
+        id: secondArg.value,
+        suffix: "Construct",
+      },
+    });
+  } else if (formattedConstructId.endsWith("Stack")) {
+    context.report({
+      node,
+      messageId: "noConstructStackSuffix",
+      data: {
+        classType: "Stack",
+        id: secondArg.value,
+        suffix: "Stack",
+      },
+    });
+  }
+};

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

@@ -0,0 +1,60 @@
+import * as path from "path";
+
+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: {
+      description:
+        "Cannot import modules from private dir at different levels of the hierarchy.",
+    },
+    messages: {
+      noImportPrivate:
+        "Cannot import modules from private dir at different levels of the hierarchy.",
+    },
+    schema: [],
+  },
+  create(context) {
+    return {
+      ImportDeclaration(node) {
+        const importPath = node.source.value?.toString() ?? "";
+        const currentFilePath = context.filename;
+        const currentDirPath = path.dirname(currentFilePath);
+
+        if (!importPath.includes("/private")) return;
+        const absoluteCurrentDirPath = path.resolve(currentDirPath);
+        const absoluteImportPath = path.resolve(currentDirPath, importPath);
+
+        // NOTE: Get the directory from the import path up to the private directory
+        const importDirBeforePrivate = absoluteImportPath.split("/private")[0];
+
+        const currentDirSegments = getDirSegments(absoluteCurrentDirPath);
+        const importDirSegments = getDirSegments(importDirBeforePrivate);
+        if (
+          currentDirSegments.length !== importDirSegments.length ||
+          currentDirSegments.some(
+            (segment, index) => segment !== importDirSegments[index]
+          )
+        ) {
+          context.report({ node, messageId: "noImportPrivate" });
+        }
+      },
+    };
+  },
+};
+
+/**
+ * Split the directory path into segments (split at `/`)
+ * @param dirPath - The directory path to split
+ * @returns The segments of the directory path
+ */
+const getDirSegments = (dirPath: string): string[] => {
+  return dirPath.split(path.sep).filter((segment) => segment !== "");
+};

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

@@ -0,0 +1,58 @@
+import { AST_NODE_TYPES, ESLintUtils } from "@typescript-eslint/utils";
+
+/**
+ * Disallow mutable properties in Props interfaces
+ * @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-props-interface} - Documentation
+ */
+export const noMutablePropsInterface = ESLintUtils.RuleCreator.withoutDocs({
+  meta: {
+    type: "problem",
+    docs: {
+      description: "Disallow mutable properties in Props interfaces",
+    },
+    fixable: "code",
+    messages: {
+      noMutablePropsInterface:
+        "Property '{{ propertyName }}' in Props interface should be readonly.",
+    },
+    schema: [],
+  },
+  defaultOptions: [],
+  create(context) {
+    return {
+      TSInterfaceDeclaration(node) {
+        const sourceCode = context.sourceCode;
+
+        // 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;
+          }
+
+          // NOTE: Skip if already readonly
+          if (property.readonly) continue;
+
+          context.report({
+            node: property,
+            messageId: "noMutablePropsInterface",
+            data: {
+              propertyName: property.key.name,
+            },
+            fix: (fixer) => {
+              const propertyText = sourceCode.getText(property);
+              return fixer.replaceText(property, `readonly ${propertyText}`);
+            },
+          });
+        }
+      },
+    };
+  },
+});

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

@@ -0,0 +1,75 @@
+import { AST_NODE_TYPES, ESLintUtils } from "@typescript-eslint/utils";
+
+import { isConstructOrStackType } from "../utils/typeCheck";
+
+/**
+ * Disallow mutable 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-mutable-public-fields} - Documentation
+ */
+export const noMutablePublicFields = ESLintUtils.RuleCreator.withoutDocs({
+  meta: {
+    type: "problem",
+    docs: {
+      description: "Disallow mutable public class fields",
+    },
+    fixable: "code",
+    messages: {
+      noMutablePublicFields:
+        "Public field '{{ 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;
+
+        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 if readonly is present
+          if (member.readonly) continue;
+
+          context.report({
+            node: member,
+            messageId: "noMutablePublicFields",
+            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}`
+              );
+            },
+          });
+        }
+      },
+    };
+  },
+});