eslint-cdk-plugin 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2024 Ren Yamanashi
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,37 @@
+# eslint-plugin-cdk
+
+ESLint plugin for [AWS CDK](https://github.com/aws/aws-cdk).
+
+## Installation
+
+```bash
+# npm
+npm install -D @nigg/eslint-plugin-cdk
+
+# yarn
+yarn add -D @nigg/eslint-plugin-cdk
+
+# pnpm
+pnpm install -D @nigg/eslint-plugin-cdk
+```
+
+## Usage
+
+### Use recommended config
+
+```js
+// eslint.config.mjs
+import eslintPluginCdk from "@nigg/eslint-plugin-cdk";
+export default [
+  {
+    plugins: {
+      cdk: eslintPluginCdk,
+    },
+    rules: {
+      ...eslintPluginCdk.configs.recommended.rules,
+    },
+  },
+];
+```
+
+### For more detailed documentation, see [docs for eslint-plugin-cdk](https://eslint-plugin-cdk.dev/)

package/dist/index.mjs

@@ -0,0 +1,35 @@
+import { noClassInInterfaceProps } from "./no-class-in-interface.mjs";
+import { noConstructStackSuffix } from "./no-construct-stack-suffix.mjs";
+import { noImportPrivate } from "./no-import-private.mjs";
+import { noMutablePropsInterface } from "./no-mutable-props-interface.mjs";
+import { noMutablePublicFields } from "./no-mutable-public-fields.mjs";
+import { noParentNameConstructIdMatch } from "./no-parent-name-construct-id-match.mjs";
+import { noPublicClassFields } from "./no-public-class-fields.mjs";
+import { pascalCaseConstructId } from "./pascal-case-construct-id.mjs";
+var plugin = {
+    rules: {
+        "no-class-in-interface": noClassInInterfaceProps,
+        "no-construct-stack-suffix": noConstructStackSuffix,
+        "no-import-private": noImportPrivate,
+        "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,
+    },
+    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/no-mutable-public-fields": "warn",
+                "cdk/no-mutable-props-interface": "warn",
+            },
+        },
+    },
+};
+export default plugin;

package/dist/no-class-in-interface.mjs

@@ -0,0 +1,46 @@
+import { ESLintUtils } from "@typescript-eslint/utils";
+import { SymbolFlags } from "typescript";
+export var noClassInInterfaceProps = 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: function (context) {
+        var parserServices = ESLintUtils.getParserServices(context);
+        var checker = parserServices.program.getTypeChecker();
+        return {
+            TSInterfaceDeclaration: function (node) {
+                for (var _i = 0, _a = node.body.body; _i < _a.length; _i++) {
+                    var property = _a[_i];
+                    if (property.type !== "TSPropertySignature" ||
+                        property.key.type !== "Identifier") {
+                        continue;
+                    }
+                    var tsNode = parserServices.esTreeNodeToTSNodeMap.get(property);
+                    var type = checker.getTypeAtLocation(tsNode);
+                    if (!type.symbol)
+                        continue;
+                    // NOTE: check class type
+                    var 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/dist/no-construct-stack-suffix.mjs

@@ -0,0 +1,192 @@
+import { ESLintUtils } from "@typescript-eslint/utils";
+import { toPascalCase } from "./utils/convertString.mjs";
+export var 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: function (context) {
+        return {
+            ClassBody: function (node) {
+                var _a;
+                var parent = node.parent;
+                if ((parent === null || parent === void 0 ? void 0 : parent.type) !== "ClassDeclaration")
+                    return;
+                var className = (_a = parent.id) === null || _a === void 0 ? void 0 : _a.name;
+                if (!className)
+                    return;
+                for (var _i = 0, _b = node.body; _i < _b.length; _i++) {
+                    var body = _b[_i];
+                    if (body.type !== "MethodDefinition" ||
+                        !["method", "constructor"].includes(body.kind) ||
+                        body.value.type !== "FunctionExpression") {
+                        continue;
+                    }
+                    validateConstructorBody(node, body.value, context);
+                }
+            },
+        };
+    },
+});
+/**
+ * Validate the constructor body for the parent class
+ * - validate each statement in the constructor body
+ */
+var validateConstructorBody = function (node, expression, context) {
+    var _a;
+    for (var _i = 0, _b = expression.body.body; _i < _b.length; _i++) {
+        var statement = _b[_i];
+        switch (statement.type) {
+            case "VariableDeclaration": {
+                var newExpression = statement.declarations[0].init;
+                if ((newExpression === null || newExpression === void 0 ? void 0 : newExpression.type) !== "NewExpression")
+                    continue;
+                validateConstructId(node, context, newExpression);
+                break;
+            }
+            case "ExpressionStatement": {
+                if (((_a = statement.expression) === null || _a === void 0 ? void 0 : _a.type) !== "NewExpression")
+                    break;
+                validateStatement(node, statement, context);
+                break;
+            }
+            case "IfStatement": {
+                traverseStatements(node, statement.consequent, context);
+                break;
+            }
+            case "SwitchStatement": {
+                for (var _c = 0, _d = statement.cases; _c < _d.length; _c++) {
+                    var switchCase = _d[_c];
+                    for (var _e = 0, _f = switchCase.consequent; _e < _f.length; _e++) {
+                        var statement_1 = _f[_e];
+                        traverseStatements(node, statement_1, context);
+                    }
+                }
+                break;
+            }
+        }
+    }
+};
+/**
+ * Recursively traverse and validate statements in the AST
+ * - Handles BlockStatement, ExpressionStatement, and VariableDeclaration
+ * - Validates construct IDs
+ */
+var traverseStatements = function (node, statement, context) {
+    switch (statement.type) {
+        case "BlockStatement": {
+            for (var _i = 0, _a = statement.body; _i < _a.length; _i++) {
+                var body = _a[_i];
+                validateStatement(node, body, context);
+            }
+            break;
+        }
+        case "ExpressionStatement": {
+            var newExpression = statement.expression;
+            if ((newExpression === null || newExpression === void 0 ? void 0 : newExpression.type) !== "NewExpression")
+                break;
+            validateStatement(node, statement, context);
+            break;
+        }
+        case "VariableDeclaration": {
+            var newExpression = statement.declarations[0].init;
+            if ((newExpression === null || newExpression === void 0 ? void 0 : newExpression.type) !== "NewExpression")
+                break;
+            validateConstructId(node, context, newExpression);
+            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
+ */
+var validateStatement = function (node, body, context) {
+    switch (body.type) {
+        case "VariableDeclaration": {
+            var newExpression = body.declarations[0].init;
+            if ((newExpression === null || newExpression === void 0 ? void 0 : newExpression.type) !== "NewExpression")
+                break;
+            validateConstructId(node, context, newExpression);
+            break;
+        }
+        case "ExpressionStatement": {
+            var newExpression = body.expression;
+            if ((newExpression === null || newExpression === void 0 ? void 0 : newExpression.type) !== "NewExpression")
+                break;
+            validateConstructId(node, context, newExpression);
+            break;
+        }
+        case "IfStatement": {
+            validateIfStatement(node, body, context);
+            break;
+        }
+        case "SwitchStatement": {
+            validateSwitchStatement(node, body, context);
+            break;
+        }
+    }
+};
+/**
+ * Validate the `if` statement
+ * - Validate recursively if `if` statements are nested
+ */
+var validateIfStatement = function (node, ifStatement, context) {
+    traverseStatements(node, ifStatement.consequent, context);
+};
+/**
+ * Validate the `switch` statement
+ * - Validate recursively if `switch` statements are nested
+ */
+var validateSwitchStatement = function (node, switchStatement, context) {
+    for (var _i = 0, _a = switchStatement.cases; _i < _a.length; _i++) {
+        var statement = _a[_i];
+        for (var _b = 0, _c = statement.consequent; _b < _c.length; _b++) {
+            var _consequent = _c[_b];
+            traverseStatements(node, _consequent, context);
+        }
+    }
+};
+/**
+ * Validate that construct ID does not end with "Construct" or "Stack"
+ */
+var validateConstructId = function (node, context, expression) {
+    if (expression.arguments.length < 2)
+        return;
+    // NOTE: Treat the second argument as ID
+    var secondArg = expression.arguments[1];
+    if (secondArg.type !== "Literal" || typeof secondArg.value !== "string") {
+        return;
+    }
+    var formattedConstructId = toPascalCase(secondArg.value);
+    if (formattedConstructId.endsWith("Construct")) {
+        context.report({
+            node: node,
+            messageId: "noConstructStackSuffix",
+            data: {
+                classType: "Construct",
+                id: secondArg.value,
+                suffix: "Construct",
+            },
+        });
+    }
+    else if (formattedConstructId.endsWith("Stack")) {
+        context.report({
+            node: node,
+            messageId: "noConstructStackSuffix",
+            data: {
+                classType: "Stack",
+                id: secondArg.value,
+                suffix: "Stack",
+            },
+        });
+    }
+};

package/dist/no-import-private.mjs

@@ -0,0 +1,43 @@
+import * as path from "path";
+/**
+ * Split the directory path into segments (split at `/`)
+ * @param dirPath - The directory path to split
+ * @returns The segments of the directory path
+ */
+var getDirSegments = function (dirPath) {
+    return dirPath.split(path.sep).filter(function (segment) { return segment !== ""; });
+};
+export var noImportPrivate = {
+    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: function (context) {
+        return {
+            ImportDeclaration: function (node) {
+                var _a, _b;
+                var importPath = (_b = (_a = node.source.value) === null || _a === void 0 ? void 0 : _a.toString()) !== null && _b !== void 0 ? _b : "";
+                var currentFilePath = context.filename;
+                var currentDirPath = path.dirname(currentFilePath);
+                if (importPath.includes("/private")) {
+                    var absoluteCurrentDirPath = path.resolve(currentDirPath);
+                    var absoluteImportPath = path.resolve(currentDirPath, importPath);
+                    // NOTE: Get the directory from the import path up to the private directory
+                    var importDirBeforePrivate = absoluteImportPath.split("/private")[0];
+                    var currentDirSegments = getDirSegments(absoluteCurrentDirPath);
+                    var importDirSegments_1 = getDirSegments(importDirBeforePrivate);
+                    if (currentDirSegments.length !== importDirSegments_1.length ||
+                        currentDirSegments.some(function (segment, index) { return segment !== importDirSegments_1[index]; })) {
+                        context.report({ node: node, messageId: "noImportPrivate" });
+                    }
+                }
+            },
+        };
+    },
+};

package/dist/no-mutable-props-interface.mjs

@@ -0,0 +1,49 @@
+import { ESLintUtils } from "@typescript-eslint/utils";
+export var 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: function (context) {
+        var sourceCode = context.sourceCode;
+        return {
+            TSInterfaceDeclaration: function (node) {
+                // NOTE: Interface name check for "Props"
+                if (!node.id.name.endsWith("Props"))
+                    return;
+                var _loop_1 = function (property) {
+                    if (property.type !== "TSPropertySignature" ||
+                        property.key.type !== "Identifier") {
+                        return "continue";
+                    }
+                    // NOTE: Skip if already readonly
+                    if (property.readonly)
+                        return "continue";
+                    context.report({
+                        node: property,
+                        messageId: "noMutablePropsInterface",
+                        data: {
+                            propertyName: property.key.name,
+                        },
+                        fix: function (fixer) {
+                            var propertyText = sourceCode.getText(property);
+                            return fixer.replaceText(property, "readonly ".concat(propertyText));
+                        },
+                    });
+                };
+                for (var _i = 0, _a = node.body.body; _i < _a.length; _i++) {
+                    var property = _a[_i];
+                    _loop_1(property);
+                }
+            },
+        };
+    },
+});

package/dist/no-mutable-public-fields.mjs

@@ -0,0 +1,56 @@
+import { ESLintUtils } from "@typescript-eslint/utils";
+export var 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: function (context) {
+        var sourceCode = context.sourceCode;
+        return {
+            ClassDeclaration: function (node) {
+                var _a;
+                var _loop_1 = function (member) {
+                    if (member.type !== "PropertyDefinition" ||
+                        member.key.type !== "Identifier") {
+                        return "continue";
+                    }
+                    // NOTE: Skip private and protected fields
+                    if (["private", "protected"].includes((_a = member.accessibility) !== null && _a !== void 0 ? _a : "")) {
+                        return "continue";
+                    }
+                    // NOTE: Skip if readonly is present
+                    if (member.readonly)
+                        return "continue";
+                    context.report({
+                        node: member,
+                        messageId: "noMutablePublicFields",
+                        data: {
+                            propertyName: member.key.name,
+                        },
+                        fix: function (fixer) {
+                            var accessibility = member.accessibility ? "public " : "";
+                            var paramText = sourceCode.getText(member);
+                            var _a = paramText.split(":"), key = _a[0], value = _a[1];
+                            var replacedKey = key.startsWith("public ")
+                                ? key.replace("public ", "")
+                                : key;
+                            return fixer.replaceText(member, "".concat(accessibility, "readonly ").concat(replacedKey, ":").concat(value));
+                        },
+                    });
+                };
+                for (var _i = 0, _b = node.body.body; _i < _b.length; _i++) {
+                    var member = _b[_i];
+                    _loop_1(member);
+                }
+            },
+        };
+    },
+});

package/dist/no-parent-name-construct-id-match.mjs

@@ -0,0 +1,257 @@
+import { ESLintUtils } from "@typescript-eslint/utils";
+import { toPascalCase } from "./utils/convertString.mjs";
+export var 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: function (context) {
+        return {
+            ClassBody: function (node) {
+                var _a;
+                var parent = node.parent;
+                if ((parent === null || parent === void 0 ? void 0 : parent.type) !== "ClassDeclaration")
+                    return;
+                var parentClassName = (_a = parent.id) === null || _a === void 0 ? void 0 : _a.name;
+                if (!parentClassName)
+                    return;
+                for (var _i = 0, _b = node.body; _i < _b.length; _i++) {
+                    var body = _b[_i];
+                    if (body.type !== "MethodDefinition" ||
+                        !["method", "constructor"].includes(body.kind) ||
+                        body.value.type !== "FunctionExpression") {
+                        continue;
+                    }
+                    validateConstructorBody({
+                        node: node,
+                        expression: body.value,
+                        parentClassName: parentClassName,
+                        context: context,
+                    });
+                }
+            },
+        };
+    },
+});
+/**
+ * Validate the constructor body for the parent class
+ * - validate each statement in the constructor body
+ */
+var validateConstructorBody = function (_a) {
+    var _b;
+    var node = _a.node, expression = _a.expression, parentClassName = _a.parentClassName, context = _a.context;
+    for (var _i = 0, _c = expression.body.body; _i < _c.length; _i++) {
+        var statement = _c[_i];
+        switch (statement.type) {
+            case "VariableDeclaration": {
+                var newExpression = statement.declarations[0].init;
+                if ((newExpression === null || newExpression === void 0 ? void 0 : newExpression.type) !== "NewExpression")
+                    continue;
+                validateConstructId({
+                    node: node,
+                    context: context,
+                    expression: newExpression,
+                    parentClassName: parentClassName,
+                });
+                break;
+            }
+            case "ExpressionStatement": {
+                if (((_b = statement.expression) === null || _b === void 0 ? void 0 : _b.type) !== "NewExpression")
+                    break;
+                validateStatement({
+                    node: node,
+                    body: statement,
+                    parentClassName: parentClassName,
+                    context: context,
+                });
+                break;
+            }
+            case "IfStatement": {
+                traverseStatements({
+                    node: node,
+                    context: context,
+                    parentClassName: parentClassName,
+                    statement: statement.consequent,
+                });
+                break;
+            }
+            case "SwitchStatement": {
+                for (var _d = 0, _e = statement.cases; _d < _e.length; _d++) {
+                    var switchCase = _e[_d];
+                    for (var _f = 0, _g = switchCase.consequent; _f < _g.length; _f++) {
+                        var statement_1 = _g[_f];
+                        traverseStatements({
+                            node: node,
+                            context: context,
+                            parentClassName: parentClassName,
+                            statement: statement_1,
+                        });
+                    }
+                }
+                break;
+            }
+        }
+    }
+};
+/**
+ * Recursively traverse and validate statements in the AST
+ * - Handles BlockStatement, ExpressionStatement, and VariableDeclaration
+ * - Validates construct IDs against parent class name
+ */
+var traverseStatements = function (_a) {
+    var node = _a.node, statement = _a.statement, parentClassName = _a.parentClassName, context = _a.context;
+    switch (statement.type) {
+        case "BlockStatement": {
+            for (var _i = 0, _b = statement.body; _i < _b.length; _i++) {
+                var body = _b[_i];
+                validateStatement({
+                    node: node,
+                    body: body,
+                    parentClassName: parentClassName,
+                    context: context,
+                });
+            }
+            break;
+        }
+        case "ExpressionStatement": {
+            var newExpression = statement.expression;
+            if ((newExpression === null || newExpression === void 0 ? void 0 : newExpression.type) !== "NewExpression")
+                break;
+            validateStatement({
+                node: node,
+                body: statement,
+                parentClassName: parentClassName,
+                context: context,
+            });
+            break;
+        }
+        case "VariableDeclaration": {
+            var newExpression = statement.declarations[0].init;
+            if ((newExpression === null || newExpression === void 0 ? void 0 : newExpression.type) !== "NewExpression")
+                break;
+            validateConstructId({
+                node: node,
+                context: context,
+                expression: newExpression,
+                parentClassName: 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
+ */
+var validateStatement = function (_a) {
+    var node = _a.node, body = _a.body, parentClassName = _a.parentClassName, context = _a.context;
+    switch (body.type) {
+        case "VariableDeclaration": {
+            var newExpression = body.declarations[0].init;
+            if ((newExpression === null || newExpression === void 0 ? void 0 : newExpression.type) !== "NewExpression")
+                break;
+            validateConstructId({
+                node: node,
+                context: context,
+                expression: newExpression,
+                parentClassName: parentClassName,
+            });
+            break;
+        }
+        case "ExpressionStatement": {
+            var newExpression = body.expression;
+            if ((newExpression === null || newExpression === void 0 ? void 0 : newExpression.type) !== "NewExpression")
+                break;
+            validateConstructId({
+                node: node,
+                context: context,
+                expression: newExpression,
+                parentClassName: parentClassName,
+            });
+            break;
+        }
+        case "IfStatement": {
+            validateIfStatement({
+                node: node,
+                ifStatement: body,
+                parentClassName: parentClassName,
+                context: context,
+            });
+            break;
+        }
+        case "SwitchStatement": {
+            validateSwitchStatement({
+                node: node,
+                switchStatement: body,
+                parentClassName: parentClassName,
+                context: context,
+            });
+            break;
+        }
+    }
+};
+/**
+ * Validate the `if` statement
+ * - Validate recursively if `if` statements are nested
+ */
+var validateIfStatement = function (_a) {
+    var node = _a.node, ifStatement = _a.ifStatement, parentClassName = _a.parentClassName, context = _a.context;
+    traverseStatements({
+        node: node,
+        context: context,
+        parentClassName: parentClassName,
+        statement: ifStatement.consequent,
+    });
+};
+/**
+ * Validate the `switch` statement
+ * - Validate recursively if `switch` statements are nested
+ */
+var validateSwitchStatement = function (_a) {
+    var node = _a.node, switchStatement = _a.switchStatement, parentClassName = _a.parentClassName, context = _a.context;
+    for (var _i = 0, _b = switchStatement.cases; _i < _b.length; _i++) {
+        var statement = _b[_i];
+        for (var _c = 0, _d = statement.consequent; _c < _d.length; _c++) {
+            var _consequent = _d[_c];
+            traverseStatements({
+                node: node,
+                context: context,
+                parentClassName: parentClassName,
+                statement: _consequent,
+            });
+        }
+    }
+};
+/**
+ * Validate that parent construct name and child id do not match
+ */
+var validateConstructId = function (_a) {
+    var node = _a.node, context = _a.context, expression = _a.expression, parentClassName = _a.parentClassName;
+    if (expression.arguments.length < 2)
+        return;
+    // NOTE: Treat the second argument as ID
+    var secondArg = expression.arguments[1];
+    if (secondArg.type !== "Literal" || typeof secondArg.value !== "string") {
+        return;
+    }
+    var formattedConstructId = toPascalCase(secondArg.value);
+    var formattedParentClassName = toPascalCase(parentClassName);
+    if (formattedParentClassName === formattedConstructId) {
+        context.report({
+            node: node,
+            messageId: "noParentNameConstructIdMatch",
+            data: {
+                constructId: secondArg.value,
+                parentConstructName: parentClassName,
+            },
+        });
+    }
+};

package/dist/no-public-class-fields.mjs

@@ -0,0 +1,111 @@
+import { ESLintUtils, } from "@typescript-eslint/utils";
+import { SymbolFlags } from "typescript";
+export var 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: function (context) {
+        var parserServices = ESLintUtils.getParserServices(context);
+        var typeChecker = parserServices.program.getTypeChecker();
+        return {
+            ClassDeclaration: function (node) {
+                // NOTE: Check class members
+                validateClassMember({
+                    node: node,
+                    context: context,
+                    parserServices: parserServices,
+                    typeChecker: typeChecker,
+                });
+                // NOTE: Check constructor parameter properties
+                var constructor = node.body.body.find(function (member) {
+                    return member.type === "MethodDefinition" && member.kind === "constructor";
+                });
+                if (!constructor || constructor.value.type !== "FunctionExpression") {
+                    return;
+                }
+                validateConstructorParameterProperty({
+                    constructor: constructor,
+                    context: context,
+                    parserServices: parserServices,
+                    typeChecker: typeChecker,
+                });
+            },
+        };
+    },
+});
+var validateClassMember = function (_a) {
+    var _b;
+    var node = _a.node, context = _a.context, parserServices = _a.parserServices, typeChecker = _a.typeChecker;
+    for (var _i = 0, _c = node.body.body; _i < _c.length; _i++) {
+        var member = _c[_i];
+        if (member.type !== "PropertyDefinition" ||
+            member.key.type !== "Identifier") {
+            continue;
+        }
+        // NOTE: Skip private and protected fields
+        if (["private", "protected"].includes((_b = member.accessibility) !== null && _b !== void 0 ? _b : "")) {
+            continue;
+        }
+        // NOTE: Skip fields without type annotation
+        if (!member.typeAnnotation) {
+            continue;
+        }
+        var tsNode = parserServices.esTreeNodeToTSNodeMap.get(member);
+        var type = typeChecker.getTypeAtLocation(tsNode);
+        if (!type.symbol)
+            continue;
+        var isClass = type.symbol.flags === SymbolFlags.Class;
+        if (!isClass)
+            continue;
+        context.report({
+            node: member,
+            messageId: "noPublicClassFields",
+            data: {
+                propertyName: member.key.name,
+                typeName: type.symbol.name,
+            },
+        });
+    }
+};
+var validateConstructorParameterProperty = function (_a) {
+    var _b;
+    var constructor = _a.constructor, context = _a.context, parserServices = _a.parserServices, typeChecker = _a.typeChecker;
+    for (var _i = 0, _c = constructor.value.params; _i < _c.length; _i++) {
+        var param = _c[_i];
+        if (param.type !== "TSParameterProperty" ||
+            param.parameter.type !== "Identifier") {
+            continue;
+        }
+        // NOTE: Skip private and protected parameters
+        if (["private", "protected"].includes((_b = param.accessibility) !== null && _b !== void 0 ? _b : "")) {
+            continue;
+        }
+        // NOTE: Skip parameters without type annotation
+        if (!param.parameter.typeAnnotation) {
+            continue;
+        }
+        var tsNode = parserServices.esTreeNodeToTSNodeMap.get(param);
+        var type = typeChecker.getTypeAtLocation(tsNode);
+        if (!type.symbol)
+            continue;
+        var 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/dist/pascal-case-construct-id.mjs

@@ -0,0 +1,69 @@
+import { toPascalCase } from "./utils/convertString.mjs";
+var QUOTE_TYPE = {
+    SINGLE: "'",
+    DOUBLE: '"',
+};
+/**
+ * check if the string is PascalCase
+ * @param str - The string to check
+ * @returns true if the string is PascalCase, false otherwise
+ */
+var isPascalCase = function (str) {
+    return /^[A-Z][a-zA-Z0-9]*$/.test(str);
+};
+var validateConstructId = function (node, context, args) {
+    var _a;
+    if (args.length < 2)
+        return;
+    // NOTE: Treat the second argument as ID
+    var secondArg = args[1];
+    if (secondArg.type !== "Literal" || typeof secondArg.value !== "string") {
+        return;
+    }
+    var quote = ((_a = secondArg.raw) === null || _a === void 0 ? void 0 : _a.startsWith('"'))
+        ? QUOTE_TYPE.DOUBLE
+        : QUOTE_TYPE.SINGLE;
+    if (!isPascalCase(secondArg.value)) {
+        context.report({
+            node: node,
+            messageId: "pascalCaseConstructId",
+            fix: function (fixer) {
+                var pascalCaseValue = toPascalCase(secondArg.value);
+                return fixer.replaceText(secondArg, "".concat(quote).concat(pascalCaseValue).concat(quote));
+            },
+        });
+    }
+};
+export var pascalCaseConstructId = {
+    meta: {
+        type: "problem",
+        docs: {
+            description: "Enforce PascalCase for Construct ID.",
+        },
+        messages: {
+            pascalCaseConstructId: "Construct ID must be PascalCase.",
+        },
+        schema: [],
+        fixable: "code",
+    },
+    create: function (context) {
+        return {
+            ExpressionStatement: function (node) {
+                if (node.expression.type !== "NewExpression")
+                    return;
+                validateConstructId(node, context, node.expression.arguments);
+            },
+            VariableDeclaration: function (node) {
+                var _a;
+                if (!node.declarations.length)
+                    return;
+                for (var _i = 0, _b = node.declarations; _i < _b.length; _i++) {
+                    var declaration = _b[_i];
+                    if (((_a = declaration.init) === null || _a === void 0 ? void 0 : _a.type) !== "NewExpression")
+                        return;
+                    validateConstructId(node, context, declaration.init.arguments);
+                }
+            },
+        };
+    },
+};

package/dist/utils/convertString.mjs

@@ -0,0 +1,18 @@
+/**
+ * Convert a string to PascalCase
+ * @param str - The string to convert
+ * @returns The PascalCase string
+ */
+export var toPascalCase = function (str) {
+    return str
+        .split(/[-_\s]/)
+        .map(function (word) {
+        // Consider camelCase, split by uppercase letters
+        return word
+            .replace(/([A-Z])/g, " $1")
+            .split(/\s+/)
+            .map(function (part) { return part.charAt(0).toUpperCase() + part.slice(1).toLowerCase(); })
+            .join("");
+    })
+        .join("");
+};

package/package.json

@@ -0,0 +1,63 @@
+{
+  "name": "eslint-cdk-plugin",
+  "version": "0.1.0",
+  "description": "eslint plugin for AWS CDK projects",
+  "main": "dist/index.mjs",
+  "type": "module",
+  "scripts": {
+    "build": "rm -rf dist && tsc src/*.*ts --outDir dist --skipLibCheck",
+    "test": "vitest --run",
+    "lint": "eslint --fix --config eslint.config.mjs",
+    "release:minor": "standard-version --release-as minor",
+    "release:major": "standard-version --release-as major",
+    "release:patch": "standard-version --release-as patch",
+    "docs:dev": "cd ./docs && pnpm install && pnpm run dev",
+    "docs:build": "cd ./docs && pnpm install && pnpm run build",
+    "docs:preview": "cd ./docs && pnpm install && pnpm run preview"
+  },
+  "devDependencies": {
+    "@eslint/js": "^9.15.0",
+    "@types/estree": "^1.0.6",
+    "@types/node": "^22.9.0",
+    "@typescript-eslint/rule-tester": "^8.14.0",
+    "eslint-plugin-import": "^2.31.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"
+  },
+  "volta": {
+    "node": "22.11.0"
+  },
+  "files": [
+    "dist",
+    "README.md",
+    "LICENSE"
+  ],
+  "keywords": [
+    "eslint",
+    "eslintplugin",
+    "eslint-plugin",
+    "aws",
+    "cdk"
+  ],
+  "homepage": "https://eslint-plugin-cdk.dev/",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/ren-yamanashi/eslint-plugin-cdk.git"
+  },
+  "engines": {
+    "node": "^18.18.0 || ^20.9.0 || >=21.1.0"
+  },
+  "author": {
+    "name": "ren-yamanashi"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "license": "MIT"
+}