eslint-cdk-plugin 1.0.4 → 1.1.0

package/dist/index.cjs

@@ -193779,19 +193779,18 @@ const getConstructorPropertyNames = (type) => {
   return constructor.parameters.map((param) => param.name.getText());
 };
 
-const isConstructOrStackType = (type) => {
+const isConstructOrStackType = (type, ignoredClasses = ["App", "Stage"]) => {
+  if (ignoredClasses.includes(type.symbol?.name ?? "")) return false;
   return isTargetSuperClassType(
     type,
     ["Construct", "Stack"],
     isConstructOrStackType
   );
 };
-const isConstructType = (type) => {
+const isConstructType = (type, ignoredClasses = ["App", "Stage", "Stack"]) => {
+  if (ignoredClasses.includes(type.symbol?.name ?? "")) return false;
   return isTargetSuperClassType(type, ["Construct"], isConstructType);
 };
-const isStackType = (type) => {
-  return isTargetSuperClassType(type, ["Stack"], isStackType);
-};
 const isTargetSuperClassType = (type, targetSuperClasses, typeCheckFunction) => {
   if (!type.symbol) return false;
   if (targetSuperClasses.some((suffix) => type.symbol.name.endsWith(suffix))) {
@@ -194317,9 +194316,7 @@ const noVariableConstructId = utils.ESLintUtils.RuleCreator.withoutDocs({
     return {
       NewExpression(node) {
         const type = parserServices.getTypeAtLocation(node);
-        if (!isConstructType(type) || isStackType(type) || node.arguments.length < 2) {
-          return;
-        }
+        if (!isConstructType(type) || node.arguments.length < 2) return;
         const constructorPropertyNames = getConstructorPropertyNames(type);
         if (constructorPropertyNames[1] !== "id") return;
         validateConstructId$1(node, context);
@@ -194405,6 +194402,118 @@ const validateConstructId = (node, context) => {
   });
 };
 
+const propsNameConvention = utils.ESLintUtils.RuleCreator.withoutDocs({
+  meta: {
+    type: "problem",
+    docs: {
+      description: "Enforce props interface name to follow ${ConstructName}Props format"
+    },
+    schema: [],
+    messages: {
+      invalidPropsName: "Props interface name '{{ interfaceName }}' should follow '${ConstructName}Props' format. Expected '{{ expectedName }}'."
+    }
+  },
+  defaultOptions: [],
+  create(context) {
+    const parserServices = utils.ESLintUtils.getParserServices(context);
+    return {
+      ClassDeclaration(node) {
+        if (!node.id || !node.superClass) return;
+        const type = parserServices.getTypeAtLocation(node.superClass);
+        if (!isConstructType(type)) return;
+        const constructor = node.body.body.find(
+          (member) => member.type === utils.AST_NODE_TYPES.MethodDefinition && member.kind === "constructor"
+        );
+        const propsParam = constructor?.value.params?.[2];
+        if (propsParam?.type !== utils.AST_NODE_TYPES.Identifier) return;
+        const typeAnnotation = propsParam.typeAnnotation;
+        if (typeAnnotation?.type !== utils.AST_NODE_TYPES.TSTypeAnnotation) return;
+        const typeNode = typeAnnotation.typeAnnotation;
+        if (typeNode.type !== utils.AST_NODE_TYPES.TSTypeReference) return;
+        const propsTypeName = typeNode.typeName;
+        if (propsTypeName.type !== utils.AST_NODE_TYPES.Identifier) return;
+        const constructName = node.id.name;
+        const expectedPropsName = `${constructName}Props`;
+        if (propsTypeName.name !== expectedPropsName) {
+          context.report({
+            node: propsTypeName,
+            messageId: "invalidPropsName",
+            data: {
+              interfaceName: propsTypeName.name,
+              expectedName: expectedPropsName
+            }
+          });
+        }
+      }
+    };
+  }
+});
+
+const requireJSDoc = utils.ESLintUtils.RuleCreator.withoutDocs({
+  meta: {
+    type: "problem",
+    docs: {
+      description: "Require JSDoc comments for interface properties and public properties in Construct classes"
+    },
+    messages: {
+      missingJSDoc: "Property '{{ propertyName }}' should have a JSDoc comment."
+    },
+    schema: []
+  },
+  defaultOptions: [],
+  create(context) {
+    const parserServices = utils.ESLintUtils.getParserServices(context);
+    return {
+      TSPropertySignature(node) {
+        if (node.key.type !== utils.AST_NODE_TYPES.Identifier || node.parent?.type !== utils.AST_NODE_TYPES.TSInterfaceBody) {
+          return;
+        }
+        const sourceCode = context.sourceCode;
+        const comments = sourceCode.getCommentsBefore(node);
+        const hasJSDoc = comments.some(
+          ({ type, value }) => type === utils.AST_TOKEN_TYPES.Block && value.startsWith("*")
+        );
+        if (!hasJSDoc) {
+          context.report({
+            node,
+            messageId: "missingJSDoc",
+            data: {
+              propertyName: node.key.name
+            }
+          });
+        }
+      },
+      PropertyDefinition(node) {
+        if (node.key.type !== utils.AST_NODE_TYPES.Identifier || node.parent.type !== utils.AST_NODE_TYPES.ClassBody) {
+          return;
+        }
+        const classDeclaration = node.parent.parent;
+        if (classDeclaration.type !== utils.AST_NODE_TYPES.ClassDeclaration || !classDeclaration.superClass) {
+          return;
+        }
+        const classType = parserServices.getTypeAtLocation(classDeclaration);
+        if (!isConstructType(classType) || node.accessibility !== "public") {
+          return;
+        }
+        const sourceCode = context.sourceCode;
+        const comments = sourceCode.getCommentsBefore(node);
+        const hasJSDoc = comments.some(
+          ({ type, value }) => type === utils.AST_TOKEN_TYPES.Block && value.startsWith("*")
+        );
+        if (!hasJSDoc) {
+          context.report({
+            node,
+            messageId: "missingJSDoc",
+            data: {
+              propertyName: node.key.name
+            }
+          });
+        }
+      }
+    };
+  }
+});
+
 const requirePassingThis = utils.ESLintUtils.RuleCreator.withoutDocs({
   meta: {
     type: "problem",
@@ -194423,9 +194532,7 @@ const requirePassingThis = utils.ESLintUtils.RuleCreator.withoutDocs({
     return {
       NewExpression(node) {
         const type = parserServices.getTypeAtLocation(node);
-        if (!isConstructType(type) || isStackType(type) || !node.arguments.length) {
-          return;
-        }
+        if (!isConstructType(type) || !node.arguments.length) return;
         const argument = node.arguments[0];
         if (argument.type === utils.AST_NODE_TYPES.ThisExpression) return;
         const constructorPropertyNames = getConstructorPropertyNames(type);
@@ -194442,6 +194549,48 @@ const requirePassingThis = utils.ESLintUtils.RuleCreator.withoutDocs({
   }
 });
 
+const requirePropsDefaultDoc = utils.ESLintUtils.RuleCreator.withoutDocs({
+  meta: {
+    type: "problem",
+    docs: {
+      description: "Require @default JSDoc for optional properties in interfaces ending with 'Props'"
+    },
+    schema: [],
+    messages: {
+      missingDefaultDoc: "Optional property '{{ propertyName }}' in Props interface must have @default JSDoc documentation"
+    }
+  },
+  defaultOptions: [],
+  create(context) {
+    return {
+      TSPropertySignature(node) {
+        if (!node.optional) return;
+        const parent = node.parent?.parent;
+        if (parent?.type !== utils.AST_NODE_TYPES.TSInterfaceDeclaration) {
+          return;
+        }
+        if (parent.id.type !== utils.AST_NODE_TYPES.Identifier || !parent.id.name.endsWith("Props")) {
+          return;
+        }
+        const sourceCode = context.sourceCode;
+        const comments = sourceCode.getCommentsBefore(node);
+        const hasDefaultDoc = comments.some(
+          (comment) => comment.type === utils.AST_TOKEN_TYPES.Block && comment.value.includes("*") && comment.value.includes("@default")
+        );
+        if (!hasDefaultDoc) {
+          context.report({
+            node,
+            messageId: "missingDefaultDoc",
+            data: {
+              propertyName: node.key.type === utils.AST_NODE_TYPES.Identifier ? node.key.name : "unknown"
+            }
+          });
+        }
+      }
+    };
+  }
+});
+
 const rules = {
   "no-class-in-interface": noClassInInterface,
   "no-construct-stack-suffix": noConstructStackSuffix,
@@ -194452,6 +194601,9 @@ const rules = {
   "no-mutable-props-interface": noMutablePropsInterface,
   "require-passing-this": requirePassingThis,
   "no-variable-construct-id": noVariableConstructId,
+  "require-jsdoc": requireJSDoc,
+  "require-props-default-doc": requirePropsDefaultDoc,
+  "props-name-convention": propsNameConvention,
   "no-import-private": noImportPrivate
 };
 const configs = {
@@ -194466,7 +194618,8 @@ const configs = {
       "cdk/require-passing-this": "error",
       "cdk/no-variable-construct-id": "error",
       "cdk/no-mutable-public-fields": "warn",
-      "cdk/no-mutable-props-interface": "warn"
+      "cdk/no-mutable-props-interface": "warn",
+      "cdk/props-name-convention": "warn"
     }
   },
   strict: {
@@ -194481,7 +194634,10 @@ const configs = {
       "cdk/no-variable-construct-id": "error",
       "cdk/no-mutable-public-fields": "error",
       "cdk/no-mutable-props-interface": "error",
-      "cdk/no-import-private": "error"
+      "cdk/no-import-private": "error",
+      "cdk/require-props-default-doc": "error",
+      "cdk/props-name-convention": "error",
+      "cdk/require-jsdoc": "error"
     }
   }
 };

package/dist/index.d.ts

@@ -8,6 +8,9 @@ declare const rules: {
     "no-mutable-props-interface": import("@typescript-eslint/utils/ts-eslint").RuleModule<"noMutablePropsInterface", [], unknown, import("@typescript-eslint/utils/ts-eslint").RuleListener>;
     "require-passing-this": import("@typescript-eslint/utils/ts-eslint").RuleModule<"requirePassingThis", [], unknown, import("@typescript-eslint/utils/ts-eslint").RuleListener>;
     "no-variable-construct-id": import("@typescript-eslint/utils/ts-eslint").RuleModule<"noVariableConstructId", [], unknown, import("@typescript-eslint/utils/ts-eslint").RuleListener>;
+    "require-jsdoc": import("@typescript-eslint/utils/ts-eslint").RuleModule<"missingJSDoc", [], unknown, import("@typescript-eslint/utils/ts-eslint").RuleListener>;
+    "require-props-default-doc": import("@typescript-eslint/utils/ts-eslint").RuleModule<"missingDefaultDoc", [], unknown, import("@typescript-eslint/utils/ts-eslint").RuleListener>;
+    "props-name-convention": import("@typescript-eslint/utils/ts-eslint").RuleModule<"invalidPropsName", [], unknown, import("@typescript-eslint/utils/ts-eslint").RuleListener>;
     "no-import-private": import("eslint").Rule.RuleModule;
 };
 declare const configs: {
@@ -23,6 +26,7 @@ declare const configs: {
             "cdk/no-variable-construct-id": string;
             "cdk/no-mutable-public-fields": string;
             "cdk/no-mutable-props-interface": string;
+            "cdk/props-name-convention": string;
         };
     };
     strict: {
@@ -38,6 +42,9 @@ declare const configs: {
             "cdk/no-mutable-public-fields": string;
             "cdk/no-mutable-props-interface": string;
             "cdk/no-import-private": string;
+            "cdk/require-props-default-doc": string;
+            "cdk/props-name-convention": string;
+            "cdk/require-jsdoc": string;
         };
     };
 };

package/dist/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAWA,QAAA,MAAM,KAAK;;;;;;;;;;;CAWV,CAAC;AAEF,QAAA,MAAM,OAAO;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA8BZ,CAAC;AAEF,OAAO,EAAE,OAAO,EAAE,KAAK,EAAE,CAAC;AAE1B,MAAM,WAAW,eAAe;IAC9B,KAAK,EAAE,OAAO,KAAK,CAAC;IACpB,OAAO,EAAE,OAAO,OAAO,CAAC;CACzB;AAED,QAAA,MAAM,eAAe,EAAE,eAGtB,CAAC;AAEF,eAAe,eAAe,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAcA,QAAA,MAAM,KAAK;;;;;;;;;;;;;;CAcV,CAAC;AAEF,QAAA,MAAM,OAAO;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAkCZ,CAAC;AAEF,OAAO,EAAE,OAAO,EAAE,KAAK,EAAE,CAAC;AAE1B,MAAM,WAAW,eAAe;IAC9B,KAAK,EAAE,OAAO,KAAK,CAAC;IACpB,OAAO,EAAE,OAAO,OAAO,CAAC;CACzB;AAED,QAAA,MAAM,eAAe,EAAE,eAGtB,CAAC;AAEF,eAAe,eAAe,CAAC"}

package/dist/index.mjs

@@ -1,4 +1,4 @@
-import { ESLintUtils, AST_NODE_TYPES } from '@typescript-eslint/utils';
+import { ESLintUtils, AST_NODE_TYPES, AST_TOKEN_TYPES } from '@typescript-eslint/utils';
 import { createRequire } from 'module';
 import require$$1 from 'fs';
 import * as path from 'path';
@@ -193756,19 +193756,18 @@ const getConstructorPropertyNames = (type) => {
   return constructor.parameters.map((param) => param.name.getText());
 };
 
-const isConstructOrStackType = (type) => {
+const isConstructOrStackType = (type, ignoredClasses = ["App", "Stage"]) => {
+  if (ignoredClasses.includes(type.symbol?.name ?? "")) return false;
   return isTargetSuperClassType(
     type,
     ["Construct", "Stack"],
     isConstructOrStackType
   );
 };
-const isConstructType = (type) => {
+const isConstructType = (type, ignoredClasses = ["App", "Stage", "Stack"]) => {
+  if (ignoredClasses.includes(type.symbol?.name ?? "")) return false;
   return isTargetSuperClassType(type, ["Construct"], isConstructType);
 };
-const isStackType = (type) => {
-  return isTargetSuperClassType(type, ["Stack"], isStackType);
-};
 const isTargetSuperClassType = (type, targetSuperClasses, typeCheckFunction) => {
   if (!type.symbol) return false;
   if (targetSuperClasses.some((suffix) => type.symbol.name.endsWith(suffix))) {
@@ -194294,9 +194293,7 @@ const noVariableConstructId = ESLintUtils.RuleCreator.withoutDocs({
     return {
       NewExpression(node) {
         const type = parserServices.getTypeAtLocation(node);
-        if (!isConstructType(type) || isStackType(type) || node.arguments.length < 2) {
-          return;
-        }
+        if (!isConstructType(type) || node.arguments.length < 2) return;
         const constructorPropertyNames = getConstructorPropertyNames(type);
         if (constructorPropertyNames[1] !== "id") return;
         validateConstructId$1(node, context);
@@ -194382,6 +194379,118 @@ const validateConstructId = (node, context) => {
   });
 };
 
+const propsNameConvention = ESLintUtils.RuleCreator.withoutDocs({
+  meta: {
+    type: "problem",
+    docs: {
+      description: "Enforce props interface name to follow ${ConstructName}Props format"
+    },
+    schema: [],
+    messages: {
+      invalidPropsName: "Props interface name '{{ interfaceName }}' should follow '${ConstructName}Props' format. Expected '{{ expectedName }}'."
+    }
+  },
+  defaultOptions: [],
+  create(context) {
+    const parserServices = ESLintUtils.getParserServices(context);
+    return {
+      ClassDeclaration(node) {
+        if (!node.id || !node.superClass) return;
+        const type = parserServices.getTypeAtLocation(node.superClass);
+        if (!isConstructType(type)) return;
+        const constructor = node.body.body.find(
+          (member) => member.type === AST_NODE_TYPES.MethodDefinition && member.kind === "constructor"
+        );
+        const propsParam = constructor?.value.params?.[2];
+        if (propsParam?.type !== AST_NODE_TYPES.Identifier) return;
+        const typeAnnotation = propsParam.typeAnnotation;
+        if (typeAnnotation?.type !== AST_NODE_TYPES.TSTypeAnnotation) return;
+        const typeNode = typeAnnotation.typeAnnotation;
+        if (typeNode.type !== AST_NODE_TYPES.TSTypeReference) return;
+        const propsTypeName = typeNode.typeName;
+        if (propsTypeName.type !== AST_NODE_TYPES.Identifier) return;
+        const constructName = node.id.name;
+        const expectedPropsName = `${constructName}Props`;
+        if (propsTypeName.name !== expectedPropsName) {
+          context.report({
+            node: propsTypeName,
+            messageId: "invalidPropsName",
+            data: {
+              interfaceName: propsTypeName.name,
+              expectedName: expectedPropsName
+            }
+          });
+        }
+      }
+    };
+  }
+});
+
+const requireJSDoc = ESLintUtils.RuleCreator.withoutDocs({
+  meta: {
+    type: "problem",
+    docs: {
+      description: "Require JSDoc comments for interface properties and public properties in Construct classes"
+    },
+    messages: {
+      missingJSDoc: "Property '{{ propertyName }}' should have a JSDoc comment."
+    },
+    schema: []
+  },
+  defaultOptions: [],
+  create(context) {
+    const parserServices = ESLintUtils.getParserServices(context);
+    return {
+      TSPropertySignature(node) {
+        if (node.key.type !== AST_NODE_TYPES.Identifier || node.parent?.type !== AST_NODE_TYPES.TSInterfaceBody) {
+          return;
+        }
+        const sourceCode = context.sourceCode;
+        const comments = sourceCode.getCommentsBefore(node);
+        const hasJSDoc = comments.some(
+          ({ type, value }) => type === AST_TOKEN_TYPES.Block && value.startsWith("*")
+        );
+        if (!hasJSDoc) {
+          context.report({
+            node,
+            messageId: "missingJSDoc",
+            data: {
+              propertyName: node.key.name
+            }
+          });
+        }
+      },
+      PropertyDefinition(node) {
+        if (node.key.type !== AST_NODE_TYPES.Identifier || node.parent.type !== AST_NODE_TYPES.ClassBody) {
+          return;
+        }
+        const classDeclaration = node.parent.parent;
+        if (classDeclaration.type !== AST_NODE_TYPES.ClassDeclaration || !classDeclaration.superClass) {
+          return;
+        }
+        const classType = parserServices.getTypeAtLocation(classDeclaration);
+        if (!isConstructType(classType) || node.accessibility !== "public") {
+          return;
+        }
+        const sourceCode = context.sourceCode;
+        const comments = sourceCode.getCommentsBefore(node);
+        const hasJSDoc = comments.some(
+          ({ type, value }) => type === AST_TOKEN_TYPES.Block && value.startsWith("*")
+        );
+        if (!hasJSDoc) {
+          context.report({
+            node,
+            messageId: "missingJSDoc",
+            data: {
+              propertyName: node.key.name
+            }
+          });
+        }
+      }
+    };
+  }
+});
+
 const requirePassingThis = ESLintUtils.RuleCreator.withoutDocs({
   meta: {
     type: "problem",
@@ -194400,9 +194509,7 @@ const requirePassingThis = ESLintUtils.RuleCreator.withoutDocs({
     return {
       NewExpression(node) {
         const type = parserServices.getTypeAtLocation(node);
-        if (!isConstructType(type) || isStackType(type) || !node.arguments.length) {
-          return;
-        }
+        if (!isConstructType(type) || !node.arguments.length) return;
         const argument = node.arguments[0];
         if (argument.type === AST_NODE_TYPES.ThisExpression) return;
         const constructorPropertyNames = getConstructorPropertyNames(type);
@@ -194419,6 +194526,48 @@ const requirePassingThis = ESLintUtils.RuleCreator.withoutDocs({
   }
 });
 
+const requirePropsDefaultDoc = ESLintUtils.RuleCreator.withoutDocs({
+  meta: {
+    type: "problem",
+    docs: {
+      description: "Require @default JSDoc for optional properties in interfaces ending with 'Props'"
+    },
+    schema: [],
+    messages: {
+      missingDefaultDoc: "Optional property '{{ propertyName }}' in Props interface must have @default JSDoc documentation"
+    }
+  },
+  defaultOptions: [],
+  create(context) {
+    return {
+      TSPropertySignature(node) {
+        if (!node.optional) return;
+        const parent = node.parent?.parent;
+        if (parent?.type !== AST_NODE_TYPES.TSInterfaceDeclaration) {
+          return;
+        }
+        if (parent.id.type !== AST_NODE_TYPES.Identifier || !parent.id.name.endsWith("Props")) {
+          return;
+        }
+        const sourceCode = context.sourceCode;
+        const comments = sourceCode.getCommentsBefore(node);
+        const hasDefaultDoc = comments.some(
+          (comment) => comment.type === AST_TOKEN_TYPES.Block && comment.value.includes("*") && comment.value.includes("@default")
+        );
+        if (!hasDefaultDoc) {
+          context.report({
+            node,
+            messageId: "missingDefaultDoc",
+            data: {
+              propertyName: node.key.type === AST_NODE_TYPES.Identifier ? node.key.name : "unknown"
+            }
+          });
+        }
+      }
+    };
+  }
+});
+
 const rules = {
   "no-class-in-interface": noClassInInterface,
   "no-construct-stack-suffix": noConstructStackSuffix,
@@ -194429,6 +194578,9 @@ const rules = {
   "no-mutable-props-interface": noMutablePropsInterface,
   "require-passing-this": requirePassingThis,
   "no-variable-construct-id": noVariableConstructId,
+  "require-jsdoc": requireJSDoc,
+  "require-props-default-doc": requirePropsDefaultDoc,
+  "props-name-convention": propsNameConvention,
   "no-import-private": noImportPrivate
 };
 const configs = {
@@ -194443,7 +194595,8 @@ const configs = {
       "cdk/require-passing-this": "error",
       "cdk/no-variable-construct-id": "error",
       "cdk/no-mutable-public-fields": "warn",
-      "cdk/no-mutable-props-interface": "warn"
+      "cdk/no-mutable-props-interface": "warn",
+      "cdk/props-name-convention": "warn"
     }
   },
   strict: {
@@ -194458,7 +194611,10 @@ const configs = {
       "cdk/no-variable-construct-id": "error",
       "cdk/no-mutable-public-fields": "error",
       "cdk/no-mutable-props-interface": "error",
-      "cdk/no-import-private": "error"
+      "cdk/no-import-private": "error",
+      "cdk/require-props-default-doc": "error",
+      "cdk/props-name-convention": "error",
+      "cdk/require-jsdoc": "error"
     }
   }
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "eslint-cdk-plugin",
-  "version": "1.0.4",
+  "version": "1.1.0",
   "description": "eslint plugin for AWS CDK projects",
   "main": "./dist/index.mjs",
   "types": "./dist/index.d.ts",

package/src/index.ts

@@ -7,7 +7,10 @@ import { noParentNameConstructIdMatch } from "./rules/no-parent-name-construct-i
 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 { propsNameConvention } from "./rules/props-name-convention";
+import { requireJSDoc } from "./rules/require-jsdoc";
 import { requirePassingThis } from "./rules/require-passing-this";
+import { requirePropsDefaultDoc } from "./rules/require-props-default-doc";
 
 const rules = {
   "no-class-in-interface": noClassInInterface,
@@ -19,6 +22,9 @@ const rules = {
   "no-mutable-props-interface": noMutablePropsInterface,
   "require-passing-this": requirePassingThis,
   "no-variable-construct-id": noVariableConstructId,
+  "require-jsdoc": requireJSDoc,
+  "require-props-default-doc": requirePropsDefaultDoc,
+  "props-name-convention": propsNameConvention,
   "no-import-private": noImportPrivate,
 };
 
@@ -35,6 +41,7 @@ const configs = {
       "cdk/no-variable-construct-id": "error",
       "cdk/no-mutable-public-fields": "warn",
       "cdk/no-mutable-props-interface": "warn",
+      "cdk/props-name-convention": "warn",
     },
   },
   strict: {
@@ -50,6 +57,9 @@ const configs = {
       "cdk/no-mutable-public-fields": "error",
       "cdk/no-mutable-props-interface": "error",
       "cdk/no-import-private": "error",
+      "cdk/require-props-default-doc": "error",
+      "cdk/props-name-convention": "error",
+      "cdk/require-jsdoc": "error",
     },
   },
 };

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

@@ -6,7 +6,7 @@ import {
 } from "@typescript-eslint/utils";
 
 import { getConstructorPropertyNames } from "../utils/parseType";
-import { isConstructType, isStackType } from "../utils/typeCheck";
+import { isConstructType } from "../utils/typeCheck";
 
 type Context = TSESLint.RuleContext<"noVariableConstructId", []>;
 
@@ -33,13 +33,7 @@ export const noVariableConstructId = ESLintUtils.RuleCreator.withoutDocs({
       NewExpression(node) {
         const type = parserServices.getTypeAtLocation(node);
 
-        if (
-          !isConstructType(type) ||
-          isStackType(type) ||
-          node.arguments.length < 2
-        ) {
-          return;
-        }
+        if (!isConstructType(type) || node.arguments.length < 2) return;
 
         const constructorPropertyNames = getConstructorPropertyNames(type);
         if (constructorPropertyNames[1] !== "id") return;

package/src/rules/props-name-convention.ts

@@ -0,0 +1,75 @@
+import {
+  AST_NODE_TYPES,
+  ESLintUtils,
+  TSESTree,
+} from "@typescript-eslint/utils";
+
+import { isConstructType } from "../utils/typeCheck";
+
+/**
+ * Enforces a naming convention for props interfaces in Construct classes
+ * @param context - The rule context provided by ESLint
+ * @returns An object containing the AST visitor functions
+ * @see {@link https://eslint-cdk-plugin.dev/rules/props-name-convention} - Documentation
+ */
+export const propsNameConvention = ESLintUtils.RuleCreator.withoutDocs({
+  meta: {
+    type: "problem",
+    docs: {
+      description:
+        "Enforce props interface name to follow ${ConstructName}Props format",
+    },
+    schema: [],
+    messages: {
+      invalidPropsName:
+        "Props interface name '{{ interfaceName }}' should follow '${ConstructName}Props' format. Expected '{{ expectedName }}'.",
+    },
+  },
+  defaultOptions: [],
+  create(context) {
+    const parserServices = ESLintUtils.getParserServices(context);
+    return {
+      ClassDeclaration(node) {
+        if (!node.id || !node.superClass) return;
+
+        const type = parserServices.getTypeAtLocation(node.superClass);
+        if (!isConstructType(type)) return;
+
+        // NOTE: check constructor parameter
+        const constructor = node.body.body.find(
+          (member): member is TSESTree.MethodDefinition =>
+            member.type === AST_NODE_TYPES.MethodDefinition &&
+            member.kind === "constructor"
+        );
+
+        const propsParam = constructor?.value.params?.[2];
+        if (propsParam?.type !== AST_NODE_TYPES.Identifier) return;
+
+        const typeAnnotation = propsParam.typeAnnotation;
+        if (typeAnnotation?.type !== AST_NODE_TYPES.TSTypeAnnotation) return;
+
+        const typeNode = typeAnnotation.typeAnnotation;
+        if (typeNode.type !== AST_NODE_TYPES.TSTypeReference) return;
+
+        const propsTypeName = typeNode.typeName;
+        if (propsTypeName.type !== AST_NODE_TYPES.Identifier) return;
+
+        // NOTE: create valid props name
+        const constructName = node.id.name;
+        const expectedPropsName = `${constructName}Props`;
+
+        // NOTE: error when props name is not expected format
+        if (propsTypeName.name !== expectedPropsName) {
+          context.report({
+            node: propsTypeName,
+            messageId: "invalidPropsName",
+            data: {
+              interfaceName: propsTypeName.name,
+              expectedName: expectedPropsName,
+            },
+          });
+        }
+      },
+    };
+  },
+});

package/src/rules/require-jsdoc.ts

@@ -0,0 +1,99 @@
+import {
+  AST_NODE_TYPES,
+  AST_TOKEN_TYPES,
+  ESLintUtils,
+} from "@typescript-eslint/utils";
+
+import { isConstructType } from "../utils/typeCheck";
+
+/**
+ * Require JSDoc comments for interface properties and public properties in Construct classes
+ * @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-jsdoc} - Documentation
+ */
+export const requireJSDoc = ESLintUtils.RuleCreator.withoutDocs({
+  meta: {
+    type: "problem",
+    docs: {
+      description:
+        "Require JSDoc comments for interface properties and public properties in Construct classes",
+    },
+    messages: {
+      missingJSDoc:
+        "Property '{{ propertyName }}' should have a JSDoc comment.",
+    },
+    schema: [],
+  },
+  defaultOptions: [],
+  create(context) {
+    const parserServices = ESLintUtils.getParserServices(context);
+    return {
+      TSPropertySignature(node) {
+        if (
+          node.key.type !== AST_NODE_TYPES.Identifier ||
+          node.parent?.type !== AST_NODE_TYPES.TSInterfaceBody
+        ) {
+          return;
+        }
+
+        const sourceCode = context.sourceCode;
+        const comments = sourceCode.getCommentsBefore(node);
+        const hasJSDoc = comments.some(
+          ({ type, value }) =>
+            type === AST_TOKEN_TYPES.Block && value.startsWith("*")
+        );
+
+        if (!hasJSDoc) {
+          context.report({
+            node,
+            messageId: "missingJSDoc",
+            data: {
+              propertyName: node.key.name,
+            },
+          });
+        }
+      },
+      PropertyDefinition(node) {
+        if (
+          node.key.type !== AST_NODE_TYPES.Identifier ||
+          node.parent.type !== AST_NODE_TYPES.ClassBody
+        ) {
+          return;
+        }
+
+        // NOTE: Check if the class extends Construct
+        const classDeclaration = node.parent.parent;
+        if (
+          classDeclaration.type !== AST_NODE_TYPES.ClassDeclaration ||
+          !classDeclaration.superClass
+        ) {
+          return;
+        }
+
+        // NOTE: Check if the class extends Construct and the property is public
+        const classType = parserServices.getTypeAtLocation(classDeclaration);
+        if (!isConstructType(classType) || node.accessibility !== "public") {
+          return;
+        }
+
+        const sourceCode = context.sourceCode;
+        const comments = sourceCode.getCommentsBefore(node);
+        const hasJSDoc = comments.some(
+          ({ type, value }) =>
+            type === AST_TOKEN_TYPES.Block && value.startsWith("*")
+        );
+
+        if (!hasJSDoc) {
+          context.report({
+            node,
+            messageId: "missingJSDoc",
+            data: {
+              propertyName: node.key.name,
+            },
+          });
+        }
+      },
+    };
+  },
+});

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

@@ -1,7 +1,7 @@
 import { AST_NODE_TYPES, ESLintUtils } from "@typescript-eslint/utils";
 
 import { getConstructorPropertyNames } from "../utils/parseType";
-import { isConstructType, isStackType } from "../utils/typeCheck";
+import { isConstructType } from "../utils/typeCheck";
 
 /**
  * Enforces that `this` is passed to the constructor
@@ -28,13 +28,7 @@ export const requirePassingThis = ESLintUtils.RuleCreator.withoutDocs({
       NewExpression(node) {
         const type = parserServices.getTypeAtLocation(node);
 
-        if (
-          !isConstructType(type) ||
-          isStackType(type) ||
-          !node.arguments.length
-        ) {
-          return;
-        }
+        if (!isConstructType(type) || !node.arguments.length) return;
 
         const argument = node.arguments[0];
         if (argument.type === AST_NODE_TYPES.ThisExpression) return;

package/src/rules/require-props-default-doc.ts

@@ -0,0 +1,72 @@
+import {
+  AST_NODE_TYPES,
+  AST_TOKEN_TYPES,
+  ESLintUtils,
+} from "@typescript-eslint/utils";
+
+/**
+ * Requires @default JSDoc documentation for optional properties in interfaces ending with '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/require-props-default-doc} - Documentation
+ */
+export const requirePropsDefaultDoc = ESLintUtils.RuleCreator.withoutDocs({
+  meta: {
+    type: "problem",
+    docs: {
+      description:
+        "Require @default JSDoc for optional properties in interfaces ending with 'Props'",
+    },
+    schema: [],
+    messages: {
+      missingDefaultDoc:
+        "Optional property '{{ propertyName }}' in Props interface must have @default JSDoc documentation",
+    },
+  },
+  defaultOptions: [],
+  create(context) {
+    return {
+      TSPropertySignature(node) {
+        // NOTE: Check if the property is optional
+        if (!node.optional) return;
+
+        // NOTE: Check if the parent is an interface
+        const parent = node.parent?.parent;
+        if (parent?.type !== AST_NODE_TYPES.TSInterfaceDeclaration) {
+          return;
+        }
+
+        // NOTE: Check if the interface name ends with 'Props'
+        if (
+          parent.id.type !== AST_NODE_TYPES.Identifier ||
+          !parent.id.name.endsWith("Props")
+        ) {
+          return;
+        }
+
+        // NOTE: Get JSDoc comments
+        const sourceCode = context.sourceCode;
+        const comments = sourceCode.getCommentsBefore(node);
+        const hasDefaultDoc = comments.some(
+          (comment) =>
+            comment.type === AST_TOKEN_TYPES.Block &&
+            comment.value.includes("*") &&
+            comment.value.includes("@default")
+        );
+
+        if (!hasDefaultDoc) {
+          context.report({
+            node,
+            messageId: "missingDefaultDoc",
+            data: {
+              propertyName:
+                node.key.type === AST_NODE_TYPES.Identifier
+                  ? node.key.name
+                  : "unknown",
+            },
+          });
+        }
+      },
+    };
+  },
+});

package/src/utils/typeCheck.ts

@@ -5,9 +5,14 @@ type SuperClassType = "Construct" | "Stack";
 /**
  * Check if the type extends Construct or Stack
  * @param type - The type to check
+ * @param ignoredClasses - Classes that inherit from Construct Class or Stack Class but do not want to be treated as Construct Class or Stack Class
  * @returns True if the type extends Construct or Stack, otherwise false
  */
-export const isConstructOrStackType = (type: Type): boolean => {
+export const isConstructOrStackType = (
+  type: Type,
+  ignoredClasses: readonly string[] = ["App", "Stage"] as const
+): boolean => {
+  if (ignoredClasses.includes(type.symbol?.name ?? "")) return false;
   return isTargetSuperClassType(
     type,
     ["Construct", "Stack"],
@@ -18,21 +23,17 @@ export const isConstructOrStackType = (type: Type): boolean => {
 /**
  * Check if the type extends Construct
  * @param type - The type to check
+ * @param ignoredClasses - Classes that inherit from Construct Class but do not want to be treated as Construct Class
  * @returns True if the type extends Construct, otherwise false
  */
-export const isConstructType = (type: Type): boolean => {
+export const isConstructType = (
+  type: Type,
+  ignoredClasses: readonly string[] = ["App", "Stage", "Stack"] as const
+): boolean => {
+  if (ignoredClasses.includes(type.symbol?.name ?? "")) return false;
   return isTargetSuperClassType(type, ["Construct"], isConstructType);
 };
 
-/**
- * Check if the type extends Stack
- * @param type - The type to check
- * @returns True if the type extends Stack, otherwise false
- */
-export const isStackType = (type: Type): boolean => {
-  return isTargetSuperClassType(type, ["Stack"], isStackType);
-};
-
 /**
  * Check if the type extends target super class
  * @param type - The type to check