@echoes-of-order/eslint-config 1.121.0

package/rules/performance-minimal.js

@@ -0,0 +1,155 @@
+export default {
+  rules: {
+    // Kritische Regex Performance - nur funktionierende Regeln
+    "regexp/confusing-quantifier": "error",
+    "regexp/control-character-escape": "error",
+    "regexp/negation": "error",
+    "regexp/no-dupe-characters-character-class": "error",
+    "regexp/no-dupe-disjunctions": "error",
+    "regexp/no-empty-alternative": "error",
+    "regexp/no-empty-capturing-group": "error",
+    "regexp/no-empty-character-class": "error",
+    "regexp/no-empty-group": "error",
+    "regexp/no-empty-lookarounds-assertion": "error",
+    "regexp/no-escape-backspace": "error",
+    "regexp/no-invalid-regexp": "error",
+    "regexp/no-lazy-ends": "error",
+    "regexp/no-misleading-capturing-group": "error",
+    "regexp/no-misleading-unicode-character": "error",
+    "regexp/no-missing-g-flag": "error",
+    "regexp/no-potentially-useless-backreference": "error",
+    "regexp/no-super-linear-backtracking": "error",
+    "regexp/no-super-linear-move": "error",
+    "regexp/no-trivially-nested-assertion": "error",
+    "regexp/no-trivially-nested-quantifier": "error",
+    "regexp/no-unused-capturing-group": "error",
+    "regexp/no-useless-assertions": "error",
+    "regexp/no-useless-backreference": "error",
+    "regexp/no-useless-character-class": "error",
+    "regexp/no-useless-dollar-replacements": "error",
+    "regexp/no-useless-escape": "error",
+    "regexp/no-useless-flag": "error",
+    "regexp/no-useless-lazy": "error",
+    "regexp/no-useless-quantifier": "error",
+    "regexp/no-useless-range": "error",
+    "regexp/no-useless-two-nums-quantifier": "error",
+    "regexp/no-zero-quantifier": "error",
+    "regexp/optimal-lookaround-quantifier": "error",
+    "regexp/optimal-quantifier-concatenation": "error",
+    "regexp/prefer-lookaround": "error",
+    "regexp/prefer-named-backreference": "error",
+    "regexp/prefer-named-capture-group": "error",
+    "regexp/prefer-named-replacement": "error",
+    "regexp/prefer-plus-quantifier": "error",
+    "regexp/prefer-predefined-assertion": "error",
+    "regexp/prefer-quantifier": "error",
+    "regexp/prefer-range": "error",
+    "regexp/prefer-regexp-exec": "error",
+    "regexp/prefer-regexp-test": "error",
+    "regexp/prefer-result-array-groups": "error",
+    "regexp/prefer-set-operation": "error",
+    "regexp/prefer-star-quantifier": "error",
+    "regexp/prefer-unicode-codepoint-escapes": "error",
+    "regexp/require-unicode-regexp": "error",
+    "regexp/simplify-set-operations": "error",
+    "regexp/sort-alternatives": "error",
+    "regexp/sort-character-class-elements": "error",
+    "regexp/sort-flags": "error",
+    "regexp/strict": "error",
+    "regexp/use-ignore-case": "error",
+
+    // Performance-kritische Standard-Regeln
+    "no-await-in-loop": "error",
+    "no-constant-binary-expression": "error",
+    "no-unreachable-loop": "error",
+    "prefer-const": "error",
+    "no-var": "error",
+    "prefer-template": "error",
+    "prefer-spread": "error",
+    "prefer-rest-params": "error",
+    "prefer-arrow-callback": ["error", {
+      "allowNamedFunctions": false,
+      "allowUnboundThis": true
+    }],
+    "object-shorthand": "error",
+    "prefer-destructuring": ["error", {
+      "VariableDeclarator": {
+        "array": false,
+        "object": true
+      },
+      "AssignmentExpression": {
+        "array": true,
+        "object": false
+      }
+    }],
+
+    // Memory-Management
+    "no-implied-eval": "error",
+    "no-new-func": "error",
+    "no-new-object": "error",
+    "no-new-wrappers": "error",
+    "no-array-constructor": "error",
+
+    // Kritische Unicorn-Regeln (nur funktionierende)
+    "unicorn/better-regex": "error",
+    "unicorn/catch-error-name": "error",
+    "unicorn/error-message": "error",
+    "unicorn/escape-case": "error",
+    "unicorn/explicit-length-check": "error",
+    "unicorn/new-for-builtins": "error",
+    "unicorn/no-abusive-eslint-disable": "error",
+    "unicorn/no-console-spaces": "error",
+    "unicorn/no-empty-file": "error",
+    "unicorn/no-hex-escape": "error",
+    "unicorn/no-instanceof-array": "error",
+    "unicorn/no-new-array": "error",
+    "unicorn/no-new-buffer": "error",
+    "unicorn/no-process-exit": "error",
+    "unicorn/no-static-only-class": "error",
+    "unicorn/no-this-assignment": "error",
+    "unicorn/no-typeof-undefined": "error",
+    "unicorn/no-unnecessary-await": "error",
+    "unicorn/no-useless-length-check": "error",
+    "unicorn/no-useless-spread": "error",
+    "unicorn/no-zero-fractions": "error",
+    "unicorn/number-literal-case": "error",
+    "unicorn/prefer-array-find": "error",
+    "unicorn/prefer-array-flat": "error",
+    "unicorn/prefer-array-flat-map": "error",
+    "unicorn/prefer-array-index-of": "error",
+    "unicorn/prefer-array-some": "error",
+    "unicorn/prefer-at": "error",
+    "unicorn/prefer-code-point": "error",
+    "unicorn/prefer-date-now": "error",
+    "unicorn/prefer-default-parameters": "error",
+    "unicorn/prefer-includes": "error",
+    "unicorn/prefer-json-parse-buffer": "error",
+    "unicorn/prefer-logical-operator-over-ternary": "error",
+    "unicorn/prefer-math-trunc": "error",
+    "unicorn/prefer-modern-math-apis": "error",
+    "unicorn/prefer-module": "error",
+    "unicorn/prefer-native-coercion-functions": "error",
+    "unicorn/prefer-negative-index": "error",
+    "unicorn/prefer-node-protocol": "error",
+    "unicorn/prefer-number-properties": "error",
+    "unicorn/prefer-object-from-entries": "error",
+    "unicorn/prefer-optional-catch-binding": "error",
+    "unicorn/prefer-prototype-methods": "error",
+    "unicorn/prefer-reflect-apply": "error",
+    "unicorn/prefer-regexp-test": "error",
+    "unicorn/prefer-set-has": "error",
+    "unicorn/prefer-set-size": "error",
+    "unicorn/prefer-string-replace-all": "error",
+    "unicorn/prefer-string-slice": "error",
+    "unicorn/prefer-string-starts-ends-with": "error",
+    "unicorn/prefer-string-trim-start-end": "error",
+    "unicorn/prefer-switch": "error",
+    "unicorn/prefer-ternary": "error",
+    "unicorn/prefer-top-level-await": "error",
+    "unicorn/prefer-type-error": "error",
+    "unicorn/require-array-join-separator": "error",
+    "unicorn/require-number-to-fixed-digits-argument": "error",
+    "unicorn/switch-case-braces": "error",
+    "unicorn/throw-new-error": "error",
+  },
+};

package/rules/performance.js

@@ -0,0 +1,44 @@
+/**
+ * Performance Rules
+ *
+ * Performance-kritische Regeln für Backend-Anwendungen
+ * Ursprünglich aus dem Image-Server
+ */
+
+export default {
+  rules: {
+    // Performance-kritische Standard-Regeln
+    "no-await-in-loop": "error",
+    "no-constant-binary-expression": "error",
+    "no-unreachable-loop": "error",
+    "prefer-const": "error",
+    "no-var": "error",
+    "prefer-template": "error",
+    "prefer-spread": "error",
+    "prefer-rest-params": "error",
+    "prefer-arrow-callback": ["error", {
+      "allowNamedFunctions": false,
+      "allowUnboundThis": true
+    }],
+    "object-shorthand": "error",
+    "prefer-destructuring": ["error", {
+      "VariableDeclarator": {
+        "array": false,
+        "object": true
+      },
+      "AssignmentExpression": {
+        "array": true,
+        "object": false
+      }
+    }],
+
+    // Memory-Management
+    "no-implied-eval": "error",
+    "no-new-func": "error",
+    "no-new-object": "error",
+    "no-new-wrappers": "error",
+    "no-array-constructor": "error",
+  },
+};
+
+

package/rules/pino-logger-format.js

@@ -0,0 +1,200 @@
+/**
+ * @fileoverview Enforce Pino logger format: logger.method({ object }, 'message')
+ * @author Echoes of Order Team
+ *
+ * This rule enforces:
+ * 1. Object must be first argument, message second
+ * 2. Error objects can be passed directly in the 'error' property - the logger wrapper will extract message and stack automatically
+ * 3. For error logs, if 'error' is an Error object, 'stack' is not required (auto-extracted)
+ */
+
+"use strict";
+
+export default {
+  meta: {
+    type: "problem",
+    docs: {
+      description: "Enforce Pino logger format: logger.method({ object }, 'message') - object first, then message. Error objects are automatically serialized.",
+      category: "Best Practices",
+      recommended: true,
+    },
+    messages: {
+      wrongOrder: "Logger call must use Pino format: logger.{{method}}({ error }, 'message') - object first, then message. Found message first.",
+      missingObject: "Logger call must include an object as first parameter: logger.{{method}}({ error }, 'message').",
+      tooManyArgs: "Logger call should have exactly 2 arguments: logger.{{method}}({ error }, 'message').",
+      deprecatedProperty: "Use '{{correct}}' instead of '{{wrong}}' in logger object.",
+      errorMustBeShorthand: "logger.error() must be called with exactly { error } as first parameter. Use: logger.error({ error }, 'message').",
+    },
+    schema: [],
+    fixable: "code",
+  },
+
+  create(context) {
+    const loggerMethods = ["error", "warn", "info", "debug", "trace", "fatal"];
+
+    const deprecatedPropertyMappings = {
+      err: "error",
+      msg: "message",
+      stackTrace: "stack",
+      errorMsg: "error",
+      errorMessage: "error",
+    };
+
+    function isLoggerCall(node) {
+      return (
+        node.callee.type === "MemberExpression" &&
+        node.callee.object.type === "Identifier" &&
+        node.callee.object.name === "logger" &&
+        node.callee.property.type === "Identifier" &&
+        loggerMethods.includes(node.callee.property.name)
+      );
+    }
+
+    function isObjectExpression(arg) {
+      return arg && arg.type === "ObjectExpression";
+    }
+
+    function isStringLiteral(arg) {
+      return (
+        arg &&
+        ((arg.type === "Literal" && typeof arg.value === "string") ||
+          arg.type === "TemplateLiteral")
+      );
+    }
+
+    function checkObjectProperties(objectNode, methodName) {
+      if (!objectNode || objectNode.type !== "ObjectExpression") {
+        return;
+      }
+
+      const properties = objectNode.properties;
+
+      // For error logs, enforce strict pattern: { error }
+      if (methodName === "error") {
+        // Check that there is exactly one property and it's 'error' as shorthand
+        if (properties.length !== 1) {
+          context.report({
+            node: objectNode,
+            messageId: "errorMustBeShorthand",
+            fix(fixer) {
+              return fixer.replaceText(objectNode, "{ error }");
+            },
+          });
+          return;
+        }
+
+        const errorProp = properties[0];
+
+        // Must be a Property node
+        if (errorProp.type !== "Property") {
+          context.report({
+            node: objectNode,
+            messageId: "errorMustBeShorthand",
+            fix(fixer) {
+              return fixer.replaceText(objectNode, "{ error }");
+            },
+          });
+          return;
+        }
+
+        // Must be named 'error'
+        if (errorProp.key.type !== "Identifier" || errorProp.key.name !== "error") {
+          context.report({
+            node: objectNode,
+            messageId: "errorMustBeShorthand",
+            fix(fixer) {
+              return fixer.replaceText(objectNode, "{ error }");
+            },
+          });
+          return;
+        }
+
+        // Must be shorthand property (error, not error: something)
+        if (!errorProp.shorthand) {
+          context.report({
+            node: errorProp,
+            messageId: "errorMustBeShorthand",
+            fix(fixer) {
+              return fixer.replaceText(objectNode, "{ error }");
+            },
+          });
+          return;
+        }
+      }
+
+      // For other log methods, check deprecated properties
+      for (const prop of properties) {
+        if (prop.type === "Property" && prop.key.type === "Identifier") {
+          const propName = prop.key.name;
+
+          if (deprecatedPropertyMappings[propName]) {
+            context.report({
+              node: prop,
+              messageId: "deprecatedProperty",
+              data: {
+                wrong: propName,
+                correct: deprecatedPropertyMappings[propName],
+              },
+            });
+          }
+        }
+      }
+    }
+
+    return {
+      CallExpression(node) {
+        if (!isLoggerCall(node)) {
+          return;
+        }
+
+        const methodName = node.callee.property.name;
+        const args = node.arguments;
+
+        if (args.length === 0) {
+          return;
+        }
+
+        if (args.length > 2) {
+          context.report({
+            node,
+            messageId: "tooManyArgs",
+            data: { method: methodName },
+          });
+          return;
+        }
+
+        const firstArg = args[0];
+        const secondArg = args[1];
+
+        if (args.length === 1) {
+          if (isStringLiteral(firstArg)) {
+            context.report({
+              node,
+              messageId: "missingObject",
+              data: { method: methodName },
+            });
+          }
+          return;
+        }
+
+        if (isStringLiteral(firstArg) && isObjectExpression(secondArg)) {
+          context.report({
+            node,
+            messageId: "wrongOrder",
+            data: { method: methodName },
+          });
+        }
+
+        if (!isObjectExpression(firstArg)) {
+          context.report({
+            node,
+            messageId: "missingObject",
+            data: { method: methodName },
+          });
+        }
+
+        checkObjectProperties(firstArg, methodName);
+      },
+    };
+  },
+};

package/rules/prefer-dto-classes.js

@@ -0,0 +1,112 @@
+/**
+ * @fileoverview Erzwingt die Verwendung von DTO-Klassen anstelle von Interfaces
+ */
+
+"use strict";
+
+const preferDtoClassesRule = {
+  meta: {
+    type: "suggestion",
+    docs: {
+      description: "Erzwingt die Verwendung von DTO-Klassen anstelle von Interfaces für Datenübertragung",
+      category: "Best Practices",
+      recommended: true,
+    },
+    fixable: null,
+    schema: [],
+    messages: {
+      preferDtoClass: "Interface '{{interfaceName}}' sollte als DTO-Klasse implementiert werden. DTO-Klassen bieten Runtime-Validierung, bessere Type Safety und Konsistenz.",
+      useFactoryFunction: "Wenn ein Interface für '{{interfaceName}}' notwendig ist (z.B. interne Types), füge eine Factory-Funktion hinzu: 'export const create{{interfaceName}} = (...) => ({ ... });'",
+    },
+  },
+
+  create(context) {
+    const filename = context.getFilename();
+
+    // Nur DTO-Dateien prüfen
+    if (!filename.includes("/dto/") || filename.includes("test") || filename.includes("spec")) {
+      return {};
+    }
+
+    // Identifiziere DTO-Interfaces
+    function isDtoInterface(interfaceName) {
+      return (
+        interfaceName.endsWith("Dto") ||
+        interfaceName.endsWith("DTO") ||
+        interfaceName.includes("Request") ||
+        interfaceName.includes("Response") ||
+        interfaceName.includes("Create") ||
+        interfaceName.includes("Update") ||
+        interfaceName.includes("Delete") ||
+        interfaceName.includes("Model") ||
+        interfaceName.includes("Data")
+      );
+    }
+
+    // Ausnahmen für akzeptable Interface-Verwendungen
+    function isAcceptableInterface(interfaceName, context) {
+      const internalTypePatterns = [
+        "Type", "Config", "Options", "Settings", "Props", "State"
+      ];
+
+      const componentPatterns = [
+        "Component", "Hook", "Context"
+      ];
+
+      return (
+        internalTypePatterns.some(pattern => interfaceName.includes(pattern)) ||
+        componentPatterns.some(pattern => interfaceName.includes(pattern)) ||
+        filename.includes("/types/") ||    // Reine Type-Definitionen
+        filename.includes("/model/")       // Business Models
+      );
+    }
+
+    return {
+      TSInterfaceDeclaration(node) {
+        const interfaceName = node.id.name;
+
+        if (isDtoInterface(interfaceName) && !isAcceptableInterface(interfaceName, context)) {
+          // Prüfe, ob eine Factory-Funktion existiert
+          const sourceCode = context.getSourceCode();
+          const text = sourceCode.getText();
+          const hasFactoryFunction = text.includes(`create${interfaceName}`) ||
+                                   text.includes(`new${interfaceName}`);
+
+          if (!hasFactoryFunction) {
+            context.report({
+              node,
+              messageId: "preferDtoClass",
+              data: { interfaceName }
+            });
+          } else {
+            // Warnung mit Hinweis auf Factory-Pattern
+            context.report({
+              node,
+              messageId: "useFactoryFunction",
+              data: { interfaceName }
+            });
+          }
+        }
+      },
+
+      // Prüfe auch Type-Aliase
+      TSTypeAliasDeclaration(node) {
+        const typeName = node.id.name;
+
+        if (isDtoInterface(typeName) && !isAcceptableInterface(typeName, context)) {
+          context.report({
+            node,
+            messageId: "preferDtoClass",
+            data: { interfaceName: typeName }
+          });
+        }
+      }
+    };
+  }
+};
+
+export default {
+  rules: {
+    "prefer-dto-classes": preferDtoClassesRule,
+  },
+};