@addon24/eslint-config/rules/enforce-dto-constructor.js

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

/**
 * ESLint-Regel: enforce-dto-constructor
 * Verbietet die Verwendung von Constructor-Aufrufen für DTOs - DTOs sollen mit create() erstellt werden
 */

// Hilfsfunktion um zu prüfen, ob wir uns innerhalb einer DTO-Factory-Methode befinden
function isInsideCreateMethod(node) {
  let parent = node.parent;
  while (parent) {
    // Prüfe ob wir in einer statischen Methode sind
    if (parent.type === "MethodDefinition" &&
        parent.static === true &&
        parent.key.type === "Identifier" &&
        (parent.key.name === "create" ||
         parent.key.name === "fromEntity" ||
         parent.key.name === "fromRequestDto" ||
         parent.key.name === "fromEntityArray")) {
      return true;
    }

    // Prüfe ob wir in einer normalen Methode sind (für toEntity)
    if (parent.type === "MethodDefinition" &&
        parent.static === false &&
        parent.key.type === "Identifier" &&
        parent.key.name === "toEntity") {
      return true;
    }

    // Prüfe ob wir in einer Arrow-Function oder FunctionExpression sind, die DTO-Factory-Namen enthält
    if ((parent.type === "ArrowFunctionExpression" || parent.type === "FunctionExpression") &&
        parent.parent &&
        parent.parent.type === "VariableDeclarator" &&
        parent.parent.id.type === "Identifier" &&
        (parent.parent.id.name.includes("create") ||
         parent.parent.id.name.includes("fromEntity") ||
         parent.parent.id.name.includes("toEntity"))) {
      return true;
    }

    parent = parent.parent;
  }
  return false;
}

/** @type {import('eslint').Rule.RuleModule} */
const enforceDtoConstructorRule = {
  meta: {
    type: "problem",
    docs: {
      description: "DTOs dürfen nicht mit 'new' erstellt werden, verwende stattdessen create()",
      category: "Best Practices",
      recommended: true,
    },
    fixable: "code",
    schema: [],
    messages: {
      noConstructorCall: "DTOs dürfen nicht mit 'new {{dtoName}}()' erstellt werden. Verwende stattdessen {{dtoName}}.create()",
    },
  },
  create(context) {
    return {
      // Prüfe auf Constructor-Aufrufe mit DTOs
      NewExpression(node) {
        if (node.callee.type === "Identifier") {
          const className = node.callee.name;

          // Prüfe ob es sich um eine DTO-Klasse handelt
          if (className && className.endsWith("Dto")) {
            // Prüfe ob wir uns innerhalb einer create-Methode befinden
            if (isInsideCreateMethod(node)) {
              return; // Erlaube 'new' innerhalb von create-Methoden
            }

            context.report({
              node,
              messageId: "noConstructorCall",
              data: {
                dtoName: className,
              },
              fix(fixer) {
                return fixer.replaceText(node, `${className}.create()`);
              },
            });
          }
        }
      },
    };
  },
};

export default {
  rules: {
    "enforce-dto-constructor": enforceDtoConstructorRule,
  },
};