@echoes-of-order/eslint-config 1.121.0

package/rules/enforce-entity-factory-pattern.js

@@ -0,0 +1,180 @@
+/**
+ * @fileoverview Enforce that Entities can only be initialized in DTO methods (fromEntity, fromEntityArray, toEntity, fromRequestDto)
+ * @author Echoes of Order Team
+ */
+
+//------------------------------------------------------------------------------
+// Rule Definition
+//------------------------------------------------------------------------------
+
+/** @type {import('eslint').Rule.RuleModule} */
+export default {
+  meta: {
+    type: "problem",
+    docs: {
+      description: "Entities dürfen nur in DTO-Methoden manuell initialisiert werden (fromEntity, fromEntityArray, toEntity, fromRequestDto)",
+      category: "Architecture",
+      recommended: true,
+    },
+    fixable: null,
+    schema: [],
+    messages: {
+      entityInitializationForbidden: "Manuelle Entity-Initialisierung 'new {{entityName}}()' ist nur in DTO-Methoden erlaubt: fromEntity, fromEntityArray, toEntity, fromRequestDto",
+      entityPropertyAssignmentForbidden: "Manuelle Property-Zuweisung an Entity '{{entityName}}' ist nur in DTO-Methoden erlaubt: fromEntity, fromEntityArray, toEntity, fromRequestDto",
+      useRepositoryCreate: "Verwende repository.create() oder DTO-Methoden statt manueller Entity-Initialisierung",
+    },
+  },
+
+  create(context) {
+    //--------------------------------------------------------------------------
+    // Helpers
+    //--------------------------------------------------------------------------
+
+    const filename = context.getFilename();
+    const isServiceFile = (filename.includes("/service/") && filename.endsWith(".ts") && !filename.includes("test")) || filename.includes("test-fixtures");
+    const isDtoFile = filename.includes("/dto/") && filename.endsWith(".ts");
+    const isEntityFile = filename.includes("/entity/") && filename.endsWith(".ts");
+    const isTestFixture = filename.includes("test-fixtures");
+    const isInvalidTestFixture = filename.includes("InvalidEntityFactoryPattern");
+
+    /**
+     * Check if we are in a fromEntity method
+     * @param {ASTNode} node - The current node
+     * @returns {boolean} True if in fromEntity method
+     */
+    function isInFromEntityMethod(node) {
+      let current = node;
+      while (current && current.parent) {
+        if (current.type === "MethodDefinition" &&
+            current.static === true &&
+            current.key?.name === "fromEntity") {
+          return true;
+        }
+        current = current.parent;
+      }
+      return false;
+    }
+
+    /**
+     * Check if we are in a fromEntityArray method
+     * @param {ASTNode} node - The current node
+     * @returns {boolean} True if in fromEntityArray method
+     */
+    function isInFromEntityArrayMethod(node) {
+      let current = node;
+      while (current && current.parent) {
+        if (current.type === "MethodDefinition" &&
+            current.static === true &&
+            current.key?.name === "fromEntityArray") {
+          return true;
+        }
+        current = current.parent;
+      }
+      return false;
+    }
+
+    /**
+     * Check if we are in a toEntity method
+     * @param {ASTNode} node - The current node
+     * @returns {boolean} True if in toEntity method
+     */
+    function isInToEntityMethod(node) {
+      let current = node;
+      while (current && current.parent) {
+        if (current.type === "MethodDefinition" &&
+            current.static === true &&
+            current.key?.name === "toEntity") {
+          return true;
+        }
+        current = current.parent;
+      }
+      return false;
+    }
+
+    /**
+     * Check if we are in a fromRequestDto method
+     * @param {ASTNode} node - The current node
+     * @returns {boolean} True if in fromRequestDto method
+     */
+    function isInFromRequestDtoMethod(node) {
+      let current = node;
+      while (current && current.parent) {
+        if (current.type === "MethodDefinition" &&
+            current.static === true &&
+            current.key?.name === "fromRequestDto") {
+          return true;
+        }
+        current = current.parent;
+      }
+      return false;
+    }
+
+    /**
+     * Check if we are in a DTO fromEntity method
+     * @param {ASTNode} node - The current node
+     * @returns {boolean} True if in DTO fromEntity method
+     */
+    function isInDtoFromEntityMethod(node) {
+      return isDtoFile && (isInFromEntityMethod(node) || isInFromEntityArrayMethod(node) || isInToEntityMethod(node) || isInFromRequestDtoMethod(node));
+    }
+
+    //--------------------------------------------------------------------------
+    // Public
+    //--------------------------------------------------------------------------
+
+    return {
+      // Überwache new Entity() Aufrufe
+      NewExpression(node) {
+        // Ignoriere Test-Fixtures, außer für InvalidEntityFactoryPattern
+        if (isTestFixture && !isInvalidTestFixture) {
+          return;
+        }
+
+        const entityName = node.callee?.name;
+
+        // Prüfe ob es eine Entity ist (Name endet mit "Entity")
+        if (entityName && entityName.endsWith("Entity")) {
+          // Erlaube nur in DTO fromEntity-Methoden
+          if (!isInDtoFromEntityMethod(node)) {
+            context.report({
+              node,
+              messageId: "entityInitializationForbidden",
+              data: {
+                entityName,
+              },
+            });
+          }
+        }
+      },
+
+      // Überwache Property-Zuweisungen an Entities
+      AssignmentExpression(node) {
+        // Ignoriere Test-Fixtures, außer für InvalidEntityFactoryPattern
+        if (isTestFixture && !isInvalidTestFixture) {
+          return;
+        }
+
+        if (isServiceFile || isEntityFile) {
+          // Prüfe ob links eine Entity-Variable ist (kann auch camelCase sein)
+          if (node.left.type === "MemberExpression" &&
+              node.left.object?.name &&
+              (node.left.object.name.endsWith("Entity") ||
+               node.left.object.name.match(/^[a-z][a-zA-Z]*Entity$/))) {
+
+            // Erlaube nur in DTO fromEntity-Methoden
+            if (!isInDtoFromEntityMethod(node)) {
+              context.report({
+                node,
+                messageId: "entityPropertyAssignmentForbidden",
+                data: {
+                  entityName: node.left.object.name,
+                },
+              });
+            }
+          }
+        }
+      },
+    };
+  },
+};
+

package/rules/enforce-entity-instantiation-in-toentity.js

@@ -0,0 +1,125 @@
+/**
+ * @fileoverview Enforce that Entity instantiation (new Entity()) is only allowed within toEntity methods
+ * @author Echoes of Order Team
+ */
+
+//------------------------------------------------------------------------------
+// Rule Definition
+//------------------------------------------------------------------------------
+
+/** @type {import('eslint').Rule.RuleModule} */
+export default {
+  rules: {
+    "enforce-entity-instantiation-in-toentity": {
+      meta: {
+        type: "problem",
+        docs: {
+          description: "Enforce that new Entity() is only allowed within toEntity methods of Entity DTOs",
+          category: "Best Practices",
+          recommended: true,
+        },
+        fixable: null,
+        schema: [],
+        messages: {
+          newEntityOutsideToEntity: "new {{entityName}}() is only allowed within the toEntity method of the corresponding Entity DTO. Use repository.create() or DTO methods instead.",
+        },
+      },
+
+      create(context) {
+        const entityDtos = new Map();
+
+        /**
+         * Check if filename is an Entity DTO file
+         */
+        function isEntityDtoFile(filename) {
+          return (
+            (filename.includes("/dto/Entity/") || filename.includes("/test-fixtures/")) &&
+            (filename.endsWith("EntityDto.ts") || filename.includes("EntityDto"))
+          );
+        }
+
+        /**
+         * Get DTO name from Entity name
+         */
+        function getDtoNameFromEntity(entityName) {
+          return entityName.replace("Entity", "EntityDto");
+        }
+
+        /**
+         * Check if node is inside a toEntity method
+         */
+        function isInsideToEntityMethod(node) {
+          let parent = node.parent;
+          while (parent) {
+            if (parent.type === "MethodDefinition" || parent.type === "Property") {
+              if (parent.key && parent.key.name === "toEntity") {
+                return true;
+              }
+            }
+            parent = parent.parent;
+          }
+          return false;
+        }
+
+        /**
+         * Check if node is inside a fromRequestDto method
+         */
+        function isInsideFromRequestDtoMethod(node) {
+          let parent = node.parent;
+          while (parent) {
+            if (parent.type === "MethodDefinition" || parent.type === "Property") {
+              if (parent.key && parent.key.name === "fromRequestDto") {
+                return true;
+              }
+            }
+            parent = parent.parent;
+          }
+          return false;
+        }
+
+        return {
+          ClassDeclaration(node) {
+            const filename = context.getFilename();
+            const className = node.id.name;
+
+            if (isEntityDtoFile(filename) && className.endsWith("EntityDto")) {
+              // Track Entity DTOs for later validation
+              entityDtos.set(className, {
+                node,
+                filename,
+              });
+            }
+          },
+
+          NewExpression(node) {
+            const filename = context.getFilename();
+            const entityName = node.callee.name;
+
+            // Only check Entity instantiations (new XxxEntity())
+            if (entityName && entityName.endsWith("Entity")) {
+              const dtoName = getDtoNameFromEntity(entityName);
+              const dtoInfo = entityDtos.get(dtoName);
+
+              // If we're in an Entity DTO file and instantiating the corresponding Entity
+              if (dtoInfo) {
+                const isInToEntity = isInsideToEntityMethod(node);
+                const isInFromRequestDto = isInsideFromRequestDtoMethod(node);
+
+                // Allow in toEntity and fromRequestDto methods
+                if (!isInToEntity && !isInFromRequestDto) {
+                  context.report({
+                    node,
+                    messageId: "newEntityOutsideToEntity",
+                    data: { entityName },
+                  });
+                }
+              }
+            }
+          },
+        };
+      },
+    },
+  },
+};
+
+

package/rules/enforce-enum-for-playable-entities.js

@@ -0,0 +1,95 @@
+export default {
+  meta: {
+    type: "problem",
+    docs: {
+      description: "Enforce enum types (PlayableRaceName, PlayableClassName, PlayableFactionName) for playable entity properties instead of string",
+      category: "Best Practices",
+      recommended: true,
+    },
+    messages: {
+      useEnumType: "Property '{{propertyName}}' must use enum type '{{enumType}}' instead of 'string'. This ensures type safety and validation at compile time.",
+    },
+    fixable: "code",
+    schema: [],
+  },
+
+  create (context) {
+    const enumMapping = {
+      playableClass: "PlayableClassName",
+      playableFaction: "PlayableFactionName",
+      playableRace: "PlayableRaceName",
+    };
+
+    function shouldSkipFile (filename) {
+      return filename.includes("Enum.ts") ||
+             filename.includes("enum/") ||
+             filename.includes(".test.ts") ||
+             filename.includes(".spec.ts");
+    }
+
+    function hasEnumImport (context, enumName) {
+      const sourceCode = context.getSourceCode();
+      const text = sourceCode.getText();
+
+      return text.includes(`import ${enumName}`) ||
+             text.includes(`import { ${enumName} }`) ||
+             text.includes(`import type { ${enumName} }`);
+    }
+
+    function createEnumImport (enumName) {
+      return `import ${enumName} from "@/enum/${enumName}";\n`;
+    }
+
+    return {
+      Identifier (node) {
+        const name = node.name;
+
+        if (!(name in enumMapping)) {
+          return;
+        }
+
+        const filename = context.getFilename();
+        if (shouldSkipFile(filename)) {
+          return;
+        }
+
+        if (!node.typeAnnotation || !node.typeAnnotation.typeAnnotation) {
+          return;
+        }
+
+        const typeAnnotation = node.typeAnnotation.typeAnnotation;
+
+        if (typeAnnotation.type !== "TSStringKeyword") {
+          return;
+        }
+
+        const enumType = enumMapping[name];
+
+        context.report({
+          messageId: "useEnumType",
+          node: node.typeAnnotation,
+          data: {
+            enumType,
+            propertyName: name,
+          },
+          fix (fixer) {
+            const fixes = [];
+
+            fixes.push(fixer.replaceText(typeAnnotation, enumType));
+
+            if (!hasEnumImport(context, enumType)) {
+              const sourceCode = context.getSourceCode();
+              const firstImport = sourceCode.ast.body.find((n) => n.type === "ImportDeclaration");
+
+              if (firstImport) {
+                fixes.push(fixer.insertTextBefore(firstImport, createEnumImport(enumType)));
+              }
+            }
+
+            return fixes;
+          },
+        });
+      },
+    };
+  },
+};

package/rules/enforce-error-handling.js

@@ -0,0 +1,257 @@
+/**
+ * ESLint-Regel: enforce-error-handling
+ * Erzwingt korrekte Error-Handling-Patterns in Services und Controllern
+ */
+
+/** @type {import('eslint').Rule.RuleModule} */
+const enforceErrorHandlingRule = {
+  meta: {
+    type: "problem",
+    docs: {
+      description: "Erzwingt korrekte Error-Handling-Patterns und englische Error-Messages",
+      category: "Error Handling",
+      recommended: true,
+    },
+    schema: [],
+    messages: {
+      missingTryCatch: "Async-Methode '{{methodName}}' muss try-catch für Error-Handling verwenden.",
+      genericErrorThrow: "Verwende spezifische Error-Klassen statt generischem 'throw new Error()'.",
+      missingErrorLogging: "Error muss geloggt werden bevor Result.failure() zurückgegeben wird.",
+      germanErrorMessage: "Error-Messages müssen auf Englisch sein. Deutsche Texte sind nicht erlaubt.",
+      unhandledPromise: "Promise muss mit .catch() oder try-catch behandelt werden.",
+      emptyCatchBlock: "Catch-Block muss einen Error-Parameter haben und den Fehler loggen.",
+      missingErrorLoggingInCatch: "Error muss im catch-Block geloggt werden.",
+    },
+  },
+  create(context) {
+    const filename = context.getFilename();
+    const isServiceFile = filename.includes("/service/") && filename.endsWith(".ts");
+    const isControllerFile = filename.includes("/controller/") && filename.endsWith("Controller.ts");
+    const isTestFile = filename.includes(".test.") || filename.includes(".spec.");
+
+    if (!isServiceFile && !isControllerFile || isTestFile) return {};
+
+    // Deutsche Indikatoren für Error-Messages
+    const germanIndicators = [
+      "fehler", "nicht", "beim", "für", "der", "die", "das",
+      "ist", "sind", "wurde", "werden", "haben", "hat",
+      "ungültig", "unbekannt", "gefunden", "existiert",
+      "berechtigung", "zugriff", "verweigert", "fehlgeschlagen"
+    ];
+
+    function containsGermanText(text) {
+      if (!text || typeof text !== "string") return false;
+      const lowerText = text.toLowerCase();
+      return germanIndicators.some(indicator => lowerText.includes(indicator));
+    }
+
+    function isAsyncMethod(node) {
+      return node.type === "MethodDefinition" && node.value?.async === true;
+    }
+
+    function hasTryCatchBlock(methodNode) {
+      const body = methodNode.value?.body;
+      if (!body || body.type !== "BlockStatement") return false;
+
+      return body.body.some(statement => statement.type === "TryStatement");
+    }
+
+    function hasValidErrorLoggingInCatch(tryStatement) {
+      if (!tryStatement || tryStatement.type !== "TryStatement") return false;
+      if (!tryStatement.handler) return false;
+
+      const catchBlock = tryStatement.handler;
+      const catchBody = catchBlock.body;
+
+      // Prüfe, ob der catch Block einen Parameter hat
+      if (!catchBlock.param) {
+        return false; // Leere catch Blöcke sind nicht erlaubt
+      }
+
+      // Prüfe, ob im catch Block ein logger.error() Aufruf vorhanden ist
+      if (catchBody.type !== "BlockStatement") return false;
+
+      return catchBody.body.some(statement => {
+        if (statement.type === "ExpressionStatement" &&
+            statement.expression?.type === "CallExpression" &&
+            statement.expression.callee?.type === "MemberExpression" &&
+            statement.expression.callee.property?.name === "error") {
+          
+          // Prüfe auf logger.error oder this.logger.error
+          const calleeObject = statement.expression.callee.object;
+          if ((calleeObject?.name === "logger") ||
+              (calleeObject?.type === "MemberExpression" &&
+               calleeObject.object?.type === "ThisExpression" &&
+               calleeObject.property?.name === "logger")) {
+            return true;
+          }
+        }
+        return false;
+      });
+    }
+
+    function hasErrorLogging(node) {
+      // Prüfe, ob vor Return-Statement ein logger.error() Aufruf steht
+      const parent = node.parent;
+      if (parent?.type !== "BlockStatement") return false;
+
+      const statements = parent.body;
+      const returnIndex = statements.indexOf(node);
+
+      // Prüfe die vorangehenden Statements auf logger.error oder this.logger.error
+      for (let i = returnIndex - 1; i >= 0; i--) {
+        const stmt = statements[i];
+        if (stmt.type === "ExpressionStatement" &&
+            stmt.expression?.type === "CallExpression" &&
+            stmt.expression.callee?.type === "MemberExpression" &&
+            stmt.expression.callee.property?.name === "error") {
+          
+          // Prüfe auf logger.error oder this.logger.error
+          const calleeObject = stmt.expression.callee.object;
+          if ((calleeObject?.name === "logger") ||
+              (calleeObject?.type === "MemberExpression" &&
+               calleeObject.object?.type === "ThisExpression" &&
+               calleeObject.property?.name === "logger")) {
+            return true;
+          }
+        }
+      }
+      return false;
+    }
+
+    return {
+      // Prüfe async Methoden auf try-catch
+      MethodDefinition(node) {
+        if (isAsyncMethod(node) && !hasTryCatchBlock(node)) {
+          const methodName = node.key?.name || "unknown";
+          context.report({
+            node,
+            messageId: "missingTryCatch",
+            data: { methodName },
+          });
+        }
+      },
+
+      // Prüfe throw new Error() auf spezifische Error-Klassen
+      ThrowStatement(node) {
+        if (node.argument?.type === "NewExpression" &&
+            node.argument.callee?.name === "Error") {
+          context.report({
+            node,
+            messageId: "genericErrorThrow",
+          });
+        }
+
+        // Prüfe Error-Messages auf deutsche Texte
+        if (node.argument?.arguments?.[0]?.type === "Literal") {
+          const message = node.argument.arguments[0].value;
+          if (containsGermanText(message)) {
+            context.report({
+              node: node.argument.arguments[0],
+              messageId: "germanErrorMessage",
+            });
+          }
+        }
+      },
+
+      // Prüfe Result.failure() auf Error-Logging
+      ReturnStatement(node) {
+        if (node.argument?.type === "CallExpression" &&
+            node.argument.callee?.type === "MemberExpression" &&
+            node.argument.callee.object?.name === "Result" &&
+            node.argument.callee.property?.name === "failure") {
+
+          if (!hasErrorLogging(node)) {
+            context.report({
+              node,
+              messageId: "missingErrorLogging",
+            });
+          }
+        }
+      },
+
+      // Prüfe Promise-Aufrufe auf Fehlerbehandlung
+      CallExpression(node) {
+        // Prüfe auf unbehandelte Promise-Aufrufe
+        if (node.callee?.type === "MemberExpression") {
+          const method = node.callee.property?.name;
+          const isPromiseMethod = ["then", "catch", "finally"].includes(method);
+
+          if (isPromiseMethod && method !== "catch") {
+            // Prüfe, ob .catch() in der Chain vorhanden ist
+            let currentNode = node.parent;
+            let hasCatch = false;
+
+            while (currentNode?.type === "CallExpression" &&
+                   currentNode.callee?.type === "MemberExpression") {
+              if (currentNode.callee.property?.name === "catch") {
+                hasCatch = true;
+                break;
+              }
+              currentNode = currentNode.parent;
+            }
+
+            if (!hasCatch && method === "then") {
+              context.report({
+                node,
+                messageId: "unhandledPromise",
+              });
+            }
+          }
+        }
+      },
+
+      // Prüfe Error-Konstruktor-Aufrufe auf deutsche Messages
+      NewExpression(node) {
+        const errorTypes = ["Error", "TypeError", "ReferenceError", "SyntaxError"];
+        if (errorTypes.includes(node.callee?.name) &&
+            node.arguments?.[0]?.type === "Literal") {
+
+          const message = node.arguments[0].value;
+          if (containsGermanText(message)) {
+            context.report({
+              node: node.arguments[0],
+              messageId: "germanErrorMessage",
+            });
+          }
+        }
+      },
+
+      // Prüfe TryStatement auf korrekte Error-Behandlung
+      TryStatement(node) {
+        if (!node.handler) {
+          context.report({
+            node,
+            messageId: "emptyCatchBlock",
+          });
+          return;
+        }
+
+        const catchBlock = node.handler;
+
+        // Prüfe, ob der catch Block einen Parameter hat
+        if (!catchBlock.param) {
+          context.report({
+            node: catchBlock,
+            messageId: "emptyCatchBlock",
+          });
+          return;
+        }
+
+        // Prüfe, ob der Fehler geloggt wird
+        if (!hasValidErrorLoggingInCatch(node)) {
+          context.report({
+            node: catchBlock,
+            messageId: "missingErrorLoggingInCatch",
+          });
+        }
+      },
+    };
+  },
+};
+
+export default {
+  rules: {
+    "enforce-error-handling": enforceErrorHandlingRule,
+  },
+};