@echoes-of-order/eslint-config 1.121.0

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

@@ -0,0 +1,314 @@
+/**
+ * ESLint-Regel: enforce-dto-from-entity
+ * Stellt sicher, dass DTOs fromEntity-Methoden haben und Services diese verwenden
+ */
+
+import fs from 'fs';
+import path from 'path';
+
+/** @type {import('eslint').Rule.RuleModule} */
+const enforceDtoFromEntityRule = {
+  meta: {
+    type: "problem",
+    docs: {
+      description: "DTOs müssen fromEntity-Methoden bereitstellen, Services dürfen keine eigene Entity-Konvertierung implementieren",
+      category: "Architecture",
+      recommended: true,
+    },
+    schema: [],
+    messages: {
+      missingFromEntityMethod: "DTO-Klasse '{{dtoName}}' muss eine statische fromEntity-Methode bereitstellen",
+      missingFromEntityArrayMethod: "DTO-Klasse '{{dtoName}}' muss eine statische fromEntityArray-Methode bereitstellen",
+      serviceEntityConversion: "Service '{{serviceName}}' darf keine eigene Entity-zu-DTO-Konvertierung implementieren. Verwende {{dtoName}}.fromEntity() stattdessen",
+      manualEntityMapping: "Manuelle Entity-zu-DTO-Konvertierung nicht erlaubt. Verwende {{dtoName}}.fromEntity() stattdessen",
+      unknownTypeForbidden: "fromEntity-Methode verwendet 'unknown' als Parameter-Typ. Verwende den korrekten Entity-Typ.",
+      anyTypeForbidden: "fromEntity-Methode verwendet 'any' als Parameter-Typ. Verwende den korrekten Entity-Typ.",
+    },
+  },
+  create(context) {
+    const filename = context.getFilename();
+    const isDtoFile = filename.includes("/dto/") && filename.endsWith(".ts");
+    const isServiceFile = filename.includes("/service/") && filename.endsWith(".ts") && !filename.includes("test");
+
+    let dtoClassName = "";
+    let hasFromEntityMethod = false;
+    let hasFromEntityArrayMethod = false;
+
+    // Hilfsfunktion um zu prüfen, ob eine entsprechende Entity existiert
+    function doesEntityExist(dtoName, context) {
+      try {
+        const filename = context.getFilename();
+        const projectRoot = path.resolve(path.dirname(filename), '../..');
+
+        // Entferne "Dto" Suffix und füge "Entity" hinzu
+        let entityName = dtoName;
+        if (entityName.endsWith('Dto')) {
+          entityName = entityName.slice(0, -3);
+        }
+        entityName += 'Entity';
+
+        // Rekursive Suche in allen Entity-Verzeichnissen
+        function findEntityRecursively(dir, entityFileName) {
+          if (!fs.existsSync(dir)) {
+            return false;
+          }
+
+          try {
+            const files = fs.readdirSync(dir, { withFileTypes: true });
+
+            for (const file of files) {
+              const fullPath = path.join(dir, file.name);
+
+              if (file.isFile() && file.name === entityFileName) {
+                return true;
+              } else if (file.isDirectory()) {
+                if (findEntityRecursively(fullPath, entityFileName)) {
+                  return true;
+                }
+              }
+            }
+          } catch (error) {
+            // Ignore permission errors etc.
+          }
+
+          return false;
+        }
+
+        // Rekursive Suche im gesamten Entity-Verzeichnis
+        const entityDir = path.join(projectRoot, 'src/entity');
+        return findEntityRecursively(entityDir, `${entityName}.ts`);
+
+      } catch (error) {
+        // Bei Fehlern nehmen wir an, dass die Entity nicht existiert
+        return false;
+      }
+    }
+
+    // Hilfsfunktion um Service-Klassennamen zu extrahieren
+    function getServiceClassName(context) {
+      const sourceCode = context.getSourceCode();
+      const ast = sourceCode.ast;
+
+      for (const node of ast.body) {
+        if (node.type === "ClassDeclaration" && node.id?.name?.endsWith("Service")) {
+          return node.id.name;
+        }
+      }
+      return null;
+    }
+
+    return {
+      // Überwache DTO-Dateien
+      ClassDeclaration(node) {
+        if (isDtoFile) {
+          dtoClassName = node.id?.name || "";
+
+          // Prüfe auf fromEntity und fromEntityArray Methoden
+          const methods = node.body.body.filter(member =>
+            member.type === "MethodDefinition" &&
+            member.static === true
+          );
+
+          hasFromEntityMethod = methods.some(method =>
+            method.key?.name === "fromEntity"
+          );
+
+          hasFromEntityArrayMethod = methods.some(method =>
+            method.key?.name === "fromEntityArray"
+          );
+        }
+      },
+
+      // Überwache fromEntity-Methoden auf unknown/any Parameter
+      MethodDefinition(node) {
+        if (isDtoFile && node.key?.name === "fromEntity" && node.static) {
+          // Prüfe auf unknown oder any Parameter-Typen
+          if (node.value && node.value.params && node.value.params.length > 0) {
+            const firstParam = node.value.params[0];
+
+            if (firstParam.typeAnnotation && firstParam.typeAnnotation.typeAnnotation) {
+              const typeAnnotation = firstParam.typeAnnotation.typeAnnotation;
+
+              // Prüfe auf unknown
+              if (typeAnnotation.type === "TSUnknownKeyword") {
+                context.report({
+                  node: firstParam,
+                  messageId: "unknownTypeForbidden",
+                });
+              }
+
+              // Prüfe auf any
+              if (typeAnnotation.type === "TSAnyKeyword") {
+                context.report({
+                  node: firstParam,
+                  messageId: "anyTypeForbidden",
+                });
+              }
+            }
+          }
+        }
+      },
+
+      // Überwache Arrow Functions in statischen Methoden auf unknown/any Parameter
+      PropertyDefinition(node) {
+        if (isDtoFile && node.static && node.value && node.value.type === "ArrowFunctionExpression") {
+          const methodName = node.key?.name;
+
+          if (methodName === "fromEntity") {
+            // Prüfe auf unknown oder any Parameter-Typen
+            if (node.value.params && node.value.params.length > 0) {
+              const firstParam = node.value.params[0];
+
+              if (firstParam.typeAnnotation && firstParam.typeAnnotation.typeAnnotation) {
+                const typeAnnotation = firstParam.typeAnnotation.typeAnnotation;
+
+                // Prüfe auf unknown
+                if (typeAnnotation.type === "TSUnknownKeyword") {
+                  context.report({
+                    node: firstParam,
+                    messageId: "unknownTypeForbidden",
+                  });
+                }
+
+                // Prüfe auf any
+                if (typeAnnotation.type === "TSAnyKeyword") {
+                  context.report({
+                    node: firstParam,
+                    messageId: "anyTypeForbidden",
+                  });
+                }
+              }
+            }
+          }
+        }
+      },
+
+      // Überwache Service-Dateien auf Entity-Konvertierung
+      MethodDefinition(node) {
+        if (isServiceFile) {
+          const methodName = node.key?.name;
+
+          // Verbiete convertEntityToDto oder ähnliche Methoden
+          if (methodName &&
+              (methodName.includes("convertEntity") ||
+               methodName.includes("entityToDto") ||
+               methodName.includes("toDto"))) {
+
+            const serviceName = getServiceClassName(context);
+
+            context.report({
+              node,
+              messageId: "serviceEntityConversion",
+              data: {
+                serviceName: serviceName || "Service",
+                dtoName: "YourDto",
+              },
+            });
+          }
+        }
+      },
+
+      // Prüfe auf manuelle Entity-Property-Zuweisungen
+      AssignmentExpression(node) {
+        if (isServiceFile) {
+          // Erkenne Patterns wie: entityDto.property = entity.property
+          if (node.left.type === "MemberExpression" &&
+              node.right.type === "MemberExpression") {
+
+            const leftObject = node.left.object;
+            const rightObject = node.right.object;
+
+            // Prüfe ob links ein EntityDto und rechts eine Entity ist
+            if (leftObject?.name?.toLowerCase().includes("entitydto") &&
+                rightObject?.name?.toLowerCase().includes("entity")) {
+
+              context.report({
+                node,
+                messageId: "manualEntityMapping",
+                data: {
+                  dtoName: "YourEntityDto",
+                },
+              });
+            }
+          }
+        }
+      },
+
+      // Prüfe auf new EntityDto() gefolgt von Property-Zuweisungen
+      VariableDeclaration(node) {
+        if (isServiceFile) {
+          for (const declarator of node.declarations) {
+            if (declarator.init?.type === "NewExpression" &&
+                declarator.init.callee?.name?.endsWith("EntityDto")) {
+
+              // Schaue nach nachfolgenden Property-Zuweisungen
+              const parent = node.parent;
+              if (parent?.type === "BlockStatement") {
+                const statements = parent.body;
+                const currentIndex = statements.indexOf(node);
+
+                // Prüfe die nächsten Statements auf Property-Zuweisungen
+                for (let i = currentIndex + 1; i < Math.min(currentIndex + 10, statements.length); i++) {
+                  const stmt = statements[i];
+                  if (stmt.type === "ExpressionStatement" &&
+                      stmt.expression.type === "AssignmentExpression" &&
+                      stmt.expression.left.type === "MemberExpression" &&
+                      stmt.expression.left.object?.name === declarator.id?.name) {
+
+                    context.report({
+                      node: stmt,
+                      messageId: "manualEntityMapping",
+                      data: {
+                        dtoName: declarator.init.callee.name,
+                      },
+                    });
+                    break;
+                  }
+                }
+              }
+            }
+          }
+        }
+      },
+
+      // Prüfe am Ende der DTO-Datei
+      "Program:exit"(node) {
+        if (isDtoFile && dtoClassName) {
+          // Request-DTOs sind von der fromEntity-Regel ausgenommen
+          const isRequestDto = dtoClassName.includes("Request") || dtoClassName.includes("Create") || dtoClassName.includes("Update");
+
+          // Prüfe nur, wenn es eine entsprechende Entity gibt
+          const entityExists = doesEntityExist(dtoClassName, context);
+
+          if (!isRequestDto && entityExists) {
+            if (!hasFromEntityMethod) {
+              context.report({
+                node,
+                messageId: "missingFromEntityMethod",
+                data: {
+                  dtoName: dtoClassName,
+                },
+              });
+            }
+
+            if (!hasFromEntityArrayMethod) {
+              context.report({
+                node,
+                messageId: "missingFromEntityArrayMethod",
+                data: {
+                  dtoName: dtoClassName,
+                },
+              });
+            }
+          }
+        }
+      },
+    };
+  },
+};
+
+export default {
+  rules: {
+    'enforce-dto-from-entity': enforceDtoFromEntityRule,
+  },
+};

package/rules/enforce-dto-naming-conventions.js

@@ -0,0 +1,212 @@
+import path from "path";
+
+export default {
+  meta: {
+    type: "problem",
+    docs: {
+      description: "Enforces DTO naming and folder conventions",
+      category: "Architecture",
+      recommended: true,
+    },
+    schema: [],
+    messages: {
+      classNameMismatch: "Klassenname '{{className}}' muss mit dem Dateinamen '{{filename}}' übereinstimmen.",
+      entityDtoWrongSuffix: "Entity-DTO '{{className}}' muss den Suffix 'EntityDto' haben (nicht '{{currentSuffix}}')",
+      entityDtoDoubleSuffix: "Entity-DTO '{{className}}' hat doppelten Suffix. Verwende '{{correctName}}' statt '{{className}}'",
+      entityDtoMixedType: "Entity-DTO '{{className}}' darf keine anderen DTO-Typen im Namen haben (z.B. 'Response', 'Request'). Verwende '{{correctName}}' statt '{{className}}'",
+      responseDtoWrongSuffix: "Response-DTO '{{className}}' muss den Suffix 'ResponseDto' haben (nicht '{{currentSuffix}}')",
+      requestDtoWrongSuffix: "Request-DTO '{{className}}' muss den Suffix 'RequestDto' haben (nicht '{{currentSuffix}}')",
+      configDtoWrongSuffix: "Config-DTO '{{className}}' muss den Suffix 'ConfigDto' haben (nicht '{{currentSuffix}}')",
+      filterDtoWrongSuffix: "Filter-DTO '{{className}}' muss den Suffix 'FilterDto' haben (nicht '{{currentSuffix}}')",
+      unknownFolderSuffix: "DTO '{{className}}' im unbekannten Ordner '{{folder}}'. Definiere einen passenden Suffix.",
+      dtoMustBeInSubfolder: "DTO '{{className}}' muss in einem Unterordner von /dto/ liegen (z.B. /dto/Response/, /dto/Request/, etc.).",
+    },
+  },
+  create(context) {
+    return {
+      ClassDeclaration(node) {
+        const filename = context.getFilename();
+        const dtoClassName = node.id?.name;
+        if (!dtoClassName) return;
+
+        const baseFilename = path.basename(filename, ".ts");
+
+        // 1. Klassenname und Dateiname müssen übereinstimmen
+        if (dtoClassName !== baseFilename) {
+          context.report({
+            node: node,
+            messageId: "classNameMismatch",
+            data: { className: dtoClassName, filename: baseFilename },
+          });
+        }
+
+        // 2. Bestimme den Ordner und erwarteten Suffix
+        const pathParts = filename.split(path.sep);
+        const dtoIndex = pathParts.findIndex(part => part === "dto");
+
+        if (dtoIndex !== -1) {
+          // Ausnahme für BaseEntityDto (abstrakte Base-Klasse)
+          if (dtoClassName === "BaseEntityDto" && filename.endsWith("/dto/BaseEntityDto.ts")) {
+            return;
+          }
+
+          // Prüfe, ob es ein Unterordner gibt (nicht die Datei selbst)
+          if (dtoIndex + 1 < pathParts.length - 1) {
+            const folder = pathParts[dtoIndex + 1];
+            const currentSuffix = dtoClassName.match(/([A-Z][a-z]*Dto)$/)?.[1] || "unbekannt";
+
+            const expectedSuffixMap = {
+              "Entity": "EntityDto",
+              "Response": "ResponseDto",
+              "Request": "RequestDto",
+              "Config": "ConfigDto",
+              "Filter": "FilterDto",
+              // Add other common DTO subfolders here if they have a specific suffix
+              // For example, if you have /dto/Auth/AuthRequestDto, you'd add "Auth": "AuthDto"
+              // For now, general DTOs in other folders just need to end with "Dto"
+              "Eoo": "Dto",
+              "Game": "Dto",
+              "User": "Dto",
+              "Auth": "Dto",
+              "Chat": "Dto",
+              "World": "Dto",
+              "Asset": "Dto",
+              "Language": "Dto",
+              "Log": "Dto",
+              "Health": "Dto",
+              "Metrics": "Dto",
+              "Admin": "Dto",
+              "Utilities": "Dto",
+              "Common": "Dto",
+              "Shared": "Dto",
+              "Core": "Dto",
+              "System": "Dto",
+              "Event": "Dto",
+              "Notification": "Dto",
+              "Payment": "Dto",
+              "Inventory": "Dto",
+              "Quest": "Dto",
+              "Skill": "Dto",
+              "Spell": "Dto",
+              "Item": "Dto",
+              "Faction": "Dto",
+              "Race": "Dto",
+              "Class": "Dto",
+              "Ability": "Dto",
+              "Buff": "Dto",
+              "Debuff": "Dto",
+              "Effect": "Dto",
+              "Stat": "Dto",
+              "Map": "Dto",
+              "Zone": "Dto",
+              "Region": "Dto",
+              "Server": "Dto",
+              "Client": "Dto",
+              "Gateway": "Dto",
+              "Proxy": "Dto",
+              "Service": "Dto",
+              "Module": "Dto",
+              "Provider": "Dto",
+              "Repository": "Dto",
+              "Controller": "Dto",
+              "Middleware": "Dto",
+              "Guard": "Dto",
+              "Interceptor": "Dto",
+              "Pipe": "Dto",
+              "Decorator": "Dto",
+              "Enum": "Dto",
+              "Interface": "Dto",
+              "Type": "Dto",
+              "Util": "Dto",
+              "Helper": "Dto",
+              "Constant": "Dto",
+              "Factory": "Dto",
+              "Strategy": "Dto",
+              "Subscriber": "Dto",
+              "Seeder": "Dto",
+              "Migration": "Dto",
+              "Test": "Dto",
+              "Mock": "Dto",
+              "Stub": "Dto",
+              "Fixture": "Dto",
+              "Seed": "Dto",
+              "Script": "Dto",
+              "Tool": "Dto",
+              "Logger": "Dto", // Added Logger as a recognized folder, but no specific suffix beyond Dto
+              "Main": "Dto",   // Added Main as a recognized folder, but no specific suffix beyond Dto
+              "OAuth": "Dto",  // Added OAuth as a recognized folder, but no specific suffix beyond Dto
+              "Utility": "Dto", // Added Utility as a recognized folder, but no specific suffix beyond Dto
+            };
+
+            const expectedSuffix = expectedSuffixMap[folder];
+
+            if (folder === "Entity") {
+              if (!dtoClassName.endsWith("EntityDto")) {
+                context.report({
+                  node: node,
+                  messageId: "entityDtoWrongSuffix",
+                  data: { className: dtoClassName, currentSuffix: currentSuffix },
+                });
+              } else if (dtoClassName.endsWith("DtoEntityDto")) {
+                const correctName = dtoClassName.replace("DtoEntityDto", "EntityDto");
+                context.report({
+                  node: node,
+                  messageId: "entityDtoDoubleSuffix",
+                  data: { className: dtoClassName, correctName: correctName },
+                });
+              } else {
+                // Prüfe, ob Entity-DTO andere DTO-Typen im Namen hat
+                const forbiddenTypes = ["Response", "Request", "Config", "Filter"];
+                const hasForbiddenType = forbiddenTypes.some(type =>
+                  dtoClassName.includes(type)
+                );
+
+                if (hasForbiddenType) {
+                  // Entferne den verbotenen Typ und ersetze durch korrekten Namen
+                  let correctName = dtoClassName;
+                  forbiddenTypes.forEach(type => {
+                    if (correctName.includes(type)) {
+                      correctName = correctName.replace(type, "");
+                    }
+                  });
+                  // Stelle sicher, dass es mit EntityDto endet
+                  if (!correctName.endsWith("EntityDto")) {
+                    correctName = correctName.replace(/Dto$/, "EntityDto");
+                  }
+
+                  context.report({
+                    node: node,
+                    messageId: "entityDtoMixedType",
+                    data: { className: dtoClassName, correctName: correctName },
+                  });
+                }
+              }
+            } else if (expectedSuffix && expectedSuffix !== "Dto") {
+              if (!dtoClassName.endsWith(expectedSuffix)) {
+                context.report({
+                  node: node,
+                  messageId: `${folder.toLowerCase()}DtoWrongSuffix`,
+                  data: { className: dtoClassName, currentSuffix: currentSuffix },
+                });
+              }
+            } else if (!expectedSuffix) {
+              context.report({
+                node: node,
+                messageId: "unknownFolderSuffix",
+                data: { className: dtoClassName, folder: folder },
+              });
+            }
+          } else {
+            // DTO direkt im /dto/ Ordner - nicht erlaubt
+            context.report({
+              node: node,
+              messageId: "dtoMustBeInSubfolder",
+              data: { className: dtoClassName },
+            });
+          }
+        }
+      },
+    };
+  },
+};
+