@echoes-of-order/eslint-config 1.121.0

package/rules/enforce-entity-dto-methods-restriction.js

@@ -0,0 +1,159 @@
+/**
+ * @fileoverview Enforce that Entity-specific methods (toEntity, fromEntity, fromEntityArray) are only allowed in EntityDto classes
+ * @author Echoes of Order Team
+ */
+
+//------------------------------------------------------------------------------
+// Rule Definition
+//------------------------------------------------------------------------------
+
+/** @type {import('eslint').Rule.RuleModule} */
+export default {
+  meta: {
+    type: "problem",
+    docs: {
+      description: "Entity-specific methods (toEntity, fromEntity, fromEntityArray) are only allowed in EntityDto classes",
+      category: "Architecture",
+      recommended: true,
+    },
+    fixable: null,
+    schema: [],
+    messages: {
+      entityMethodInNonEntityDto: "Method '{{methodName}}' is only allowed in Entity DTOs (classes ending with 'EntityDto' in /dto/Entity/). Found in '{{className}}' which is a {{dtoType}}.",
+      entityMethodMustBeStatic: "Method '{{methodName}}' in Entity DTO '{{className}}' must be static.",
+    },
+  },
+
+  create(context) {
+    //--------------------------------------------------------------------------
+    // Helpers
+    //--------------------------------------------------------------------------
+
+    const ENTITY_SPECIFIC_METHODS = [
+      "toEntity",
+      "fromEntity",
+      "fromEntityArray",
+    ];
+
+    /**
+     * Check if a file is an Entity DTO
+     * @param {string} filename - The filename
+     * @returns {boolean} True if it's an Entity DTO
+     */
+    function isEntityDtoFile(filename) {
+      return (
+        (filename.includes("/dto/Entity/") || filename.includes("/test-fixtures/")) &&
+        (filename.endsWith("EntityDto.ts") || filename.includes("EntityDto"))
+      );
+    }
+
+    /**
+     * Check if a class name indicates it's an Entity DTO
+     * @param {string} className - The class name
+     * @returns {boolean} True if it's an Entity DTO
+     */
+    function isEntityDtoClass(className) {
+      return className.endsWith("EntityDto");
+    }
+
+    /**
+     * Get the DTO type from class name
+     * @param {string} className - The class name
+     * @returns {string} The DTO type
+     */
+    function getDtoType(className) {
+      if (className.endsWith("RequestDto")) {
+        return "Request DTO";
+      }
+
+      if (className.endsWith("ResponseDto")) {
+        return "Response DTO";
+      }
+
+      if (className.endsWith("FilterDto")) {
+        return "Filter DTO";
+      }
+
+      if (className.endsWith("ConfigDto")) {
+        return "Config DTO";
+      }
+
+      if (className.endsWith("Dto")) {
+        return "DTO";
+      }
+
+      return "non-Entity DTO";
+    }
+
+    /**
+     * Check if a method is an entity-specific method
+     * @param {string} methodName - The method name
+     * @returns {boolean} True if it's an entity-specific method
+     */
+    function isEntitySpecificMethod(methodName) {
+      return ENTITY_SPECIFIC_METHODS.includes(methodName);
+    }
+
+    //--------------------------------------------------------------------------
+    // Public
+    //--------------------------------------------------------------------------
+
+    return {
+      MethodDefinition(node) {
+        const filename = context.getFilename();
+        const methodName = node.key.name;
+
+        // Only check entity-specific methods
+        if (!isEntitySpecificMethod(methodName)) {
+          return;
+        }
+
+        // Find the ClassDeclaration by walking up the AST
+        let parent = node.parent;
+        while (parent && parent.type !== "ClassDeclaration") {
+          parent = parent.parent;
+        }
+
+        if (!parent || !parent.id) {
+          return;
+        }
+
+        const className = parent.id.name;
+        const isEntityDto = isEntityDtoFile(filename) && isEntityDtoClass(className);
+
+        // If it's NOT an Entity DTO, report error
+        if (!isEntityDto) {
+          const dtoType = getDtoType(className);
+
+          context.report({
+            node,
+            messageId: "entityMethodInNonEntityDto",
+            data: {
+              methodName,
+              className,
+              dtoType,
+            },
+          });
+
+          return;
+        }
+
+        // If it IS an Entity DTO, ensure the method is static
+        if (isEntityDto && !node.static) {
+          context.report({
+            node,
+            messageId: "entityMethodMustBeStatic",
+            data: {
+              methodName,
+              className,
+            },
+          });
+        }
+      },
+    };
+  },
+};
+
+
+
+

package/rules/enforce-entity-dto-no-request-dto.js

@@ -0,0 +1,102 @@
+export default {
+  meta: {
+    type: "problem",
+    docs: {
+      description: "Entity DTOs dürfen keine Request DTOs als Properties haben",
+      category: "Best Practices",
+      recommended: true,
+    },
+    fixable: null,
+    schema: [],
+    messages: {
+      requestDtoInEntityDto: "Entity-DTO '{{dtoName}}' darf keine Request-DTO '{{requestDtoName}}' als Property haben. Verwende stattdessen normale DTOs oder Entity-DTOs.",
+    },
+  },
+  create(context) {
+    const filename = context.getFilename();
+
+    // Nur in Entity-DTO-Dateien anwenden
+    if (!filename.includes("/dto/Entity/") && !filename.includes("test-fixtures")) {
+      return {};
+    }
+
+    // Prüfe ob es eine Entity-DTO-Datei ist
+    if (!filename.endsWith("EntityDto.ts") && !filename.includes("EntityDto")) {
+      return {};
+    }
+
+    return {
+      ClassDeclaration(node) {
+        const className = node.id.name;
+
+        // Prüfe alle Properties der Klasse
+        node.body.body.forEach(member => {
+          if (member.type === "PropertyDefinition" ||
+              (member.type === "TSParameterProperty" && member.parameter.type === "TSTypeAnnotation")) {
+
+            let typeAnnotation = null;
+            if (member.type === "PropertyDefinition" && member.typeAnnotation) {
+              typeAnnotation = member.typeAnnotation.typeAnnotation;
+            } else if (member.type === "TSParameterProperty" && member.parameter.typeAnnotation) {
+              typeAnnotation = member.parameter.typeAnnotation.typeAnnotation;
+            }
+
+            if (typeAnnotation) {
+              // Prüfe auf Request-DTO-Typen
+              if (typeAnnotation.type === "TSTypeReference") {
+                const typeName = typeAnnotation.typeName.name;
+                if (typeName && typeName.endsWith("RequestDto")) {
+                  context.report({
+                    node: member,
+                    messageId: "requestDtoInEntityDto",
+                    data: {
+                      dtoName: className,
+                      requestDtoName: typeName,
+                    },
+                  });
+                }
+              }
+
+              // Prüfe auf Array-Typen mit Request-DTOs
+              if (typeAnnotation.type === "TSArrayType") {
+                const elementType = typeAnnotation.elementType;
+                if (elementType.type === "TSTypeReference") {
+                  const typeName = elementType.typeName.name;
+                  if (typeName && typeName.endsWith("RequestDto")) {
+                    context.report({
+                      node: member,
+                      messageId: "requestDtoInEntityDto",
+                      data: {
+                        dtoName: className,
+                        requestDtoName: typeName,
+                      },
+                    });
+                  }
+                }
+              }
+
+              // Prüfe auf Union-Typen
+              if (typeAnnotation.type === "TSUnionType") {
+                typeAnnotation.types.forEach(unionType => {
+                  if (unionType.type === "TSTypeReference") {
+                    const typeName = unionType.typeName.name;
+                    if (typeName && typeName.endsWith("RequestDto")) {
+                      context.report({
+                        node: member,
+                        messageId: "requestDtoInEntityDto",
+                        data: {
+                          dtoName: className,
+                          requestDtoName: typeName,
+                        },
+                      });
+                    }
+                  }
+                });
+              }
+            }
+          }
+        });
+      },
+    };
+  },
+};

package/rules/enforce-entity-dto-optional-auto-fields.js

@@ -0,0 +1,101 @@
+/**
+ * @fileoverview Enforce that id, createdAt, and updatedAt are optional in Entity DTOs
+ * @author Echoes of Order Team
+ */
+
+//------------------------------------------------------------------------------
+// Rule Definition
+//------------------------------------------------------------------------------
+
+/** @type {import('eslint').Rule.RuleModule} */
+const enforceEntityDtoOptionalAutoFieldsRule = {
+  meta: {
+    type: "problem",
+    docs: {
+      description: "id, createdAt, and updatedAt must be optional in Entity DTOs (generated by database/TypeORM)",
+      category: "Architecture",
+      recommended: true,
+    },
+    fixable: "code",
+    schema: [],
+    messages: {
+      idMustBeOptional: "Property 'id' in Entity DTO '{{className}}' must be optional (id?: string). The ID is generated by the database.",
+      createdAtMustBeOptional: "Property 'createdAt' in Entity DTO '{{className}}' must be optional (createdAt?: Date). The field is set by TypeORM automatically.",
+      updatedAtMustBeOptional: "Property 'updatedAt' in Entity DTO '{{className}}' must be optional (updatedAt?: Date). The field is set by TypeORM automatically.",
+    },
+  },
+
+  create(context) {
+    const filename = context.getFilename();
+
+    // Only check Entity DTO files
+    const isEntityDtoFile = filename.includes("/dto/Entity/") && filename.endsWith("EntityDto.ts");
+
+    if (!isEntityDtoFile) {
+      return {};
+    }
+
+    // Skip BaseEntityDto
+    if (filename.endsWith("/dto/BaseEntityDto.ts")) {
+      return {};
+    }
+
+    const AUTO_GENERATED_FIELDS = {
+      "id": "idMustBeOptional",
+      "createdAt": "createdAtMustBeOptional",
+      "updatedAt": "updatedAtMustBeOptional",
+    };
+
+    return {
+      PropertyDefinition(node) {
+        // Find the containing class
+        let parent = node.parent;
+        while (parent && parent.type !== "ClassDeclaration") {
+          parent = parent.parent;
+        }
+
+        if (!parent || !parent.id) {
+          return;
+        }
+
+        const className = parent.id.name;
+
+        // Only check Entity DTOs
+        if (!className.endsWith("EntityDto")) {
+          return;
+        }
+
+        const propertyName = node.key?.name;
+
+        // Check if this is one of the auto-generated fields
+        if (propertyName && AUTO_GENERATED_FIELDS[propertyName]) {
+          // Check if property is optional
+          const isOptional = node.optional === true;
+
+          if (!isOptional) {
+            context.report({
+              node,
+              messageId: AUTO_GENERATED_FIELDS[propertyName],
+              data: { className },
+              fix(fixer) {
+                // Find the property name in the source
+                const sourceCode = context.getSourceCode();
+                const propertyText = sourceCode.getText(node.key);
+
+                // Add ? after property name
+                return fixer.replaceText(node.key, `${propertyText}?`);
+              },
+            });
+          }
+        }
+      },
+    };
+  },
+};
+
+export default {
+  rules: {
+    "enforce-entity-dto-optional-auto-fields": enforceEntityDtoOptionalAutoFieldsRule,
+  },
+};
+

package/rules/enforce-entity-dto-required-methods.js

@@ -0,0 +1,248 @@
+/**
+ * @fileoverview Enforce required methods in Entity DTOs and validate fromRequestDto parameter types
+ * @author Echoes of Order Team
+ */
+
+//------------------------------------------------------------------------------
+// Rule Definition
+//------------------------------------------------------------------------------
+
+/** @type {import('eslint').Rule.RuleModule} */
+export default {
+  meta: {
+    type: "problem",
+    docs: {
+      description: "Entity DTOs must have fromEntity and toEntity methods. fromEntityArray and fromRequestDto are optional but must use correct types.",
+      category: "Architecture",
+      recommended: true,
+    },
+    fixable: null,
+    schema: [],
+    messages: {
+      missingFromEntity: "Entity DTO '{{className}}' must have a static 'fromEntity' method.",
+      missingToEntity: "Entity DTO '{{className}}' must have a static 'toEntity' method.",
+      invalidFromRequestDtoParameter: "Entity DTO '{{className}}' has 'fromRequestDto' method but parameter type '{{paramType}}' does not match expected '{{expectedType}}'.",
+      fromRequestDtoMustBeStatic: "Method 'fromRequestDto' in Entity DTO '{{className}}' must be static.",
+      optionalMethodMustBeStatic: "Method '{{methodName}}' in Entity DTO '{{className}}' must be static.",
+      requiredMethodMustBeStatic: "Method '{{methodName}}' in Entity DTO '{{className}}' must be static.",
+      forbiddenMethod: "Entity DTO '{{className}}' must not have method '{{methodName}}'. Only 'fromEntity', 'toEntity', and optionally 'fromEntityArray', 'fromRequestDto' are allowed.",
+    },
+  },
+
+  create(context) {
+    //--------------------------------------------------------------------------
+    // Helpers
+    //--------------------------------------------------------------------------
+
+    const REQUIRED_METHODS = ["fromEntity", "toEntity"];
+    const ALLOWED_OPTIONAL_METHODS = ["fromEntityArray", "fromRequestDto"];
+    const ALL_ALLOWED_METHODS = [...REQUIRED_METHODS, ...ALLOWED_OPTIONAL_METHODS];
+
+    /**
+     * Check if a file is an Entity DTO
+     * @param {string} filename - The filename
+     * @returns {boolean} True if it's an Entity DTO
+     */
+    function isEntityDtoFile(filename) {
+      return (
+        filename.includes("/dto/Entity/") &&
+        filename.endsWith("EntityDto.ts")
+      );
+    }
+
+    /**
+     * Check if a class name indicates it's an Entity DTO
+     * @param {string} className - The class name
+     * @returns {boolean} True if it's an Entity DTO
+     */
+    function isEntityDtoClass(className) {
+      return className && className.endsWith("EntityDto");
+    }
+
+    /**
+     * Get expected RequestDto name from EntityDto name
+     * @param {string} entityDtoName - The Entity DTO name (e.g., "ItemEntityDto")
+     * @returns {string} The expected RequestDto name (e.g., "ItemRequestDto")
+     */
+    function getExpectedRequestDtoName(entityDtoName) {
+      // Remove "EntityDto" suffix and add "RequestDto"
+      return entityDtoName.replace(/EntityDto$/, "RequestDto");
+    }
+
+    /**
+     * Get parameter type name from TypeAnnotation
+     * @param {object} param - The parameter node
+     * @returns {string|null} The type name or null
+     */
+    function getParameterTypeName(param) {
+      if (!param || !param.typeAnnotation) {
+        return null;
+      }
+
+      const typeAnnotation = param.typeAnnotation.typeAnnotation;
+
+      if (typeAnnotation.type === "TSTypeReference") {
+        if (typeAnnotation.typeName.type === "Identifier") {
+          return typeAnnotation.typeName.name;
+        }
+      }
+
+      return null;
+    }
+
+    /**
+     * Check if a method name is allowed in Entity DTOs
+     * @param {string} methodName - The method name
+     * @returns {boolean} True if allowed
+     */
+    function isAllowedMethod(methodName) {
+      return ALL_ALLOWED_METHODS.includes(methodName);
+    }
+
+    //--------------------------------------------------------------------------
+    // Public
+    //--------------------------------------------------------------------------
+
+    let classNode = null;
+    let className = null;
+    let foundMethods = {};
+    let methodNodes = {};
+
+    return {
+      ClassDeclaration(node) {
+        const filename = context.getFilename();
+
+        // Only check Entity DTOs
+        if (!isEntityDtoFile(filename)) {
+          return;
+        }
+
+        classNode = node;
+        className = node.id?.name;
+
+        // Only check classes that are Entity DTOs
+        if (!isEntityDtoClass(className)) {
+          return;
+        }
+
+        // Reset tracking
+        foundMethods = {};
+        methodNodes = {};
+
+        // Special case: Skip BaseEntityDto
+        if (className === "BaseEntityDto" && filename.endsWith("/dto/BaseEntityDto.ts")) {
+          return;
+        }
+
+        // Collect all static methods
+        node.body.body.forEach((member) => {
+          if (member.type === "MethodDefinition" && member.key && member.key.name) {
+            const methodName = member.key.name;
+
+            // Track found methods
+            foundMethods[methodName] = {
+              isStatic: member.static === true,
+              node: member,
+            };
+            methodNodes[methodName] = member;
+
+            // Check if method is allowed
+            if (!isAllowedMethod(methodName) && member.kind !== "constructor") {
+              context.report({
+                node: member,
+                messageId: "forbiddenMethod",
+                data: {
+                  className,
+                  methodName,
+                },
+              });
+            }
+
+            // Check if required methods are static
+            if (REQUIRED_METHODS.includes(methodName) && !member.static) {
+              context.report({
+                node: member,
+                messageId: "requiredMethodMustBeStatic",
+                data: {
+                  className,
+                  methodName,
+                },
+              });
+            }
+
+            // Check if optional methods are static (fromEntityArray, fromRequestDto)
+            if (ALLOWED_OPTIONAL_METHODS.includes(methodName) && !member.static) {
+              context.report({
+                node: member,
+                messageId: "optionalMethodMustBeStatic",
+                data: {
+                  className,
+                  methodName,
+                },
+              });
+            }
+
+            // Check fromRequestDto parameter type
+            if (methodName === "fromRequestDto") {
+
+              // Check parameter type
+              if (member.value && member.value.params && member.value.params.length > 0) {
+                const firstParam = member.value.params[0];
+                const paramTypeName = getParameterTypeName(firstParam);
+                const expectedTypeName = getExpectedRequestDtoName(className);
+
+                if (paramTypeName && paramTypeName !== expectedTypeName) {
+                  context.report({
+                    node: firstParam,
+                    messageId: "invalidFromRequestDtoParameter",
+                    data: {
+                      className,
+                      paramType: paramTypeName,
+                      expectedType: expectedTypeName,
+                    },
+                  });
+                }
+              }
+            }
+          }
+        });
+      },
+
+      "Program:exit"(node) {
+        if (!classNode || !className) {
+          return;
+        }
+
+        const filename = context.getFilename();
+
+        // Only check Entity DTOs
+        if (!isEntityDtoFile(filename) || !isEntityDtoClass(className)) {
+          return;
+        }
+
+        // Special case: Skip BaseEntityDto
+        if (className === "BaseEntityDto" && filename.endsWith("/dto/BaseEntityDto.ts")) {
+          return;
+        }
+
+        // Check for missing required methods
+        REQUIRED_METHODS.forEach((methodName) => {
+          if (!foundMethods[methodName]) {
+            context.report({
+              node: classNode,
+              messageId: `missing${methodName.charAt(0).toUpperCase()}${methodName.slice(1)}`,
+              data: { className },
+            });
+          }
+        });
+
+        // Reset for next file
+        classNode = null;
+        className = null;
+        foundMethods = {};
+        methodNodes = {};
+      },
+    };
+  },
+};
+