@echoes-of-order/eslint-config 1.121.0

package/rules/enforce-explicit-dto-types.js

@@ -0,0 +1,118 @@
+export default {
+  meta: {
+    type: "suggestion",
+    docs: {
+      description: "Enforce explicit type annotations in DTO classes",
+      category: "Best Practices",
+      recommended: true,
+    },
+    fixable: "code",
+    schema: [],
+    messages: {
+      missingExplicitType: "DTO property '{{propertyName}}' must have explicit type annotation",
+      missingTypeAnnotation: "Property '{{propertyName}}' in DTO class must have explicit type annotation",
+    },
+  },
+
+  create(context) {
+    return {
+      ClassDeclaration(node) {
+        // Prüfe nur DTO-Klassen (endet mit 'Dto' oder 'EntityDto')
+        if (!node.id || !node.id.name.endsWith('Dto')) {
+          return;
+        }
+
+        node.body.body.forEach(member => {
+          if (member.type === "PropertyDefinition" && member.key?.name) {
+            const propertyName = member.key.name;
+
+            // Überspringe private Properties (beginnen mit _)
+            if (propertyName.startsWith('_')) {
+              return;
+            }
+
+            // Überspringe statische Properties
+            if (member.static) {
+              return;
+            }
+
+            // Prüfe ob explizite Typ-Annotation vorhanden ist
+            if (!member.typeAnnotation) {
+              context.report({
+                node: member,
+                messageId: "missingExplicitType",
+                data: { propertyName },
+                fix(fixer) {
+                  // Versuche den Typ aus dem Initialwert abzuleiten
+                  const inferredType = inferTypeFromValue(member.value);
+                  if (inferredType !== "unknown") {
+                    return fixer.insertTextAfter(member.key, `: ${inferredType}`);
+                  }
+                  return null;
+                },
+              });
+            }
+          }
+        });
+      },
+
+      ClassExpression(node) {
+        // Behandle auch anonyme Klassen
+        if (node.id && node.id.name && node.id.name.endsWith('Dto')) {
+          node.body.body.forEach(member => {
+            if (member.type === "PropertyDefinition" && member.key?.name) {
+              const propertyName = member.key.name;
+
+              if (propertyName.startsWith('_') || member.static) {
+                return;
+              }
+
+              if (!member.typeAnnotation) {
+                context.report({
+                  node: member,
+                  messageId: "missingExplicitType",
+                  data: { propertyName },
+                  fix(fixer) {
+                    const inferredType = inferTypeFromValue(member.value);
+                    if (inferredType !== "unknown") {
+                      return fixer.insertTextAfter(member.key, `: ${inferredType}`);
+                    }
+                    return null;
+                  },
+                });
+              }
+            }
+          });
+        }
+      },
+    };
+  },
+};
+
+// Hilfsfunktion um Typ aus Initialwert abzuleiten
+function inferTypeFromValue(value) {
+  if (!value) return "unknown";
+
+  switch (value.type) {
+    case "StringLiteral":
+      return "string";
+    case "NumericLiteral":
+      return "number";
+    case "BooleanLiteral":
+      return "boolean";
+    case "ArrayExpression":
+      return "array";
+    case "ObjectExpression":
+      return "object";
+    case "NewExpression":
+      return "object";
+    case "Identifier":
+      if (value.name === "true" || value.name === "false") return "boolean";
+      if (value.name === "null") return "null";
+      if (value.name === "undefined") return "undefined";
+      return "unknown";
+    default:
+      return "unknown";
+  }
+}
+

package/rules/enforce-from-request-dto-usage.js

@@ -0,0 +1,62 @@
+export default {
+  meta: {
+    type: "problem",
+    docs: {
+      description: "Enforce EntityDto.fromRequestDto() usage in services and validate method existence",
+      category: "Best Practices",
+      recommended: true,
+    },
+    messages: {
+      useFromRequestDto: "Services müssen EntityDto.fromRequestDto(requestDto) verwenden statt repository.create(). Verwende das DTO-Pattern für typsichere Entity-Erstellung.",
+      noDirectRequestDtoProperties: "RequestDto-Properties dürfen nicht direkt an Entity zugewiesen werden. Verwende EntityDto.fromRequestDto() für typsichere Konvertierung.",
+      missingFromRequestDtoMethod: "EntityDto '{{entityDtoName}}' muss eine statische fromRequestDto() Methode haben, wenn sie im Service aufgerufen wird. Füge die Methode hinzu oder verwende ein anderes Pattern.",
+    },
+    schema: [],
+  },
+  create (context) {
+    const filename = context.getFilename();
+
+    if (!filename.includes("/service/") && !filename.includes("Service.ts")) {
+      return {};
+    }
+
+    function isInMergeOrLoadMethod (node) {
+      let current = node;
+      while (current && current.parent) {
+        if (current.type === "MethodDefinition" &&
+            current.key?.name) {
+          const methodName = current.key.name;
+          if (methodName.startsWith("merge") || 
+              (methodName.startsWith("load") && methodName.endsWith("EntityDto"))) {
+            return true;
+          }
+        }
+        current = current.parent;
+      }
+      return false;
+    }
+
+    return {
+      CallExpression (node) {
+        if (isInMergeOrLoadMethod(node)) {
+          return;
+        }
+
+        if (
+          node.callee.type === "MemberExpression" &&
+          node.callee.property.name === "create" &&
+          node.callee.object.name?.toLowerCase().includes("repository")
+        ) {
+          const args = node.arguments;
+          if (args.length > 0 && args[0].type === "ObjectExpression") {
+            context.report({
+              messageId: "useFromRequestDto",
+              node,
+            });
+          }
+        }
+      },
+    };
+  },
+};
+

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

@@ -0,0 +1,71 @@
+export default {
+  meta: {
+    type: "problem",
+    docs: {
+      description: "Generic Entity-DTOs benötigen spezielle Behandlung für Conditional Types",
+      category: "Architecture",
+      recommended: true,
+    },
+    schema: [],
+    messages: {
+      genericEntityDtoDetected: "Generic Entity-DTO '{{dtoName}}' erkannt. Type-Matching-Regeln werden für diese DTO umgangen.",
+      missingGenericFromEntityMethod: "Generic Entity-DTO '{{dtoName}}' muss eine fromEntity-Methode haben, die mit allen Generic-Typen umgehen kann.",
+    },
+  },
+  create(context) {
+    const filename = context.getFilename();
+
+    // Prüfe, ob es sich um eine Generic-Entity-DTO handelt
+    const isGenericEntityDto = filename.includes("BackpackRefItemEntityDto") ||
+                              filename.includes("GenericEntityDto") ||
+                              filename.includes("test-fixtures");
+
+    if (!isGenericEntityDto) {
+      return {};
+    }
+
+    let classNode = null;
+    let dtoClassName = "";
+
+    return {
+      ClassDeclaration(node) {
+        classNode = node;
+        dtoClassName = node.id?.name;
+      },
+      ExportDefaultDeclaration(node) {
+        if (node.declaration.type === "ClassDeclaration") {
+          classNode = node.declaration;
+          dtoClassName = node.declaration.id?.name;
+        }
+      },
+      "Program:exit"(node) {
+        if (!classNode || !dtoClassName) return;
+
+        const methods = classNode.body.body.filter(member =>
+          member.type === "MethodDefinition" &&
+          member.static === true
+        );
+
+        const hasFromEntityMethod = methods.some(method =>
+          method.key?.name === "fromEntity"
+        );
+
+        // Für Generic-Entity-DTOs sind die Standard-Regeln gelockert
+        if (isGenericEntityDto) {
+          if (!hasFromEntityMethod) {
+            context.report({
+              node: classNode,
+              messageId: "missingGenericFromEntityMethod",
+              data: { dtoName: dtoClassName }
+            });
+          }
+        }
+      },
+    };
+  },
+};
+
+
+
+
+

package/rules/enforce-inject-decorator.js

@@ -0,0 +1,133 @@
+"use strict";
+
+export default {
+  meta: {
+    type: "problem",
+    docs: {
+      description: "Enforce @Inject() decorator for all service dependencies in constructor parameters",
+      category: "Best Practices",
+      recommended: true,
+    },
+          messages: {
+            missingInjectDecorator: "Dependency '{{serviceName}}' in constructor parameter must use @Inject({{serviceName}}) decorator for proper NestJS dependency injection.",
+            invalidInjectUsage: "@Inject() decorator should only be used on constructor parameters with dependency names (Service, Repository, Factory, dataSource, logger).",
+          },
+    fixable: "code",
+    schema: [],
+  },
+
+  create(context) {
+    const filename = context.getFilename();
+
+    // Nur in Controller-, Service- und Factory-Dateien anwenden
+    if ((!filename.includes("/controller/") && !filename.includes("/service/")) ||
+        (!filename.includes("Controller") && !filename.includes("Service") && !filename.includes("Factory"))) {
+      return {};
+    }
+
+    let hasInjectImport = false;
+
+    return {
+      ImportDeclaration(node) {
+        if (node.source.value === "@nestjs/common") {
+          const hasInject = node.specifiers.some(
+            spec => spec.type === "ImportSpecifier" && spec.imported.name === "Inject"
+          );
+          if (hasInject) {
+            hasInjectImport = true;
+          }
+        }
+      },
+
+      ClassDeclaration(node) {
+        // Nur für Controller-, Service- und Factory-Klassen
+        if (!node.id || (!node.id.name.endsWith("Controller") && !node.id.name.endsWith("Service") && !node.id.name.endsWith("Factory"))) {
+          return;
+        }
+
+        // Finde den Constructor
+        const constructor = node.body.body.find(
+          (member) => member.type === "MethodDefinition" && member.key.name === "constructor"
+        );
+
+        if (!constructor || !constructor.value) {
+          return;
+        }
+
+        // Prüfe Constructor-Parameter
+        constructor.value.params.forEach((param, index) => {
+          if (param.type !== "TSParameterProperty") {
+            return;
+          }
+
+        // ALLE Dependencies benötigen @Inject() in diesem Projekt
+        const paramName = param.parameter.name;
+        const isDependency = paramName.endsWith("Service") ||
+                            paramName.endsWith("Repository") ||
+                            paramName.endsWith("Factory") ||
+                            paramName === "dataSource" ||
+                            paramName === "logger";
+
+        if (!isDependency) {
+          return;
+        }
+
+          // Prüfe, ob @Inject() Decorator vorhanden ist
+          const hasInjectDecorator = param.decorators &&
+            param.decorators.some(decorator =>
+              decorator.expression &&
+              decorator.expression.callee &&
+              decorator.expression.callee.name === "Inject"
+            );
+
+          if (!hasInjectDecorator) {
+            const typeAnnotation = param.parameter.typeAnnotation;
+            const typeName = typeAnnotation && typeAnnotation.typeAnnotation && typeAnnotation.typeAnnotation.typeName
+              ? typeAnnotation.typeAnnotation.typeName.name
+              : paramName.charAt(0).toUpperCase() + paramName.slice(1);
+
+            context.report({
+              node: param,
+              messageId: "missingInjectDecorator",
+              data: { serviceName: paramName },
+              fix(fixer) {
+                const sourceCode = context.getSourceCode();
+                const paramText = sourceCode.getText(param);
+                const injectDecorator = paramName === "dataSource" 
+                  ? "@Inject(DataSource) "
+                  : `@Inject(${typeName}) `;
+                
+                return fixer.replaceText(param, injectDecorator + paramText);
+              },
+            });
+          }
+        });
+      },
+
+      // @Inject() ist optional für normale Services, aber sollte nicht auf anderen Parametern verwendet werden
+      Decorator(node) {
+        if (node.expression && node.expression.callee && node.expression.callee.name === "Inject") {
+          // Finde den Parameter, auf den dieser Decorator angewendet wird
+          const parent = node.parent;
+
+                if (parent && parent.type === "TSParameterProperty") {
+                  const paramName = parent.parameter.name;
+                  const isValidInjectTarget = paramName.endsWith("Service") ||
+                                      paramName.endsWith("Repository") ||
+                                      paramName.endsWith("Factory") ||
+                                      paramName === "dataSource" ||
+                                      paramName === "logger";
+
+                  if (!isValidInjectTarget) {
+                    context.report({
+                      node: node,
+                      messageId: "invalidInjectUsage",
+                      data: { paramName },
+                    });
+                  }
+                }
+        }
+      },
+    };
+  },
+};

package/rules/enforce-lazy-type-loading.js

@@ -0,0 +1,170 @@
+/**
+ * @fileoverview Enforce lazy type loading in @ApiProperty decorators to prevent circular import issues
+ * @author Echoes of Order Team
+ */
+
+export default {
+  meta: {
+    type: "problem",
+    docs: {
+      description: "Enforce lazy type loading in @ApiProperty decorators to prevent circular import issues",
+      category: "Best Practices",
+      recommended: true,
+    },
+    fixable: "code",
+    schema: [],
+    messages: {
+      lazyTypeRequired: "Use lazy type loading 'type: () => [{{className}}]' instead of 'type: [{{className}}]' to prevent circular import issues",
+      lazyTypeRequiredSingle: "Use lazy type loading 'type: () => {{className}}' instead of 'type: {{className}}' to prevent circular import issues",
+    },
+  },
+
+  create(context) {
+    const sourceCode = context.getSourceCode();
+
+    /**
+     * Check if a node is an @ApiProperty decorator
+     */
+    function isApiPropertyDecorator(node) {
+      return (
+        node.type === "CallExpression" &&
+        node.callee &&
+        node.callee.type === "Identifier" &&
+        node.callee.name === "ApiProperty"
+      );
+    }
+
+    /**
+     * Check if a property is a DTO class reference
+     */
+    function isDtoClassReference(property) {
+      if (!property || property.type !== "Identifier") {
+        return false;
+      }
+      
+      // Check if it ends with Dto (case insensitive)
+      return /dto$/i.test(property.name);
+    }
+
+    /**
+     * Check if a property is an array of DTO classes
+     */
+    function isDtoArrayReference(property) {
+      if (!property || property.type !== "ArrayExpression") {
+        return false;
+      }
+      
+      if (property.elements.length !== 1) {
+        return false;
+      }
+      
+      return isDtoClassReference(property.elements[0]);
+    }
+
+    /**
+     * Get the DTO class name from a property
+     */
+    function getDtoClassName(property) {
+      if (property.type === "Identifier") {
+        return property.name;
+      }
+      if (property.type === "ArrayExpression" && property.elements.length === 1) {
+        return property.elements[0].name;
+      }
+      return null;
+    }
+
+    /**
+     * Check if type property already uses lazy loading
+     */
+    function isLazyTypeLoading(property) {
+      return (
+        property.type === "ArrowFunctionExpression" &&
+        property.params.length === 0 &&
+        property.body &&
+        (property.body.type === "ArrayExpression" || property.body.type === "Identifier")
+      );
+    }
+
+    /**
+     * Create fix for lazy type loading
+     */
+    function createFix(node, property, isArray) {
+      const className = getDtoClassName(property);
+      if (!className) return null;
+
+      const newType = isArray 
+        ? `() => [${className}]`
+        : `() => ${className}`;
+
+      return (fixer) => {
+        const propertyText = sourceCode.getText(property);
+        const newPropertyText = newType;
+        
+        return fixer.replaceText(property, newPropertyText);
+      };
+    }
+
+    return {
+      CallExpression(node) {
+        if (!isApiPropertyDecorator(node)) {
+          return;
+        }
+
+        // Find the type property in the decorator arguments
+        const firstArg = node.arguments[0];
+        if (!firstArg || firstArg.type !== "ObjectExpression") {
+          return;
+        }
+
+        const typeProperty = firstArg.properties.find(
+          (prop) =>
+            prop.type === "Property" &&
+            prop.key &&
+            prop.key.type === "Identifier" &&
+            prop.key.name === "type"
+        );
+
+        if (!typeProperty || !typeProperty.value) {
+          return;
+        }
+
+        const typeValue = typeProperty.value;
+
+        // Skip if already using lazy loading
+        if (isLazyTypeLoading(typeValue)) {
+          return;
+        }
+
+        // Check for array of DTOs
+        if (isDtoArrayReference(typeValue)) {
+          const className = getDtoClassName(typeValue);
+          context.report({
+            node: typeValue,
+            messageId: "lazyTypeRequired",
+            data: { className },
+            fix: createFix(node, typeValue, true),
+          });
+          return;
+        }
+
+        // Check for single DTO reference
+        if (isDtoClassReference(typeValue)) {
+          const className = getDtoClassName(typeValue);
+          context.report({
+            node: typeValue,
+            messageId: "lazyTypeRequiredSingle",
+            data: { className },
+            fix: createFix(node, typeValue, false),
+          });
+          return;
+        }
+      },
+    };
+  },
+};
+
+
+
+
+