@echoes-of-order/eslint-config 1.121.0

package/rules/enforce-eager-translation-loading.js

@@ -0,0 +1,178 @@
+export default {
+  meta: {
+    type: "problem",
+    docs: {
+      description: "Enforce eager loading for translation relations and prevent manual translation loading",
+      category: "Best Practices",
+      recommended: true,
+    },
+    messages: {
+      missingEagerTrue: "Translation relation 'translations' must have 'eager: true' option. This ensures translations are always loaded automatically.",
+      manualTranslationLoading: "Do not manually load 'translations' in relations array. Translation relations use 'eager: true' and are loaded automatically.",
+      addEagerTrue: "Add 'eager: true' to the @OneToMany decorator options for 'translations' relation.",
+      removeFromRelations: "Remove 'translations' from relations array - it's loaded automatically via eager loading.",
+    },
+    fixable: "code",
+    schema: [],
+  },
+
+  create (context) {
+    return {
+      "PropertyDefinition[key.name='translations']" (node) {
+        const decorators = node.decorators;
+        if (!decorators || decorators.length === 0) {
+          return;
+        }
+
+        const oneToManyDecorator = decorators.find((decorator) => {
+          if (decorator.expression.type !== "CallExpression") {
+            return false;
+          }
+
+          const callee = decorator.expression.callee;
+
+          return callee.type === "Identifier" && callee.name === "OneToMany";
+        });
+
+        if (!oneToManyDecorator) {
+          return;
+        }
+
+        const args = oneToManyDecorator.expression.arguments;
+        const optionsArg = args[2];
+
+        if (!optionsArg || optionsArg.type !== "ObjectExpression") {
+          context.report({
+            messageId: "missingEagerTrue",
+            node: oneToManyDecorator,
+            fix (fixer) {
+              const lastArg = args[args.length - 1];
+
+              return fixer.insertTextAfter(
+                lastArg,
+                ', {\n    cascade: true,\n    eager: true,\n  }',
+              );
+            },
+          });
+
+          return;
+        }
+
+        const hasEager = optionsArg.properties.some((prop) => {
+          if (prop.type !== "Property") {
+            return false;
+          }
+          if (prop.key.type !== "Identifier") {
+            return false;
+          }
+
+          return prop.key.name === "eager";
+        });
+
+        const eagerProp = optionsArg.properties.find((prop) => {
+          if (prop.type !== "Property") {
+            return false;
+          }
+          if (prop.key.type !== "Identifier") {
+            return false;
+          }
+
+          return prop.key.name === "eager";
+        });
+
+        if (!hasEager) {
+          context.report({
+            messageId: "missingEagerTrue",
+            node: oneToManyDecorator,
+            fix (fixer) {
+              const lastProperty = optionsArg.properties[optionsArg.properties.length - 1];
+
+              return fixer.insertTextAfter(
+                lastProperty,
+                ',\n    eager: true',
+              );
+            },
+          });
+
+          return;
+        }
+
+        if (eagerProp && eagerProp.type === "Property" && eagerProp.value.type === "Literal" && eagerProp.value.value !== true) {
+          context.report({
+            messageId: "missingEagerTrue",
+            node: eagerProp,
+            fix (fixer) {
+              return fixer.replaceText(eagerProp.value, "true");
+            },
+          });
+        }
+      },
+
+      ArrayExpression (node) {
+        const parent = node.parent;
+        if (!parent || parent.type !== "Property") {
+          return;
+        }
+
+        if (parent.key.type !== "Identifier" || parent.key.name !== "relations") {
+          return;
+        }
+
+        node.elements.forEach((element) => {
+          if (!element || element.type !== "Literal") {
+            return;
+          }
+
+          const value = element.value;
+          if (typeof value !== "string") {
+            return;
+          }
+
+          if (value === "translations" || value.endsWith(".translations")) {
+            context.report({
+              messageId: "manualTranslationLoading",
+              node: element,
+              fix (fixer) {
+                const sourceCode = context.getSourceCode();
+                const elementIndex = node.elements.indexOf(element);
+                const tokenBefore = sourceCode.getTokenBefore(element);
+                const tokenAfter = sourceCode.getTokenAfter(element);
+
+                if (node.elements.length === 1) {
+                  return fixer.remove(element);
+                }
+
+                if (elementIndex === 0) {
+                  if (tokenAfter && tokenAfter.value === ",") {
+                    return fixer.removeRange([element.range[0], tokenAfter.range[1]]);
+                  }
+
+                  return fixer.remove(element);
+                }
+
+                if (elementIndex === node.elements.length - 1) {
+                  if (tokenBefore && tokenBefore.value === ",") {
+                    return fixer.removeRange([tokenBefore.range[0], element.range[1]]);
+                  }
+
+                  return fixer.remove(element);
+                }
+
+                if (tokenBefore && tokenBefore.value === ",") {
+                  return fixer.removeRange([tokenBefore.range[0], element.range[1]]);
+                }
+
+                if (tokenAfter && tokenAfter.value === ",") {
+                  return fixer.removeRange([element.range[0], tokenAfter.range[1]]);
+                }
+
+                return fixer.remove(element);
+              },
+            });
+          }
+        });
+      },
+    };
+  },
+};
+

package/rules/enforce-entity-creation-pattern.js

@@ -0,0 +1,137 @@
+export default {
+  rules: {
+    "enforce-entity-creation-pattern": {
+      meta: {
+        type: "problem",
+        docs: {
+          description: "Enforce entity creation pattern: use DTOs and convert with .toEntity() before saving",
+          category: "Best Practices",
+          recommended: true,
+        },
+        fixable: null,
+        schema: [],
+        messages: {
+          directEntityCreation: "Direct entity creation with 'new {{entityName}}()' is not allowed. Use DTOs and convert with .toEntity() instead.",
+          missingToEntityConversion: "Entity must be converted with .toEntity() before saving. Use '{{dtoName}}.toEntity({{dtoVariable}})' instead of direct entity creation.",
+          invalidEntityManagerUsage: "entityManager.create() should only be used with DTOs that have been converted with .toEntity().",
+        },
+      },
+
+      create(context) {
+        const entityDtos = new Map();
+        const entityManagerCalls = new Map();
+
+        function isEntityDtoFile(filename) {
+          return (filename.includes("/dto/Entity/") || filename.includes("test-fixtures")) &&
+                 (filename.endsWith("EntityDto.ts") || filename.includes("EntityDto"));
+        }
+
+        function getEntityNameFromDto(dtoName) {
+          if (dtoName.endsWith("EntityDto")) {
+            return dtoName.replace("EntityDto", "Entity");
+          }
+          return dtoName;
+        }
+
+        function isInsideToEntityMethod(node) {
+          let parent = node.parent;
+          while (parent) {
+            if (parent.type === "MethodDefinition" || parent.type === "Property") {
+              if (parent.key && (parent.key.name === "toEntity" || parent.key.name === "fromRequestDto")) {
+                return true;
+              }
+            }
+            parent = parent.parent;
+          }
+          return false;
+        }
+
+        function isEntityManagerCall(node) {
+          if (node.type === "CallExpression" && node.callee) {
+            if (node.callee.type === "MemberExpression") {
+              const objectName = node.callee.object.name;
+              const methodName = node.callee.property.name;
+
+              // Check for entityManager.create, transactionalEntityManager.create, etc.
+              if ((objectName === "entityManager" ||
+                   objectName === "transactionalEntityManager" ||
+                   objectName === "manager") &&
+                  methodName === "create") {
+                return true;
+              }
+            }
+          }
+          return false;
+        }
+
+        return {
+          ClassDeclaration(node) {
+            const filename = context.getFilename();
+            const className = node.id.name;
+
+            if (isEntityDtoFile(filename) && className.endsWith("EntityDto")) {
+              entityDtos.set(className, {
+                node,
+                hasToEntityMethod: node.body.body.some(member =>
+                  member.type === "MethodDefinition" &&
+                  member.key.name === "toEntity" &&
+                  member.static
+                ),
+              });
+            }
+          },
+
+          NewExpression(node) {
+            const filename = context.getFilename();
+            const entityName = node.callee.name;
+
+            if (entityName && entityName.endsWith("Entity")) {
+              // Allow entity creation inside toEntity methods
+              if (isInsideToEntityMethod(node)) {
+                return;
+              }
+
+              // Check if this is a direct entity creation outside of toEntity
+              const dtoName = entityName.replace("Entity", "EntityDto");
+              const dtoInfo = entityDtos.get(dtoName);
+
+              if (dtoInfo) {
+                context.report({
+                  node,
+                  messageId: "directEntityCreation",
+                  data: { entityName },
+                });
+              }
+            }
+          },
+
+          CallExpression(node) {
+            if (isEntityManagerCall(node)) {
+              // Check if the second argument is a direct entity creation
+              if (node.arguments && node.arguments.length >= 2) {
+                const secondArg = node.arguments[1];
+
+                if (secondArg.type === "NewExpression" &&
+                    secondArg.callee.name &&
+                    secondArg.callee.name.endsWith("Entity")) {
+
+                  const entityName = secondArg.callee.name;
+                  const dtoName = entityName.replace("Entity", "EntityDto");
+
+                  context.report({
+                    node: secondArg,
+                    messageId: "missingToEntityConversion",
+                    data: {
+                      dtoName,
+                      dtoVariable: "dtoData"
+                    },
+                  });
+                }
+              }
+            }
+          },
+        };
+      },
+    },
+  },
+};

package/rules/enforce-entity-dto-convert-method.js

@@ -0,0 +1,157 @@
+export default {
+  meta: {
+    type: "problem",
+    docs: {
+      description: "Enforce that Entity DTOs use convertEntityToDto in fromEntity method",
+      category: "Best Practices",
+      recommended: true,
+    },
+    messages: {
+      missingConvertImport: "Entity-DTO '{{className}}' muss convertEntityToDto importieren: import { convertEntityToDto } from '@/dto/BaseEntityDto'",
+      fromEntityMustUseConvert: "fromEntity-Methode in '{{className}}' muss 'return convertEntityToDto(...)' verwenden, um zirkuläre Abhängigkeiten zu vermeiden",
+      invalidConvertStructure: "convertEntityToDto in '{{className}}' muss 3 Argumente haben: (entity, factory, populate)",
+      factoryMustBeArrowFunction: "Zweites Argument von convertEntityToDto muss eine Arrow-Function sein: () => new {{className}}()",
+      populateMustBeArrowFunction: "Drittes Argument von convertEntityToDto muss eine Arrow-Function sein: (dto, entity) => {{ ... }}",
+    },
+    fixable: null,
+    schema: [],
+  },
+
+  create (context) {
+    const filename = context.getFilename();
+
+    // Skip non-DTO files
+    if (!filename.includes("/dto/Entity/")) {
+      return {};
+    }
+
+    // Skip BaseEntityDto itself
+    if (filename.endsWith("/BaseEntityDto.ts")) {
+      return {};
+    }
+
+    // Skip test files
+    if (filename.includes(".test.") || filename.includes(".spec.") || filename.includes("__tests__")) {
+      return {};
+    }
+
+    let hasConvertImport = false;
+    let className = null;
+
+    return {
+      ImportDeclaration (node) {
+        // Check for convertEntityToDto import (absolute or relative)
+        const isBaseImport = node.source.value === "@/dto/BaseEntityDto" ||
+                             node.source.value.endsWith("/BaseEntityDto") ||
+                             node.source.value === "./BaseEntityDto";
+
+        if (isBaseImport) {
+          const hasConvert = node.specifiers.some(
+            (spec) => spec.type === "ImportSpecifier" && spec.imported.name === "convertEntityToDto",
+          );
+          if (hasConvert) {
+            hasConvertImport = true;
+          }
+        }
+      },
+
+      ClassDeclaration (node) {
+        // Only check Entity DTOs
+        if (!node.id || !node.id.name.endsWith("EntityDto")) {
+          return;
+        }
+
+        className = node.id.name;
+      },
+
+      MethodDefinition (node) {
+        // Only check static fromEntity methods
+        if (!node.static || !node.key || node.key.name !== "fromEntity") {
+          return;
+        }
+
+        // Check if import exists
+        if (!hasConvertImport) {
+          context.report({
+            node,
+            messageId: "missingConvertImport",
+            data: { className },
+          });
+
+          return;
+        }
+
+        // Check if method body uses convertEntityToDto
+        const methodBody = node.value.body;
+        if (!methodBody || methodBody.type !== "BlockStatement") {
+          return;
+        }
+
+        // Find return statement
+        const returnStatement = methodBody.body.find((stmt) => stmt.type === "ReturnStatement");
+        if (!returnStatement || !returnStatement.argument) {
+          return;
+        }
+
+        // Check if return statement calls convertEntityToDto
+        const returnArg = returnStatement.argument;
+        if (
+          returnArg.type !== "CallExpression"
+          || !returnArg.callee
+          || returnArg.callee.name !== "convertEntityToDto"
+        ) {
+          context.report({
+            node: returnStatement,
+            messageId: "fromEntityMustUseConvert",
+            data: { className },
+          });
+
+          return;
+        }
+
+        // Validate convertEntityToDto arguments
+        const args = returnArg.arguments;
+        if (args.length !== 3) {
+          context.report({
+            node: returnArg,
+            messageId: "invalidConvertStructure",
+            data: { className },
+          });
+
+          return;
+        }
+
+        // Validate factory function (second argument)
+        const factoryArg = args[1];
+        if (factoryArg.type !== "ArrowFunctionExpression") {
+          context.report({
+            node: factoryArg,
+            messageId: "factoryMustBeArrowFunction",
+            data: { className },
+          });
+        }
+
+        // Validate populate function (third argument)
+        const populateArg = args[2];
+        if (populateArg.type !== "ArrowFunctionExpression") {
+          context.report({
+            node: populateArg,
+            messageId: "populateMustBeArrowFunction",
+            data: { className },
+          });
+        }
+
+        // Validate populate function has 2 parameters (dto, entity)
+        if (populateArg.type === "ArrowFunctionExpression" && populateArg.params.length !== 2) {
+          context.report({
+            node: populateArg,
+            messageId: "populateMustBeArrowFunction",
+            data: { className },
+          });
+        }
+      },
+    };
+  },
+};
+
+

package/rules/enforce-entity-dto-create-no-id.js

@@ -0,0 +1,117 @@
+/**
+ * @fileoverview Enforce that EntityDto.create() methods never have id parameter or set id property
+ * @author Echoes of Order Team
+ */
+
+export default {
+  meta: {
+    type: "problem",
+    docs: {
+      description: "EntityDto.create() methods dürfen kein id-Feld haben (weder als Parameter noch in der Zuweisung)",
+      category: "Architecture",
+      recommended: true,
+    },
+    messages: {
+      noIdParameter: "EntityDto.create() Methode darf keinen 'id' Parameter haben. Die ID wird von der Datenbank generiert.",
+      noIdAssignment: "EntityDto.create() Methode darf kein 'id' Feld setzen. Die ID wird von der Datenbank generiert.",
+      noCreatedAtParameter: "EntityDto.create() Methode darf keinen 'createdAt' Parameter haben. Das Feld wird von TypeORM automatisch gesetzt.",
+      noCreatedAtAssignment: "EntityDto.create() Methode darf kein 'createdAt' Feld setzen. Das Feld wird von TypeORM automatisch gesetzt.",
+      noUpdatedAtParameter: "EntityDto.create() Methode darf keinen 'updatedAt' Parameter haben. Das Feld wird von TypeORM automatisch gesetzt.",
+      noUpdatedAtAssignment: "EntityDto.create() Methode darf kein 'updatedAt' Feld setzen. Das Feld wird von TypeORM automatisch gesetzt.",
+    },
+    schema: [],
+  },
+
+  create (context) {
+    const filename = context.getFilename();
+
+    const isEntityDtoFile = filename.includes("/dto/Entity/") &&
+                           filename.endsWith("EntityDto.ts");
+
+    if (!isEntityDtoFile) {
+      return {};
+    }
+
+    return {
+      MethodDefinition (node) {
+        if (node.static &&
+            node.key?.name === "create" &&
+            node.value?.params) {
+
+          const params = node.value.params;
+
+          if (params.length > 0 && params[0].type === "Identifier") {
+            const param = params[0];
+
+            if (param.typeAnnotation &&
+                param.typeAnnotation.typeAnnotation?.type === "TSTypeLiteral") {
+              const properties = param.typeAnnotation.typeAnnotation.members;
+
+              properties.forEach((prop) => {
+                if (prop.type === "TSPropertySignature" &&
+                    prop.key?.type === "Identifier") {
+                  const propName = prop.key.name;
+
+                  if (propName === "id") {
+                    context.report({
+                      node: prop,
+                      messageId: "noIdParameter",
+                    });
+                  }
+
+                  if (propName === "createdAt") {
+                    context.report({
+                      node: prop,
+                      messageId: "noCreatedAtParameter",
+                    });
+                  }
+
+                  if (propName === "updatedAt") {
+                    context.report({
+                      node: prop,
+                      messageId: "noUpdatedAtParameter",
+                    });
+                  }
+                }
+              });
+            }
+          }
+
+          if (node.value?.body?.body) {
+            const body = node.value.body.body;
+
+            body.forEach((statement) => {
+              if (statement.type === "ExpressionStatement" &&
+                  statement.expression?.type === "AssignmentExpression" &&
+                  statement.expression.left?.type === "MemberExpression") {
+                const propName = statement.expression.left.property?.name;
+
+                if (propName === "id") {
+                  context.report({
+                    node: statement,
+                    messageId: "noIdAssignment",
+                  });
+                }
+
+                if (propName === "createdAt") {
+                  context.report({
+                    node: statement,
+                    messageId: "noCreatedAtAssignment",
+                  });
+                }
+
+                if (propName === "updatedAt") {
+                  context.report({
+                    node: statement,
+                    messageId: "noUpdatedAtAssignment",
+                  });
+                }
+              }
+            });
+          }
+        }
+      },
+    };
+  },
+};
+