@echoes-of-order/eslint-config 1.121.0

package/rules/enforce-dto-naming.js

@@ -0,0 +1,176 @@
+export default {
+  rules: {
+    "enforce-dto-naming": {
+      meta: {
+        type: "problem",
+        docs: {
+          description: "Enforce correct DTO naming conventions and filename matching",
+          category: "Best Practices",
+          recommended: true,
+        },
+        fixable: null,
+        schema: [],
+        messages: {
+          invalidDtoSuffix: "Invalid DTO suffix pattern. Avoid double suffixes like 'DtoEntityDto', 'EntityDtoEntityDto', or 'EntityEntityDto'. Use only one suffix: 'EntityDto' for entity DTOs or 'Dto' for other DTOs.",
+          filenameMismatch: "Filename '{{filename}}' does not match class name '{{className}}'. Rename the file to '{{expectedFilename}}'.",
+          suggestCorrectName: "Consider renaming the class to '{{suggestedName}}' to match the filename.",
+          suggestCorrectFilename: "Consider renaming the file to '{{suggestedFilename}}' to match the class name.",
+        },
+      },
+
+      create(context) {
+        function hasInvalidDtoSuffix(className) {
+          // Verbotene Muster:
+          // - DtoEntityDto (doppeltes Dto)
+          // - EntityDtoEntityDto (doppeltes EntityDto)
+          // - EntityEntityDto (doppeltes Entity)
+          // - DtoDto (doppeltes Dto)
+
+          const invalidPatterns = [
+            /DtoEntityDto$/,           // DtoEntityDto
+            /EntityDtoEntityDto$/,     // EntityDtoEntityDto
+            /EntityEntityDto$/,        // EntityEntityDto
+            /DtoDto$/,                 // DtoDto
+            /EntityEntity$/,           // EntityEntity
+            /DtoEntityEntity$/,        // DtoEntityEntity
+            /EntityDtoEntity$/,        // EntityDtoEntity
+          ];
+
+          return invalidPatterns.some(pattern => pattern.test(className));
+        }
+
+        function getValidDtoSuffix(className) {
+          // Entferne alle bekannten Suffixe
+          let cleanName = className
+            .replace(/EntityDto$/, '')
+            .replace(/Dto$/, '')
+            .replace(/Entity$/, '');
+
+          // Füge den korrekten Suffix hinzu
+          if (className.endsWith('EntityDto')) {
+            return `${cleanName}EntityDto`;
+          } else if (className.endsWith('Dto')) {
+            return `${cleanName}Dto`;
+          } else if (className.endsWith('Entity')) {
+            return `${cleanName}Entity`;
+          }
+
+          // Standardfall: Dto hinzufügen
+          return `${cleanName}Dto`;
+        }
+
+        function getExpectedFilename(className) {
+          return `${className}.ts`;
+        }
+
+        function getCurrentFilename(context) {
+          const filename = context.getFilename();
+          // Extrahiere den Dateinamen ohne Pfad und Erweiterung
+          const pathParts = filename.split('/');
+          const filenameWithExt = pathParts[pathParts.length - 1];
+          return filenameWithExt.replace(/\.ts$/, '');
+        }
+
+        function isDtoFile(filename) {
+          // Prüfe, ob es sich um eine DTO-Datei handelt
+          return filename.includes('Dto') || filename.includes('Entity');
+        }
+
+        function isTestFile(filename) {
+          return filename.includes('.test.') ||
+                 filename.includes('.spec.') ||
+                 filename.includes('__tests__');
+        }
+
+        return {
+          ClassDeclaration(node) {
+            if (!node.id) return;
+
+            const className = node.id.name;
+            const currentFilename = getCurrentFilename(context);
+
+            // Überspringe Test-Dateien
+            if (isTestFile(currentFilename)) return;
+
+            // Prüfe nur DTO-Dateien
+            if (!isDtoFile(currentFilename)) return;
+
+            // Regel 1: Prüfe auf ungültige DTO-Suffixe
+            if (hasInvalidDtoSuffix(className)) {
+              const validName = getValidDtoSuffix(className);
+
+              context.report({
+                node: node.id,
+                messageId: "invalidDtoSuffix",
+                data: {
+                  className,
+                  suggestedName: validName,
+                },
+              });
+            }
+
+            // Regel 2: Prüfe auf Dateiname-Klassenname-Übereinstimmung
+            if (currentFilename !== className) {
+              const expectedFilename = getExpectedFilename(className);
+
+              context.report({
+                node: node.id,
+                messageId: "filenameMismatch",
+                data: {
+                  filename: currentFilename,
+                  className,
+                  expectedFilename,
+                  suggestedFilename: expectedFilename,
+                },
+              });
+            }
+          },
+
+          ExportDefaultDeclaration(node) {
+            if (node.declaration.type !== 'ClassDeclaration') return;
+            if (!node.declaration.id) return;
+
+            const className = node.declaration.id.name;
+            const currentFilename = getCurrentFilename(context);
+
+            // Überspringe Test-Dateien
+            if (isTestFile(currentFilename)) return;
+
+            // Prüfe nur DTO-Dateien
+            if (!isDtoFile(currentFilename)) return;
+
+            // Regel 1: Prüfe auf ungültige DTO-Suffixe
+            if (hasInvalidDtoSuffix(className)) {
+              const validName = getValidDtoSuffix(className);
+
+              context.report({
+                node: node.declaration.id,
+                messageId: "invalidDtoSuffix",
+                data: {
+                  className,
+                  suggestedName: validName,
+                },
+              });
+            }
+
+            // Regel 2: Prüfe auf Dateiname-Klassenname-Übereinstimmung
+            if (currentFilename !== className) {
+              const expectedFilename = getExpectedFilename(className);
+
+              context.report({
+                node: node.declaration.id,
+                messageId: "filenameMismatch",
+                data: {
+                  filename: currentFilename,
+                  className,
+                  expectedFilename,
+                  suggestedFilename: expectedFilename,
+                },
+              });
+            }
+          },
+        };
+      },
+    },
+  },
+};

package/rules/enforce-dto-usage-simple.js

@@ -0,0 +1,114 @@
+export default {
+  meta: {
+    type: "problem",
+    docs: {
+      description: "Enforce usage of DTOs instead of anonymous objects",
+      category: "Best Practices",
+      recommended: true,
+    },
+    fixable: null,
+    schema: [],
+    messages: {
+      anonymousObjectForbidden: "Anonymous objects are not allowed. Use a DTO class instead.",
+      anonymousObjectInReturn: "Returning anonymous objects is not allowed. Create a DTO class for the return type.",
+      anonymousObjectInAssignment: "Assigning anonymous objects is not allowed. Use a DTO class instead.",
+      anonymousObjectInFunctionCall: "Passing anonymous objects to functions is not allowed. Use a DTO class instead.",
+    },
+  },
+
+  create(context) {
+    function isTestFile() {
+      const filename = context.getFilename();
+      return filename.includes('.test.') || filename.includes('.spec.') || filename.includes('__tests__');
+    }
+
+    function isExemptFunction(node) {
+      if (!node || !node.callee) return false;
+
+      // Check for method calls like logger.error
+      if (node.callee.type === "MemberExpression") {
+        const objectName = node.callee.object.name;
+        const propertyName = node.callee.property.name;
+        const fullName = `${objectName}.${propertyName}`;
+
+        // Allow logger methods
+        if (fullName.startsWith('logger.')) {
+          return true;
+        }
+
+        // Allow console methods
+        if (fullName.startsWith('console.')) {
+          return true;
+        }
+
+        // Allow DTO factory methods
+        if (propertyName === "create" && objectName && objectName.endsWith("Dto")) {
+          return true;
+        }
+      }
+
+      // Check for direct function calls
+      if (node.callee.type === "Identifier") {
+        const exemptFunctions = [
+          "Object.assign", "JSON.stringify", "JSON.parse", "collectDefaultMetrics"
+        ];
+        return exemptFunctions.includes(node.callee.name);
+      }
+
+      return false;
+    }
+
+    function isInsideExemptFunction(node) {
+      let parent = node.parent;
+      while (parent) {
+        if (parent.type === "CallExpression" && isExemptFunction(parent)) {
+          return true;
+        }
+        parent = parent.parent;
+      }
+      return false;
+    }
+
+    function checkObjectExpression(node) {
+      // Skip if it's a test file
+      if (isTestFile()) return;
+
+      // Skip if it's inside an exempt function
+      if (isInsideExemptFunction(node)) return;
+
+      // Skip if it's a simple object with only basic properties
+      if (node.properties && node.properties.length <= 2) {
+        const propertyNames = node.properties
+          .filter(prop => prop.type === "Property" && prop.key.type === "Identifier")
+          .map(prop => prop.key.name);
+
+        // Allow simple objects with basic properties
+        if (propertyNames.every(name => ["id", "isActive", "name", "type", "value"].includes(name))) {
+          return;
+        }
+      }
+
+      // Report the anonymous object
+      let messageId = "anonymousObjectForbidden";
+
+      if (node.parent) {
+        if (node.parent.type === "ReturnStatement") {
+          messageId = "anonymousObjectInReturn";
+        } else if (node.parent.type === "VariableDeclarator") {
+          messageId = "anonymousObjectInAssignment";
+        } else if (node.parent.type === "CallExpression") {
+          messageId = "anonymousObjectInFunctionCall";
+        }
+      }
+
+      context.report({
+        node,
+        messageId,
+      });
+    }
+
+    return {
+      ObjectExpression: checkObjectExpression,
+    };
+  },
+};

package/rules/enforce-dto-usage.js

@@ -0,0 +1,407 @@
+export default {
+  rules: {
+    "enforce-dto-usage": {
+      meta: {
+        type: "problem",
+        docs: {
+          description: "Enforce usage of DTOs instead of anonymous objects",
+          category: "Best Practices",
+          recommended: true,
+        },
+        messages: {
+          anonymousObjectForbidden: "Anonymous objects are not allowed. Use DTO classes instead.",
+          anonymousObjectInReturn: "Returning anonymous objects is not allowed. Use a DTO class instead.",
+          anonymousObjectInAssignment: "Assigning anonymous objects is not allowed. Use a DTO class instead.",
+          anonymousObjectInFunctionCall: "Passing anonymous objects to functions is not allowed. Use a DTO class instead.",
+        },
+      },
+
+      create(context) {
+        function isTestFile() {
+          const filename = context.getFilename();
+          return filename.includes('.test.') || filename.includes('.spec.') || filename.includes('__tests__');
+        }
+
+        function isDtoFile() {
+          const filename = context.getFilename();
+          return filename.includes('/dto/') || filename.includes('\\dto\\');
+        }
+
+        function isExternalLibraryCall(node) {
+          if (!node || !node.callee) return false;
+
+          // Check for method calls like repository.findOne, repository.save, etc.
+          if (node.callee.type === "MemberExpression") {
+            const objectName = node.callee.object.name;
+            const propertyName = node.callee.property.name;
+
+            // TypeORM repository methods - check if object name suggests it's a repository
+            if (objectName && (
+                objectName.includes("Repository") ||
+                objectName === "repository" ||
+                objectName === "manager" ||
+                objectName === "transactionalEntityManager" ||
+                objectName === "entityManager" ||
+                objectName === "dataSource"
+            )) {
+              return true;
+            }
+
+            // TypeORM DataSource methods
+            if (objectName === "dataSource") {
+              return true;
+            }
+
+            // Check if the call is to a method that's likely from an external library
+            // by checking if the object is imported from node_modules
+            const sourceCode = context.getSourceCode();
+            const nodeText = sourceCode.getText(node.callee.object);
+
+            // If the object is a property access chain that starts with a variable
+            // that's likely from an external library, consider it external
+            if (node.callee.object.type === "MemberExpression") {
+              const rootObject = node.callee.object.object;
+              if (rootObject && rootObject.type === "Identifier") {
+                const rootObjectName = rootObject.name;
+                // Common external library objects
+                const externalObjects = [
+                  "dataSource", "repository", "manager", "entityManager",
+                  "transactionalEntityManager", "queryRunner", "connection"
+                ];
+                if (externalObjects.includes(rootObjectName)) {
+                  return true;
+                }
+              }
+            }
+
+            // Check for specific TypeORM method names
+            const typeOrmMethods = [
+              "findOne", "find", "save", "create", "update", "delete", "remove",
+              "findOneBy", "findBy", "findAndCount", "findAndCountBy",
+              "count", "countBy", "exists", "existsBy",
+              "query", "transaction", "getRepository", "createQueryBuilder",
+              "insert", "upsert", "softDelete", "restore", "recover",
+              "increment", "decrement", "clear"
+            ];
+
+            if (typeOrmMethods.includes(propertyName)) {
+              return true;
+            }
+          }
+
+          return false;
+        }
+
+        function isExemptFunction(node) {
+          if (!node || !node.callee) return false;
+
+          // Check if it's an external library call first
+          if (isExternalLibraryCall(node)) {
+            return true;
+          }
+
+          // Check for method calls like logger.error
+          if (node.callee.type === "MemberExpression") {
+            const objectName = node.callee.object.name;
+            const propertyName = node.callee.property.name;
+            const fullName = `${objectName}.${propertyName}`;
+
+            // Allow logger methods
+            if (fullName.startsWith('logger.')) {
+              return true;
+            }
+
+            // Allow console methods
+            if (fullName.startsWith('console.')) {
+              return true;
+            }
+
+            // Allow DTO factory methods (create, fromEntity, fromEntityArray, etc.)
+            if ((propertyName === "create" ||
+                 propertyName === "fromEntity" ||
+                 propertyName === "fromEntityArray" ||
+                 propertyName === "fromRequestDto" ||
+                 propertyName === "toEntity" ||
+                 propertyName === "createInventorySlot") &&
+                objectName && objectName.endsWith("Dto")) {
+              return true;
+            }
+
+            // Allow Service methods
+            if (objectName && (
+                objectName.endsWith("Service") ||
+                objectName.endsWith("Manager") ||
+                objectName.endsWith("Repository")
+            )) {
+              return true;
+            }
+
+            // Allow this.service.method calls
+            if (objectName === "this" && propertyName && (
+                propertyName.endsWith("Service") ||
+                propertyName.endsWith("Manager") ||
+                propertyName.endsWith("Repository")
+            )) {
+              return true;
+            }
+          }
+
+          // Check for direct function calls
+          if (node.callee.type === "Identifier") {
+            const exemptFunctions = [
+              "Object.assign", "JSON.stringify", "JSON.parse", "collectDefaultMetrics"
+            ];
+            return exemptFunctions.includes(node.callee.name);
+          }
+
+          return false;
+        }
+
+        function isInsideExemptFunction(node) {
+          let parent = node.parent;
+          while (parent) {
+            if (parent.type === "CallExpression" && isExemptFunction(parent)) {
+              return true;
+            }
+            parent = parent.parent;
+          }
+          return false;
+        }
+
+        function isInsideDecorator(node) {
+          let parent = node.parent;
+          while (parent) {
+            // Check if we're inside a decorator call like @ApiResponse({...})
+            if (parent.type === "CallExpression" &&
+                parent.callee &&
+                parent.callee.type === "Identifier" &&
+                parent.callee.name &&
+                (parent.callee.name.startsWith("Api") ||
+                 parent.callee.name.includes("Decorator") ||
+                 parent.callee.name === "Column" ||
+                 parent.callee.name === "Entity" ||
+                 parent.callee.name === "PrimaryGeneratedColumn" ||
+                 parent.callee.name === "CreateDateColumn" ||
+                 parent.callee.name === "UpdateDateColumn" ||
+                 parent.callee.name === "OneToMany" ||
+                 parent.callee.name === "ManyToOne" ||
+                 parent.callee.name === "ManyToMany" ||
+                 parent.callee.name === "OneToOne" ||
+                 parent.callee.name === "JoinColumn" ||
+                 parent.callee.name === "Index" ||
+                 parent.callee.name === "Unique")) {
+              return true;
+            }
+
+            // Check if we're inside a decorator expression
+            if (parent.type === "Decorator") {
+              return true;
+            }
+
+            parent = parent.parent;
+          }
+          return false;
+        }
+
+        function checkObjectExpression(node) {
+          // Skip if it's a test file
+          if (isTestFile()) return;
+
+          // Skip if it's inside an exempt function
+          if (isInsideExemptFunction(node)) return;
+
+          // Skip if it's inside a decorator
+          if (isInsideDecorator(node)) return;
+
+          // Skip if it's inside a DTO factory method
+          if (node.parent && node.parent.type === "CallExpression" &&
+              node.parent.callee && node.parent.callee.type === "MemberExpression" &&
+              node.parent.callee.property && node.parent.callee.property.name === "create" &&
+              node.parent.callee.object && node.parent.callee.object.name &&
+              (node.parent.callee.object.name.endsWith("Dto") || node.parent.callee.object.name.includes("Dto"))) {
+            return;
+          }
+
+          // Skip if it's a prom-client metric call
+          if (node.parent && node.parent.type === "CallExpression" &&
+              node.parent.callee && node.parent.callee.type === "MemberExpression" &&
+              node.parent.callee.property &&
+              ["inc", "set", "observe", "histogram"].includes(node.parent.callee.property.name)) {
+            return;
+          }
+
+          // Skip if it's Object.assign with Error objects (common pattern for custom errors)
+          if (node.parent && node.parent.type === "CallExpression" &&
+              node.parent.callee && node.parent.callee.type === "MemberExpression" &&
+              node.parent.callee.object && node.parent.callee.object.name === "Object" &&
+              node.parent.callee.property && node.parent.callee.property.name === "assign" &&
+              node.parent.arguments && node.parent.arguments.length >= 2 &&
+              node.parent.arguments[0].type === "NewExpression" &&
+              node.parent.arguments[0].callee && node.parent.arguments[0].callee.name === "Error") {
+            return;
+          }
+
+          // Skip if in transformRequestToEntity method (common pattern for TypeORM)
+          const filename = context.getFilename();
+          if (filename.includes('/service/') && node.parent &&
+              node.parent.type === "ReturnStatement") {
+            let parent = node.parent;
+            while (parent) {
+              if (parent.type === "FunctionDeclaration" || parent.type === "MethodDefinition") {
+                const methodName = parent.key?.name || parent.id?.name;
+                if (methodName === "transformRequestToEntity") {
+                  return;
+                }
+              }
+              parent = parent.parent;
+            }
+          }
+
+          // Skip if in BaseController or ObservabilityController (generische Helper)
+          if (filename.includes('BaseController.ts') || filename.includes('ObservabilityController.ts')) {
+            return;
+          }
+
+          // Skip if it's a Prometheus Gauge/Counter/Histogram constructor
+          if (node.parent && node.parent.type === "NewExpression" &&
+              node.parent.callee && node.parent.callee.name &&
+              ["Gauge", "Counter", "Histogram", "Summary"].includes(node.parent.callee.name)) {
+            return;
+          }
+
+          // Skip if it's a Zod schema definition (z.object)
+          if (node.parent && node.parent.type === "CallExpression" &&
+              node.parent.callee && node.parent.callee.type === "MemberExpression" &&
+              node.parent.callee.object && node.parent.callee.object.name === "z" &&
+              node.parent.callee.property && node.parent.callee.property.name === "object") {
+            return;
+          }
+
+          // Skip if it's assigned to a typed variable for logging or TypeORM options
+          if (node.parent && node.parent.type === "VariableDeclarator" &&
+              node.parent.id && node.parent.id.typeAnnotation) {
+            const typeAnnotation = context.getSourceCode().getText(node.parent.id.typeAnnotation);
+            if (typeAnnotation.includes("LogData") ||
+                typeAnnotation.includes("ChatLogData") ||
+                typeAnnotation.includes("AuthLogData") ||
+                typeAnnotation.includes("FindOptions") ||
+                typeAnnotation.includes("FindManyOptions") ||
+                typeAnnotation.includes("FindOneOptions")) {
+              return;
+            }
+          }
+
+          // Skip if it's a nested object inside a LogData or FindOptions variable
+          let parent = node.parent;
+          while (parent) {
+            if (parent.type === "VariableDeclarator" && parent.id && parent.id.typeAnnotation) {
+              const typeAnnotation = context.getSourceCode().getText(parent.id.typeAnnotation);
+              if (typeAnnotation.includes("LogData") ||
+                  typeAnnotation.includes("AuthLogData") ||
+                  typeAnnotation.includes("FindOptions") ||
+                  typeAnnotation.includes("FindManyOptions") ||
+                  typeAnnotation.includes("FindOneOptions")) {
+                return;
+              }
+            }
+            parent = parent.parent;
+          }
+
+          // Skip if inside checkAiCommit method (test data arrays)
+          let checkParent = node.parent;
+          while (checkParent) {
+            if (checkParent.type === "MethodDefinition" || checkParent.type === "FunctionDeclaration") {
+              const methodName = checkParent.key?.name || checkParent.id?.name;
+              if (methodName === "checkAiCommit") {
+                return;
+              }
+            }
+            checkParent = checkParent.parent;
+          }
+
+          // Skip if in main.ts (Express/Server configuration)
+          if (filename.includes('main.ts') || filename.includes('server.ts')) {
+            return;
+          }
+
+          // Skip if in middleware files (Express middleware configuration)
+          if (filename.includes('/middleware/')) {
+            return;
+          }
+
+          // Skip if in Socket.ts (Socket.IO event handlers)
+          if (filename.includes('Socket.ts')) {
+            return;
+          }
+
+          // Skip if in module files (Modul-Konfiguration)
+          if (filename.includes('Module.ts')) {
+            return;
+          }
+
+          // Skip if in repository files (TypeORM where clauses and FindOptions)
+          if (filename.includes('/repository/')) {
+            return;
+          }
+
+          // Skip if in enum files (Enum configuration objects)
+          if (filename.includes('/enum/')) {
+            return;
+          }
+
+          // Skip if in migration/script files (Database migration objects)
+          if (filename.includes('/migration/') || filename.includes('/scripts/')) {
+            return;
+          }
+
+          // Skip if in service files (Business logic internal data structures)
+          if (filename.includes('/service/')) {
+            return;
+          }
+
+          // Skip if in guard/filter files (Auth logic)
+          if (filename.includes('/guards/') || filename.includes('/filters/')) {
+            return;
+          }
+
+          // Skip if in utility files (Helper functions)
+          if (filename.includes('/utilities/')) {
+            return;
+          }
+
+          // Skip if in socket handler files (WebSocket events)
+          if (filename.includes('/socket/')) {
+            return;
+          }
+
+          // Skip if in config files (ORM configuration)
+          if (filename.includes('Ormconfig.ts') || filename.includes('ormconfig.ts')) {
+            return;
+          }
+
+          // Report the anonymous object
+          let messageId = "anonymousObjectForbidden";
+
+          if (node.parent) {
+            if (node.parent.type === "ReturnStatement") {
+              messageId = "anonymousObjectInReturn";
+            } else if (node.parent.type === "VariableDeclarator" || node.parent.type === "AssignmentExpression") {
+              messageId = "anonymousObjectInAssignment";
+            } else if (node.parent.type === "CallExpression") {
+              messageId = "anonymousObjectInFunctionCall";
+            }
+          }
+
+          context.report({
+            node,
+            messageId,
+          });
+        }
+
+        return {
+          ObjectExpression: checkObjectExpression,
+        };
+      },
+    },
+  },
+};