eslint-cdk-plugin 1.0.1 → 1.0.3

package/dist/index.cjs

@@ -0,0 +1,783 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var utils = require('@typescript-eslint/utils');
+var path = require('path');
+
+function _interopNamespaceDefault(e) {
+  var n = Object.create(null);
+  if (e) {
+    Object.keys(e).forEach(function (k) {
+      if (k !== 'default') {
+        var d = Object.getOwnPropertyDescriptor(e, k);
+        Object.defineProperty(n, k, d.get ? d : {
+          enumerable: true,
+          get: function () { return e[k]; }
+        });
+      }
+    });
+  }
+  n.default = e;
+  return Object.freeze(n);
+}
+
+var path__namespace = /*#__PURE__*/_interopNamespaceDefault(path);
+
+var SymbolFlags = /* @__PURE__ */ ((SymbolFlags2) => {
+  SymbolFlags2[SymbolFlags2["Class"] = 32] = "Class";
+  return SymbolFlags2;
+})(SymbolFlags || {});
+
+const noClassInInterface = utils.ESLintUtils.RuleCreator.withoutDocs({
+  meta: {
+    type: "problem",
+    docs: {
+      description: "Disallow class types in interface properties"
+    },
+    messages: {
+      noClassInInterfaceProps: "Interface property '{{ propertyName }}' should not use class type '{{ typeName }}'. Consider using an interface or type alias instead."
+    },
+    schema: []
+  },
+  defaultOptions: [],
+  create(context) {
+    const parserServices = utils.ESLintUtils.getParserServices(context);
+    return {
+      TSInterfaceDeclaration(node) {
+        for (const property of node.body.body) {
+          if (property.type !== utils.AST_NODE_TYPES.TSPropertySignature || property.key.type !== utils.AST_NODE_TYPES.Identifier) {
+            continue;
+          }
+          const type = parserServices.getTypeAtLocation(property);
+          if (!type.symbol) continue;
+          const isClass = type.symbol.flags === SymbolFlags.Class;
+          if (!isClass) continue;
+          context.report({
+            node: property,
+            messageId: "noClassInInterfaceProps",
+            data: {
+              propertyName: property.key.name,
+              typeName: type.symbol.name
+            }
+          });
+        }
+      }
+    };
+  }
+});
+
+const toPascalCase = (str) => {
+  return str.split(/[-_\s]/).map((word) => {
+    return word.replace(/([A-Z])/g, " $1").split(/\s+/).map(
+      (part) => part.charAt(0).toUpperCase() + part.slice(1).toLowerCase()
+    ).join("");
+  }).join("");
+};
+
+const isConstructOrStackType = (type) => {
+  return isTargetSuperClassType(
+    type,
+    ["Construct", "Stack"],
+    isConstructOrStackType
+  );
+};
+const isConstructType = (type) => {
+  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))) {
+    return true;
+  }
+  const baseTypes = type.getBaseTypes() || [];
+  return baseTypes.some((baseType) => typeCheckFunction(baseType));
+};
+
+const noConstructStackSuffix = utils.ESLintUtils.RuleCreator.withoutDocs({
+  meta: {
+    type: "problem",
+    docs: {
+      description: "Effort to avoid using 'Construct' and 'Stack' suffix in construct id."
+    },
+    messages: {
+      noConstructStackSuffix: "{{ classType }} ID '{{ id }}' should not include {{ suffix }} suffix."
+    },
+    schema: []
+  },
+  defaultOptions: [],
+  create(context) {
+    const parserServices = utils.ESLintUtils.getParserServices(context);
+    return {
+      NewExpression(node) {
+        const type = parserServices.getTypeAtLocation(node);
+        if (!isConstructOrStackType(type) || node.arguments.length < 2) {
+          return;
+        }
+        validateConstructId$3(node, context);
+      }
+    };
+  }
+});
+const validateConstructId$3 = (node, context) => {
+  const secondArg = node.arguments[1];
+  if (secondArg.type !== utils.AST_NODE_TYPES.Literal || typeof secondArg.value !== "string") {
+    return;
+  }
+  const formattedConstructId = toPascalCase(secondArg.value);
+  if (formattedConstructId.endsWith("Construct")) {
+    context.report({
+      node,
+      messageId: "noConstructStackSuffix",
+      data: {
+        classType: "Construct",
+        id: secondArg.value,
+        suffix: "Construct"
+      }
+    });
+  } else if (formattedConstructId.endsWith("Stack")) {
+    context.report({
+      node,
+      messageId: "noConstructStackSuffix",
+      data: {
+        classType: "Stack",
+        id: secondArg.value,
+        suffix: "Stack"
+      }
+    });
+  }
+};
+
+const 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(context) {
+    return {
+      ImportDeclaration(node) {
+        const importPath = node.source.value?.toString() ?? "";
+        const currentFilePath = context.filename;
+        const currentDirPath = path__namespace.dirname(currentFilePath);
+        if (!importPath.includes("/private")) return;
+        const absoluteCurrentDirPath = path__namespace.resolve(currentDirPath);
+        const absoluteImportPath = path__namespace.resolve(currentDirPath, importPath);
+        const importDirBeforePrivate = absoluteImportPath.split("/private")[0];
+        const currentDirSegments = getDirSegments(absoluteCurrentDirPath);
+        const importDirSegments = getDirSegments(importDirBeforePrivate);
+        if (currentDirSegments.length !== importDirSegments.length || currentDirSegments.some(
+          (segment, index) => segment !== importDirSegments[index]
+        )) {
+          context.report({ node, messageId: "noImportPrivate" });
+        }
+      }
+    };
+  }
+};
+const getDirSegments = (dirPath) => {
+  return dirPath.split(path__namespace.sep).filter((segment) => segment !== "");
+};
+
+const noMutablePropsInterface = utils.ESLintUtils.RuleCreator.withoutDocs({
+  meta: {
+    type: "problem",
+    docs: {
+      description: "Disallow mutable properties in Props interfaces"
+    },
+    fixable: "code",
+    messages: {
+      noMutablePropsInterface: "Property '{{ propertyName }}' in Props interface should be readonly."
+    },
+    schema: []
+  },
+  defaultOptions: [],
+  create(context) {
+    return {
+      TSInterfaceDeclaration(node) {
+        const sourceCode = context.sourceCode;
+        if (!node.id.name.endsWith("Props")) return;
+        for (const property of node.body.body) {
+          if (property.type !== utils.AST_NODE_TYPES.TSPropertySignature || property.key.type !== utils.AST_NODE_TYPES.Identifier) {
+            continue;
+          }
+          if (property.readonly) continue;
+          context.report({
+            node: property,
+            messageId: "noMutablePropsInterface",
+            data: {
+              propertyName: property.key.name
+            },
+            fix: (fixer) => {
+              const propertyText = sourceCode.getText(property);
+              return fixer.replaceText(property, `readonly ${propertyText}`);
+            }
+          });
+        }
+      }
+    };
+  }
+});
+
+const noMutablePublicFields = utils.ESLintUtils.RuleCreator.withoutDocs({
+  meta: {
+    type: "problem",
+    docs: {
+      description: "Disallow mutable public class fields"
+    },
+    fixable: "code",
+    messages: {
+      noMutablePublicFields: "Public field '{{ propertyName }}' should be readonly. Consider adding the 'readonly' modifier."
+    },
+    schema: []
+  },
+  defaultOptions: [],
+  create(context) {
+    const parserServices = utils.ESLintUtils.getParserServices(context);
+    return {
+      ClassDeclaration(node) {
+        const sourceCode = context.sourceCode;
+        const type = parserServices.getTypeAtLocation(node);
+        if (!isConstructOrStackType(type)) return;
+        for (const member of node.body.body) {
+          if (member.type !== utils.AST_NODE_TYPES.PropertyDefinition || member.key.type !== utils.AST_NODE_TYPES.Identifier) {
+            continue;
+          }
+          if (["private", "protected"].includes(member.accessibility ?? "")) {
+            continue;
+          }
+          if (member.readonly) continue;
+          context.report({
+            node: member,
+            messageId: "noMutablePublicFields",
+            data: {
+              propertyName: member.key.name
+            },
+            fix: (fixer) => {
+              const accessibility = member.accessibility ? "public " : "";
+              const paramText = sourceCode.getText(member);
+              const [key, value] = paramText.split(":");
+              const replacedKey = key.startsWith("public ") ? key.replace("public ", "") : key;
+              return fixer.replaceText(
+                member,
+                `${accessibility}readonly ${replacedKey}:${value}`
+              );
+            }
+          });
+        }
+      }
+    };
+  }
+});
+
+const noParentNameConstructIdMatch = utils.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(context) {
+      return {
+        ClassBody(node) {
+          const parent = node.parent;
+          if (parent?.type !== utils.AST_NODE_TYPES.ClassDeclaration) return;
+          const parentClassName = parent.id?.name;
+          if (!parentClassName) return;
+          for (const body of node.body) {
+            if (body.type !== utils.AST_NODE_TYPES.MethodDefinition || !["method", "constructor"].includes(body.kind) || body.value.type !== utils.AST_NODE_TYPES.FunctionExpression) {
+              continue;
+            }
+            validateConstructorBody({
+              node,
+              expression: body.value,
+              parentClassName,
+              context
+            });
+          }
+        }
+      };
+    }
+  }
+);
+const validateConstructorBody = ({
+  node,
+  expression,
+  parentClassName,
+  context
+}) => {
+  for (const statement of expression.body.body) {
+    switch (statement.type) {
+      case utils.AST_NODE_TYPES.VariableDeclaration: {
+        const newExpression = statement.declarations[0].init;
+        if (newExpression?.type !== utils.AST_NODE_TYPES.NewExpression) continue;
+        validateConstructId$2({
+          node,
+          context,
+          expression: newExpression,
+          parentClassName
+        });
+        break;
+      }
+      case utils.AST_NODE_TYPES.ExpressionStatement: {
+        if (statement.expression?.type !== utils.AST_NODE_TYPES.NewExpression) break;
+        validateStatement({
+          node,
+          statement,
+          parentClassName,
+          context
+        });
+        break;
+      }
+      case utils.AST_NODE_TYPES.IfStatement: {
+        traverseStatements({
+          node,
+          context,
+          parentClassName,
+          statement: statement.consequent
+        });
+        break;
+      }
+      case utils.AST_NODE_TYPES.SwitchStatement: {
+        for (const switchCase of statement.cases) {
+          for (const statement2 of switchCase.consequent) {
+            traverseStatements({
+              node,
+              context,
+              parentClassName,
+              statement: statement2
+            });
+          }
+        }
+        break;
+      }
+    }
+  }
+};
+const traverseStatements = ({
+  node,
+  statement,
+  parentClassName,
+  context
+}) => {
+  switch (statement.type) {
+    case utils.AST_NODE_TYPES.BlockStatement: {
+      for (const body of statement.body) {
+        validateStatement({
+          node,
+          statement: body,
+          parentClassName,
+          context
+        });
+      }
+      break;
+    }
+    case utils.AST_NODE_TYPES.ExpressionStatement: {
+      const newExpression = statement.expression;
+      if (newExpression?.type !== utils.AST_NODE_TYPES.NewExpression) break;
+      validateStatement({
+        node,
+        statement,
+        parentClassName,
+        context
+      });
+      break;
+    }
+    case utils.AST_NODE_TYPES.VariableDeclaration: {
+      const newExpression = statement.declarations[0].init;
+      if (newExpression?.type !== utils.AST_NODE_TYPES.NewExpression) break;
+      validateConstructId$2({
+        node,
+        context,
+        expression: newExpression,
+        parentClassName
+      });
+      break;
+    }
+  }
+};
+const validateStatement = ({
+  node,
+  statement,
+  parentClassName,
+  context
+}) => {
+  switch (statement.type) {
+    case utils.AST_NODE_TYPES.VariableDeclaration: {
+      const newExpression = statement.declarations[0].init;
+      if (newExpression?.type !== utils.AST_NODE_TYPES.NewExpression) break;
+      validateConstructId$2({
+        node,
+        context,
+        expression: newExpression,
+        parentClassName
+      });
+      break;
+    }
+    case utils.AST_NODE_TYPES.ExpressionStatement: {
+      const newExpression = statement.expression;
+      if (newExpression?.type !== utils.AST_NODE_TYPES.NewExpression) break;
+      validateConstructId$2({
+        node,
+        context,
+        expression: newExpression,
+        parentClassName
+      });
+      break;
+    }
+    case utils.AST_NODE_TYPES.IfStatement: {
+      validateIfStatement({
+        node,
+        statement,
+        parentClassName,
+        context
+      });
+      break;
+    }
+    case utils.AST_NODE_TYPES.SwitchStatement: {
+      validateSwitchStatement({
+        node,
+        statement,
+        parentClassName,
+        context
+      });
+      break;
+    }
+  }
+};
+const validateIfStatement = ({
+  node,
+  statement,
+  parentClassName,
+  context
+}) => {
+  traverseStatements({
+    node,
+    context,
+    parentClassName,
+    statement: statement.consequent
+  });
+};
+const validateSwitchStatement = ({
+  node,
+  statement,
+  parentClassName,
+  context
+}) => {
+  for (const caseStatement of statement.cases) {
+    for (const _consequent of caseStatement.consequent) {
+      traverseStatements({
+        node,
+        context,
+        parentClassName,
+        statement: _consequent
+      });
+    }
+  }
+};
+const validateConstructId$2 = ({
+  node,
+  context,
+  expression,
+  parentClassName
+}) => {
+  if (expression.arguments.length < 2) return;
+  const secondArg = expression.arguments[1];
+  if (secondArg.type !== utils.AST_NODE_TYPES.Literal || typeof secondArg.value !== "string") {
+    return;
+  }
+  const formattedConstructId = toPascalCase(secondArg.value);
+  const formattedParentClassName = toPascalCase(parentClassName);
+  if (formattedParentClassName !== formattedConstructId) return;
+  context.report({
+    node,
+    messageId: "noParentNameConstructIdMatch",
+    data: {
+      constructId: secondArg.value,
+      parentConstructName: parentClassName
+    }
+  });
+};
+
+const noPublicClassFields = utils.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 = utils.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 === utils.AST_NODE_TYPES.MethodDefinition && member.kind === "constructor"
+        );
+        if (!constructor || constructor.value.type !== utils.AST_NODE_TYPES.FunctionExpression) {
+          return;
+        }
+        validateConstructorParameterProperty(
+          constructor,
+          context,
+          parserServices
+        );
+      }
+    };
+  }
+});
+const validateClassMember = (node, context, parserServices) => {
+  for (const member of node.body.body) {
+    if (member.type !== utils.AST_NODE_TYPES.PropertyDefinition || member.key.type !== utils.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 === SymbolFlags.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 !== utils.AST_NODE_TYPES.TSParameterProperty || param.parameter.type !== utils.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 === SymbolFlags.Class;
+    if (!isClass) continue;
+    context.report({
+      node: param,
+      messageId: "noPublicClassFields",
+      data: {
+        propertyName: param.parameter.name,
+        typeName: type.symbol.name
+      }
+    });
+  }
+};
+
+const noVariableConstructId = utils.ESLintUtils.RuleCreator.withoutDocs({
+  meta: {
+    type: "problem",
+    docs: {
+      description: `Enforce using literal strings for Construct ID.`
+    },
+    messages: {
+      noVariableConstructId: "Shouldn't use a parameter as a Construct ID."
+    },
+    schema: []
+  },
+  defaultOptions: [],
+  create(context) {
+    const parserServices = utils.ESLintUtils.getParserServices(context);
+    return {
+      NewExpression(node) {
+        const type = parserServices.getTypeAtLocation(node);
+        if (!isConstructType(type) || isStackType(type) || node.arguments.length < 2) {
+          return;
+        }
+        validateConstructId$1(node, context);
+      }
+    };
+  }
+});
+const validateConstructId$1 = (node, context) => {
+  if (node.arguments.length < 2 || isInsideLoop(node)) return;
+  const secondArg = node.arguments[1];
+  if (secondArg.type === utils.AST_NODE_TYPES.Literal && typeof secondArg.value === "string") {
+    return;
+  }
+  if (secondArg.type === utils.AST_NODE_TYPES.TemplateLiteral && !secondArg.expressions.length) {
+    return;
+  }
+  context.report({
+    node,
+    messageId: "noVariableConstructId"
+  });
+};
+const isInsideLoop = (node) => {
+  let current = node.parent;
+  while (current) {
+    if (current.type === utils.AST_NODE_TYPES.ForStatement || current.type === utils.AST_NODE_TYPES.ForInStatement || current.type === utils.AST_NODE_TYPES.ForOfStatement || current.type === utils.AST_NODE_TYPES.WhileStatement || current.type === utils.AST_NODE_TYPES.DoWhileStatement) {
+      return true;
+    }
+    current = current.parent;
+  }
+  return false;
+};
+
+const QUOTE_TYPE = {
+  SINGLE: "'",
+  DOUBLE: '"'
+};
+const pascalCaseConstructId = utils.ESLintUtils.RuleCreator.withoutDocs({
+  meta: {
+    type: "problem",
+    docs: {
+      description: "Enforce PascalCase for Construct ID."
+    },
+    messages: {
+      pascalCaseConstructId: "Construct ID must be PascalCase."
+    },
+    schema: [],
+    fixable: "code"
+  },
+  defaultOptions: [],
+  create(context) {
+    const parserServices = utils.ESLintUtils.getParserServices(context);
+    return {
+      NewExpression(node) {
+        const type = parserServices.getTypeAtLocation(node);
+        if (!isConstructOrStackType(type) || node.arguments.length < 2) {
+          return;
+        }
+        validateConstructId(node, context);
+      }
+    };
+  }
+});
+const isPascalCase = (str) => {
+  return /^[A-Z][a-zA-Z0-9]*$/.test(str);
+};
+const validateConstructId = (node, context) => {
+  if (node.arguments.length < 2) return;
+  const secondArg = node.arguments[1];
+  if (secondArg.type !== utils.AST_NODE_TYPES.Literal || typeof secondArg.value !== "string") {
+    return;
+  }
+  const quote = secondArg.raw?.startsWith('"') ? QUOTE_TYPE.DOUBLE : QUOTE_TYPE.SINGLE;
+  if (isPascalCase(secondArg.value)) return;
+  context.report({
+    node,
+    messageId: "pascalCaseConstructId",
+    fix: (fixer) => {
+      const pascalCaseValue = toPascalCase(secondArg.value);
+      return fixer.replaceText(secondArg, `${quote}${pascalCaseValue}${quote}`);
+    }
+  });
+};
+
+const requirePassingThis = utils.ESLintUtils.RuleCreator.withoutDocs({
+  meta: {
+    type: "problem",
+    docs: {
+      description: "Require passing `this` in a constructor."
+    },
+    messages: {
+      requirePassingThis: "Require passing `this` in a constructor."
+    },
+    schema: [],
+    fixable: "code"
+  },
+  defaultOptions: [],
+  create(context) {
+    const parserServices = utils.ESLintUtils.getParserServices(context);
+    return {
+      NewExpression(node) {
+        const type = parserServices.getTypeAtLocation(node);
+        if (!isConstructType(type) || isStackType(type) || !node.arguments.length) {
+          return;
+        }
+        const argument = node.arguments[0];
+        if (argument.type === utils.AST_NODE_TYPES.ThisExpression) return;
+        context.report({
+          node,
+          messageId: "requirePassingThis",
+          fix: (fixer) => {
+            return fixer.replaceText(argument, "this");
+          }
+        });
+      }
+    };
+  }
+});
+
+const rules = {
+  "no-class-in-interface": noClassInInterface,
+  "no-construct-stack-suffix": noConstructStackSuffix,
+  "no-parent-name-construct-id-match": noParentNameConstructIdMatch,
+  "no-public-class-fields": noPublicClassFields,
+  "pascal-case-construct-id": pascalCaseConstructId,
+  "no-mutable-public-fields": noMutablePublicFields,
+  "no-mutable-props-interface": noMutablePropsInterface,
+  "require-passing-this": requirePassingThis,
+  "no-variable-construct-id": noVariableConstructId,
+  "no-import-private": noImportPrivate
+};
+const configs = {
+  recommended: {
+    plugins: ["cdk"],
+    rules: {
+      "cdk/no-class-in-interface": "error",
+      "cdk/no-construct-stack-suffix": "error",
+      "cdk/no-parent-name-construct-id-match": "error",
+      "cdk/no-public-class-fields": "error",
+      "cdk/pascal-case-construct-id": "error",
+      "cdk/require-passing-this": "error",
+      "cdk/no-variable-construct-id": "error",
+      "cdk/no-mutable-public-fields": "warn",
+      "cdk/no-mutable-props-interface": "warn"
+    }
+  },
+  strict: {
+    plugins: ["cdk"],
+    rules: {
+      "cdk/no-class-in-interface": "error",
+      "cdk/no-construct-stack-suffix": "error",
+      "cdk/no-parent-name-construct-id-match": "error",
+      "cdk/no-public-class-fields": "error",
+      "cdk/pascal-case-construct-id": "error",
+      "cdk/require-passing-this": "error",
+      "cdk/no-variable-construct-id": "error",
+      "cdk/no-mutable-public-fields": "error",
+      "cdk/no-mutable-props-interface": "error",
+      "cdk/no-import-private": "error"
+    }
+  }
+};
+const eslintCdkPlugin = {
+  rules,
+  configs
+};
+
+exports.configs = configs;
+exports.default = eslintCdkPlugin;
+exports.rules = rules;