@addon24/eslint-config/rules/no-dto-in-entity.js

ESLint configuration rules for WorldOfTextcraft projects - Centralized configuration for all project types

/**
 * ESLint-Regel: Verhindert die Verwendung von DTOs in Entity-Dateien
 * Für JSONB-Felder müssen eigene Typen definiert werden
 */
export default {
  meta: {
    type: "problem",
    docs: {
      description: "Verhindert die Verwendung von DTOs in Entity-Dateien. Für JSONB-Felder müssen eigene Typen definiert werden.",
      category: "Architecture",
      recommended: true,
    },
    hasSuggestions: true,
    schema: [],
    messages: {
      dtoInEntity: "Entity '{{entityName}}' verwendet DTO '{{dtoName}}' in Property '{{propertyName}}'. Für JSONB-Felder müssen eigene Typen definiert werden.",
      suggestType: "Definiere einen eigenen Typ für '{{propertyName}}' anstatt '{{dtoName}}' zu verwenden.",
    },
  },

  create(context) {
    const filename = context.getFilename();

    // Regel nur auf Entity-Dateien im backend anwenden
    if (!filename.includes("/backend/src/entity/") || !filename.endsWith(".ts")) {
      return {};
    }

    // Prüfe, ob es sich um eine Entity-Datei handelt
    const isEntityFile = filename.includes("/entity/") &&
                        !filename.includes("/dto/") &&
                        !filename.includes("/service/") &&
                        !filename.includes("/controller/");

    if (!isEntityFile) {
      return {};
    }

    return {
      ClassDeclaration(node) {
        if (!node.id?.name) return;

        const className = node.id.name;

        // Prüfe alle Properties der Klasse
        node.body.body.forEach(member => {
          if (member.type === "PropertyDefinition" && member.key?.name) {
            const propertyName = member.key.name;

            // Prüfe Type-Annotation
            if (member.typeAnnotation?.typeAnnotation) {
              const typeAnnotation = member.typeAnnotation.typeAnnotation;

              // Prüfe auf DTO-Verwendung
              if (typeAnnotation.type === "TSTypeReference") {
                const typeName = typeAnnotation.typeName?.name;

                // Prüfe, ob der Typ ein DTO ist (endet mit "Dto" oder "EntityDto")
                if (typeName && (typeName.endsWith("Dto") || typeName.endsWith("EntityDto"))) {
                  context.report({
                    node: member,
                    messageId: "dtoInEntity",
                    data: {
                      entityName: className,
                      dtoName: typeName,
                      propertyName: propertyName,
                    },
                  });
                }
              }

              // Prüfe Union-Types
              if (typeAnnotation.type === "TSUnionType") {
                typeAnnotation.types.forEach(unionType => {
                  if (unionType.type === "TSTypeReference") {
                    const typeName = unionType.typeName?.name;

                    if (typeName && (typeName.endsWith("Dto") || typeName.endsWith("EntityDto"))) {
                      context.report({
                        node: member,
                        messageId: "dtoInEntity",
                        data: {
                          entityName: className,
                          dtoName: typeName,
                          propertyName: propertyName,
                        },
                      });
                    }
                  }
                });
              }
            }
          }
        });
      },
    };
  },
};