@echoes-of-order/eslint-config 1.121.0

package/rules/enforce-request-dto-required-fields.js

@@ -0,0 +1,217 @@
+/**
+ * @fileoverview Enforce that Request DTOs have required fields for properties that are required in the corresponding Entity DTO
+ * @author Echoes of Order Team
+ */
+
+import fs from "fs";
+import path from "path";
+
+/** @type {import('eslint').Rule.RuleModule} */
+const enforceRequestDtoRequiredFieldsRule = {
+  meta: {
+    type: "problem",
+    docs: {
+      description: "Request DTOs must not have optional properties if they are required in the corresponding Entity DTO",
+      category: "Architecture",
+      recommended: true,
+    },
+    fixable: null,
+    schema: [],
+    messages: {
+      optionalPropertyInRequestDto: "Property '{{propertyName}}' is optional in Request DTO but required in Entity DTO '{{entityDtoName}}'. Make it required: {{propertyName}}!: {{propertyType}}",
+    },
+  },
+
+  create(context) {
+    const filename = context.getFilename();
+
+    // Nur auf Request DTOs anwenden
+    if (!filename.includes("/dto/Request/") || !filename.endsWith("RequestDto.ts")) {
+      return {};
+    }
+
+    function getRequestDtoName(filename) {
+      return path.basename(filename, ".ts");
+    }
+
+    function getCorrespondingEntityDtoPath(filename) {
+      const requestDtoName = getRequestDtoName(filename);
+      const entityDtoName = requestDtoName.replace(/RequestDto$/, "EntityDto");
+      
+      // Suche nach der Entity DTO im gleichen Verzeichnis oder in /dto/Entity/
+      const baseDir = path.dirname(filename);
+      const projectRoot = filename.substring(0, filename.indexOf("/dto/"));
+      
+      // Mögliche Pfade für Entity DTOs
+      const possiblePaths = [
+        path.join(baseDir, `${entityDtoName}.ts`),
+        path.join(projectRoot, "dto", "Entity", `${entityDtoName}.ts`),
+        // Weitere mögliche Unterverzeichnisse
+        ...findEntityDtoInSubdirectories(path.join(projectRoot, "dto", "Entity"), entityDtoName),
+      ];
+
+      for (const possiblePath of possiblePaths) {
+        if (fs.existsSync(possiblePath)) {
+          return possiblePath;
+        }
+      }
+
+      return null;
+    }
+
+    function findEntityDtoInSubdirectories(baseDir, entityDtoName) {
+      const results = [];
+      
+      if (!fs.existsSync(baseDir)) {
+        return results;
+      }
+
+      function traverse(dir) {
+        try {
+          const entries = fs.readdirSync(dir, { withFileTypes: true });
+          
+          for (const entry of entries) {
+            const fullPath = path.join(dir, entry.name);
+            
+            if (entry.isDirectory()) {
+              traverse(fullPath);
+            } else if (entry.isFile() && entry.name === `${entityDtoName}.ts`) {
+              results.push(fullPath);
+            }
+          }
+        } catch (error) {
+          // Ignoriere Fehler beim Durchsuchen
+        }
+      }
+
+      traverse(baseDir);
+      return results;
+    }
+
+    function getEntityDtoProperties(entityDtoPath) {
+      try {
+        const content = fs.readFileSync(entityDtoPath, "utf-8");
+        const lines = content.split("\n");
+        const properties = {};
+
+        let inClassBody = false;
+        const AUTO_MANAGED_FIELDS = ["id", "createdAt", "updatedAt"];
+
+        for (const line of lines) {
+          if (line.includes("export default class") || line.includes("export class")) {
+            inClassBody = true;
+            continue;
+          }
+
+          if (inClassBody && line.trim() === "}") {
+            break;
+          }
+
+          if (inClassBody && !line.includes("static ") && !line.trim().startsWith("@")) {
+            const propertyMatch = line.match(/^\s+(\w+)(\?)?:\s+([^;]+);/);
+            if (propertyMatch) {
+              const propertyName = propertyMatch[1];
+              const isOptional = propertyMatch[2] === "?";
+              const propertyType = propertyMatch[3].trim();
+
+              // Ignoriere auto-managed fields
+              if (!AUTO_MANAGED_FIELDS.includes(propertyName) && !propertyName.startsWith("_")) {
+                properties[propertyName] = {
+                  isOptional,
+                  type: propertyType,
+                };
+              }
+            }
+          }
+        }
+
+        return properties;
+      } catch (error) {
+        return {};
+      }
+    }
+
+    function getRequestDtoProperties(classNode) {
+      const properties = {};
+
+      if (!classNode || !classNode.body) {
+        return properties;
+      }
+
+      for (const member of classNode.body.body) {
+        if (member.type === "PropertyDefinition" || member.type === "ClassProperty") {
+          const key = member.key;
+          if (key && key.type === "Identifier") {
+            const propertyName = key.name;
+            const isOptional = member.optional === true;
+            
+            let propertyType = "unknown";
+            if (member.typeAnnotation && member.typeAnnotation.typeAnnotation) {
+              const typeNode = member.typeAnnotation.typeAnnotation;
+              if (typeNode.type === "TSTypeReference" && typeNode.typeName) {
+                propertyType = typeNode.typeName.name;
+              } else if (typeNode.type === "TSStringKeyword") {
+                propertyType = "string";
+              } else if (typeNode.type === "TSNumberKeyword") {
+                propertyType = "number";
+              } else if (typeNode.type === "TSBooleanKeyword") {
+                propertyType = "boolean";
+              }
+            }
+
+            if (!propertyName.startsWith("_") && propertyName !== "constructor") {
+              properties[propertyName] = {
+                isOptional,
+                type: propertyType,
+                node: member,
+              };
+            }
+          }
+        }
+      }
+
+      return properties;
+    }
+
+    return {
+      ClassDeclaration(node) {
+        const entityDtoPath = getCorrespondingEntityDtoPath(filename);
+        
+        if (!entityDtoPath) {
+          // Keine korrespondierende Entity DTO gefunden - kein Fehler
+          return;
+        }
+
+        const entityDtoProperties = getEntityDtoProperties(entityDtoPath);
+        const requestDtoProperties = getRequestDtoProperties(node);
+
+        // Vergleiche Properties
+        for (const [propertyName, requestProp] of Object.entries(requestDtoProperties)) {
+          const entityProp = entityDtoProperties[propertyName];
+
+          if (entityProp) {
+            // Property existiert in beiden DTOs
+            if (requestProp.isOptional && !entityProp.isOptional) {
+              // Property ist im Request DTO optional, aber in Entity DTO required
+              context.report({
+                node: requestProp.node,
+                messageId: "optionalPropertyInRequestDto",
+                data: {
+                  propertyName,
+                  entityDtoName: getRequestDtoName(filename).replace(/RequestDto$/, "EntityDto"),
+                  propertyType: requestProp.type,
+                },
+              });
+            }
+          }
+        }
+      },
+    };
+  },
+};
+
+export default {
+  rules: {
+    "enforce-request-dto-required-fields": enforceRequestDtoRequiredFieldsRule,
+  },
+};

package/rules/enforce-result-pattern.js

@@ -0,0 +1,45 @@
+export default {
+  meta: {
+    type: "suggestion",
+    docs: {
+      description: "Enforce consistent Result pattern usage",
+      category: "Best Practices",
+      recommended: true,
+    },
+    fixable: null,
+    schema: [],
+  },
+  create(context) {
+    return {
+      ImportDeclaration(node) {
+        if (node.source.value === "@/dto/Result") {
+          const specifiers = node.specifiers;
+          const hasDefaultImport = specifiers.some(spec => spec.type === "ImportDefaultSpecifier");
+          const hasNamedImport = specifiers.some(spec => spec.type === "ImportSpecifier" && spec.imported.name === "Result");
+
+          if (hasDefaultImport && hasNamedImport) {
+            context.report({
+              node,
+              message: "Duplicate Result import detected. Use either default or named import, not both.",
+              fix(fixer) {
+                return fixer.replaceText(node, 'import { Result } from "@/dto/Result";');
+              }
+            });
+          }
+        }
+      },
+
+      CallExpression(node) {
+        if (node.callee.type === "Identifier" && node.callee.name === "Result") {
+          const args = node.arguments;
+          if (args.length === 0) {
+            context.report({
+              node,
+              message: "Result constructor requires at least one argument."
+            });
+          }
+        }
+      }
+    };
+  }
+};

package/rules/enforce-service-relation-loading.js

@@ -0,0 +1,116 @@
+export default {
+  meta: {
+    type: "problem",
+    docs: {
+      description: "Enforce services load relations with load*EntityDto() methods",
+      category: "Best Practices",
+      recommended: true,
+    },
+    messages: {
+      useLoadEntityDtoMethods: "Relations müssen mit private async load*EntityDto() Methoden geladen werden. Pattern: loadQualityEntityDto(), loadBindingEntityDto(), etc.",
+      convertEntityToDto: "Entities müssen mit EntityDto.fromEntity() zu EntityDto konvertiert werden. Direkte Entity-Zuweisung ohne DTO-Konvertierung ist nicht erlaubt.",
+      missingLoadMethod: "Service sollte eine private async load{{relationName}}EntityDto() Methode haben für das Laden von {{relationName}} Relations.",
+    },
+    schema: [],
+  },
+  create (context) {
+    const filename = context.getFilename();
+
+    if (!filename.includes("/service/") && !filename.endsWith("Service.ts")) {
+      return {};
+    }
+
+    let hasFromRequestDtoCall = false;
+    const relationAssignments = [];
+    const loadEntityDtoVariables = new Set();
+
+    return {
+      CallExpression (node) {
+        if (
+          node.callee.type === "MemberExpression" &&
+          node.callee.property.name === "fromRequestDto" &&
+          node.callee.object.name?.endsWith("EntityDto")
+        ) {
+          hasFromRequestDtoCall = true;
+        }
+      },
+      VariableDeclarator (node) {
+        if (
+          node.init &&
+          node.init.type === "AwaitExpression" &&
+          node.init.argument &&
+          node.init.argument.type === "CallExpression" &&
+          node.init.argument.callee.type === "MemberExpression" &&
+          node.init.argument.callee.property.name.startsWith("load") &&
+          node.init.argument.callee.property.name.endsWith("EntityDto")
+        ) {
+          if (node.id.type === "Identifier") {
+            loadEntityDtoVariables.add(node.id.name);
+          }
+        }
+      },
+      ArrayPattern (node) {
+        const parent = node.parent;
+        if (
+          parent &&
+          parent.type === "VariableDeclarator" &&
+          parent.init &&
+          parent.init.type === "AwaitExpression" &&
+          parent.init.argument &&
+          parent.init.argument.type === "CallExpression" &&
+          parent.init.argument.callee.type === "MemberExpression" &&
+          parent.init.argument.callee.object.name === "Promise" &&
+          parent.init.argument.callee.property.name === "all"
+        ) {
+          node.elements.forEach((element) => {
+            if (element && element.type === "Identifier") {
+              loadEntityDtoVariables.add(element.name);
+            }
+          });
+        }
+      },
+      AssignmentExpression (node) {
+        if (
+          hasFromRequestDtoCall &&
+          node.left.type === "MemberExpression" &&
+          node.left.object.name?.toLowerCase().includes("dto")
+        ) {
+          const propertyName = node.left.property.name;
+          const rightValue = node.right;
+
+          const relationKeywords = [
+            "quality",
+            "binding",
+            "itemClass",
+            "itemSubclass",
+            "inventoryType",
+            "type",
+            "parent",
+            "child",
+          ];
+
+          if (relationKeywords.some((keyword) => propertyName.toLowerCase().includes(keyword))) {
+            if (
+              rightValue.type === "Identifier" &&
+              !loadEntityDtoVariables.has(rightValue.name)
+            ) {
+              relationAssignments.push({
+                node,
+                propertyName,
+              });
+            }
+          }
+        }
+      },
+      "Program:exit" () {
+        for (const { node } of relationAssignments) {
+          context.report({
+            messageId: "convertEntityToDto",
+            node,
+          });
+        }
+      },
+    };
+  },
+};
+

package/rules/enforce-test-coverage.js

@@ -0,0 +1,96 @@
+/**
+ * ESLint-Regel: enforce-test-coverage
+ * Stellt sicher, dass alle Services und Controller entsprechende Test-Dateien haben
+ */
+
+import fs from "fs";
+import path from "path";
+
+/** @type {import('eslint').Rule.RuleModule} */
+const enforceTestCoverageRule = {
+  meta: {
+    type: "problem",
+    docs: {
+      description: "Alle Services und Controller müssen entsprechende Test-Dateien haben",
+      category: "Testing",
+      recommended: true,
+    },
+    schema: [],
+    messages: {
+      missingTestFile: "{{fileType}} '{{className}}' hat keine entsprechende Test-Datei. Erwarte: {{expectedTestPath}}",
+      testFileExists: "Test-Datei gefunden: {{testPath}}",
+    },
+  },
+  create(context) {
+    const filename = context.getFilename();
+
+    // Nur Services und Controller prüfen
+    const isServiceFile = filename.includes("/service/") && filename.endsWith(".ts") && !filename.includes("test");
+    const isControllerFile = filename.includes("/controller/") && filename.endsWith("Controller.ts") && !filename.includes("test");
+
+    if (!isServiceFile && !isControllerFile) return {};
+
+    function findTestFile(originalFilePath) {
+      const dir = path.dirname(originalFilePath);
+      const baseName = path.basename(originalFilePath, ".ts");
+
+      // Mögliche Test-Datei-Patterns
+      const testPatterns = [
+        path.join(dir, "__tests__", `${baseName}.test.ts`),
+        path.join(dir, "__tests__", `${baseName}.spec.ts`),
+        path.join(dir, `${baseName}.test.ts`),
+        path.join(dir, `${baseName}.spec.ts`),
+      ];
+
+      for (const testPath of testPatterns) {
+        try {
+          if (fs.existsSync(testPath)) {
+            return testPath;
+          }
+        } catch (error) {
+          // Datei nicht gefunden, weiter suchen
+        }
+      }
+
+      return null;
+    }
+
+    return {
+      ClassDeclaration(node) {
+        const className = node.id?.name;
+        if (!className) return;
+
+        // Bestimme Dateityp
+        let fileType = "Class";
+        if (className.endsWith("Service")) {
+          fileType = "Service";
+        } else if (className.endsWith("Controller")) {
+          fileType = "Controller";
+        }
+
+        // Nur Services und Controller prüfen
+        if (fileType === "Class") return;
+
+        const testFile = findTestFile(filename);
+
+        if (!testFile) {
+          const dir = path.dirname(filename);
+          const baseName = path.basename(filename, ".ts");
+          const expectedTestPath = path.join(dir, "__tests__", `${baseName}.test.ts`);
+
+          context.report({
+            node,
+            messageId: "missingTestFile",
+            data: {
+              fileType,
+              className,
+              expectedTestPath: path.relative(process.cwd(), expectedTestPath),
+            },
+          });
+        }
+      },
+    };
+  },
+};
+
+export default enforceTestCoverageRule;

package/rules/enforce-toentity-conditional-assignment.js

@@ -0,0 +1,132 @@
+/**
+ * @fileoverview Enforce conditional assignment for id, createdAt, updatedAt in toEntity methods
+ * @author Echoes of Order Team
+ */
+
+/** @type {import('eslint').Rule.RuleModule} */
+const enforceToEntityConditionalAssignmentRule = {
+  meta: {
+    type: "problem",
+    docs: {
+      description: "id, createdAt, and updatedAt must be set conditionally in toEntity methods (if (dto.field) { entity.field = dto.field; })",
+      category: "Architecture",
+      recommended: true,
+    },
+    fixable: "code",
+    schema: [],
+    messages: {
+      mustUseConditional: "Property '{{fieldName}}' in toEntity() must be set conditionally: if (dto.{{fieldName}}) { entity.{{fieldName}} = dto.{{fieldName}}; }",
+    },
+  },
+  create(context) {
+    const AUTO_MANAGED_FIELDS = ["id", "createdAt", "updatedAt"];
+
+    function isToEntityMethod(node) {
+      return (
+        (node.type === "MethodDefinition" || node.type === "Property") &&
+        node.key?.name === "toEntity" &&
+        node.static === true
+      );
+    }
+
+    function isDirectAssignment(node, fieldName) {
+      if (
+        node.type === "ExpressionStatement" &&
+        node.expression?.type === "AssignmentExpression"
+      ) {
+        const left = node.expression.left;
+        const right = node.expression.right;
+
+        if (
+          left?.type === "MemberExpression" &&
+          left.object?.name === "entity" &&
+          left.property?.name === fieldName &&
+          right?.type === "MemberExpression" &&
+          right.object?.name === "dto" &&
+          right.property?.name === fieldName
+        ) {
+          return true;
+        }
+      }
+      return false;
+    }
+
+    function isConditionalAssignment(node, fieldName) {
+      if (node.type === "IfStatement") {
+        const test = node.test;
+        if (
+          test?.type === "MemberExpression" &&
+          test.object?.name === "dto" &&
+          test.property?.name === fieldName
+        ) {
+          const body = node.consequent?.body || [node.consequent];
+          const hasCorrectAssignment = body.some((stmt) => {
+            if (
+              stmt.type === "ExpressionStatement" &&
+              stmt.expression?.type === "AssignmentExpression"
+            ) {
+              const left = stmt.expression.left;
+              const right = stmt.expression.right;
+              return (
+                left?.type === "MemberExpression" &&
+                left.object?.name === "entity" &&
+                left.property?.name === fieldName &&
+                right?.type === "MemberExpression" &&
+                right.object?.name === "dto" &&
+                right.property?.name === fieldName
+              );
+            }
+            return false;
+          });
+          return hasCorrectAssignment;
+        }
+      }
+      return false;
+    }
+
+    return {
+      MethodDefinition(node) {
+        if (!isToEntityMethod(node)) {
+          return;
+        }
+
+        const body = node.value?.body?.body;
+        if (!body || !Array.isArray(body)) {
+          return;
+        }
+
+        AUTO_MANAGED_FIELDS.forEach((fieldName) => {
+          let hasDirectAssignment = false;
+          let hasConditionalAssignment = false;
+
+          body.forEach((statement) => {
+            if (isDirectAssignment(statement, fieldName)) {
+              hasDirectAssignment = true;
+              context.report({
+                node: statement,
+                messageId: "mustUseConditional",
+                data: { fieldName },
+                fix(fixer) {
+                  const assignmentText = `if (dto.${fieldName}) {\n      entity.${fieldName} = dto.${fieldName};\n    }`;
+                  return fixer.replaceText(statement, assignmentText);
+                },
+              });
+            }
+
+            if (isConditionalAssignment(statement, fieldName)) {
+              hasConditionalAssignment = true;
+            }
+          });
+        });
+      },
+    };
+  },
+};
+
+export default {
+  rules: {
+    "enforce-toentity-conditional-assignment": enforceToEntityConditionalAssignmentRule,
+  },
+};
+
+