@echoes-of-order/eslint-config 1.121.0

package/rules/controller-swagger-english.js

@@ -0,0 +1,320 @@
+/**
+ * @fileoverview Ensure all controller Swagger documentation is written in English
+ */
+
+"use strict";
+
+import { franc } from "franc";
+
+export default {
+  meta: {
+    type: "problem",
+    docs: {
+      description: "enforce that all Swagger documentation in controllers is written in English",
+      category: "Best Practices",
+      recommended: true,
+    },
+    fixable: null,
+    schema: [],
+    messages: {
+      germanDocumentation: "Swagger documentation should be in English. Found German text: '{{text}}'",
+      nonEnglishDocumentation: "Swagger documentation should be in English. Detected language: '{{language}}' in text: '{{text}}'",
+      missingApiOperation: "Controller method '{{methodName}}' is missing @ApiOperation decorator",
+      emptyApiOperation: "Controller method '{{methodName}}' has empty @ApiOperation summary or description",
+    },
+  },
+
+  create(context) {
+    // Common German words that shouldn't appear in API documentation (fallback)
+    const germanWords = [
+      // Articles
+      "der", "die", "das", "ein", "eine", "einen", "einem", "einer", "eines",
+      // Common verbs
+      "ist", "sind", "wird", "werden", "hat", "haben", "kann", "können",
+      "gibt", "geben", "ruft", "abrufen", "erstellt", "erstellen", "aktualisiert",
+      "aktualisieren", "löscht", "löschen", "zurück", "erfolgreich",
+      // Common nouns
+      "daten", "fehler", "serverfehler", "liste", "details",
+      "gesundheit", "position", "koordinate", "karten",
+      // Adjectives/Adverbs
+      "alle", "aller", "neues", "neue", "bestimmten", "ungültige", "ungültiger",
+      // Prepositions
+      "mit", "von", "für", "beim", "nach", "oder", "und",
+      // Other common words
+      "nicht", "gefunden", "wo", "wenn", "dass", "welche", "welcher",
+      // Status messages
+      "erfolgreich", "fehlgeschlagen", "abgerufen", "gelöscht"
+    ];
+
+    // Language code mappings for better error messages
+    const languageNames = {
+      "deu": "German",
+      "fra": "French",
+      "spa": "Spanish",
+      "ita": "Italian",
+      "por": "Portuguese",
+      "rus": "Russian",
+      "jpn": "Japanese",
+      "kor": "Korean",
+      "chi": "Chinese",
+      "ara": "Arabic",
+      "hin": "Hindi",
+      "ben": "Bengali",
+      "urd": "Urdu",
+      "tur": "Turkish",
+      "pol": "Polish",
+      "nld": "Dutch",
+      "swe": "Swedish",
+      "dan": "Danish",
+      "nor": "Norwegian",
+      "fin": "Finnish",
+    };
+
+    function isControllerClass(node) {
+      if (node.type !== "ClassDeclaration") return false;
+
+      return node.decorators && node.decorators.some(decorator => {
+        return decorator.expression &&
+               ((decorator.expression.type === "Identifier" && decorator.expression.name === "Controller") ||
+                (decorator.expression.type === "CallExpression" &&
+                 decorator.expression.callee.name === "Controller"));
+      });
+    }
+
+    function containsGermanWords(text) {
+      if (!text || typeof text !== "string") return null;
+
+      const lowerText = text.toLowerCase();
+
+      for (const word of germanWords) {
+        // Use word boundaries to avoid false positives
+        const regex = new RegExp(`\\b${word}\\b`, "i");
+        if (regex.test(lowerText)) {
+          return word;
+        }
+      }
+
+      return null;
+    }
+
+    function detectLanguageWithFranc(text) {
+      if (!text || typeof text !== "string" || text.trim().length < 20) {
+        // For very short texts, franc is unreliable, skip detection
+        return null;
+      }
+
+      try {
+        const detectedLanguage = franc(text);
+
+        // franc returns 'und' for undetermined language
+        if (detectedLanguage === "und" || detectedLanguage === "eng") {
+          return null; // Assume English or undetermined is OK
+        }
+
+        // Only report if confidence is high and text is long enough
+        if (text.length < 30) {
+          return null; // Skip detection for short technical texts
+        }
+
+        return detectedLanguage;
+      } catch (error) {
+        // If franc fails, fall back to word detection
+        return null;
+      }
+    }
+
+    function checkStringForLanguage(stringNode, context) {
+      if (stringNode && stringNode.type === "Literal" && typeof stringNode.value === "string") {
+        const text = stringNode.value.trim();
+
+        // Skip very short texts (likely single words or technical terms)
+        if (text.length < 10) {
+          return;
+        }
+
+        // Skip common API terms that might be misdetected
+        const commonApiTerms = [
+          "retrieved", "retrieves", "monster", "monsters", "error", "server",
+          "fetching", "filter", "list", "found", "not found", "successfully",
+          "user", "details", "available", "aura", "definitions", "specific",
+          "statistic", "formula", "returns", "get", "cat"
+        ];
+
+        const lowerText = text.toLowerCase();
+        const hasCommonApiTerms = commonApiTerms.some(term => lowerText.includes(term));
+
+        if (hasCommonApiTerms && text.length < 100) {
+          // Skip short texts with common API terms
+          return;
+        }
+
+        // Primary check: Use franc for language detection
+        const detectedLanguage = detectLanguageWithFranc(text);
+        if (detectedLanguage) {
+          const languageName = languageNames[detectedLanguage] || detectedLanguage;
+          context.report({
+            node: stringNode,
+            messageId: "nonEnglishDocumentation",
+            data: {
+              language: languageName,
+              text: text.substring(0, 50) + (text.length > 50 ? "..." : "")
+            }
+          });
+          return;
+        }
+
+        // Fallback check: Use German word detection for more specific cases
+        const germanWord = containsGermanWords(text);
+        if (germanWord) {
+          context.report({
+            node: stringNode,
+            messageId: "germanDocumentation",
+            data: {
+              text: text.substring(0, 50) + (text.length > 50 ? "..." : "")
+            }
+          });
+        }
+      }
+    }
+
+    function hasApiOperationDecorator(decorators) {
+      if (!decorators) return false;
+
+      return decorators.some(decorator => {
+        return decorator.expression &&
+               decorator.expression.type === "CallExpression" &&
+               decorator.expression.callee.name === "ApiOperation";
+      });
+    }
+
+    function getApiOperationContent(decorators) {
+      if (!decorators) return null;
+
+      for (const decorator of decorators) {
+        if (decorator.expression &&
+            decorator.expression.type === "CallExpression" &&
+            decorator.expression.callee.name === "ApiOperation") {
+
+          const args = decorator.expression.arguments;
+          if (args.length > 0 && args[0].type === "ObjectExpression") {
+            return args[0];
+          }
+        }
+      }
+      return null;
+    }
+
+    function validateApiOperation(member) {
+      const methodName = member.key.name;
+
+      if (!hasApiOperationDecorator(member.decorators)) {
+        context.report({
+          node: member,
+          messageId: "missingApiOperation",
+          data: { methodName }
+        });
+        return;
+      }
+
+      const apiOpContent = getApiOperationContent(member.decorators);
+      if (!apiOpContent) return;
+
+      let hasSummary = false;
+      let hasDescription = false;
+
+      // Check each property in ApiOperation
+      apiOpContent.properties.forEach(prop => {
+        if (prop.key && prop.key.name === "summary") {
+          hasSummary = true;
+          checkStringForLanguage(prop.value, context);
+        } else if (prop.key && prop.key.name === "description") {
+          hasDescription = true;
+          checkStringForLanguage(prop.value, context);
+        }
+      });
+
+      if (!hasSummary || !hasDescription) {
+        context.report({
+          node: member,
+          messageId: "emptyApiOperation",
+          data: { methodName }
+        });
+      }
+    }
+
+    function validateApiResponseDecorators(member) {
+      if (!member.decorators) return;
+
+      member.decorators.forEach(decorator => {
+        if (decorator.expression &&
+            decorator.expression.type === "CallExpression" &&
+            decorator.expression.callee.name === "ApiResponseDecorator") {
+
+          const args = decorator.expression.arguments;
+          if (args.length > 0 && args[0].type === "ObjectExpression") {
+            args[0].properties.forEach(prop => {
+              if (prop.key && prop.key.name === "description") {
+                checkStringForLanguage(prop.value, context);
+              }
+            });
+          }
+        }
+      });
+    }
+
+    function validateApiParamDecorators(member) {
+      if (!member.decorators) return;
+
+      member.decorators.forEach(decorator => {
+        if (decorator.expression &&
+            decorator.expression.type === "CallExpression" &&
+            (decorator.expression.callee.name === "ApiParam" ||
+             decorator.expression.callee.name === "ApiQuery" ||
+             decorator.expression.callee.name === "ApiBody")) {
+
+          const args = decorator.expression.arguments;
+          if (args.length > 0 && args[0].type === "ObjectExpression") {
+            args[0].properties.forEach(prop => {
+              if (prop.key && prop.key.name === "description") {
+                checkStringForLanguage(prop.value, context);
+              }
+            });
+          }
+        }
+      });
+    }
+
+    function getHttpMethodType(decorators) {
+      if (!decorators) return null;
+
+      const httpMethods = ["Get", "Post", "Put", "Delete", "Patch"];
+      for (const decorator of decorators) {
+        const decoratorName = decorator.expression?.name || decorator.expression?.callee?.name;
+        if (httpMethods.includes(decoratorName)) {
+          return decoratorName.toLowerCase();
+        }
+      }
+      return null;
+    }
+
+    return {
+      ClassDeclaration(node) {
+        if (!isControllerClass(node)) return;
+
+        node.body.body.forEach(member => {
+          if (member.type === "MethodDefinition" &&
+              member.kind === "method" &&
+              member.accessibility === "public") {
+
+            const httpMethod = getHttpMethodType(member.decorators);
+            if (httpMethod) {
+              validateApiOperation(member);
+              validateApiResponseDecorators(member);
+              validateApiParamDecorators(member);
+            }
+          }
+        });
+      },
+    };
+  },
+};

package/rules/coordinate-naming.js

@@ -0,0 +1,132 @@
+/**
+ * ESLint-Regel: coordinate-naming
+ *
+ * Erweitert die standard id-length Regel um spezifische Vorschläge
+ * für Koordinaten-Variablen x und y.
+ */
+
+export default {
+  meta: {
+    type: "suggestion",
+    docs: {
+      description: "Enforce minimum identifier length with coordinate naming suggestions",
+      category: "Stylistic Issues",
+      recommended: false,
+    },
+    fixable: "code",
+    schema: [
+      {
+        type: "object",
+        properties: {
+          min: {
+            type: "integer",
+            minimum: 0,
+            default: 2,
+          },
+          max: {
+            type: "integer",
+          },
+          exceptions: {
+            type: "array",
+            uniqueItems: true,
+            items: {
+              type: "string",
+            },
+          },
+        },
+        additionalProperties: false,
+      },
+    ],
+  },
+
+  create (context) {
+    const options = context.options[0] || {};
+    const min = typeof options.min === "number" ? options.min : 2;
+    const max = typeof options.max === "number" ? options.max : Infinity;
+    const exceptions = new Set(options.exceptions || []);
+
+    const coordinateMapping = {
+      x: "positionX",
+      y: "positionY",
+    };
+
+    /**
+     * Checks if an identifier is a coordinate variable that needs better naming
+     */
+    function checkIdentifier (node, name) {
+      if (exceptions.has(name)) {
+        return;
+      }
+
+      // Only check for coordinate variables x and y
+      if (coordinateMapping[name]) {
+        context.report({
+          node,
+          message: `Identifier name '${name}' is too short (< ${min}). For coordinates, consider using '${coordinateMapping[name]}' instead.`,
+          fix (fixer) {
+            // Only fix if it's a variable declaration or parameter
+            const parent = node.parent;
+
+            // Check if this is a safe context to rename
+            if (
+              parent.type === "VariableDeclarator" ||
+              parent.type === "Property" ||
+              parent.type === "FunctionExpression" ||
+              parent.type === "ArrowFunctionExpression" ||
+              parent.type === "AssignmentPattern"
+            ) {
+              return fixer.replaceText(node, coordinateMapping[name]);
+            }
+
+            // Don't autofix in complex contexts to avoid breaking code
+            return null;
+          },
+        });
+      }
+    }
+
+    return {
+      Identifier (node) {
+        const name = node.name;
+        const parent = node.parent;
+
+        /*
+         * Don't check properties that don't have their name computed:
+         * - foo.bar
+         * - foo["bar"] (computed property names are checked)
+         * Don't check destructured identifiers (parameters):
+         * - function foo({ prop }) {}
+         * - function foo([item1, item2]) {}
+         * Don't check property shorthand (ES6 features):
+         * - const { x } = {}; (destructuring shorthand)
+         * - const { x: x } = {}; (destructuring alias)
+         */
+        if (parent.type === "MemberExpression") {
+          if (parent.property === node && !parent.computed) {
+            return;
+          }
+        } else if (parent.type === "Property") {
+          if (parent.method || parent.shorthand || parent.key === node) {
+            return;
+          }
+        } else if (parent.type === "ImportDefaultSpecifier") {
+          return;
+        } else if (parent.type === "RestElement") {
+          return;
+        } else if (parent.type === "ExportSpecifier") {
+          return;
+        } else if (parent.type === "FunctionExpression" || parent.type === "ArrowFunctionExpression") {
+          // Don't check function names
+          if (parent.id === node) {
+            return;
+          }
+        }
+
+        // Only check coordinate variables (x, y)
+        if (coordinateMapping[name]) {
+          checkIdentifier(node, name);
+        }
+      },
+    };
+  },
+};

package/rules/custom-mui-button.js

@@ -0,0 +1,135 @@
+/**
+ * ESLint-Regel, die die Verwendung von MUI-Button statt unserer eigenen Button-Komponente prüft
+ */
+const noMuiButtonRule = {
+  meta: {
+    type: "suggestion",
+    docs: {
+      description: "Verbietet die direkte Verwendung von MUI-Button",
+      category: "Best Practices",
+      recommended: true,
+    },
+    fixable: "code",
+    messages: {
+      noMuiButton: "Bitte verwende die eigene Button-Komponente aus '@/components/UI/Button' statt der MUI-Button-Komponente.",
+      noMuiButtonImport: "Bitte verwende die eigene Button-Komponente aus '@/components/UI/Button' statt der MUI-Button-Komponente.",
+    },
+  },
+  create(context) {
+    // Speichert Material-UI Button Importe
+    const muiButtonImports = new Set();
+
+    return {
+      // Prüft alle Import-Deklarationen
+      ImportDeclaration(node) {
+        // Überprüft, ob aus @mui/material importiert wird
+        if (node.source.value === "@mui/material" || node.source.value === "@material-ui/core") {
+          // Überprüft alle Importe aus diesem Modul
+          node.specifiers.forEach((specifier) => {
+            // Wenn Button importiert wird
+            if (
+              (specifier.type === "ImportSpecifier" && specifier.imported && specifier.imported.name === "Button") ||
+              (specifier.type === "ImportDefaultSpecifier" && specifier.local.name === "Button")
+            ) {
+              // Speichert den lokalen Namen des importierten Buttons
+              muiButtonImports.add(specifier.local.name);
+
+              context.report({
+                node,
+                messageId: "noMuiButtonImport",
+                fix(fixer) {
+                  // Entfernt Button aus dem Import
+                  // Behandelt verschiedene Fälle, je nachdem wie der Import aussieht
+
+                  // Fall 1: Einziger Import aus @mui/material
+                  if (node.specifiers.length === 1) {
+                    return fixer.remove(node);
+                  }
+
+                  // Fall 2: Benannter Import in geschweiften Klammern
+                  if (specifier.type === "ImportSpecifier") {
+                    const importText = context.getSourceCode().getText(node);
+                    const buttonPattern = specifier.local.name === "Button"
+                      ? "Button" // Direkter Import: import { Button } from "@mui/material"
+                      : `Button as ${specifier.local.name}`; // Alias Import: import { Button as MuiButton } from "@mui/material"
+
+                    // Entfernt nur Button aus der Import-Liste
+                    if (importText.includes(`, ${buttonPattern}`)) {
+                      return fixer.replaceText(node, importText.replace(`, ${buttonPattern}`, ""));
+                    } else if (importText.includes(`${buttonPattern}, `)) {
+                      return fixer.replaceText(node, importText.replace(`${buttonPattern}, `, ""));
+                    } else if (importText.includes(`{ ${buttonPattern} }`)) {
+                      return fixer.remove(node);
+                    }
+                  }
+
+                  return null;
+                }
+              });
+            }
+          });
+        }
+      },
+
+      // Prüft alle JSX-Elemente
+      JSXOpeningElement(node) {
+        // Wenn ein Element mit dem Namen "Button" gefunden wird
+        if (node.name.type === "JSXIdentifier" && node.name.name === "Button") {
+          // Prüfe anhand des Scopes, ob dieser Button aus @mui/material stammt
+          const scope = context.getScope();
+          let currentScope = scope;
+
+          // Durchsuche alle Scopes nach dem Button-Variablennamen
+          while (currentScope) {
+            const buttonVar = currentScope.variables.find(v => v.name === "Button");
+
+            if (buttonVar) {
+              // Prüfe jede Definition der Button-Variable
+              for (const def of buttonVar.defs) {
+                // Wenn es sich um einen Import handelt
+                if (def.type === "ImportBinding" && def.parent && def.parent.source) {
+                  const importSource = def.parent.source.value;
+
+                  // Wenn der Import von @mui/material oder @material-ui/core stammt
+                  if (importSource === "@mui/material" || importSource === "@material-ui/core") {
+                    context.report({
+                      node,
+                      messageId: "noMuiButton",
+                    });
+                    return;
+                  }
+                }
+              }
+
+              // Wenn wir eine Definition gefunden haben, aber sie ist nicht von MUI,
+              // dann brechen wir die Suche ab (überschreibende Variable gefunden)
+              break;
+            }
+
+            // Zum übergeordneten Scope wechseln
+            currentScope = currentScope.upper;
+          }
+
+          // Außerdem prüfen wir anhand unserer Liste von MUI-Button-Importen
+          if (muiButtonImports.has("Button")) {
+            context.report({
+              node,
+              messageId: "noMuiButton",
+            });
+          }
+        }
+      },
+
+      // Am Ende der Datei werden die gesammelten Informationen zurückgesetzt
+      "Program:exit": function() {
+        muiButtonImports.clear();
+      }
+    };
+  }
+};
+
+export default {
+  rules: {
+    "no-mui-button": noMuiButtonRule
+  }
+};

package/rules/dead-code-detection-backend.js

@@ -0,0 +1,50 @@
+/**
+ * Dead Code Detection Rules für Backend
+ *
+ * Diese Regeln erkennen und verhindern toten Code in Backend-Anwendungen
+ * Ohne Frontend-spezifische Regeln (React, JSX)
+ */
+export default {
+  rules: {
+    // Ungenutzte Variablen und Funktionen
+    "@typescript-eslint/no-unused-vars": ["error", {
+      "vars": "all",
+      "args": "after-used",
+      "ignoreRestSiblings": true,
+      "argsIgnorePattern": "^_",
+      "varsIgnorePattern": "^_"
+    }],
+
+    // Ungenutzte private Klassen-Member
+    "no-unused-private-class-members": "error",
+
+    // Unreachable Code Detection
+    "no-unreachable": "error",
+    "no-unreachable-loop": "error",
+
+    // Unused Expressions
+    "@typescript-eslint/no-unused-expressions": ["error", {
+      "allowShortCircuit": true,
+      "allowTernary": true,
+      "allowTaggedTemplates": true
+    }],
+
+    // Dead Code durch logische Operatoren
+    "no-constant-condition": ["error", {
+      "checkLoops": false
+    }],
+
+    // Ungenutzte Labels
+    "no-unused-labels": "error",
+
+    // Ungenutzte Escape-Sequenzen in RegExp
+    "no-useless-escape": "error",
+
+    // Ungenutzte Return-Werte
+    "no-useless-return": "error",
+
+    // Redundante Konstruktor-Calls
+    "no-useless-constructor": "off", // Deaktiviert wegen TypeScript
+    "@typescript-eslint/no-useless-constructor": "error",
+  }
+};

package/rules/dead-code-detection-frontend.js

@@ -0,0 +1,48 @@
+/**
+ * Dead Code Detection Rules für Frontend/Admin
+ *
+ * Diese Regeln erkennen und verhindern toten Code in Frontend-Anwendungen
+ */
+export default {
+  rules: {
+    // Import/Export Dead Code Detection - deaktiviert wegen Flat Config Kompatibilität
+    // "import/no-unused-modules": ["error", {
+    //   "missingExports": true,
+    //   "unusedExports": true,
+    //   "ignoreExports": [
+    //     "src/main.tsx",
+    //     "src/App.tsx",
+    //     "src/AppRouter.tsx",
+    //     "src/vite-env.d.ts",
+    //     "**/*.d.ts",
+    //     "**/test/**",
+    //     "**/tests/**",
+    //     "**/*.test.*",
+    //     "**/*.spec.*"
+    //   ]
+    // }],
+
+    // Ungenutzte Variablen und Funktionen
+    "@typescript-eslint/no-unused-vars": ["error", {
+      "vars": "all",
+      "args": "after-used",
+      "ignoreRestSiblings": true,
+      "argsIgnorePattern": "^_",
+      "varsIgnorePattern": "^_"
+    }],
+
+    // Ungenutzte private Klassen-Member
+    "no-unused-private-class-members": "error",
+
+    // Unreachable Code Detection
+    "no-unreachable": "error",
+    "no-unreachable-loop": "error",
+
+    // Unused Expressions
+    "@typescript-eslint/no-unused-expressions": ["error", {
+      "allowShortCircuit": true,
+      "allowTernary": true,
+      "allowTaggedTemplates": true
+    }],
+  }
+};