@echoes-of-order/eslint-config 1.121.0

package/rules/enforce-custom-error-classes.js

@@ -0,0 +1,242 @@
+/**
+ * ESLint-Regel: Erzwingt Custom Error-Klassen statt generischem Error
+ *
+ * Diese Regel verbietet `throw new Error()` und erzwingt die Verwendung
+ * von spezifischen Error-Klassen für bessere Fehlerbehandlung.
+ */
+
+export default {
+  meta: {
+    type: "problem",
+    docs: {
+      description: "Enforce custom error classes instead of generic Error",
+      category: "Best Practices",
+      recommended: true,
+    },
+    messages: {
+      useCustomError: "Use custom error classes instead of generic 'throw new Error()'. Use existing error classes from /src/errors/ like 'NotFoundError', 'ValidationError', 'UnauthorizedError', etc.\n\nExample for '{{suggestedName}}':\nimport {{suggestedName}} from '@/errors/{{suggestedName}}';\nthrow new {{suggestedName}}('your message');",
+      suggestCustomError: "Consider using an existing error class like '{{suggestedName}}' from /src/errors/ for this specific error case.",
+      noObjectAssignError: "Do not use Object.assign() with Error. This is an anti-pattern!\n\nInstead, use an existing custom error class from /src/errors/ like '{{suggestedName}}':\n\nimport {{suggestedName}} from '@/errors/{{suggestedName}}';\nthrow new {{suggestedName}}('{{errorMessage}}');\n\nIf '{{suggestedName}}' doesn't exist yet, create it:\n\nclass {{suggestedName}} extends Error {\n  constructor(message: string) {\n    super(message);\n    this.name = '{{suggestedName}}';\n  }\n}",
+    },
+    fixable: null,
+    schema: [
+      {
+        type: "object",
+        properties: {
+          allowedPatterns: {
+            type: "array",
+            items: { type: "string" },
+            description: "Patterns that are allowed to use generic Error",
+          },
+          exemptFiles: {
+            type: "array",
+            items: { type: "string" },
+            description: "File patterns that are exempt from this rule",
+          },
+        },
+        additionalProperties: false,
+      },
+    ],
+  },
+
+  create(context) {
+    const options = context.options[0] || {};
+    const allowedPatterns = options.allowedPatterns || [];
+    const exemptFiles = options.exemptFiles || ["**/*.test.ts", "**/*.spec.ts", "**/__tests__/**"];
+
+    const filename = context.getFilename();
+
+    // Prüfe ob Datei von der Regel ausgenommen ist
+    const isExempt = exemptFiles.some(pattern => {
+      if (pattern.includes("**")) {
+        const regex = new RegExp(pattern.replace(/\*\*/g, ".*").replace(/\*/g, "[^/]*"));
+        return regex.test(filename);
+      }
+      return filename.includes(pattern);
+    });
+
+    if (isExempt) {
+      return {};
+    }
+
+    return {
+      ThrowStatement(node) {
+        // Prüfe ob es ein 'throw new Error()' ist
+        if (
+          node.argument &&
+          node.argument.type === "NewExpression" &&
+          node.argument.callee &&
+          node.argument.callee.name === "Error"
+        ) {
+          // Prüfe ob es ein erlaubtes Pattern ist
+          const errorMessage = node.argument.arguments[0];
+          if (errorMessage && errorMessage.type === "Literal") {
+            const message = errorMessage.value;
+            const isAllowed = allowedPatterns.some(pattern =>
+              message && message.includes(pattern)
+            );
+
+            if (!isAllowed) {
+              // Generiere vorgeschlagenen Error-Klassennamen basierend auf Kontext
+              const suggestedName = generateErrorClassName(node, context);
+
+              context.report({
+                node,
+                messageId: "useCustomError",
+                data: {
+                  suggestedName,
+                },
+              });
+            }
+          } else {
+            context.report({
+              node,
+              messageId: "useCustomError",
+            });
+          }
+        }
+
+        // Prüfe ob es ein 'throw Object.assign(new Error(), ...)' ist
+        if (
+          node.argument &&
+          node.argument.type === "CallExpression" &&
+          node.argument.callee &&
+          node.argument.callee.type === "MemberExpression" &&
+          node.argument.callee.object &&
+          node.argument.callee.object.name === "Object" &&
+          node.argument.callee.property &&
+          node.argument.callee.property.name === "assign"
+        ) {
+          // Prüfe ob das erste Argument 'new Error()' ist
+          const firstArg = node.argument.arguments[0];
+          if (
+            firstArg &&
+            firstArg.type === "NewExpression" &&
+            firstArg.callee &&
+            firstArg.callee.name === "Error"
+          ) {
+            const suggestedName = generateErrorClassName(node, context);
+
+            // Extrahiere Error-Message für bessere Fehlermeldung
+            let errorMessage = "your error message";
+            if (firstArg.arguments && firstArg.arguments[0]) {
+              const messageArg = firstArg.arguments[0];
+              if (messageArg.type === "Literal") {
+                errorMessage = String(messageArg.value);
+              } else if (messageArg.type === "TemplateLiteral" && messageArg.quasis && messageArg.quasis[0]) {
+                errorMessage = messageArg.quasis[0].value.raw;
+              }
+            }
+
+            context.report({
+              node,
+              messageId: "noObjectAssignError",
+              data: {
+                suggestedName,
+                errorMessage,
+              },
+            });
+          }
+        }
+      },
+    };
+  },
+};
+
+/**
+ * Generiert einen vorgeschlagenen Error-Klassennamen basierend auf dem Kontext
+ */
+function generateErrorClassName(node, context) {
+  const filename = context.getFilename();
+  const functionName = getFunctionName(node, context);
+
+  // Extrahiere Entity/Service-Namen aus Dateiname
+  const fileNameMatch = filename.match(/\/([^/]+)Service\.ts$/);
+  const entityName = fileNameMatch ? fileNameMatch[1] : "Unknown";
+
+  // Extrahiere Error-Message aus verschiedenen Strukturen
+  let errorMessage = null;
+
+  // Fall 1: throw new Error("message")
+  if (node.argument && node.argument.type === "NewExpression" && node.argument.arguments[0]) {
+    errorMessage = node.argument.arguments[0];
+  }
+
+  // Fall 2: throw Object.assign(new Error("message"), {...})
+  if (node.argument && node.argument.type === "CallExpression") {
+    const firstArg = node.argument.arguments[0];
+    if (firstArg && firstArg.type === "NewExpression" && firstArg.arguments[0]) {
+      errorMessage = firstArg.arguments[0];
+    }
+  }
+
+  // Generiere basierend auf Error-Message
+  if (errorMessage && (errorMessage.type === "Literal" || errorMessage.type === "TemplateLiteral")) {
+    let message = "";
+
+    if (errorMessage.type === "Literal") {
+      message = String(errorMessage.value).toLowerCase();
+    } else if (errorMessage.type === "TemplateLiteral" && errorMessage.quasis) {
+      // Kombiniere alle quasi-Teile für vollständige Message-Analyse
+      message = errorMessage.quasis.map(q => q.value.raw).join('').toLowerCase();
+    }
+
+    if (message.includes("not found")) {
+      // Versuche spezifischen Entity-Namen aus der ORIGINAL-Message zu extrahieren (nicht lowercase!)
+      // Hole die Original-Message
+      let originalMessage = "";
+      if (errorMessage.type === "Literal") {
+        originalMessage = String(errorMessage.value);
+      } else if (errorMessage.type === "TemplateLiteral" && errorMessage.quasis) {
+        // Kombiniere alle quasi-Teile für vollständige Original-Message
+        originalMessage = errorMessage.quasis.map(q => q.value.raw).join('');
+      }
+
+      // Pattern: "ItemStatsType with id" oder "User not found" (mit Original-Groß-/Kleinschreibung)
+      const match1 = originalMessage.match(/^([A-Za-z][A-Za-z0-9]*)\s+(?:with|not found)/);
+      if (match1 && match1[1]) {
+        return `${match1[1]}NotFoundError`;
+      }
+
+      return `${entityName}NotFoundError`;
+    }
+    if (message.includes("invalid") || message.includes("validation")) {
+      return `Invalid${entityName}Error`;
+    }
+    if (message.includes("unauthorized") || message.includes("permission")) {
+      return `Unauthorized${entityName}Error`;
+    }
+    if (message.includes("already exists") || message.includes("duplicate")) {
+      return `${entityName}AlreadyExistsError`;
+    }
+  }
+
+  // Fallback basierend auf Funktionsname
+  if (functionName) {
+    return `${functionName}Error`;
+  }
+
+  return `${entityName}Error`;
+}
+
+/**
+ * Findet den Funktionsnamen, in dem der Error geworfen wird
+ */
+function getFunctionName(node, context) {
+  let current = node.parent;
+
+  while (current) {
+    if (current.type === "FunctionDeclaration" && current.id) {
+      return current.id.name;
+    }
+    if (current.type === "MethodDefinition" && current.key) {
+      return current.key.name;
+    }
+    if (current.type === "ArrowFunctionExpression" && current.parent && current.parent.type === "VariableDeclarator" && current.parent.id) {
+      return current.parent.id.name;
+    }
+    current = current.parent;
+  }
+
+  return null;
+}

package/rules/enforce-database-transaction-safety.js

@@ -0,0 +1,179 @@
+/**
+ * ESLint-Regel: enforce-database-transaction-safety
+ * Stellt sicher, dass alle schreibenden Datenbankoperationen in Transaktionen eingewrapped sind
+ */
+
+/** @type {import('eslint').Rule.RuleModule} */
+const enforceDatabaseTransactionSafetyRule = {
+  meta: {
+    type: "problem",
+    docs: {
+      description: "Alle schreibenden Datenbankoperationen müssen in Transaktionen eingewrapped sein",
+      category: "Database Safety",
+      recommended: true,
+    },
+    schema: [],
+    messages: {
+      unsafeDbOperation: "Datenbankoperation '{{operation}}' muss in einer Transaktion ausgeführt werden. Verwende this.dataSource.transaction().",
+      missingTransactionImport: "Service führt Datenbankoperationen aus, aber importiert DataSource nicht.",
+      bulkOperationWithoutTransaction: "Bulk-Operationen wie '{{operation}}' müssen zwingend in Transaktionen ausgeführt werden.",
+      cascadeWithoutTransaction: "Operationen mit Cascade-Effekten müssen in Transaktionen ausgeführt werden für Rollback-Sicherheit.",
+    },
+  },
+  create(context) {
+    const filename = context.getFilename();
+    const isServiceFile = filename.includes("/service/") && filename.endsWith(".ts") && !filename.includes("test");
+
+    if (!isServiceFile) return {};
+
+    let hasDataSourceImport = false;
+    let hasTransaction = false;
+    const writingOperations = new Set();
+
+    // Schreibende Datenbankoperationen, die Transaktionen erfordern
+    const WRITING_METHODS = [
+      "save", "insert", "update", "delete", "remove", "softDelete", "recover",
+      "upsert", "createQueryBuilder", "manager", "merge"
+    ];
+
+    // Bulk-Operationen, die besonders kritisch sind
+    const BULK_METHODS = [
+      "saveBulk", "insertBulk", "updateBulk", "deleteBulk", "removeBulk"
+    ];
+
+    function isInTransactionBlock(node) {
+      // Prüfe ob sich der Knoten innerhalb eines Transaction-Callbacks befindet
+      let parent = node.parent;
+      while (parent) {
+        if (parent.type === "CallExpression") {
+          if (parent.callee?.type === "MemberExpression" &&
+              parent.callee.property?.name === "transaction") {
+            return true;
+          }
+        }
+        if (parent.type === "ArrowFunctionExpression" || parent.type === "FunctionExpression") {
+          // Prüfe ob diese Funktion ein Transaction-Callback ist
+          const grandParent = parent.parent;
+          if (grandParent?.type === "CallExpression" &&
+              grandParent.callee?.type === "MemberExpression" &&
+              grandParent.callee.property?.name === "transaction") {
+            return true;
+          }
+        }
+        parent = parent.parent;
+      }
+      return false;
+    }
+
+    function hasEntityWithCascade(node) {
+      // Vereinfachte Prüfung auf Cascade-Operationen in der Nähe
+      const sourceCode = context.getSourceCode();
+      const text = sourceCode.getText(node);
+      return text.includes("cascade") || text.includes("Cascade");
+    }
+
+    return {
+      ImportDeclaration(node) {
+        if (node.source.value === "typeorm" || node.source.value.includes("data-source")) {
+          const hasDataSourceSpecifier = node.specifiers.some(spec =>
+            (spec.type === "ImportDefaultSpecifier" && spec.local.name.includes("DataSource")) ||
+            (spec.type === "ImportSpecifier" && spec.imported.name === "DataSource")
+          );
+          if (hasDataSourceSpecifier) {
+            hasDataSourceImport = true;
+          }
+        }
+      },
+
+      CallExpression(node) {
+        // Erkenne Transaction-Blöcke
+        if (node.callee?.type === "MemberExpression" &&
+            node.callee.property?.name === "transaction") {
+          hasTransaction = true;
+        }
+
+        // Prüfe auf Repository-Operationen
+        if (node.callee?.type === "MemberExpression") {
+          const methodName = node.callee.property?.name;
+
+          if (WRITING_METHODS.includes(methodName)) {
+            writingOperations.add({
+              node,
+              operation: methodName,
+              isBulk: BULK_METHODS.includes(methodName),
+              hasCascade: hasEntityWithCascade(node),
+            });
+
+            // Prüfe ob Operation in Transaktion ist
+            if (!isInTransactionBlock(node)) {
+              if (BULK_METHODS.includes(methodName)) {
+                context.report({
+                  node,
+                  messageId: "bulkOperationWithoutTransaction",
+                  data: {
+                    operation: methodName,
+                  },
+                });
+              } else if (hasEntityWithCascade(node)) {
+                context.report({
+                  node,
+                  messageId: "cascadeWithoutTransaction",
+                });
+              } else {
+                context.report({
+                  node,
+                  messageId: "unsafeDbOperation",
+                  data: {
+                    operation: methodName,
+                  },
+                });
+              }
+            }
+          }
+        }
+
+        // Prüfe auf QueryBuilder-Operationen
+        if (node.callee?.type === "MemberExpression") {
+          const methodName = node.callee.property?.name;
+          const dangerousQueryMethods = ["execute", "getMany", "getOne"];
+
+          if (dangerousQueryMethods.includes(methodName)) {
+            // Prüfe ob es sich um eine schreibende Query handelt
+            let currentNode = node;
+            while (currentNode.parent && currentNode.parent.type === "MemberExpression") {
+              currentNode = currentNode.parent;
+            }
+
+            const sourceCode = context.getSourceCode();
+            const chainText = sourceCode.getText(currentNode);
+
+            if (chainText.includes("insert") || chainText.includes("update") ||
+                chainText.includes("delete") || chainText.includes("set")) {
+
+              if (!isInTransactionBlock(node)) {
+                context.report({
+                  node,
+                  messageId: "unsafeDbOperation",
+                  data: {
+                    operation: "QueryBuilder." + methodName,
+                  },
+                });
+              }
+            }
+          }
+        }
+      },
+
+      "Program:exit"() {
+        if (writingOperations.size > 0 && !hasDataSourceImport) {
+          context.report({
+            loc: { line: 1, column: 0 },
+            messageId: "missingTransactionImport",
+          });
+        }
+      },
+    };
+  },
+};
+
+export default enforceDatabaseTransactionSafetyRule;

package/rules/enforce-dto-constructor.js

@@ -0,0 +1,95 @@
+/**
+ * ESLint-Regel: enforce-dto-constructor
+ * Verbietet die Verwendung von Constructor-Aufrufen für DTOs - DTOs sollen mit create() erstellt werden
+ */
+
+// Hilfsfunktion um zu prüfen, ob wir uns innerhalb einer DTO-Factory-Methode befinden
+function isInsideCreateMethod(node) {
+  let parent = node.parent;
+  while (parent) {
+    // Prüfe ob wir in einer statischen Methode sind
+    if (parent.type === "MethodDefinition" &&
+        parent.static === true &&
+        parent.key.type === "Identifier" &&
+        (parent.key.name === "create" ||
+         parent.key.name === "fromEntity" ||
+         parent.key.name === "fromRequestDto" ||
+         parent.key.name === "fromEntityArray")) {
+      return true;
+    }
+
+    // Prüfe ob wir in einer normalen Methode sind (für toEntity)
+    if (parent.type === "MethodDefinition" &&
+        parent.static === false &&
+        parent.key.type === "Identifier" &&
+        parent.key.name === "toEntity") {
+      return true;
+    }
+
+    // Prüfe ob wir in einer Arrow-Function oder FunctionExpression sind, die DTO-Factory-Namen enthält
+    if ((parent.type === "ArrowFunctionExpression" || parent.type === "FunctionExpression") &&
+        parent.parent &&
+        parent.parent.type === "VariableDeclarator" &&
+        parent.parent.id.type === "Identifier" &&
+        (parent.parent.id.name.includes("create") ||
+         parent.parent.id.name.includes("fromEntity") ||
+         parent.parent.id.name.includes("toEntity"))) {
+      return true;
+    }
+
+    parent = parent.parent;
+  }
+  return false;
+}
+
+/** @type {import('eslint').Rule.RuleModule} */
+const enforceDtoConstructorRule = {
+  meta: {
+    type: "problem",
+    docs: {
+      description: "DTOs dürfen nicht mit 'new' erstellt werden, verwende stattdessen create()",
+      category: "Best Practices",
+      recommended: true,
+    },
+    fixable: "code",
+    schema: [],
+    messages: {
+      noConstructorCall: "DTOs dürfen nicht mit 'new {{dtoName}}()' erstellt werden. Verwende stattdessen {{dtoName}}.create()",
+    },
+  },
+  create(context) {
+    return {
+      // Prüfe auf Constructor-Aufrufe mit DTOs
+      NewExpression(node) {
+        if (node.callee.type === "Identifier") {
+          const className = node.callee.name;
+
+          // Prüfe ob es sich um eine DTO-Klasse handelt
+          if (className && className.endsWith("Dto")) {
+            // Prüfe ob wir uns innerhalb einer create-Methode befinden
+            if (isInsideCreateMethod(node)) {
+              return; // Erlaube 'new' innerhalb von create-Methoden
+            }
+
+            context.report({
+              node,
+              messageId: "noConstructorCall",
+              data: {
+                dtoName: className,
+              },
+              fix(fixer) {
+                return fixer.replaceText(node, `${className}.create()`);
+              },
+            });
+          }
+        }
+      },
+    };
+  },
+};
+
+export default {
+  rules: {
+    "enforce-dto-constructor": enforceDtoConstructorRule,
+  },
+};

package/rules/enforce-dto-create-parameter-types.js

@@ -0,0 +1,170 @@
+/**
+ * @fileoverview Enforce 1:1 type matching for DTO create method parameters.
+ * @author echoes-of-order
+ */
+
+import { AST_NODE_TYPES } from '@typescript-eslint/utils';
+
+export default {
+  meta: {
+    type: "problem",
+    docs: {
+      description: "Enforce that DTO create method parameters match the DTO's properties 1:1 regarding optionality.",
+      category: "Possible Errors",
+      recommended: true,
+    },
+    messages: {
+      parameterOptionalityMismatch: "Parameter '{{paramName}}' in create method has optionality mismatch with DTO property '{{propertyName}}'. DTO property is '{{dtoOptionality}}', but parameter is '{{paramOptionality}}'.",
+      propertyNotFound: "Parameter '{{paramName}}' in create method does not correspond to a property in the DTO.",
+    },
+    schema: [],
+  },
+
+  create(context) {
+    /**
+     * Extrahiert Properties aus einer Klasse (inkl. Parent-Klasse)
+     */
+    function getClassProperties(classNode) {
+      const properties = new Map();
+
+      for (const member of classNode.body.body) {
+        if (member.type === AST_NODE_TYPES.PropertyDefinition) {
+          const propertyName = member.key.name;
+          const isOptional = member.optional || false;
+          properties.set(propertyName, { isOptional });
+        }
+      }
+
+      if (classNode.superClass && classNode.superClass.type === AST_NODE_TYPES.Identifier) {
+        const sourceCode = context.getSourceCode();
+        const scope = sourceCode.getScope(classNode);
+        const parentClassVar = scope.variables.find((v) => v.name === classNode.superClass.name);
+
+        if (parentClassVar && parentClassVar.defs.length > 0) {
+          const parentDef = parentClassVar.defs[0];
+          if (parentDef.node.type === AST_NODE_TYPES.ClassDeclaration) {
+            const parentProperties = getClassProperties(parentDef.node);
+            for (const [name, info] of parentProperties) {
+              if (!properties.has(name)) {
+                properties.set(name, info);
+              }
+            }
+          }
+        }
+      }
+
+      return properties;
+    }
+
+    /**
+     * Extrahiert Properties aus einem Type Literal
+     */
+    function getTypeLiteralProperties(typeLiteral) {
+      const properties = new Map();
+
+      for (const member of typeLiteral.members) {
+        if (member.type === AST_NODE_TYPES.TSPropertySignature) {
+          const propertyName = member.key.name;
+          const isOptional = member.optional || false;
+          properties.set(propertyName, { isOptional });
+        }
+      }
+
+      return properties;
+    }
+
+    return {
+      MethodDefinition(node) {
+        if (
+          node.kind === 'method' &&
+          node.static &&
+          node.key.type === AST_NODE_TYPES.Identifier &&
+          node.key.name === 'create' &&
+          node.parent.type === AST_NODE_TYPES.ClassBody &&
+          node.parent.parent.type === AST_NODE_TYPES.ClassDeclaration
+        ) {
+          const classNode = node.parent.parent;
+
+          if (classNode.superClass) {
+            return;
+          }
+
+          const classProperties = getClassProperties(classNode);
+
+          // Find the 'data' parameter (with or without default value)
+          const dataParam = node.value.params.find(
+            (param) => {
+              if (param.type === AST_NODE_TYPES.Identifier && param.name === 'data') {
+                return true;
+              }
+              // Handle default parameters: AssignmentPattern with Identifier
+              if (param.type === AST_NODE_TYPES.AssignmentPattern &&
+                  param.left.type === AST_NODE_TYPES.Identifier &&
+                  param.left.name === 'data') {
+                return true;
+              }
+              return false;
+            }
+          );
+
+          if (!dataParam) {
+            return; // 'data' parameter not found
+          }
+
+          // Get type annotation from the parameter (handle both regular and default parameters)
+          let typeAnnotation;
+          if (dataParam.type === AST_NODE_TYPES.Identifier) {
+            typeAnnotation = dataParam.typeAnnotation;
+          } else if (dataParam.type === AST_NODE_TYPES.AssignmentPattern) {
+            typeAnnotation = dataParam.left.typeAnnotation;
+          }
+
+          if (!typeAnnotation?.typeAnnotation || typeAnnotation.typeAnnotation.type !== AST_NODE_TYPES.TSTypeLiteral) {
+            return; // type annotation not found or not an object literal
+          }
+
+          const dataTypeLiteral = typeAnnotation.typeAnnotation;
+          const dataProperties = getTypeLiteralProperties(dataTypeLiteral);
+
+          // Check each parameter property against class properties
+          for (const [paramName, paramInfo] of dataProperties) {
+            const classProperty = classProperties.get(paramName);
+
+            if (!classProperty) {
+              context.report({
+                node: dataTypeLiteral,
+                messageId: "propertyNotFound",
+                data: { paramName },
+              });
+              continue;
+            }
+
+            if (paramInfo.isOptional !== classProperty.isOptional) {
+              context.report({
+                node: dataTypeLiteral,
+                messageId: "parameterOptionalityMismatch",
+                data: {
+                  paramName,
+                  propertyName: paramName,
+                  dtoOptionality: classProperty.isOptional ? 'optional' : 'required',
+                  paramOptionality: paramInfo.isOptional ? 'optional' : 'required',
+                },
+              });
+            }
+          }
+
+          // Check if all required class properties are present in parameters
+          for (const [className, classProperty] of classProperties) {
+            if (!classProperty.isOptional && !dataProperties.has(className)) {
+              context.report({
+                node: dataTypeLiteral,
+                messageId: "propertyNotFound",
+                data: { paramName: className },
+              });
+            }
+          }
+        }
+      },
+    };
+  },
+};