eslint-cdk-plugin 1.0.5 → 1.1.0

package/dist/index.cjs

@@ -194402,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",
@@ -194437,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,
@@ -194447,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 = {
@@ -194461,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: {
@@ -194476,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';
@@ -194379,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",
@@ -194414,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,
@@ -194424,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 = {
@@ -194438,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: {
@@ -194453,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.5",
+  "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/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-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",
+            },
+          });
+        }
+      },
+    };
+  },
+});