@echoes-of-order/eslint-config 1.121.0

package/rules/enforce-module-existence.js

@@ -0,0 +1,157 @@
+/**
+ * ESLint-Regel: enforce-module-existence
+ *
+ * Überprüft, ob importierte Module tatsächlich existieren.
+ * Verhindert TS2307-Fehler zur Build-Zeit.
+ */
+
+import fs from "fs";
+import path from "path";
+
+export default {
+  rules: {
+    "enforce-module-existence": {
+      meta: {
+        type: "problem",
+        docs: {
+          description: "Enforce that imported modules actually exist",
+          category: "Type Safety",
+          recommended: true,
+        },
+        messages: {
+          moduleNotFound: "Module '{{moduleName}}' not found at path '{{resolvedPath}}'",
+          cannotResolveModule: "Cannot resolve module '{{moduleName}}'",
+        },
+        schema: [
+          {
+            type: "object",
+            properties: {
+              ignorePatterns: {
+                type: "array",
+                items: { type: "string" },
+                description: "Patterns to ignore",
+                default: []
+              }
+            },
+            additionalProperties: false
+          }
+        ]
+      },
+
+      create(context) {
+        const options = context.options[0] || {};
+        const ignorePatterns = options.ignorePatterns || [];
+
+        /**
+         * Resolves a module path relative to the current file
+         */
+        function resolveModulePath(moduleName, currentFilePath) {
+          const projectRoot = context.getCwd();
+
+          // Handle @/ imports
+          if (moduleName.startsWith("@/")) {
+            const relativePath = moduleName.substring(2);
+            return path.join(projectRoot, "src", relativePath);
+          }
+
+          // Handle relative imports
+          if (moduleName.startsWith("./") || moduleName.startsWith("../")) {
+            const currentDir = path.dirname(currentFilePath);
+            return path.resolve(currentDir, moduleName);
+          }
+
+          // Handle absolute imports (node_modules)
+          if (!moduleName.startsWith(".") && !moduleName.startsWith("/")) {
+            return path.join(projectRoot, "node_modules", moduleName);
+          }
+
+          return null;
+        }
+
+        /**
+         * Checks if a module exists
+         */
+        function checkModuleExists(moduleName, currentFilePath) {
+          // Ignore certain patterns
+          for (const pattern of ignorePatterns) {
+            if (moduleName.match(new RegExp(pattern))) {
+              return;
+            }
+          }
+
+          // Ignore npm packages (don't start with @/ or ./ or ../)
+          if (!moduleName.startsWith("@/") && !moduleName.startsWith("./") && !moduleName.startsWith("../")) {
+            return;
+          }
+
+          const resolvedPath = resolveModulePath(moduleName, currentFilePath);
+          if (!resolvedPath) {
+            return;
+          }
+
+          // Check for .ts, .tsx, .js, .jsx files
+          const extensions = [".ts", ".tsx", ".js", ".jsx", "/index.ts", "/index.tsx", "/index.js", "/index.jsx"];
+
+          for (const ext of extensions) {
+            const fullPath = resolvedPath + ext;
+            if (fs.existsSync(fullPath)) {
+              return;
+            }
+          }
+
+          // Check if it's a directory with index file
+          if (fs.existsSync(resolvedPath) && fs.statSync(resolvedPath).isDirectory()) {
+            const indexPath = path.join(resolvedPath, "index.ts");
+            if (fs.existsSync(indexPath)) {
+              return;
+            }
+          }
+
+          return resolvedPath;
+        }
+
+        return {
+          ImportDeclaration(node) {
+            const moduleName = node.source.value;
+            const currentFilePath = context.getFilename();
+
+            const missingPath = checkModuleExists(moduleName, currentFilePath);
+            if (missingPath) {
+              context.report({
+                node: node.source,
+                messageId: "moduleNotFound",
+                data: {
+                  moduleName,
+                  resolvedPath: missingPath
+                }
+              });
+            }
+          },
+
+          CallExpression(node) {
+            // Check dynamic imports
+            if (node.callee.type === "Import" && node.arguments.length > 0) {
+              const arg = node.arguments[0];
+              if (arg.type === "Literal" && typeof arg.value === "string") {
+                const moduleName = arg.value;
+                const currentFilePath = context.getFilename();
+
+                const missingPath = checkModuleExists(moduleName, currentFilePath);
+                if (missingPath) {
+                  context.report({
+                    node: arg,
+                    messageId: "moduleNotFound",
+                    data: {
+                      moduleName,
+                      resolvedPath: missingPath
+                    }
+                  });
+                }
+              }
+            }
+          }
+        };
+      }
+    }
+  }
+};

package/rules/enforce-nonentity-dto-create.js

@@ -0,0 +1,107 @@
+const enforceNonEntityDtoCreateRule = {
+  meta: {
+    type: "problem",
+    docs: {
+      description: "Non-Entity-DTOs müssen create-Methoden bereitstellen und dürfen keine fromEntity-Methoden haben",
+      category: "Architecture",
+      recommended: true,
+    },
+    schema: [],
+    messages: {
+      missingCreateMethod: "Non-Entity-DTO-Klasse '{{dtoName}}' muss eine statische create-Methode bereitstellen",
+      forbiddenStaticMethods: "Non-Entity-DTO-Klasse '{{dtoName}}' darf nur eine statische 'create'-Methode haben. Die Methode '{{methodName}}' ist nicht erlaubt.",
+      forbiddenInstanceMethods: "Non-Entity-DTO-Klasse '{{dtoName}}' darf keine Instance-Methoden haben. Die Methode '{{methodName}}' ist nicht erlaubt.",
+    },
+  },
+  create(context) {
+    const filename = context.getFilename();
+
+    // Prüfe, ob es sich um eine Non-Entity-DTO-Datei handelt
+    const isNonEntityDtoFile = filename.includes("/dto/") && !filename.includes("/dto/Entity/");
+
+    if (!isNonEntityDtoFile) {
+      return {};
+    }
+
+    let classNode = null;
+    let dtoClassName = "";
+
+    return {
+      ClassDeclaration(node) {
+        classNode = node;
+        dtoClassName = node.id?.name;
+      },
+      ExportDefaultDeclaration(node) {
+        if (node.declaration.type === "ClassDeclaration") {
+          classNode = node.declaration;
+          dtoClassName = node.declaration.id?.name;
+        }
+      },
+      "Program:exit"(node) {
+        if (!classNode || !dtoClassName) return;
+
+        // Ausnahme für BaseEntityDto (abstrakte Base-Klasse)
+        if (dtoClassName === "BaseEntityDto" && filename.endsWith("/dto/BaseEntityDto.ts")) {
+          return;
+        }
+
+        // Hole alle Methoden (static und non-static)
+        const allMethods = classNode.body.body.filter(member =>
+          member.type === "MethodDefinition" &&
+          member.kind !== "constructor"
+        );
+
+        const staticMethods = allMethods.filter(method => method.static === true);
+        const instanceMethods = allMethods.filter(method => method.static !== true);
+
+        const hasCreateMethod = staticMethods.some(method =>
+          method.key?.name === "create"
+        );
+
+        // Prüfe, ob create-Methode vorhanden ist
+        if (!hasCreateMethod) {
+          context.report({
+            node: classNode,
+            messageId: "missingCreateMethod",
+            data: { dtoName: dtoClassName }
+          });
+        }
+
+        // Prüfe statische Methoden: Nur 'create' ist erlaubt
+        const forbiddenStaticMethods = staticMethods.filter(method =>
+          method.key?.name && method.key.name !== "create"
+        );
+
+        forbiddenStaticMethods.forEach(method => {
+          context.report({
+            node: method,
+            messageId: "forbiddenStaticMethods",
+            data: {
+              dtoName: dtoClassName,
+              methodName: method.key.name
+            }
+          });
+        });
+
+        // Prüfe Instance-Methoden: KEINE sind erlaubt
+        instanceMethods.forEach(method => {
+          context.report({
+            node: method,
+            messageId: "forbiddenInstanceMethods",
+            data: {
+              dtoName: dtoClassName,
+              methodName: method.key?.name || "unknown"
+            }
+          });
+        });
+      }
+    };
+  },
+};
+
+export default {
+  rules: {
+    "enforce-nonentity-dto-create": enforceNonEntityDtoCreateRule,
+  },
+};
+

package/rules/enforce-playable-entity-naming.js

@@ -0,0 +1,108 @@
+export default {
+  meta: {
+    type: "problem",
+    docs: {
+      description: "Enforce consistent naming for playable entity references (playableRace, playableClass, playableFaction instead of race, class, faction)",
+      category: "Best Practices",
+      recommended: true,
+    },
+    messages: {
+      usePlayablePrefix: "Use '{{correctName}}' instead of '{{incorrectName}}' for playable entity references. Properties and parameters should use 'playable' prefix for consistency.",
+    },
+    fixable: "code",
+    schema: [],
+  },
+
+  create (context) {
+    const entityMapping = {
+      class: "playableClass",
+      faction: "playableFaction",
+      race: "playableRace",
+    };
+
+    function isAlreadyCorrect (name) {
+      return name && name.startsWith("playable");
+    }
+
+    function shouldSkipFile (filename) {
+      return filename.includes("Enum.ts") || filename.includes("enum/");
+    }
+
+    function isRelevantIdentifier (node) {
+      const parent = node.parent;
+      if (!parent) {
+        return false;
+      }
+
+      if (parent.type === "Property" && parent.key === node) {
+        return true;
+      }
+
+      if (parent.type === "PropertyDefinition" && parent.key === node) {
+        return true;
+      }
+
+      if (parent.type === "VariableDeclarator" && parent.id === node) {
+        return true;
+      }
+
+      if (parent.type === "TSPropertySignature" && parent.key === node) {
+        return true;
+      }
+
+      const grandparent = parent.parent;
+      if (grandparent) {
+        if (grandparent.type === "FunctionDeclaration" && grandparent.params && grandparent.params.includes(node)) {
+          return true;
+        }
+
+        if (grandparent.type === "MethodDefinition" && grandparent.value && grandparent.value.params && grandparent.value.params.includes(node)) {
+          return true;
+        }
+
+        if (grandparent.type === "ArrowFunctionExpression" && grandparent.params && grandparent.params.includes(node)) {
+          return true;
+        }
+      }
+
+      return false;
+    }
+
+    return {
+      Identifier (node) {
+        const name = node.name;
+
+        if (!name || !(name in entityMapping)) {
+          return;
+        }
+
+        if (isAlreadyCorrect(name)) {
+          return;
+        }
+
+        const filename = context.getFilename();
+        if (shouldSkipFile(filename)) {
+          return;
+        }
+
+        if (!isRelevantIdentifier(node)) {
+          return;
+        }
+
+        const correctName = entityMapping[name];
+
+        context.report({
+          messageId: "usePlayablePrefix",
+          node,
+          data: {
+            correctName,
+            incorrectName: name,
+          },
+          fix (fixer) {
+            return fixer.replaceText(node, correctName);
+          },
+        });
+      },
+    };
+  },
+};

package/rules/enforce-repository-token-handling.js

@@ -0,0 +1,92 @@
+/**
+ * @fileoverview Enforce centralized token handling in repositories
+ * @author Echoes of Order Team
+ */
+
+"use strict";
+
+export default {
+  meta: {
+    type: "problem",
+    docs: {
+      description: "Enforce centralized token handling in repositories",
+      category: "Best Practices",
+      recommended: true,
+    },
+    messages: {
+      mustExtendAbstractRepo: "Repository '{{className}}' must extend AbstractRepo for centralized token handling",
+      noManualTokenCalls: "Manual token calls are forbidden. Use AbstractRepo for automatic token handling",
+      noDirectApiClient: "Direct ApiClient instantiation is forbidden. Use AbstractRepo instead",
+      noManualSetToken: "Manual setToken() calls are forbidden. Use AbstractRepo for automatic token handling",
+      noManualEnsureToken: "Manual ensureToken() calls are forbidden. Use AbstractRepo for automatic token handling",
+    },
+    fixable: null,
+    schema: [],
+  },
+
+  create(context) {
+    const filename = context.getFilename();
+
+    // Nur in Frontend-Repository-Dateien anwenden
+    if (!filename.includes("/infrastructure/") || !filename.includes("Repo")) {
+      return {};
+    }
+
+    let className = null;
+    let extendsAbstractRepo = false;
+
+    return {
+      ClassDeclaration(node) {
+        className = node.id.name;
+        extendsAbstractRepo = node.superClass &&
+          node.superClass.type === "Identifier" &&
+          node.superClass.name === "AbstractRepo";
+      },
+
+      NewExpression(node) {
+        if (node.callee.type === "Identifier" && node.callee.name === "ApiClient") {
+          context.report({
+            node,
+            messageId: "noDirectApiClient",
+            data: { className },
+          });
+        }
+      },
+
+      CallExpression(node) {
+        const callee = node.callee;
+
+        // Prüfe auf manuelle Token-Aufrufe
+        if (callee.type === "MemberExpression" && callee.property.type === "Identifier") {
+          const methodName = callee.property.name;
+
+          if (methodName === "ensureToken" || methodName === "ensureAuthenticated") {
+            context.report({
+              node,
+              messageId: "noManualTokenCalls",
+              data: { className },
+            });
+          }
+
+          if (methodName === "setToken") {
+            context.report({
+              node,
+              messageId: "noManualSetToken",
+              data: { className },
+            });
+          }
+        }
+      },
+
+      "ClassDeclaration:exit"(node) {
+        if (className && !extendsAbstractRepo) {
+          context.report({
+            node: node.id,
+            messageId: "mustExtendAbstractRepo",
+            data: { className },
+          });
+        }
+      },
+    };
+  },
+};

package/rules/enforce-request-dto-no-entity-dto.js

@@ -0,0 +1,201 @@
+/**
+ * @fileoverview Enforce that Request DTOs cannot have EntityDto properties
+ * @author Echoes of Order Team
+ */
+
+//------------------------------------------------------------------------------
+// Rule Definition
+//------------------------------------------------------------------------------
+
+/** @type {import('eslint').Rule.RuleModule} */
+export default {
+  meta: {
+    type: "problem",
+    docs: {
+      description: "Request DTOs cannot have EntityDto properties",
+      category: "Architecture",
+      recommended: true,
+    },
+    fixable: null,
+    schema: [],
+    messages: {
+      requestDtoEntityDtoForbidden: "Request DTO '{{className}}' cannot have EntityDto property '{{propertyName}}'. Use a regular DTO instead.",
+      requestDtoEntityDtoImportForbidden: "Request DTO '{{className}}' cannot import EntityDto '{{importName}}'. Use a regular DTO instead.",
+    },
+  },
+
+  create(context) {
+    //--------------------------------------------------------------------------
+    // Helpers
+    //--------------------------------------------------------------------------
+
+    /**
+     * Check if a file is a Request DTO
+     * @param {string} filename - The filename
+     * @returns {boolean} True if it's a Request DTO
+     */
+    function isRequestDto(filename) {
+      // Allow specific test fixtures for testing
+      if (filename.includes("test-fixtures")) {
+        return filename.includes("InvalidRequestDto.ts") || 
+               filename.includes("ValidRequestDtoNoEntityDto.ts");
+      }
+
+      return filename.includes("/dto/Request/") ||
+             filename.includes("RequestDto.ts") ||
+             filename.includes("RequestDto.js");
+    }
+
+    /**
+     * Check if a class name indicates it's a Request DTO
+     * @param {string} className - The class name
+     * @returns {boolean} True if it's a Request DTO
+     */
+    function isRequestDtoClass(className) {
+      return className.endsWith("RequestDto") ||
+             className.endsWith("Request");
+    }
+
+    /**
+     * Check if an import is an EntityDto
+     * @param {string} importName - The import name
+     * @returns {boolean} True if it's an EntityDto
+     */
+    function isEntityDtoImport(importName) {
+      return importName.endsWith("EntityDto") ||
+             importName.includes("EntityDto");
+    }
+
+    /**
+     * Check if a property type is an EntityDto
+     * @param {ASTNode} property - The property node
+     * @returns {boolean} True if it's an EntityDto
+     */
+    function isEntityDtoProperty(property) {
+      if (!property.typeAnnotation || !property.typeAnnotation.typeAnnotation) {
+        return false;
+      }
+
+      const typeAnnotation = property.typeAnnotation.typeAnnotation;
+
+      // Check for direct EntityDto type
+      if (typeAnnotation.type === "TSTypeReference" &&
+          typeAnnotation.typeName &&
+          typeAnnotation.typeName.type === "Identifier") {
+        return isEntityDtoImport(typeAnnotation.typeName.name);
+      }
+
+      // Check for array of EntityDto
+      if (typeAnnotation.type === "TSTypeReference" &&
+          typeAnnotation.typeName &&
+          typeAnnotation.typeName.type === "TSQualifiedName") {
+        const qualifiedName = typeAnnotation.typeName;
+        if (qualifiedName.right && qualifiedName.right.type === "Identifier") {
+          return isEntityDtoImport(qualifiedName.right.name);
+        }
+      }
+
+      return false;
+    }
+
+    //--------------------------------------------------------------------------
+    // Public
+    //--------------------------------------------------------------------------
+
+    return {
+      // Check imports in Request DTO files
+      ImportDeclaration(node) {
+        const filename = context.getFilename();
+
+        if (!isRequestDto(filename)) {
+          return;
+        }
+
+        // Check if importing an EntityDto
+        if (node.specifiers) {
+          for (const specifier of node.specifiers) {
+            if (specifier.type === "ImportDefaultSpecifier" ||
+                specifier.type === "ImportSpecifier") {
+              const importName = specifier.imported ?
+                specifier.imported.name :
+                specifier.local.name;
+
+              if (isEntityDtoImport(importName)) {
+                context.report({
+                  node: specifier,
+                  messageId: "requestDtoEntityDtoImportForbidden",
+                  data: {
+                    className: "Unknown", // Will be updated when we find the class
+                    importName: importName,
+                  },
+                });
+              }
+            }
+          }
+        }
+      },
+
+      // Check class properties in Request DTO files
+      ClassDeclaration(node) {
+        const filename = context.getFilename();
+
+        if (!isRequestDto(filename) && !isRequestDtoClass(node.id.name)) {
+          return;
+        }
+
+        // Check all class properties
+        for (const member of node.body.body) {
+          if (member.type === "TSParameterProperty" ||
+              member.type === "ClassProperty" ||
+              member.type === "PropertyDefinition") {
+
+            if (isEntityDtoProperty(member)) {
+              const propertyName = member.key.name || member.key.value;
+
+              context.report({
+                node: member,
+                messageId: "requestDtoEntityDtoForbidden",
+                data: {
+                  className: node.id.name,
+                  propertyName: propertyName,
+                },
+              });
+            }
+          }
+        }
+      },
+
+      // Check method parameters in Request DTO files
+      MethodDefinition(node) {
+        const filename = context.getFilename();
+
+        if (!isRequestDto(filename)) {
+          return;
+        }
+
+        // Check method parameters
+        if (node.value && node.value.params) {
+          for (const param of node.value.params) {
+            if (param.typeAnnotation &&
+                param.typeAnnotation.typeAnnotation &&
+                isEntityDtoProperty(param)) {
+
+              const methodName = node.key.name || node.key.value;
+
+              context.report({
+                node: param,
+                messageId: "requestDtoEntityDtoForbidden",
+                data: {
+                  className: "Unknown", // Will be updated when we find the class
+                  propertyName: `${methodName} parameter`,
+                },
+              });
+            }
+          }
+        }
+      },
+    };
+  },
+};
+
+