@echoes-of-order/eslint-config 1.121.0

package/rules/max-classes-per-file.js

@@ -0,0 +1,49 @@
+export default {
+  meta: {
+    type: "problem",
+    docs: {
+      description: "Enforce only one class per file",
+      category: "Best Practices",
+    },
+    fixable: null,
+    schema: [],
+    messages: {
+      tooManyClasses: "Only one class per file is allowed. Found {{count}} classes: {{names}}. Please split into separate files.",
+    },
+  },
+
+  create(context) {
+    const classes = [];
+
+    function checkClasses() {
+      if (classes.length > 1) {
+        const classNames = classes.map(d => d.name);
+
+        // Report on the first class found
+        const firstClass = classes[0];
+
+        context.report({
+          node: firstClass.node,
+          messageId: "tooManyClasses",
+          data: {
+            count: classes.length,
+            names: classNames.join(", "),
+          },
+        });
+      }
+    }
+
+    return {
+      ClassDeclaration(node) {
+        classes.push({
+          node,
+          name: node.id ? node.id.name : "Anonymous",
+        });
+      },
+
+      "Program:exit"() {
+        checkClasses();
+      },
+    };
+  },
+};

package/rules/multiline-formatting.js

@@ -0,0 +1,146 @@
+/**
+ * ESLint Custom Rule: multiline-formatting
+ *
+ * Erzwingt und fixt automatisch Zeilenumbrüche bei:
+ * 1. Langen Method-Chains (.filter().map())
+ * 2. Langen Property-Zuweisungen
+ * 3. Objekten mit mehreren Properties
+ *
+ * ❌ Falsch:
+ * items: result.items.filter((item): item is ItemEntity => item !== null).map((item) => ItemEntityDto.fromEntity(item)),
+ *
+ * ✅ Richtig:
+ * items: result.items
+ *   .filter((item): item is ItemEntity => item !== null)
+ *   .map((item) => ItemEntityDto.fromEntity(item)),
+ */
+
+export default {
+  meta: {
+    type: "layout",
+    docs: {
+      description: "Automatische Zeilenumbrüche bei langen Ausdrücken",
+      category: "Stylistic Issues",
+      recommended: true,
+    },
+    fixable: "whitespace",
+    messages: {
+      tooLongLine: "Diese Zeile ist zu lang ({{length}} Zeichen, max {{max}}). Breche sie um.",
+      methodChainShouldBreak: "Method-Chains sollten auf separate Zeilen umgebrochen werden.",
+    },
+    schema: [{
+      type: "object",
+      properties: {
+        maxLength: {
+          type: "number",
+          default: 120,
+        },
+      },
+      additionalProperties: false,
+    }],
+  },
+
+  create (context) {
+    const sourceCode = context.sourceCode ?? context.getSourceCode();
+    const maxLength = context.options[0]?.maxLength ?? 120;
+
+    function getLineLength (node) {
+      const start = node.loc.start;
+      const end = node.loc.end;
+
+      if (start.line === end.line) {
+        return sourceCode.lines[start.line - 1]?.length ?? 0;
+      }
+
+      return 0;
+    }
+
+    function fixMethodChain (fixer, node) {
+      const text = sourceCode.getText(node);
+      const fixes = [];
+
+      if (node.type === "CallExpression" && node.callee.type === "MemberExpression") {
+        const chain = [];
+        let current = node;
+
+        while (current.type === "CallExpression" && current.callee.type === "MemberExpression") {
+          chain.unshift(current);
+          current = current.callee.object;
+        }
+
+        if (chain.length > 1) {
+          const baseObject = sourceCode.getText(current);
+          const indent = " ".repeat(node.loc.start.column);
+
+          let newCode = baseObject;
+
+          for (const call of chain) {
+            const methodName = call.callee.property.name;
+            const args = call.arguments.map((arg) => sourceCode.getText(arg)).join(", ");
+            newCode += `\n${indent}  .${methodName}(${args})`;
+          }
+
+          return fixer.replaceText(node, newCode);
+        }
+      }
+
+      return null;
+    }
+
+    return {
+      CallExpression (node) {
+        const lineLength = getLineLength(node);
+
+        if (lineLength > maxLength && node.callee.type === "MemberExpression") {
+          let current = node;
+          let chainLength = 0;
+
+          while (current.type === "CallExpression" && current.callee.type === "MemberExpression") {
+            chainLength++;
+            current = current.callee.object;
+          }
+
+          if (chainLength > 1) {
+            context.report({
+              node,
+              messageId: "methodChainShouldBreak",
+              fix (fixer) {
+                return fixMethodChain(fixer, node);
+              },
+            });
+          }
+        }
+      },
+
+      Property (node) {
+        if (node.value && node.value.type === "CallExpression") {
+          const lineLength = getLineLength(node);
+
+          if (lineLength > maxLength) {
+            const valueNode = node.value;
+
+            if (valueNode.callee.type === "MemberExpression") {
+              let current = valueNode;
+              let chainLength = 0;
+
+              while (current.type === "CallExpression" && current.callee.type === "MemberExpression") {
+                chainLength++;
+                current = current.callee.object;
+              }
+
+              if (chainLength > 1) {
+                context.report({
+                  node: valueNode,
+                  messageId: "methodChainShouldBreak",
+                  fix (fixer) {
+                    return fixMethodChain(fixer, valueNode);
+                  },
+                });
+              }
+            }
+          }
+        }
+      },
+    };
+  },
+};

package/rules/no-blank-lines-between-decorators-and-properties.js

@@ -0,0 +1,95 @@
+/**
+ * @fileoverview Verbot von Leerzeilen zwischen Dekoratoren und Properties
+ * @author Echoes of Order Team
+ */
+
+export default {
+  meta: {
+    type: "layout",
+    docs: {
+      description: "Verbot von Leerzeilen zwischen Dekoratoren und Properties",
+      category: "Stylistic Issues",
+      recommended: false,
+    },
+    fixable: "whitespace",
+    schema: [],
+    messages: {
+      noBlankLinesBetweenDecoratorsAndProperties:
+        "Leerzeilen zwischen Dekoratoren und Properties sind nicht erlaubt. Entferne die Leerzeile(n)."
+    }
+  },
+
+  create(context) {
+    const sourceCode = context.getSourceCode();
+
+    function checkForBlankLinesBetweenDecoratorsAndProperties(node) {
+      // Nur für Property-Definitionen prüfen
+      if (node.type !== "PropertyDefinition" && node.type !== "MethodDefinition") {
+        return;
+      }
+
+      // Prüfen ob das Property/Method Dekoratoren hat
+      if (!node.decorators || node.decorators.length === 0) {
+        return;
+      }
+
+      const lastDecorator = node.decorators[node.decorators.length - 1];
+      const propertyStart = node.key ? node.key.loc.start : node.loc.start;
+
+      // Alle Tokens zwischen dem letzten Dekorator und dem Property finden
+      const tokens = sourceCode.getTokensBetween(lastDecorator, node);
+
+      // Nach Leerzeilen suchen
+      let hasBlankLines = false;
+
+      for (let i = 0; i < tokens.length; i++) {
+        const token = tokens[i];
+
+        if (token.type === "Punctuator" && token.value === "@") {
+          // Wenn wir einen weiteren Dekorator finden, stoppen
+          break;
+        }
+
+        // Nach Leerzeilen suchen
+        if (token.type === "Whitespace" || token.type === "Line") {
+          const lines = token.value.split("\n");
+          if (lines.length > 2) { // Mehr als eine Leerzeile
+            hasBlankLines = true;
+          }
+        }
+      }
+
+      // Alternative Prüfung über Zeilen
+      const lastDecoratorLine = lastDecorator.loc.end.line;
+      const propertyLine = propertyStart.line;
+
+      if (propertyLine - lastDecoratorLine > 1) {
+        hasBlankLines = true;
+      }
+
+      if (hasBlankLines) {
+        context.report({
+          node,
+          messageId: "noBlankLinesBetweenDecoratorsAndProperties",
+          fix(fixer) {
+            // Alle Leerzeilen zwischen Dekorator und Property entfernen
+            const range = [
+              lastDecorator.range[1],
+              node.range[0]
+            ];
+
+            const text = sourceCode.text.slice(range[0], range[1]);
+            const cleanedText = text.replace(/\n\s*\n/g, "\n");
+
+            return fixer.replaceTextRange(range, cleanedText);
+          }
+        });
+      }
+    }
+
+    return {
+      PropertyDefinition: checkForBlankLinesBetweenDecoratorsAndProperties,
+      MethodDefinition: checkForBlankLinesBetweenDecoratorsAndProperties
+    };
+  }
+};

package/rules/no-comments.js

@@ -0,0 +1,62 @@
+/**
+ * No Comments Rules
+ *
+ * Verbot von Kommentaren im Code
+ */
+
+export default {
+  rules: {
+    // No-Comments-Regel
+    "no-comments/no-comments": {
+      meta: {
+        type: "problem",
+        docs: {
+          description: "Disallow comments in code",
+          category: "Stylistic Issues",
+          recommended: false,
+        },
+        fixable: null,
+        schema: [],
+      },
+      create (context) {
+        const sourceCode = context.getSourceCode();
+        return {
+          Program () {
+            const comments = sourceCode.getAllComments();
+            comments.forEach((comment) => {
+              const value = comment.value.trim();
+              if (value.startsWith("eslint-disable")
+                || value.startsWith("eslint-enable")
+                || value.startsWith("@ts-ignore")
+                || value.startsWith("@ts-expect-error")
+                || value.startsWith("@ts-nocheck")
+                || value.startsWith("@ts-check")
+                || value.includes("prettier-ignore")
+                || value.includes("istanbul ignore")
+                || value.includes("c8 ignore")
+                || value.includes("coverage ignore")
+                || value.includes("codecov ignore")
+                || value.startsWith("SPDX-License-Identifier")
+                || value.startsWith("Copyright")
+                || value.startsWith("(c)")
+                || value.startsWith("MIT License")
+                || value.includes("Apache License")
+                || value.includes("GPL")
+                || value.includes("BSD")
+                || value.includes("ISC License")
+              ) {
+                return;
+              }
+              context.report({
+                node: comment,
+                message: "Comments are not allowed in code. Code should be self-explanatory.",
+              });
+            });
+          },
+        };
+      },
+    },
+  },
+};
+
+

package/rules/no-dto-constructors.js

@@ -0,0 +1,126 @@
+/**
+ * @fileoverview Verbietet Konstruktoren in DTO-Klassen
+ * DTOs sind reine Datencontainer und sollten keine Konstruktoren haben.
+ * Sie werden automatisch von class-transformer aus JSON erstellt.
+ */
+
+export default {
+  meta: {
+    type: "error",
+    docs: {
+      description: "Forbid constructors in DTO classes - DTOs should be pure data containers",
+      category: "Best Practices",
+      recommended: true,
+    },
+    fixable: "code",
+    schema: [],
+    messages: {
+      noDtoConstructor: "DTO class '{{className}}' must not have a constructor. DTOs are pure data containers that are automatically instantiated by class-transformer from JSON. Remove the constructor and let the framework handle object creation.",
+      constructorRemoved: "Constructor removed from DTO class '{{className}}'",
+    },
+  },
+
+  create(context) {
+    const filename = context.getFilename();
+
+    // Ignoriere Test-Dateien und Non-DTO-Dateien
+    if (!filename.includes("/dto/") ||
+        filename.includes("test") ||
+        filename.includes("spec") ||
+        filename.includes("__tests__") ||
+        filename.endsWith(".test.ts") ||
+        filename.endsWith(".spec.ts")) {
+      return {};
+    }
+
+    function isDtoClass(className) {
+      return (
+        className.endsWith("Dto") ||
+        className.endsWith("DTO") ||
+        className.includes("Request") ||
+        className.includes("Response") ||
+        className.includes("Create") ||
+        className.includes("Update") ||
+        className.includes("Delete")
+      );
+    }
+
+    function isInDtoClass(node) {
+      let parent = node.parent;
+
+      // Traverse up to find the class declaration
+      while (parent) {
+        if (parent.type === "ClassDeclaration" ||
+            (parent.type === "ExportDefaultDeclaration" && parent.declaration?.type === "ClassDeclaration")) {
+
+          const classNode = parent.type === "ClassDeclaration" ? parent : parent.declaration;
+          const className = classNode.id?.name;
+
+          if (className && isDtoClass(className)) {
+            return { isDto: true, className, classNode };
+          }
+          break;
+        }
+        parent = parent.parent;
+      }
+
+      return { isDto: false, className: null, classNode: null };
+    }
+
+    return {
+      MethodDefinition(node) {
+        // Prüfe nur Konstruktoren
+        if (node.kind !== "constructor") {
+          return;
+        }
+
+        const { isDto, className } = isInDtoClass(node);
+
+        if (isDto) {
+          context.report({
+            node,
+            messageId: "noDtoConstructor",
+            data: {
+              className: className || "unknown"
+            },
+            fix(fixer) {
+              const sourceCode = context.getSourceCode();
+
+              // Finde den Konstruktor-Block
+              const constructorStart = node.range[0];
+              const constructorEnd = node.range[1];
+
+              // Prüfe, ob es Leerzeilen vor/nach dem Konstruktor gibt
+              const beforeConstructor = sourceCode.getText().substring(0, constructorStart);
+              const afterConstructor = sourceCode.getText().substring(constructorEnd);
+
+              // Entferne auch überflüssige Leerzeilen
+              let startPos = constructorStart;
+              let endPos = constructorEnd;
+
+              // Prüfe auf Leerzeilen vor dem Konstruktor
+              const lines = beforeConstructor.split('\n');
+              if (lines.length > 1 && lines[lines.length - 1].trim() === '') {
+                // Finde die Position der letzten nicht-leeren Zeile vor dem Konstruktor
+                for (let i = lines.length - 2; i >= 0; i--) {
+                  if (lines[i].trim() !== '') {
+                    break;
+                  }
+                  startPos -= (lines[lines.length - 1 - (lines.length - 2 - i)].length + 1);
+                }
+              }
+
+              // Prüfe auf Leerzeilen nach dem Konstruktor
+              const afterLines = afterConstructor.split('\n');
+              if (afterLines.length > 1 && afterLines[0].trim() === '') {
+                endPos += afterLines[0].length + 1;
+              }
+
+              return fixer.removeRange([startPos, endPos]);
+            },
+          });
+        }
+      }
+    };
+  },
+};

package/rules/no-dto-default-values.js

@@ -0,0 +1,220 @@
+/**
+ * ESLint-Regel: no-dto-default-values
+ * Verbietet Default Values in DTO-Klassen
+ * Verbesserte Version für TypeScript
+ */
+
+/** @type {import('eslint').Rule.RuleModule} */
+const noDtoDefaultValuesRule = {
+  meta: {
+    type: "problem",
+    docs: {
+      description: "DTO-Klassen dürfen keine Default Values haben",
+      category: "Best Practices",
+      recommended: true,
+    },
+    fixable: "code",
+    schema: [],
+    messages: {
+      noDefaultValue: "DTO property '{{propertyName}}' darf keinen Default Value haben. Verwende stattdessen explizite Typ-Annotation ohne Initialisierung.",
+      noDefaultValueInConstructor: "DTO-Properties dürfen nicht im Constructor initialisiert werden. Verwende stattdessen die create()-Methode.",
+    },
+  },
+  create(context) {
+    function isDtoClass(node) {
+      return node.id && node.id.name && node.id.name.endsWith('Dto');
+    }
+
+    function hasDefaultValue(member) {
+      // Für Getter: Prüfe Return-Statements im Body
+      if (member.type === "MethodDefinition" && member.kind === "get" && member.value?.body) {
+        const returnStatements = member.value.body.body.filter(stmt =>
+          stmt.type === "ReturnStatement" && stmt.argument
+        );
+
+        // Wenn es Returns mit Literal-Werten gibt (außer undefined), ist das ein Default
+        return returnStatements.some(stmt => {
+          const arg = stmt.argument;
+          return arg.type === "ObjectExpression" ||
+                 (arg.type === "Literal" && arg.value !== undefined) ||
+                 (arg.type === "ArrayExpression");
+        });
+      }
+
+      // Für reguläre Properties: Prüfe ob value vorhanden ist
+      return member.value !== null && member.value !== undefined;
+    }
+
+    function isPrivateProperty(propertyName) {
+      return propertyName.startsWith('_');
+    }
+
+    function inferTypeFromValue(value) {
+      if (!value) return "unknown";
+      switch (value.type) {
+        case "Literal":
+          if (typeof value.value === "string") return "string";
+          if (typeof value.value === "number") return "number";
+          if (typeof value.value === "boolean") return "boolean";
+          return "unknown";
+        case "ArrayExpression": return "any[]";
+        case "ObjectExpression": return "object";
+        case "NewExpression": return "object";
+        case "Identifier":
+          if (value.name === "true" || value.name === "false") return "boolean";
+          if (value.name === "null") return "null";
+          if (value.name === "undefined") return "undefined";
+          return "unknown";
+        default: return "unknown";
+      }
+    }
+
+    function checkPropertyForDefaultValue(member) {
+      if (!member.key?.name) return;
+
+      const propertyName = member.key.name;
+
+      // Überspringe private Properties und statische Properties
+      if (isPrivateProperty(propertyName) || member.static) {
+        return;
+      }
+
+      // Für Getter: Prüfe ob der Body einen Default-Wert zurückgibt
+      if (member.type === "MethodDefinition" && member.kind === "get" && member.value?.body) {
+        const returnStatements = member.value.body.body.filter(stmt =>
+          stmt.type === "ReturnStatement" && stmt.argument
+        );
+
+        // Wenn alle Returns Literal-Werte haben (außer undefined), ist das ein Default
+        const hasDefaultReturn = returnStatements.some(stmt => {
+          const arg = stmt.argument;
+          return arg.type === "ObjectExpression" ||
+                 (arg.type === "Literal" && arg.value !== undefined) ||
+                 (arg.type === "ArrayExpression");
+        });
+
+        if (hasDefaultReturn) {
+          context.report({
+            node: member,
+            messageId: "noDefaultValue",
+            data: { propertyName },
+            fix(fixer) {
+              // Für Getter: Entferne die Returns mit Default-Werten
+              const statementsToRemove = returnStatements.filter(stmt => {
+                const arg = stmt.argument;
+                return arg.type === "ObjectExpression" ||
+                       (arg.type === "Literal" && arg.value !== undefined) ||
+                       (arg.type === "ArrayExpression");
+              });
+
+              if (statementsToRemove.length > 0) {
+                const ranges = statementsToRemove.map(stmt => stmt.range);
+                // Entferne die Statements von hinten nach vorne
+                return ranges.reverse().map(range => fixer.removeRange(range));
+              }
+              return null;
+            },
+          });
+        }
+        return;
+      }
+
+      // Prüfe ob Default Value vorhanden ist (für reguläre Properties)
+      if (hasDefaultValue(member)) {
+        context.report({
+          node: member,
+          messageId: "noDefaultValue",
+          data: { propertyName },
+          fix(fixer) {
+            if (member.typeAnnotation) {
+              // Hat bereits Type Annotation, entferne nur den Default Value
+              const valueStart = member.value.range[0];
+              // Finde das "=" Zeichen vor dem Wert
+              let equalPos = valueStart - 1;
+              const sourceCode = context.getSourceCode();
+              const text = sourceCode.getText();
+              while (equalPos > 0 && text[equalPos] !== '=') {
+                equalPos--;
+              }
+              // Entferne alles von "=" bis zum Ende des Wertes (inklusive Whitespace)
+              return fixer.removeRange([equalPos - 1, member.value.range[1]]);
+            } else {
+              // Keine Type Annotation, infere Typ und ersetze
+              const inferredType = inferTypeFromValue(member.value);
+              if (inferredType !== "unknown") {
+                return fixer.replaceText(member, `${propertyName}: ${inferredType};`);
+              }
+            }
+            return null;
+          },
+        });
+      }
+    }
+
+    return {
+      ClassDeclaration(node) {
+        if (!isDtoClass(node)) return;
+
+        node.body.body.forEach(member => {
+          // Unterstütze verschiedene Property-Typen für TypeScript
+          if ((member.type === "PropertyDefinition" ||
+               member.type === "ClassProperty" ||
+               member.type === "TSPropertySignature" ||
+               (member.type === "MethodDefinition" && member.kind === "get")) &&
+               member.key?.name &&
+               member.kind !== "method" &&
+               member.kind !== "constructor") {
+            checkPropertyForDefaultValue(member);
+          }
+        });
+      },
+
+      ClassExpression(node) {
+        if (!isDtoClass(node)) return;
+
+        node.body.body.forEach(member => {
+          if ((member.type === "PropertyDefinition" ||
+               member.type === "ClassProperty" ||
+               member.type === "TSPropertySignature" ||
+               (member.type === "MethodDefinition" && member.kind === "get")) &&
+               member.key?.name &&
+               member.kind !== "method" &&
+               member.kind !== "constructor") {
+            checkPropertyForDefaultValue(member);
+          }
+        });
+      },
+
+      MethodDefinition(node) {
+        if (node.kind === "constructor") {
+          const classNode = node.parent.parent;
+          if (!isDtoClass(classNode)) return;
+
+          if (node.value.body) {
+            node.value.body.body.forEach(stmt => {
+              if (stmt.type === "ExpressionStatement" &&
+                  stmt.expression.type === "AssignmentExpression" &&
+                  stmt.expression.left.type === "MemberExpression" &&
+                  stmt.expression.left.object.type === "ThisExpression") {
+                const propertyName = stmt.expression.left.property.name;
+                if (!isPrivateProperty(propertyName)) {
+                  context.report({
+                    node: stmt,
+                    messageId: "noDefaultValueInConstructor",
+                    data: { propertyName },
+                  });
+                }
+              }
+            });
+          }
+        }
+      },
+    };
+  },
+};
+
+export default {
+  rules: {
+    "no-dto-default-values": noDtoDefaultValuesRule,
+  },
+};