@echoes-of-order/eslint-config 1.121.0

package/rules/enforce-entity-dto-extends-base.js

@@ -0,0 +1,141 @@
+export default {
+  meta: {
+    type: "problem",
+    docs: {
+      description: "Enforce that Entity DTOs extend BaseEntityDto to prevent circular dependencies",
+      category: "Best Practices",
+      recommended: true,
+    },
+    messages: {
+      missingBaseClass: "Entity-DTO '{{className}}' muss BaseEntityDto erweitern, um zirkuläre Abhängigkeiten zu vermeiden",
+      invalidBaseClass: "Entity-DTO '{{className}}' muss genau BaseEntityDto erweitern, nicht '{{extendedClass}}'",
+      missingBaseImport: "Entity-DTO '{{className}}' muss BaseEntityDto importieren: import { BaseEntityDto } from '@/dto/BaseEntityDto'",
+    },
+    fixable: "code",
+    schema: [],
+  },
+
+  create (context) {
+    const filename = context.getFilename();
+
+    // Skip non-DTO files
+    if (!filename.includes("/dto/Entity/")) {
+      return {};
+    }
+
+    // Skip BaseEntityDto itself
+    if (filename.endsWith("/BaseEntityDto.ts")) {
+      return {};
+    }
+
+    // Skip test files
+    if (filename.includes(".test.") || filename.includes(".spec.") || filename.includes("__tests__")) {
+      return {};
+    }
+
+    let hasBaseImport = false;
+    let className = null;
+    let hasFromEntity = false;
+
+    return {
+      ImportDeclaration (node) {
+        // Check for BaseEntityDto import (absolute or relative)
+        const isBaseImport = node.source.value === "@/dto/BaseEntityDto" ||
+                             node.source.value.endsWith("/BaseEntityDto") ||
+                             node.source.value === "./BaseEntityDto";
+
+        if (isBaseImport) {
+          const hasBaseEntityDto = node.specifiers.some(
+            (spec) => spec.type === "ImportSpecifier" && spec.imported.name === "BaseEntityDto",
+          );
+          if (hasBaseEntityDto) {
+            hasBaseImport = true;
+          }
+        }
+      },
+
+      ClassDeclaration (node) {
+        // Only check classes that are Entity DTOs
+        if (!node.id || !node.id.name.endsWith("EntityDto")) {
+          return;
+        }
+
+        className = node.id.name;
+
+        // Check if class has fromEntity method
+        hasFromEntity = node.body.body.some(
+          (member) => member.type === "MethodDefinition"
+            && member.static
+            && member.key.name === "fromEntity",
+        );
+
+        // Only enforce if class has fromEntity method
+        if (!hasFromEntity) {
+          return;
+        }
+
+        // Check if class extends BaseEntityDto
+        if (!node.superClass) {
+          context.report({
+            node,
+            messageId: "missingBaseClass",
+            data: { className },
+            fix (fixer) {
+              const fixes = [];
+
+              // Add import if missing
+              if (!hasBaseImport) {
+                const sourceCode = context.getSourceCode();
+                const firstImport = sourceCode.ast.body.find((n) => n.type === "ImportDeclaration");
+                if (firstImport) {
+                  fixes.push(
+                    fixer.insertTextBefore(
+                    firstImport,
+                    "import { BaseEntityDto } from \"@/dto/BaseEntityDto\";\n",
+                  ),
+                  );
+                }
+              }
+
+              // Add extends clause
+              const classKeyword = context.getSourceCode().getFirstToken(node);
+              const className = context.getSourceCode().getFirstToken(node, 1);
+              fixes.push(fixer.insertTextAfter(className, " extends BaseEntityDto"));
+
+              return fixes;
+            },
+          });
+        } else if (node.superClass.name !== "BaseEntityDto") {
+          context.report({
+            node: node.superClass,
+            messageId: "invalidBaseClass",
+            data: {
+              className,
+              extendedClass: node.superClass.name,
+            },
+          });
+        } else if (!hasBaseImport) {
+          // Class extends BaseEntityDto but import is missing
+          context.report({
+            node,
+            messageId: "missingBaseImport",
+            data: { className },
+            fix (fixer) {
+              const sourceCode = context.getSourceCode();
+              const firstImport = sourceCode.ast.body.find((n) => n.type === "ImportDeclaration");
+              if (firstImport) {
+                return fixer.insertTextBefore(
+                  firstImport,
+                  "import { BaseEntityDto } from \"@/dto/BaseEntityDto\";\n",
+                );
+              }
+
+              return null;
+            },
+          });
+        }
+      },
+    };
+  },
+};
+

package/rules/enforce-entity-dto-from-request-dto-structure.js

@@ -0,0 +1,113 @@
+export default {
+  meta: {
+    type: "problem",
+    docs: {
+      description: "Enforce correct structure of EntityDto.fromRequestDto() methods",
+      category: "Best Practices",
+      recommended: true,
+    },
+    messages: {
+      wrongReturnType: "fromRequestDto() muss {{entityDtoName}} zurückgeben, nicht Entity. Das Pattern ist: EntityDto → toEntity() → save().",
+      wrongParameterType: "fromRequestDto() muss {{requestDtoName}} als Parameter haben für typsichere Konvertierung.",
+      noRelationsAllowed: "fromRequestDto() darf keine Relations setzen. Relations werden im Service mit load*EntityDto() Methoden geladen. Nur direkte Properties sind erlaubt.",
+    },
+    schema: [],
+  },
+  create (context) {
+    const filename = context.getFilename();
+
+    if (!filename.includes("/dto/Entity/") || !filename.endsWith("EntityDto.ts")) {
+      return {};
+    }
+
+    return {
+      MethodDefinition (node) {
+        if (
+          node.static &&
+          node.key.name === "fromRequestDto" &&
+          node.value.type === "FunctionExpression"
+        ) {
+          const returnType = node.value.returnType;
+          const params = node.value.params;
+
+          if (returnType && returnType.typeAnnotation) {
+            const returnTypeName = context.getSourceCode().getText(returnType.typeAnnotation);
+
+            if (returnTypeName.includes("Entity") && !returnTypeName.includes("Dto")) {
+              const className = context.getSourceCode().getText(node.parent.parent.id);
+              context.report({
+                messageId: "wrongReturnType",
+                node: returnType,
+                data: {
+                  entityDtoName: className,
+                },
+              });
+            }
+          }
+
+          if (params.length > 0 && params[0].typeAnnotation) {
+            const typeAnnotation = params[0].typeAnnotation.typeAnnotation;
+            const isInlineInterface = typeAnnotation.type === "TSTypeLiteral";
+            const paramTypeName = context.getSourceCode().getText(typeAnnotation);
+
+            if (!isInlineInterface && !paramTypeName.includes("RequestDto") && !paramTypeName.includes("import(")) {
+              context.report({
+                messageId: "wrongParameterType",
+                node: params[0],
+                data: {
+                  requestDtoName: paramTypeName,
+                },
+              });
+            }
+          }
+
+          const bodyStatements = node.value.body.body;
+          for (const statement of bodyStatements) {
+            if (statement.type === "ExpressionStatement") {
+              const expr = statement.expression;
+
+              if (
+                expr.type === "AssignmentExpression" &&
+                expr.left.type === "MemberExpression" &&
+                expr.left.object.name === "dto"
+              ) {
+                const propertyName = expr.left.property.name;
+
+                const exactRelationNames = [
+                  "quality",
+                  "binding",
+                  "itemClass",
+                  "itemSubclass",
+                  "inventoryType",
+                  "parent",
+                  "child",
+                  "relation",
+                  "playableClass",
+                  "playableRace",
+                  "playableFaction",
+                  "character",
+                  "account",
+                  "stats",
+                  "translations",
+                  "abilities",
+                  "baseStats",
+                  "raceAbilities",
+                ];
+
+                const isRelation = exactRelationNames.includes(propertyName);
+
+                if (isRelation) {
+                  context.report({
+                    messageId: "noRelationsAllowed",
+                    node: statement,
+                  });
+                }
+              }
+            }
+          }
+        }
+      },
+    };
+  },
+};
+

package/rules/enforce-entity-dto-fromentity-complex.js

@@ -0,0 +1,69 @@
+export default {
+  meta: {
+    type: "problem",
+    docs: {
+      description: "Entity-DTOs müssen fromEntity-Methoden bereitstellen",
+      category: "Architecture",
+      recommended: true,
+    },
+    schema: [],
+    messages: {
+      missingFromEntityMethod: "Entity-DTO-Klasse '{{dtoName}}' muss eine statische fromEntity-Methode bereitstellen",
+      forbiddenCreateMethod: "Entity-DTO-Klasse '{{dtoName}}' darf keine create-Methode haben. Verwende stattdessen fromEntity-Methoden.",
+    },
+  },
+  create(context) {
+    const filename = context.getFilename();
+
+    // Prüfe, ob es sich um eine Entity-DTO-Datei handelt
+    const isEntityDtoFile = filename.includes("/dto/Entity/");
+
+    if (!isEntityDtoFile) {
+      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;
+
+        const methods = classNode.body.body.filter(member =>
+          member.type === "MethodDefinition" &&
+          member.static === true
+        );
+
+        const hasFromEntityMethod = methods.some(method =>
+          method.key?.name === "fromEntity"
+        );
+
+        const hasCreateMethod = methods.some(method =>
+          method.key?.name === "create"
+        );
+
+        // Request-DTOs sind von der fromEntity-Regel ausgenommen
+        const isRequestDto = filename.includes("/dto/Request/");
+
+        if (!isRequestDto) {
+          if (!hasFromEntityMethod) {
+            context.report({ node: classNode, messageId: "missingFromEntityMethod", data: { dtoName: dtoClassName } });
+          }
+          if (hasCreateMethod) {
+            context.report({ node: classNode, messageId: "forbiddenCreateMethod", data: { dtoName: dtoClassName } });
+          }
+        }
+      },
+    };
+  },
+};

package/rules/enforce-entity-dto-fromentity-simple.js

@@ -0,0 +1,69 @@
+export default {
+  meta: {
+    type: "problem",
+    docs: {
+      description: "Entity-DTOs müssen fromEntity-Methoden bereitstellen",
+      category: "Architecture",
+      recommended: true,
+    },
+    schema: [],
+    messages: {
+      missingFromEntityMethod: "Entity-DTO-Klasse '{{dtoName}}' muss eine statische fromEntity-Methode bereitstellen",
+      forbiddenCreateMethod: "Entity-DTO-Klasse '{{dtoName}}' darf keine create-Methode haben. Verwende stattdessen fromEntity-Methoden.",
+    },
+  },
+  create(context) {
+    const filename = context.getFilename();
+
+    // Prüfe, ob es sich um eine Entity-DTO-Datei handelt
+    const isEntityDtoFile = filename.includes("/dto/Entity/");
+
+    if (!isEntityDtoFile) {
+      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;
+
+        const methods = classNode.body.body.filter(member =>
+          member.type === "MethodDefinition" &&
+          member.static === true
+        );
+
+        const hasFromEntityMethod = methods.some(method =>
+          method.key?.name === "fromEntity"
+        );
+
+        const hasCreateMethod = methods.some(method =>
+          method.key?.name === "create"
+        );
+
+        // Request-DTOs sind von der fromEntity-Regel ausgenommen
+        const isRequestDto = filename.includes("/dto/Request/");
+
+        if (!isRequestDto) {
+          if (!hasFromEntityMethod) {
+            context.report({ node: classNode, messageId: "missingFromEntityMethod", data: { dtoName: dtoClassName } });
+          }
+          if (hasCreateMethod) {
+            context.report({ node: classNode, messageId: "forbiddenCreateMethod", data: { dtoName: dtoClassName } });
+          }
+        }
+      },
+    };
+  },
+};

package/rules/enforce-entity-dto-fromrequestdto-structure.js

@@ -0,0 +1,262 @@
+/**
+ * @fileoverview Enforce correct structure for fromRequestDto methods in Entity DTOs
+ * @author Echoes of Order Team
+ */
+
+import fs from "fs";
+import path from "path";
+
+/** @type {import('eslint').Rule.RuleModule} */
+const enforceEntityDtoFromRequestDtoStructureRule = {
+  meta: {
+    type: "problem",
+    docs: {
+      description: "Enforce correct structure for fromRequestDto methods in Entity DTOs",
+      category: "Architecture",
+      recommended: true,
+    },
+    fixable: null,
+    schema: [],
+    messages: {
+      invalidParameterName: "fromRequestDto-Parameter muss 'requestDto' heissen, nicht '{{actualName}}'",
+      invalidParameterType: "fromRequestDto-Parameter muss vom Typ '{{expectedType}}' sein, nicht '{{actualType}}'",
+      missingDtoInstantiation: "fromRequestDto muss das EntityDto instanziieren: const dto = new {{className}}();",
+      wrongVariableName: "fromRequestDto muss die Variable 'dto' verwenden, nicht '{{actualName}}'. Verwende: const dto = new {{className}}();",
+      missingPropertyAssignment: "Property '{{propertyName}}' fehlt in fromRequestDto-Methode. Fuege hinzu: dto.{{propertyName}} = requestDto.{{propertyName}};",
+      autoFieldDirectAssignment: "Property '{{fieldName}}' darf nicht direkt zugewiesen werden. Verwende conditional assignment: if (requestDto.{{fieldName}}) { dto.{{fieldName}} = requestDto.{{fieldName}}; }",
+      invalidReturnType: "fromRequestDto muss '{{className}}' zurueckgeben, nicht '{{actualType}}'",
+      missingReturn: "fromRequestDto muss 'dto' zurueckgeben: return dto;",
+    },
+  },
+
+  create(context) {
+    const filename = context.getFilename();
+    const AUTO_MANAGED_FIELDS = ["id", "createdAt", "updatedAt"];
+
+    if (!filename.includes("/dto/Entity/") || filename.endsWith("/BaseEntityDto.ts")) {
+      return {};
+    }
+
+    function getEntityDtoClassName(filename) {
+      return path.basename(filename, ".ts");
+    }
+
+    function getExpectedRequestDtoName(entityDtoName) {
+      const baseRequestDtoName = entityDtoName.replace(/EntityDto$/, "RequestDto");
+      return {
+        base: baseRequestDtoName,
+        create: `Create${baseRequestDtoName}`,
+        update: `Update${baseRequestDtoName}`,
+      };
+    }
+
+    function isValidRequestDtoType(actualType, expectedNames) {
+      return actualType === expectedNames.base ||
+             actualType === expectedNames.create ||
+             actualType === expectedNames.update;
+    }
+
+    function getEntityDtoProperties(filename) {
+      try {
+        const content = fs.readFileSync(filename, "utf-8");
+        const lines = content.split("\n");
+        const properties = [];
+        let inDecorator = false;
+        let decoratorBraceCount = 0;
+
+        for (let i = 0; i < lines.length; i++) {
+          const line = lines[i];
+
+          if (line.trim().startsWith("@")) {
+            if (line.includes("(")) {
+              inDecorator = true;
+              decoratorBraceCount = (line.match(/\(/g) || []).length - (line.match(/\)/g) || []).length;
+            }
+          }
+
+          if (inDecorator) {
+            decoratorBraceCount += (line.match(/\(/g) || []).length - (line.match(/\)/g) || []).length;
+            if (decoratorBraceCount === 0) {
+              inDecorator = false;
+            }
+            continue;
+          }
+
+          const propertyMatch = line.match(/^\s+(\w+)(\?)?:\s+([^;]+);/);
+          if (propertyMatch && !line.trim().startsWith("@") && !line.includes("static ") && !line.includes("get ")) {
+            const propertyName = propertyMatch[1];
+            const propertyType = propertyMatch[3].trim();
+            
+            // Skip relations (EntityDto properties, arrays of EntityDto)
+            const isRelation = propertyType.includes("EntityDto") || 
+                               propertyType.includes("EntityDto[]") ||
+                               propertyType.includes("Array<") ||
+                               propertyType.match(/\[\s*\]/);
+            
+            if (propertyName !== "static" && !propertyName.startsWith("_") && !isRelation) {
+              properties.push({ name: propertyName });
+            }
+          }
+        }
+
+        return properties;
+      } catch (error) {
+        return [];
+      }
+    }
+
+    function isDirectAssignment(node, fieldName) {
+      if (node.type === "ExpressionStatement" && node.expression?.type === "AssignmentExpression") {
+        const left = node.expression.left;
+        return left?.type === "MemberExpression" && left.object?.name === "dto" && left.property?.name === fieldName;
+      }
+      return false;
+    }
+
+    function getAssignedProperties(body) {
+      const assigned = new Set();
+
+      function traverse(statements) {
+        if (!Array.isArray(statements)) return;
+
+        for (const stmt of statements) {
+          if (stmt.type === "ExpressionStatement" && stmt.expression?.type === "AssignmentExpression" && stmt.expression.left?.type === "MemberExpression" && stmt.expression.left.object?.name === "dto") {
+            assigned.add(stmt.expression.left.property.name);
+          }
+
+          if (stmt.type === "IfStatement") {
+            traverse(stmt.consequent?.body || [stmt.consequent]);
+            traverse(stmt.alternate?.body || [stmt.alternate]);
+          }
+
+          if (stmt.type === "BlockStatement") {
+            traverse(stmt.body);
+          }
+        }
+      }
+
+      traverse(body);
+      return assigned;
+    }
+
+    function isFromRequestDtoMethod(node) {
+      return (
+        (node.type === "MethodDefinition" || node.type === "Property") &&
+        node.key?.name === "fromRequestDto" &&
+        node.static === true
+      );
+    }
+
+    return {
+      MethodDefinition(node) {
+        if (!isFromRequestDtoMethod(node)) {
+          return;
+        }
+
+        const className = getEntityDtoClassName(filename);
+        const expectedRequestDtoName = getExpectedRequestDtoName(className);
+
+        const params = node.value.params;
+        if (params.length !== 1) {
+          return;
+        }
+
+        const param = params[0];
+
+        if (param.name !== "requestDto") {
+          context.report({ node: param, messageId: "invalidParameterName", data: { actualName: param.name } });
+        }
+
+        if (param.typeAnnotation) {
+          const typeAnnotation = param.typeAnnotation.typeAnnotation;
+          let actualType = "";
+
+          if (typeAnnotation.type === "TSTypeReference") {
+            actualType = typeAnnotation.typeName.name;
+          } else if (typeAnnotation.type === "TSImportType") {
+            const importPath = typeAnnotation.argument?.value;
+            if (importPath) {
+              const match = importPath.match(/\/([^/]+)$/);
+              actualType = match ? match[1] : "";
+            }
+          }
+
+          if (!isValidRequestDtoType(actualType, expectedRequestDtoName)) {
+            const expectedTypesList = `${expectedRequestDtoName.base}, ${expectedRequestDtoName.create}, or ${expectedRequestDtoName.update}`;
+            context.report({ node: param.typeAnnotation, messageId: "invalidParameterType", data: { expectedType: expectedTypesList, actualType: actualType || "unknown" } });
+          }
+        }
+
+        const body = node.value.body?.body;
+        if (!body || !Array.isArray(body)) {
+          return;
+        }
+
+        let dtoVarName = null;
+        const hasDtoInstantiation = body.some((stmt) => {
+          if (stmt.type === "VariableDeclaration") {
+            return stmt.declarations.some((decl) => {
+              if (decl.init?.type === "NewExpression" && decl.init.callee?.name === className) {
+                if (decl.id?.name !== "dto") {
+                  context.report({ node: decl.id, messageId: "wrongVariableName", data: { actualName: decl.id?.name || "unknown", className } });
+                  return false;
+                }
+                dtoVarName = "dto";
+                return true;
+              }
+              return false;
+            });
+          }
+          return false;
+        });
+
+        if (!hasDtoInstantiation) {
+          context.report({ node: node.value.body, messageId: "missingDtoInstantiation", data: { className } });
+        }
+
+        const dtoProperties = getEntityDtoProperties(filename);
+        const requiredProperties = dtoProperties.filter((prop) => !AUTO_MANAGED_FIELDS.includes(prop.name));
+
+        const assignedProperties = getAssignedProperties(body);
+
+        requiredProperties.forEach((prop) => {
+          if (!assignedProperties.has(prop.name)) {
+            context.report({ node: node.value.body, messageId: "missingPropertyAssignment", data: { propertyName: prop.name } });
+          }
+        });
+
+        AUTO_MANAGED_FIELDS.forEach((fieldName) => {
+          body.forEach((statement) => {
+            if (isDirectAssignment(statement, fieldName)) {
+              context.report({ node: statement, messageId: "autoFieldDirectAssignment", data: { fieldName } });
+            }
+          });
+        });
+
+        const returnStatement = body.find((stmt) => stmt.type === "ReturnStatement");
+        if (!returnStatement || returnStatement.argument?.name !== "dto") {
+          context.report({ node: node.value.body, messageId: "missingReturn" });
+        }
+
+        if (node.value.returnType) {
+          const returnTypeAnnotation = node.value.returnType.typeAnnotation;
+          let actualReturnType = "";
+
+          if (returnTypeAnnotation.type === "TSTypeReference") {
+            actualReturnType = returnTypeAnnotation.typeName.name;
+          }
+
+          if (actualReturnType !== className) {
+            context.report({ node: node.value.returnType, messageId: "invalidReturnType", data: { className, actualType: actualReturnType || "unknown" } });
+          }
+        }
+      },
+    };
+  },
+};
+
+export default {
+  rules: {
+    "enforce-entity-dto-fromrequestdto-structure": enforceEntityDtoFromRequestDtoStructureRule,
+  },
+};