eslint-cdk-plugin 2.1.0 → 3.0.0

package/dist/index.mjs

@@ -3,7 +3,7 @@ import { ESLintUtils, AST_NODE_TYPES, AST_TOKEN_TYPES } from '@typescript-eslint
 import * as path from 'path';
 
 var name = "eslint-cdk-plugin";
-var version = "2.0.1";
+var version = "2.2.0";
 
 const isConstructOrStackType = (type, ignoredClasses = ["App", "Stage"]) => {
   if (ignoredClasses.includes(type.symbol?.name ?? "")) return false;
@@ -59,7 +59,7 @@ const validateConstructorProperty = (constructor, context) => {
   const params = constructor.value.params;
   if (params.length < 2) {
     context.report({
-      node: constructor,
+      node: constructor.value,
       messageId: "invalidConstructorProperty"
     });
     return;
@@ -67,7 +67,7 @@ const validateConstructorProperty = (constructor, context) => {
   const firstParam = params[0];
   if (firstParam.type === AST_NODE_TYPES.Identifier && firstParam.name !== "scope") {
     context.report({
-      node: constructor,
+      node: firstParam,
       messageId: "invalidConstructorProperty"
     });
     return;
@@ -75,7 +75,7 @@ const validateConstructorProperty = (constructor, context) => {
   const secondParam = params[1];
   if (secondParam.type === AST_NODE_TYPES.Identifier && secondParam.name !== "id") {
     context.report({
-      node: constructor,
+      node: secondParam,
       messageId: "invalidConstructorProperty"
     });
     return;
@@ -84,29 +84,21 @@ const validateConstructorProperty = (constructor, context) => {
   const thirdParam = params[2];
   if (thirdParam.type === AST_NODE_TYPES.Identifier && thirdParam.name !== "props") {
     context.report({
-      node: constructor,
+      node: thirdParam,
       messageId: "invalidConstructorProperty"
     });
     return;
   }
 };
 
-const SYMBOL_FLAGS = {
-  CLASS: 32
-};
-const SYNTAX_KIND = {
-  CLASS_DECLARATION: 263,
-  CONSTRUCTOR: 176
-};
-
-const noClassInInterface = ESLintUtils.RuleCreator.withoutDocs({
+const noConstructInInterface = ESLintUtils.RuleCreator.withoutDocs({
   meta: {
     type: "problem",
     docs: {
-      description: "Disallow class types in interface properties"
+      description: "Disallow CDK Construct types in interface properties"
     },
     messages: {
-      noClassInInterfaceProps: "Interface property '{{ propertyName }}' should not use class type '{{ typeName }}'. Consider using an interface or type alias instead."
+      invalidInterfaceProperty: "Interface property '{{ propertyName }}' should not use CDK Construct type '{{ typeName }}'. Consider using an interface or type alias instead."
     },
     schema: []
   },
@@ -120,12 +112,10 @@ const noClassInInterface = ESLintUtils.RuleCreator.withoutDocs({
             continue;
           }
           const type = parserServices.getTypeAtLocation(property);
-          if (!type.symbol) continue;
-          const isClass = type.symbol.flags === SYMBOL_FLAGS.CLASS;
-          if (!isClass) continue;
+          if (!isConstructOrStackType(type)) continue;
           context.report({
             node: property,
-            messageId: "noClassInInterfaceProps",
+            messageId: "invalidInterfaceProperty",
             data: {
               propertyName: property.key.name,
               typeName: type.symbol.name
@@ -137,6 +127,83 @@ const noClassInInterface = ESLintUtils.RuleCreator.withoutDocs({
   }
 });
 
+const noConstructInPublicPropertyOfConstruct = ESLintUtils.RuleCreator.withoutDocs({
+  meta: {
+    type: "problem",
+    docs: {
+      description: "Disallow Construct types in public property of Construct"
+    },
+    messages: {
+      invalidPublicPropertyOfConstruct: "Public property '{{ propertyName }}' of Construct should not use Construct type '{{ typeName }}'. Consider using an interface or type alias instead."
+    },
+    schema: []
+  },
+  defaultOptions: [],
+  create(context) {
+    const parserServices = ESLintUtils.getParserServices(context);
+    return {
+      ClassDeclaration(node) {
+        const type = parserServices.getTypeAtLocation(node);
+        if (!isConstructOrStackType(type)) return;
+        validatePublicPropertyOfConstruct(node, context, parserServices);
+        const constructor = node.body.body.find(
+          (member) => member.type === AST_NODE_TYPES.MethodDefinition && member.kind === "constructor"
+        );
+        if (!constructor || constructor.value.type !== AST_NODE_TYPES.FunctionExpression) {
+          return;
+        }
+        validateConstructorParameterProperty(
+          constructor,
+          context,
+          parserServices
+        );
+      }
+    };
+  }
+});
+const validatePublicPropertyOfConstruct = (node, context, parserServices) => {
+  for (const property of node.body.body) {
+    if (property.type !== AST_NODE_TYPES.PropertyDefinition || property.key.type !== AST_NODE_TYPES.Identifier) {
+      continue;
+    }
+    if (["private", "protected"].includes(property.accessibility ?? "")) {
+      continue;
+    }
+    if (!property.typeAnnotation) continue;
+    const type = parserServices.getTypeAtLocation(property);
+    if (!isConstructOrStackType(type)) continue;
+    context.report({
+      node: property,
+      messageId: "invalidPublicPropertyOfConstruct",
+      data: {
+        propertyName: property.key.name,
+        typeName: type.symbol.name
+      }
+    });
+  }
+};
+const validateConstructorParameterProperty = (constructor, context, parserServices) => {
+  for (const param of constructor.value.params) {
+    if (param.type !== AST_NODE_TYPES.TSParameterProperty || param.parameter.type !== AST_NODE_TYPES.Identifier) {
+      continue;
+    }
+    if (["private", "protected"].includes(param.accessibility ?? "")) {
+      continue;
+    }
+    if (!param.parameter.typeAnnotation) continue;
+    const type = parserServices.getTypeAtLocation(param);
+    if (!isConstructOrStackType(type)) continue;
+    context.report({
+      node: param,
+      messageId: "invalidPublicPropertyOfConstruct",
+      data: {
+        propertyName: param.parameter.name,
+        typeName: type.symbol.name
+      }
+    });
+  }
+};
+
 const toPascalCase = (str) => {
   return str.split(/[-_\s]/).map((word) => {
     return word.replace(/([A-Z])/g, " $1").split(/\s+/).map(
@@ -145,6 +212,11 @@ const toPascalCase = (str) => {
   }).join("");
 };
 
+const SYNTAX_KIND = {
+  CLASS_DECLARATION: 263,
+  CONSTRUCTOR: 176
+};
+
 const getConstructorPropertyNames = (type) => {
   const declarations = type.symbol?.declarations;
   if (!declarations?.length) return [];
@@ -174,7 +246,7 @@ const noConstructStackSuffix = ESLintUtils.RuleCreator.withoutDocs({
       description: "Effort to avoid using 'Construct' and 'Stack' suffix in construct id."
     },
     messages: {
-      noConstructStackSuffix: "{{ classType }} ID '{{ id }}' should not include {{ suffix }} suffix."
+      invalidConstructId: "{{ classType }} ID '{{ id }}' should not include {{ suffix }} suffix."
     },
     schema: [
       {
@@ -225,8 +297,8 @@ const validateConstructId$3 = (node, context, options) => {
   const disallowedSuffixes = options.disallowedSuffixes;
   if (disallowedSuffixes.includes(SUFFIX_TYPE.CONSTRUCT) && formattedConstructId.endsWith(SUFFIX_TYPE.CONSTRUCT)) {
     context.report({
-      node,
-      messageId: "noConstructStackSuffix",
+      node: secondArg,
+      messageId: "invalidConstructId",
       data: {
         classType: "Construct",
         id: secondArg.value,
@@ -235,8 +307,8 @@ const validateConstructId$3 = (node, context, options) => {
     });
   } else if (disallowedSuffixes.includes(SUFFIX_TYPE.STACK) && formattedConstructId.endsWith(SUFFIX_TYPE.STACK)) {
     context.report({
-      node,
-      messageId: "noConstructStackSuffix",
+      node: secondArg,
+      messageId: "invalidConstructId",
       data: {
         classType: "Stack",
         id: secondArg.value,
@@ -253,7 +325,7 @@ const noImportPrivate = {
       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."
+      invalidImportPath: "Cannot import modules from private dir at different levels of the hierarchy."
     },
     schema: []
   },
@@ -272,7 +344,7 @@ const noImportPrivate = {
         if (currentDirSegments.length !== importDirSegments.length || currentDirSegments.some(
           (segment, index) => segment !== importDirSegments[index]
         )) {
-          context.report({ node, messageId: "noImportPrivate" });
+          context.report({ node, messageId: "invalidImportPath" });
         }
       }
     };
@@ -282,15 +354,15 @@ const getDirSegments = (dirPath) => {
   return dirPath.split(path.sep).filter((segment) => segment !== "");
 };
 
-const noMutablePropsInterface = ESLintUtils.RuleCreator.withoutDocs({
+const noMutablePropertyOfPropsInterface = ESLintUtils.RuleCreator.withoutDocs({
   meta: {
     type: "problem",
     docs: {
-      description: "Disallow mutable properties in Props interfaces"
+      description: "Disallow mutable properties of Construct Props (interface)"
     },
     fixable: "code",
     messages: {
-      noMutablePropsInterface: "Property '{{ propertyName }}' in Props interface should be readonly."
+      invalidPropertyOfPropsInterface: "Property '{{ propertyName }}' of Construct Props should be readonly."
     },
     schema: []
   },
@@ -307,7 +379,7 @@ const noMutablePropsInterface = ESLintUtils.RuleCreator.withoutDocs({
           if (property.readonly) continue;
           context.report({
             node: property,
-            messageId: "noMutablePropsInterface",
+            messageId: "invalidPropertyOfPropsInterface",
             data: {
               propertyName: property.key.name
             },
@@ -322,15 +394,15 @@ const noMutablePropsInterface = ESLintUtils.RuleCreator.withoutDocs({
   }
 });
 
-const noMutablePublicFields = ESLintUtils.RuleCreator.withoutDocs({
+const noMutablePublicPropertyOfConstruct = ESLintUtils.RuleCreator.withoutDocs({
   meta: {
     type: "problem",
     docs: {
-      description: "Disallow mutable public class fields"
+      description: "Disallow mutable public properties of Construct"
     },
     fixable: "code",
     messages: {
-      noMutablePublicFields: "Public field '{{ propertyName }}' should be readonly. Consider adding the 'readonly' modifier."
+      invalidPublicPropertyOfConstruct: "Public property '{{ propertyName }}' should be readonly. Consider adding the 'readonly' modifier."
     },
     schema: []
   },
@@ -352,7 +424,7 @@ const noMutablePublicFields = ESLintUtils.RuleCreator.withoutDocs({
           if (member.readonly) continue;
           context.report({
             node: member,
-            messageId: "noMutablePublicFields",
+            messageId: "invalidPublicPropertyOfConstruct",
             data: {
               propertyName: member.key.name
             },
@@ -381,12 +453,30 @@ const noParentNameConstructIdMatch = ESLintUtils.RuleCreator.withoutDocs(
         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."
+        invalidConstructId: "Construct ID '{{ constructId }}' should not match parent construct name '{{ parentConstructName }}'. Use a more specific identifier."
       },
-      schema: []
+      schema: [
+        {
+          type: "object",
+          properties: {
+            disallowContainingParentName: {
+              type: "boolean",
+              default: false
+            }
+          },
+          additionalProperties: false
+        }
+      ]
     },
-    defaultOptions: [],
+    defaultOptions: [
+      {
+        disallowContainingParentName: false
+      }
+    ],
     create(context) {
+      const option = context.options[0] || {
+        disallowContainingParentName: false
+      };
       const parserServices = ESLintUtils.getParserServices(context);
       return {
         ClassBody(node) {
@@ -401,11 +491,11 @@ const noParentNameConstructIdMatch = ESLintUtils.RuleCreator.withoutDocs(
               continue;
             }
             validateConstructorBody({
-              node,
               expression: body.value,
               parentClassName,
               context,
-              parserServices
+              parserServices,
+              option
             });
           }
         }
@@ -414,11 +504,11 @@ const noParentNameConstructIdMatch = ESLintUtils.RuleCreator.withoutDocs(
   }
 );
 const validateConstructorBody = ({
-  node,
   expression,
   parentClassName,
   context,
-  parserServices
+  parserServices,
+  option
 }) => {
   for (const statement of expression.body.body) {
     switch (statement.type) {
@@ -426,32 +516,32 @@ const validateConstructorBody = ({
         const newExpression = statement.declarations[0].init;
         if (newExpression?.type !== AST_NODE_TYPES.NewExpression) continue;
         validateConstructId$2({
-          node,
           context,
           expression: newExpression,
           parentClassName,
-          parserServices
+          parserServices,
+          option
         });
         break;
       }
       case AST_NODE_TYPES.ExpressionStatement: {
         if (statement.expression?.type !== AST_NODE_TYPES.NewExpression) break;
         validateStatement({
-          node,
           statement,
           parentClassName,
           context,
-          parserServices
+          parserServices,
+          option
         });
         break;
       }
       case AST_NODE_TYPES.IfStatement: {
         traverseStatements({
-          node,
           context,
           parentClassName,
           statement: statement.consequent,
-          parserServices
+          parserServices,
+          option
         });
         break;
       }
@@ -459,11 +549,11 @@ const validateConstructorBody = ({
         for (const switchCase of statement.cases) {
           for (const statement2 of switchCase.consequent) {
             traverseStatements({
-              node,
               context,
               parentClassName,
               statement: statement2,
-              parserServices
+              parserServices,
+              option
             });
           }
         }
@@ -473,21 +563,21 @@ const validateConstructorBody = ({
   }
 };
 const traverseStatements = ({
-  node,
   statement,
   parentClassName,
   context,
-  parserServices
+  parserServices,
+  option
 }) => {
   switch (statement.type) {
     case AST_NODE_TYPES.BlockStatement: {
       for (const body of statement.body) {
         validateStatement({
-          node,
           statement: body,
           parentClassName,
           context,
-          parserServices
+          parserServices,
+          option
         });
       }
       break;
@@ -496,11 +586,11 @@ const traverseStatements = ({
       const newExpression = statement.expression;
       if (newExpression?.type !== AST_NODE_TYPES.NewExpression) break;
       validateStatement({
-        node,
         statement,
         parentClassName,
         context,
-        parserServices
+        parserServices,
+        option
       });
       break;
     }
@@ -508,33 +598,33 @@ const traverseStatements = ({
       const newExpression = statement.declarations[0].init;
       if (newExpression?.type !== AST_NODE_TYPES.NewExpression) break;
       validateConstructId$2({
-        node,
         context,
         expression: newExpression,
         parentClassName,
-        parserServices
+        parserServices,
+        option
       });
       break;
     }
   }
 };
 const validateStatement = ({
-  node,
   statement,
   parentClassName,
   context,
-  parserServices
+  parserServices,
+  option
 }) => {
   switch (statement.type) {
     case AST_NODE_TYPES.VariableDeclaration: {
       const newExpression = statement.declarations[0].init;
       if (newExpression?.type !== AST_NODE_TYPES.NewExpression) break;
       validateConstructId$2({
-        node,
         context,
         expression: newExpression,
         parentClassName,
-        parserServices
+        parserServices,
+        option
       });
       break;
     }
@@ -542,76 +632,76 @@ const validateStatement = ({
       const newExpression = statement.expression;
       if (newExpression?.type !== AST_NODE_TYPES.NewExpression) break;
       validateConstructId$2({
-        node,
         context,
         expression: newExpression,
         parentClassName,
-        parserServices
+        parserServices,
+        option
       });
       break;
     }
     case AST_NODE_TYPES.IfStatement: {
       validateIfStatement({
-        node,
         statement,
         parentClassName,
         context,
-        parserServices
+        parserServices,
+        option
       });
       break;
     }
     case AST_NODE_TYPES.SwitchStatement: {
       validateSwitchStatement({
-        node,
         statement,
         parentClassName,
         context,
-        parserServices
+        parserServices,
+        option
       });
       break;
     }
   }
 };
 const validateIfStatement = ({
-  node,
   statement,
   parentClassName,
   context,
-  parserServices
+  parserServices,
+  option
 }) => {
   traverseStatements({
-    node,
     context,
     parentClassName,
     statement: statement.consequent,
-    parserServices
+    parserServices,
+    option
   });
 };
 const validateSwitchStatement = ({
-  node,
   statement,
   parentClassName,
   context,
-  parserServices
+  parserServices,
+  option
 }) => {
   for (const caseStatement of statement.cases) {
     for (const _consequent of caseStatement.consequent) {
       traverseStatements({
-        node,
         context,
         parentClassName,
         statement: _consequent,
-        parserServices
+        parserServices,
+        option
       });
     }
   }
 };
 const validateConstructId$2 = ({
-  node,
   context,
   expression,
   parentClassName,
-  parserServices
+  parserServices,
+  option
 }) => {
   const type = parserServices.getTypeAtLocation(expression);
   if (expression.arguments.length < 2) return;
@@ -622,94 +712,24 @@ const validateConstructId$2 = ({
   const formattedConstructId = toPascalCase(secondArg.value);
   const formattedParentClassName = toPascalCase(parentClassName);
   if (!isConstructType(type)) return;
-  if (formattedConstructId.includes(formattedParentClassName)) {
+  if (option.disallowContainingParentName && formattedConstructId.includes(formattedParentClassName)) {
     context.report({
-      node,
-      messageId: "noParentNameConstructIdMatch",
+      node: secondArg,
+      messageId: "invalidConstructId",
       data: {
         constructId: secondArg.value,
         parentConstructName: parentClassName
       }
     });
+    return;
   }
-};
-
-const noPublicClassFields = ESLintUtils.RuleCreator.withoutDocs({
-  meta: {
-    type: "problem",
-    docs: {
-      description: "Disallow class types in public class fields"
-    },
-    messages: {
-      noPublicClassFields: "Public field '{{ propertyName }}' should not use class type '{{ typeName }}'. Consider using an interface or type alias instead."
-    },
-    schema: []
-  },
-  defaultOptions: [],
-  create(context) {
-    const parserServices = ESLintUtils.getParserServices(context);
-    return {
-      ClassDeclaration(node) {
-        const type = parserServices.getTypeAtLocation(node);
-        if (!isConstructOrStackType(type)) return;
-        validateClassMember(node, context, parserServices);
-        const constructor = node.body.body.find(
-          (member) => member.type === AST_NODE_TYPES.MethodDefinition && member.kind === "constructor"
-        );
-        if (!constructor || constructor.value.type !== AST_NODE_TYPES.FunctionExpression) {
-          return;
-        }
-        validateConstructorParameterProperty(
-          constructor,
-          context,
-          parserServices
-        );
-      }
-    };
-  }
-});
-const validateClassMember = (node, context, parserServices) => {
-  for (const member of node.body.body) {
-    if (member.type !== AST_NODE_TYPES.PropertyDefinition || member.key.type !== AST_NODE_TYPES.Identifier) {
-      continue;
-    }
-    if (["private", "protected"].includes(member.accessibility ?? "")) {
-      continue;
-    }
-    if (!member.typeAnnotation) continue;
-    const type = parserServices.getTypeAtLocation(member);
-    if (!type.symbol) continue;
-    const isClass = type.symbol.flags === SYMBOL_FLAGS.CLASS;
-    if (!isClass) continue;
-    context.report({
-      node: member,
-      messageId: "noPublicClassFields",
-      data: {
-        propertyName: member.key.name,
-        typeName: type.symbol.name
-      }
-    });
-  }
-};
-const validateConstructorParameterProperty = (constructor, context, parserServices) => {
-  for (const param of constructor.value.params) {
-    if (param.type !== AST_NODE_TYPES.TSParameterProperty || param.parameter.type !== AST_NODE_TYPES.Identifier) {
-      continue;
-    }
-    if (["private", "protected"].includes(param.accessibility ?? "")) {
-      continue;
-    }
-    if (!param.parameter.typeAnnotation) continue;
-    const type = parserServices.getTypeAtLocation(param);
-    if (!type.symbol) continue;
-    const isClass = type.symbol.flags === SYMBOL_FLAGS.CLASS;
-    if (!isClass) continue;
+  if (formattedParentClassName === formattedConstructId) {
     context.report({
-      node: param,
-      messageId: "noPublicClassFields",
+      node: secondArg,
+      messageId: "invalidConstructId",
       data: {
-        propertyName: param.parameter.name,
-        typeName: type.symbol.name
+        constructId: secondArg.value,
+        parentConstructName: parentClassName
       }
     });
   }
@@ -722,7 +742,7 @@ const noVariableConstructId = ESLintUtils.RuleCreator.withoutDocs({
       description: `Enforce using literal strings for Construct ID.`
     },
     messages: {
-      noVariableConstructId: "Shouldn't use a parameter as a Construct ID."
+      invalidConstructId: "Shouldn't use a parameter as a Construct ID."
     },
     schema: []
   },
@@ -750,8 +770,8 @@ const validateConstructId$1 = (node, context) => {
     return;
   }
   context.report({
-    node,
-    messageId: "noVariableConstructId"
+    node: secondArg,
+    messageId: "invalidConstructId"
   });
 };
 const isInsideLoop = (node) => {
@@ -787,7 +807,7 @@ const pascalCaseConstructId = ESLintUtils.RuleCreator.withoutDocs({
       description: "Enforce PascalCase for Construct ID."
     },
     messages: {
-      pascalCaseConstructId: "Construct ID must be PascalCase."
+      invalidConstructId: "Construct ID must be PascalCase."
     },
     schema: [],
     fixable: "code"
@@ -820,8 +840,8 @@ const validateConstructId = (node, context) => {
   const quote = secondArg.raw?.startsWith('"') ? QUOTE_TYPE.DOUBLE : QUOTE_TYPE.SINGLE;
   if (isPascalCase(secondArg.value)) return;
   context.report({
-    node,
-    messageId: "pascalCaseConstructId",
+    node: secondArg,
+    messageId: "invalidConstructId",
     fix: (fixer) => {
       const pascalCaseValue = toPascalCase(secondArg.value);
       return fixer.replaceText(secondArg, `${quote}${pascalCaseValue}${quote}`);
@@ -948,7 +968,7 @@ const requirePassingThis = ESLintUtils.RuleCreator.withoutDocs({
       description: "Require passing `this` in a constructor."
     },
     messages: {
-      requirePassingThis: "Require passing `this` in a constructor."
+      missingPassingThis: "Require passing `this` in a constructor."
     },
     schema: [
       {
@@ -984,8 +1004,8 @@ const requirePassingThis = ESLintUtils.RuleCreator.withoutDocs({
         if (constructorPropertyNames[0] !== "scope") return;
         if (!options.allowNonThisAndDisallowScope) {
           context.report({
-            node,
-            messageId: "requirePassingThis",
+            node: argument,
+            messageId: "missingPassingThis",
             fix: (fixer) => {
               return fixer.replaceText(argument, "this");
             }
@@ -994,8 +1014,8 @@ const requirePassingThis = ESLintUtils.RuleCreator.withoutDocs({
         }
         if (argument.type === AST_NODE_TYPES.Identifier && argument.name === "scope") {
           context.report({
-            node,
-            messageId: "requirePassingThis",
+            node: argument,
+            messageId: "missingPassingThis",
             fix: (fixer) => {
               return fixer.replaceText(argument, "this");
             }
@@ -1049,20 +1069,20 @@ const requirePropsDefaultDoc = ESLintUtils.RuleCreator.withoutDocs({
 });
 
 const rules = {
-  "no-class-in-interface": noClassInInterface,
+  "construct-constructor-property": constructConstructorProperty,
+  "no-construct-in-interface": noConstructInInterface,
+  "no-construct-in-public-property-of-construct": noConstructInPublicPropertyOfConstruct,
   "no-construct-stack-suffix": noConstructStackSuffix,
+  "no-import-private": noImportPrivate,
+  "no-mutable-property-of-props-interface": noMutablePropertyOfPropsInterface,
+  "no-mutable-public-property-of-construct": noMutablePublicPropertyOfConstruct,
   "no-parent-name-construct-id-match": noParentNameConstructIdMatch,
-  "no-public-class-fields": noPublicClassFields,
-  "pascal-case-construct-id": pascalCaseConstructId,
-  "require-passing-this": requirePassingThis,
   "no-variable-construct-id": noVariableConstructId,
-  "no-mutable-public-fields": noMutablePublicFields,
-  "no-mutable-props-interface": noMutablePropsInterface,
-  "construct-constructor-property": constructConstructorProperty,
-  "require-jsdoc": requireJSDoc,
-  "require-props-default-doc": requirePropsDefaultDoc,
+  "pascal-case-construct-id": pascalCaseConstructId,
   "props-name-convention": propsNameConvention,
-  "no-import-private": noImportPrivate
+  "require-jsdoc": requireJSDoc,
+  "require-passing-this": requirePassingThis,
+  "require-props-default-doc": requirePropsDefaultDoc
 };
 const cdkPlugin = {
   meta: { name, version },
@@ -1083,32 +1103,38 @@ const createFlatConfig = (rules2) => {
   };
 };
 const recommended = createFlatConfig({
-  "cdk/no-class-in-interface": "error",
+  "cdk/construct-constructor-property": "error",
+  "cdk/no-construct-in-interface": "error",
+  "cdk/no-construct-in-public-property-of-construct": "error",
   "cdk/no-construct-stack-suffix": "error",
-  "cdk/no-parent-name-construct-id-match": "error",
-  "cdk/no-public-class-fields": "error",
-  "cdk/pascal-case-construct-id": "error",
-  "cdk/require-passing-this": ["error", { allowNonThisAndDisallowScope: true }],
+  "cdk/no-mutable-property-of-props-interface": "warn",
+  "cdk/no-mutable-public-property-of-construct": "warn",
+  "cdk/no-parent-name-construct-id-match": [
+    "error",
+    { disallowContainingParentName: false }
+  ],
   "cdk/no-variable-construct-id": "error",
-  "cdk/no-mutable-public-fields": "warn",
-  "cdk/no-mutable-props-interface": "warn",
-  "cdk/construct-constructor-property": "error"
+  "cdk/pascal-case-construct-id": "error",
+  "cdk/require-passing-this": ["error", { allowNonThisAndDisallowScope: true }]
 });
 const strict = createFlatConfig({
-  "cdk/no-class-in-interface": "error",
+  "cdk/construct-constructor-property": "error",
+  "cdk/no-construct-in-interface": "error",
+  "cdk/no-construct-in-public-property-of-construct": "error",
   "cdk/no-construct-stack-suffix": "error",
-  "cdk/no-parent-name-construct-id-match": "error",
-  "cdk/no-public-class-fields": "error",
-  "cdk/pascal-case-construct-id": "error",
-  "cdk/require-passing-this": "error",
+  "cdk/no-import-private": "error",
+  "cdk/no-mutable-property-of-props-interface": "error",
+  "cdk/no-mutable-public-property-of-construct": "error",
+  "cdk/no-parent-name-construct-id-match": [
+    "error",
+    { disallowContainingParentName: true }
+  ],
   "cdk/no-variable-construct-id": "error",
-  "cdk/no-mutable-public-fields": "error",
-  "cdk/no-mutable-props-interface": "error",
-  "cdk/construct-constructor-property": "error",
-  "cdk/require-jsdoc": "error",
-  "cdk/require-props-default-doc": "error",
+  "cdk/pascal-case-construct-id": "error",
   "cdk/props-name-convention": "error",
-  "cdk/no-import-private": "error"
+  "cdk/require-jsdoc": "error",
+  "cdk/require-passing-this": "error",
+  "cdk/require-props-default-doc": "error"
 });
 const configs = {
   recommended,