@echoes-of-order/eslint-config 1.121.0

package/rules/dto-entity-swagger-separation.js

@@ -0,0 +1,265 @@
+/**
+ * @fileoverview Enforce Swagger attributes in DTOs and prohibit them in Entities based on folder structure
+ */
+
+"use strict";
+
+export default {
+  meta: {
+    type: "problem",
+    docs: {
+      description: "enforce @ApiProperty in DTOs and prohibit Swagger attributes in Entities",
+      category: "Architecture",
+      recommended: true,
+    },
+    fixable: "code",
+    schema: [],
+    messages: {
+      missingApiPropertyInDto: "DTO property '{{propertyName}}' is missing @ApiProperty decorator. All DTO properties must have Swagger documentation.",
+      forbiddenSwaggerInEntity: "Entity property '{{propertyName}}' has Swagger decorator '{{decoratorName}}'. Entities should not contain API documentation - use DTOs instead.",
+      missingApiPropertyImportInDto: "DTO file is missing 'ApiProperty' import from '@nestjs/swagger'. All DTO properties must be documented.",
+      unnecessarySwaggerImportInEntity: "Entity file imports Swagger decorators ('{{importName}}'). Entities should not contain API documentation - remove Swagger imports.",
+      germanDescriptionInApiProperty: "DTO property '{{propertyName}}' has German description in @ApiProperty. All API descriptions must be in English for international compatibility.",
+    },
+  },
+
+  create(context) {
+    const filename = context.getFilename();
+    const isDtoFile = filename.includes("/dto/") || filename.includes("\\dto\\");
+    const isEntityFile = filename.includes("/entity/") || filename.includes("\\entity\\");
+
+    if (!isDtoFile && !isEntityFile) {
+      return {};
+    }
+
+    let hasApiPropertyImport = false;
+    let hasSwaggerImports = [];
+
+    function isSwaggerDecorator(decoratorName) {
+      const swaggerDecorators = [
+        "ApiProperty",
+        "ApiHideProperty",
+        "ApiPropertyOptional",
+        "ApiResponse",
+        "ApiOperation",
+        "ApiTags",
+        "ApiBearerAuth",
+        "ApiBody",
+        "ApiParam",
+        "ApiQuery"
+      ];
+      return swaggerDecorators.includes(decoratorName);
+    }
+
+    function hasApiPropertyDecorator(decorators) {
+      if (!decorators) return false;
+
+      return decorators.some(decorator => {
+        const decoratorName = decorator.expression?.name || decorator.expression?.callee?.name;
+        return decoratorName === "ApiProperty" || decoratorName === "ApiPropertyOptional";
+      });
+    }
+
+    function getSwaggerDecorators(decorators) {
+      if (!decorators) return [];
+
+      return decorators.filter(decorator => {
+        const decoratorName = decorator.expression?.name || decorator.expression?.callee?.name;
+        return isSwaggerDecorator(decoratorName);
+      }).map(decorator => decorator.expression?.name || decorator.expression?.callee?.name);
+    }
+
+    function isPublicProperty(member) {
+      // TypeScript class properties that are public (default) or explicitly public
+      return member.type === "PropertyDefinition" ||
+             (member.type === "TSParameterProperty" &&
+              (member.accessibility === "public" || !member.accessibility));
+    }
+
+    function shouldCheckProperty(member) {
+      // Skip private/protected properties and constructor parameters
+      if (member.accessibility === "private" || member.accessibility === "protected") {
+        return false;
+      }
+
+      // Skip static properties
+      if (member.static) {
+        return false;
+      }
+
+      // Skip methods
+      if (member.type === "MethodDefinition") {
+        return false;
+      }
+
+      return isPublicProperty(member);
+    }
+
+    function containsGermanWords(text) {
+      if (!text || typeof text !== "string") return false;
+
+      // Verwende franc für automatische Spracherkennung
+      // franc erkennt über 400 Sprachen und ist sehr präzise
+      try {
+        // Importiere franc dynamisch für ESLint-Regel
+        const franc = require("franc");
+
+        // Mindestlänge für zuverlässige Erkennung
+        if (text.length < 10) {
+          // Für sehr kurze Texte: einfache Heuristik mit häufigen deutschen Wörtern
+          const shortGermanWords = ["der", "die", "das", "und", "für", "von", "mit", "ist", "sind", "hat", "haben", "wird", "werden"];
+          const lowercaseText = text.toLowerCase();
+          return shortGermanWords.some(word => new RegExp(`\\b${word}\\b`).test(lowercaseText));
+        }
+
+        // franc gibt ISO 639-3 Codes zurück: 'deu' für Deutsch, 'eng' für Englisch
+        const detectedLanguage = franc(text);
+
+        // Prüfe auf deutsche Sprache (alle deutschen Varianten)
+        const germanLanguageCodes = ["deu", "gsw", "bar", "ksh", "pfl", "sli", "vmf", "wae"];
+        return germanLanguageCodes.includes(detectedLanguage);
+
+      } catch (error) {
+        // Fallback: Einfache Heuristik wenn franc nicht verfügbar ist
+        const commonGermanWords = ["der", "die", "das", "und", "oder", "für", "von", "zu", "mit", "bei", "ist", "sind", "wird", "werden", "benutzer", "anwender", "einstellung", "konfiguration", "beschreibung"];
+        const lowercaseText = text.toLowerCase();
+        return commonGermanWords.some(word => new RegExp(`\\b${word}\\b`).test(lowercaseText));
+      }
+    }
+
+    function checkApiPropertyDescription(decorator, propertyName) {
+      if (!decorator.expression?.arguments?.[0]) return;
+
+      const optionsNode = decorator.expression.arguments[0];
+      if (optionsNode.type !== "ObjectExpression") return;
+
+      const descriptionProperty = optionsNode.properties.find(prop =>
+        prop.key?.name === "description" ||
+        (prop.key?.type === "Literal" && prop.key?.value === "description")
+      );
+
+      if (descriptionProperty && descriptionProperty.value?.type === "Literal") {
+        const description = descriptionProperty.value.value;
+        if (containsGermanWords(description)) {
+          context.report({
+            node: descriptionProperty,
+            messageId: "germanDescriptionInApiProperty",
+            data: {
+              propertyName: propertyName
+            }
+          });
+        }
+      }
+    }
+
+    return {
+      ImportDeclaration(node) {
+        if (node.source.value === "@nestjs/swagger") {
+          node.specifiers.forEach(spec => {
+            const importName = spec.imported?.name || spec.local?.name;
+
+            if (importName === "ApiProperty" || importName === "ApiPropertyOptional") {
+              hasApiPropertyImport = true;
+            }
+
+            if (isSwaggerDecorator(importName)) {
+              hasSwaggerImports.push(importName);
+            }
+          });
+
+          // Check for Entity files with Swagger imports
+          if (isEntityFile && hasSwaggerImports.length > 0) {
+            context.report({
+              node,
+              messageId: "unnecessarySwaggerImportInEntity",
+              data: {
+                importName: hasSwaggerImports.join(", ")
+              }
+            });
+          }
+        }
+      },
+
+      ClassDeclaration(node) {
+        if (!node.body || !node.body.body) return;
+
+        const classProperties = node.body.body.filter(shouldCheckProperty);
+
+        // For DTO files
+        if (isDtoFile) {
+          // Check if DTO has properties but no ApiProperty import
+          if (classProperties.length > 0 && !hasApiPropertyImport) {
+            context.report({
+              node,
+              messageId: "missingApiPropertyImportInDto",
+              fix (fixer) {
+                const sourceCode = context.getSourceCode();
+                const program = sourceCode.ast;
+
+                // Find the last import statement
+                const imports = program.body.filter(stmt => stmt.type === "ImportDeclaration");
+
+                if (imports.length > 0) {
+                  const lastImport = imports[imports.length - 1];
+                  return fixer.insertTextAfter(
+                    lastImport,
+                    '\nimport { ApiProperty } from "@nestjs/swagger";'
+                  );
+                } else {
+                  // Insert at the beginning of the file
+                  return fixer.insertTextBefore(
+                    program.body[0],
+                    'import { ApiProperty } from "@nestjs/swagger";\n\n'
+                  );
+                }
+              },
+            });
+          }
+
+          // Check each property for @ApiProperty
+          classProperties.forEach(member => {
+            if (!hasApiPropertyDecorator(member.decorators)) {
+              const propertyName = member.key?.name || "unknown";
+
+              context.report({
+                node: member,
+                messageId: "missingApiPropertyInDto",
+                data: {
+                  propertyName: propertyName
+                }
+              });
+            } else {
+              // Check existing ApiProperty decorators for German descriptions
+              member.decorators?.forEach(decorator => {
+                const decoratorName = decorator.expression?.name || decorator.expression?.callee?.name;
+                if (decoratorName === "ApiProperty" || decoratorName === "ApiPropertyOptional") {
+                  const propertyName = member.key?.name || "unknown";
+                  checkApiPropertyDescription(decorator, propertyName);
+                }
+              });
+            }
+          });
+        }
+
+        // For Entity files
+        if (isEntityFile) {
+          classProperties.forEach(member => {
+            const swaggerDecorators = getSwaggerDecorators(member.decorators);
+            if (swaggerDecorators.length > 0) {
+              const propertyName = member.key?.name || "unknown";
+
+              context.report({
+                node: member,
+                messageId: "forbiddenSwaggerInEntity",
+                data: {
+                  propertyName: propertyName,
+                  decoratorName: swaggerDecorators.join(", ")
+                }
+              });
+            }
+          });
+        }
+      }
+    };
+  }
+};

package/rules/dto-entity-type-consistency.js

@@ -0,0 +1,352 @@
+/**
+ * ESLint-Regel: Prüft korrekte Typ-Übereinstimmung zwischen Entity und DTO Properties
+ * Spezifisch für Entity-DTO-Mappings:
+ * - ClassTranslationEntity[] -> ClassTranslationEntityDto[]
+ * - MonsterEntity[] -> MonsterEntityDto[]
+ * - etc.
+ */
+
+import fs from "fs";
+import path from "path";
+
+/** @type {import('eslint').Rule.RuleModule} */
+const dtoEntityTypeConsistencyRule = {
+  meta: {
+    type: "problem",
+    docs: {
+      description: "Entity-DTO Properties müssen korrekte DTO-Typen für Relations haben",
+      category: "Architecture",
+      recommended: true,
+    },
+    hasSuggestions: true,
+    schema: [],
+    messages: {
+      incorrectRelationType: "Entity-DTO '{{dtoName}}' Property '{{prop}}' hat falschen Relation-Typ: DTO hat '{{dtoType}}', Entity hat '{{entityType}}'. Erwartet: {{expectedDtoType}}",
+      missingRelationDto: "Entity-DTO '{{dtoName}}' Property '{{prop}}' verwendet Entity-Typ '{{entityType}}' statt DTO-Typ '{{expectedDtoType}}'",
+    },
+  },
+
+  create(context) {
+    return {
+      ClassDeclaration(node) {
+        const filename = context.getFilename();
+
+        // Nur für DTO-Dateien anwenden
+        if (!filename.includes('/dto/') && !filename.endsWith('Dto.ts')) {
+          return;
+        }
+
+        const dtoName = node.id.name;
+        if (!dtoName) return;
+
+        // Ausnahme: CreationDataDto-Klassen verwenden Entity-Typen für Entity-Erstellung
+        if (dtoName.includes('CreationData') || dtoName.includes('CreateData')) {
+          return;
+        }
+
+        // Prüfe DTO-Properties direkt
+        node.body.body.forEach(member => {
+          if (member.type === 'PropertyDefinition' && member.key.type === 'Identifier') {
+            const propName = member.key.name;
+            const dtoType = getTypeString(member.typeAnnotation?.typeAnnotation);
+
+            // Prüfe, ob es sich um eine Entity-Relation handelt (ohne EntityDto)
+            // Enums sind erlaubt (z.B. EntityTargetType, MovementPatternType)
+            if (isEntityRelationType(dtoType)) {
+              const expectedDtoType = getExpectedDtoType(dtoType);
+
+              context.report({
+                node: member,
+                messageId: 'missingRelationDto',
+                data: {
+                  dtoName,
+                  prop: propName,
+                  dtoType,
+                  entityType: dtoType,
+                  expectedDtoType
+                }
+              });
+            }
+          }
+        });
+      }
+    };
+
+    function findEntityFile(dtoName) {
+      let entityName = dtoName;
+      if (entityName.endsWith("DtoEntityDto")) {
+        entityName = entityName.replace("DtoEntityDto", "Entity");
+      } else if (entityName.endsWith("EntityDto")) {
+        entityName = entityName.replace("EntityDto", "Entity");
+      } else if (entityName.endsWith("Dto")) {
+        entityName = entityName.replace("Dto", "Entity");
+      }
+
+      const currentFile = context.getFilename();
+      const srcIndex = currentFile.indexOf('/src/');
+      const testIndex = currentFile.indexOf('/__tests__/');
+
+      if (srcIndex === -1 && testIndex === -1) {
+        return null;
+      }
+
+      let entityDir;
+      if (srcIndex !== -1) {
+        const srcPath = currentFile.substring(0, srcIndex + 5);
+        entityDir = path.resolve(srcPath, "entity");
+      } else {
+        // Für Test-Fixtures: Suche nach Entity-Dateien in der Nähe
+        const testPath = currentFile.substring(0, testIndex);
+        entityDir = path.resolve(testPath, "src", "entity");
+
+        // Fallback: Suche in den Fixtures selbst
+        if (!fs.existsSync(entityDir)) {
+          entityDir = path.resolve(testPath, "__tests__", "fixtures");
+        }
+      }
+
+      try {
+        const entityFile = findFileRecursively(entityDir, entityName + ".ts");
+        if (entityFile) {
+          return entityFile;
+        }
+      } catch {
+        // Entity-Verzeichnis existiert nicht
+      }
+
+      return null;
+    }
+
+    function findFileRecursively(dir, filename) {
+      if (!fs.existsSync(dir)) {
+        return null;
+      }
+
+      const files = fs.readdirSync(dir);
+      for (const file of files) {
+        const filePath = path.join(dir, file);
+        const stat = fs.statSync(filePath);
+
+        if (stat.isDirectory()) {
+          const result = findFileRecursively(filePath, filename);
+          if (result) {
+            return result;
+          }
+        } else if (file === filename) {
+          return filePath;
+        }
+      }
+      return null;
+    }
+
+    function extractEntityRelations(entityContent) {
+      const relations = new Map();
+
+      // Suche nach @OneToMany, @ManyToOne, @OneToOne, @ManyToMany Dekoratoren
+      const relationPatterns = [
+        /@OneToMany\s*\(\s*\(\)\s*=>\s*(\w+)/g,
+        /@ManyToOne\s*\(\s*\(\)\s*=>\s*(\w+)/g,
+        /@OneToOne\s*\(\s*\(\)\s*=>\s*(\w+)/g,
+        /@ManyToMany\s*\(\s*\(\)\s*=>\s*(\w+)/g,
+      ];
+
+      const lines = entityContent.split('\n');
+
+      for (let i = 0; i < lines.length; i++) {
+        const line = lines[i].trim();
+
+        // Suche nach Relation-Dekoratoren
+        for (const pattern of relationPatterns) {
+          const match = pattern.exec(line);
+          if (match) {
+            const relationEntityName = match[1];
+
+            // Suche nach der Property-Definition nach dem Dekorator
+            let j = i + 1;
+            while (j < lines.length && !lines[j].trim().match(/^\w+:\s*[^;]+;$/)) {
+              j++;
+            }
+
+            if (j < lines.length) {
+              const propLine = lines[j].trim();
+              const propMatch = propLine.match(/^(\w+):\s*([^;]+);$/);
+
+              if (propMatch) {
+                const propName = propMatch[1];
+                const propType = propMatch[2].trim();
+
+                relations.set(propName, {
+                  entityType: relationEntityName,
+                  fullType: propType
+                });
+              }
+            }
+          }
+        }
+      }
+
+      return relations;
+    }
+
+    function extractDtoProperties(classNode) {
+      const properties = new Map();
+
+      classNode.body.body.forEach(member => {
+        if (member.type === "PropertyDefinition" && member.key?.name) {
+          const propName = member.key.name;
+          let propType = "unknown";
+
+          if (member.typeAnnotation?.typeAnnotation) {
+            propType = getTypeString(member.typeAnnotation.typeAnnotation);
+          }
+
+          properties.set(propName, propType);
+        }
+      });
+
+      return properties;
+    }
+
+    function getTypeString(typeNode) {
+      if (!typeNode) {
+        return "unknown";
+      }
+      switch (typeNode.type) {
+        case "TSStringKeyword":
+          return "string";
+        case "TSNumberKeyword":
+          return "number";
+        case "TSBooleanKeyword":
+          return "boolean";
+        case "TSNullKeyword":
+          return "null";
+        case "TSUndefinedKeyword":
+          return "undefined";
+        case "TSTypeReference":
+          return typeNode.typeName?.name || "unknown";
+        case "TSUnionType":
+          return typeNode.types.map(getTypeString).join(" | ");
+        case "TSArrayType":
+          return getTypeString(typeNode.elementType) + "[]";
+        case "TSTypeLiteral":
+          return "object";
+        default:
+          return "unknown";
+      }
+    }
+
+    function isEntityRelationType(type) {
+      // Prüfe, ob der Typ eine Entity-Relation ist
+      // Enums sind erlaubt (z.B. EntityTargetType, MovementPatternType)
+      if (type.includes("Type") || type.includes("Enum")) {
+        return false;
+      }
+      return type.includes("Entity") && !type.includes("EntityDto");
+    }
+
+    function getExpectedDtoType(entityType) {
+      // Transformiere Entity-Typ zu DTO-Typ
+      if (entityType.endsWith("Entity")) {
+        return entityType.replace("Entity", "EntityDto");
+      }
+      return entityType + "Dto";
+    }
+
+    function isCorrectDtoType(dtoType, expectedEntityType) {
+      const expectedDtoType = getExpectedDtoType(expectedEntityType);
+
+      // Prüfe verschiedene Varianten
+      const variants = [
+        expectedDtoType,
+        expectedDtoType + "[]",
+        expectedDtoType + " | null",
+        expectedDtoType + "[] | null"
+      ];
+
+      return variants.some(variant => dtoType === variant);
+    }
+
+    // Speichere DTO-Informationen für spätere Verwendung
+    const dtoInfoMap = new Map();
+
+    return {
+      ClassDeclaration(node) {
+        const filename = context.getFilename();
+        if (!filename.includes("/dto/Entity/")) return;
+
+        const dtoName = node.id.name;
+        const entityFile = findEntityFile(dtoName);
+
+        if (!entityFile) return;
+
+        // Parse Entity-Datei und extrahiere Relations
+        const entityContent = fs.readFileSync(entityFile, "utf8");
+        const entityRelations = extractEntityRelations(entityContent);
+        const dtoProperties = extractDtoProperties(node);
+
+        dtoInfoMap.set(dtoName, {
+          entityRelations,
+          dtoProperties,
+          entityName: path.basename(entityFile, ".ts")
+        });
+      },
+
+      NewExpression(node) {
+        if (node.callee.type !== "Identifier") return;
+
+        const dtoName = node.callee.name;
+        const dtoInfo = dtoInfoMap.get(dtoName);
+
+        if (!dtoInfo) return;
+
+        const { entityRelations, dtoProperties } = dtoInfo;
+
+        // Prüfe jede Entity-Relation
+        for (const [propName, relationInfo] of entityRelations) {
+          const dtoType = dtoProperties.get(propName);
+
+          if (!dtoType) continue;
+
+          const { entityType } = relationInfo;
+          const expectedDtoType = getExpectedDtoType(entityType);
+
+          // Prüfe, ob DTO-Typ korrekt ist
+          if (!isCorrectDtoType(dtoType, entityType)) {
+            // Spezielle Behandlung: Wenn DTO-Typ Entity-Typ verwendet statt DTO-Typ
+            if (isEntityRelationType(dtoType)) {
+              context.report({
+                node,
+                messageId: "missingRelationDto",
+                data: {
+                  dtoName,
+                  prop: propName,
+                  dtoType,
+                  entityType,
+                  expectedDtoType
+                }
+              });
+            } else {
+              context.report({
+                node,
+                messageId: "incorrectRelationType",
+                data: {
+                  dtoName,
+                  prop: propName,
+                  dtoType,
+                  entityType,
+                  expectedDtoType
+                }
+              });
+            }
+          }
+        }
+      }
+    };
+  },
+};
+
+export default {
+  rules: {
+    "dto-entity-type-consistency": dtoEntityTypeConsistencyRule,
+  },
+};