@echoes-of-order/eslint-config 1.121.0

package/rules/dto-visibility-modifiers.js

@@ -0,0 +1,159 @@
+export default {
+  meta: {
+    type: "problem",
+    docs: {
+      description: "Enforce no explicit visibility modifiers or readonly in DTO classes",
+      category: "Best Practices",
+      recommended: true,
+    },
+    fixable: "code",
+    schema: [],
+    messages: {
+      removePublicModifier: "Remove unnecessary 'public' modifier from DTO member '{{memberName}}'",
+      removePrivateModifier: "Remove 'private' modifier from DTO member '{{memberName}}' - DTO members should be accessible",
+      removeProtectedModifier: "Remove 'protected' modifier from DTO member '{{memberName}}' - DTO members should be accessible",
+      removeReadonlyModifier: "Remove 'readonly' modifier from DTO member '{{memberName}}' - DTO members should be mutable",
+    },
+  },
+
+  create (context) {
+    return {
+      PropertyDefinition (node) {
+        // Check if this property is in a DTO class
+        const parent = node.parent;
+        if (parent && parent.type === "ClassBody") {
+          const classNode = parent.parent;
+          if (classNode && classNode.type === "ClassDeclaration") {
+            const className = classNode.id?.name;
+            if (className && className.endsWith("Dto")) {
+              // This is a DTO class property
+
+              // Check for visibility modifiers
+              if (node.accessibility) {
+                const memberName = node.key?.name || "unknown";
+                const modifier = node.accessibility;
+
+                context.report({
+                  node,
+                  messageId: `remove${modifier.charAt(0).toUpperCase() + modifier.slice(1)}Modifier`,
+                  data: {
+                    memberName,
+                  },
+                  fix (fixer) {
+                    const sourceCode = context.getSourceCode();
+                    const tokens = sourceCode.getTokens(node);
+
+                    // Find the visibility modifier token
+                    for (const token of tokens) {
+                      if (token.type === "Keyword" &&
+                          (token.value === "public" || token.value === "private" || token.value === "protected")) {
+
+                        // Find the next token after the modifier
+                        const nextToken = sourceCode.getTokenAfter(token);
+
+                        if (nextToken) {
+                          // Remove from start of modifier to start of next token (includes whitespace)
+                          return fixer.removeRange([token.range[0], nextToken.range[0]]);
+                        } else {
+                          // Just remove the modifier token
+                          return fixer.remove(token);
+                        }
+                      }
+                    }
+
+                    return null;
+                  },
+                });
+              }
+
+              // Check for readonly modifier
+              if (node.readonly) {
+                const memberName = node.key?.name || "unknown";
+
+                context.report({
+                  node,
+                  messageId: "removeReadonlyModifier",
+                  data: {
+                    memberName,
+                  },
+                  fix (fixer) {
+                    const sourceCode = context.getSourceCode();
+                    const tokens = sourceCode.getTokens(node);
+
+                    // Find the readonly modifier token
+                    for (const token of tokens) {
+                      if (token.type === "Keyword" && token.value === "readonly") {
+                        // Find the next token after the modifier
+                        const nextToken = sourceCode.getTokenAfter(token);
+
+                        if (nextToken) {
+                          // Remove from start of modifier to start of next token (includes whitespace)
+                          return fixer.removeRange([token.range[0], nextToken.range[0]]);
+                        } else {
+                          // Just remove the modifier token
+                          return fixer.remove(token);
+                        }
+                      }
+                    }
+
+                    return null;
+                  },
+                });
+              }
+            }
+          }
+        }
+      },
+
+      MethodDefinition (node) {
+        // Check if this method is in a DTO class
+        const parent = node.parent;
+        if (parent && parent.type === "ClassBody") {
+          const classNode = parent.parent;
+          if (classNode && classNode.type === "ClassDeclaration") {
+            const className = classNode.id?.name;
+            if (className && className.endsWith("Dto")) {
+              // This is a DTO class method
+              if (node.accessibility) {
+                const memberName = node.key?.name || "unknown";
+                const modifier = node.accessibility;
+
+                context.report({
+                  node,
+                  messageId: `remove${modifier.charAt(0).toUpperCase() + modifier.slice(1)}Modifier`,
+                  data: {
+                    memberName,
+                  },
+                  fix (fixer) {
+                    const sourceCode = context.getSourceCode();
+                    const tokens = sourceCode.getTokens(node);
+
+                    // Find the visibility modifier token
+                    for (const token of tokens) {
+                      if (token.type === "Keyword" &&
+                          (token.value === "public" || token.value === "private" || token.value === "protected")) {
+
+                        // Find the next token after the modifier
+                        const nextToken = sourceCode.getTokenAfter(token);
+
+                        if (nextToken) {
+                          // Remove from start of modifier to start of next token (includes whitespace)
+                          return fixer.removeRange([token.range[0], nextToken.range[0]]);
+                        } else {
+                          // Just remove the modifier token
+                          return fixer.remove(token);
+                        }
+                      }
+                    }
+
+                    return null;
+                  },
+                });
+              }
+            }
+          }
+        }
+      },
+    };
+  },
+};

package/rules/enforce-api-versioning.js

@@ -0,0 +1,122 @@
+/**
+ * ESLint-Regel: enforce-api-versioning
+ * Erzwingt einheitliche API-Versionierung in Controller-Routen
+ */
+
+/** @type {import('eslint').Rule.RuleModule} */
+const enforceApiVersioningRule = {
+  meta: {
+    type: "problem",
+    docs: {
+      description: "Erzwingt einheitliche API-Versionierung (/api/v1/) in allen Controller-Routen",
+      category: "API Standards",
+      recommended: true,
+    },
+    schema: [],
+    messages: {
+      missingApiVersion: "Controller-Route '{{route}}' muss API-Versionierung verwenden. Erwarte '/api/v1/' Prefix.",
+      inconsistentVersion: "Controller-Route '{{route}}' verwendet inkonsistente Versionierung. Verwende '/api/v1/' für alle Routen.",
+      invalidRouteFormat: "Controller-Route '{{route}}' hat ungültiges Format. Erwarte '/api/v1/resource-name'.",
+    },
+  },
+  create(context) {
+    const filename = context.getFilename();
+    const isControllerFile = filename.includes("/controller/") && filename.endsWith("Controller.ts");
+    const isAliasController = filename.includes("AliasController.ts");
+
+    if (!isControllerFile || isAliasController) return {};
+
+    const API_VERSION_PATTERN = /^\/api\/v1\/?.*/;
+    const VALID_ROUTE_PATTERN = /^\/api\/v1\/?[a-z-]*[a-z0-9-]*(?:\/[a-z-]+[a-z0-9-]*)*$/;
+
+    function validateControllerRoute(routePath) {
+      if (!routePath) return { valid: false, reason: "empty" };
+
+      // Entferne führende/trailing Whitespace
+      const cleanPath = routePath.trim();
+
+      // Prüfe auf API-Versionierung
+      if (!API_VERSION_PATTERN.test(cleanPath)) {
+        return { valid: false, reason: "missing-version" };
+      }
+
+      // Prüfe auf korrektes Format
+      if (!VALID_ROUTE_PATTERN.test(cleanPath)) {
+        return { valid: false, reason: "invalid-format" };
+      }
+
+      return { valid: true };
+    }
+
+    return {
+      Decorator(node) {
+        // Prüfe @Controller() Decorator
+        if (node.expression?.name === "Controller" ||
+            (node.expression?.type === "CallExpression" &&
+             node.expression.callee?.name === "Controller")) {
+
+          const args = node.expression?.arguments;
+          if (args && args.length > 0 && args[0].type === "Literal") {
+            const routePath = args[0].value;
+            const validation = validateControllerRoute(routePath);
+
+            if (!validation.valid) {
+              let messageId, data;
+
+              switch (validation.reason) {
+                case "missing-version":
+                  messageId = "missingApiVersion";
+                  data = { route: routePath };
+                  break;
+                case "invalid-format":
+                  messageId = "invalidRouteFormat";
+                  data = { route: routePath };
+                  break;
+                default:
+                  messageId = "missingApiVersion";
+                  data = { route: routePath || "undefined" };
+              }
+
+              context.report({
+                node: args[0],
+                messageId,
+                data,
+              });
+            }
+          }
+        }
+
+        // Prüfe HTTP-Method Decoratoren (@Get, @Post, etc.)
+        const httpMethods = ["Get", "Post", "Put", "Patch", "Delete"];
+        const decoratorName = node.expression?.name || node.expression?.callee?.name;
+
+        if (httpMethods.includes(decoratorName)) {
+          const args = node.expression?.arguments;
+          if (args && args.length > 0 && args[0].type === "Literal") {
+            const routePath = args[0].value;
+
+            // Relative Routen sind erlaubt (werden mit Controller-Route kombiniert)
+            if (!routePath.startsWith("/")) {
+              return;
+            }
+
+            const validation = validateControllerRoute(routePath);
+            if (!validation.valid && validation.reason === "missing-version") {
+              context.report({
+                node: args[0],
+                messageId: "missingApiVersion",
+                data: { route: routePath },
+              });
+            }
+          }
+        }
+      },
+    };
+  },
+};
+
+export default {
+  rules: {
+    "enforce-api-versioning": enforceApiVersioningRule,
+  },
+};

package/rules/enforce-app-module-registration.js

@@ -0,0 +1,179 @@
+/**
+ * ESLint-Regel: enforce-app-module-registration
+ *
+ * Überprüft, ob alle Controller und Services korrekt im AppModule registriert sind.
+ * Verhindert Dependency Injection Fehler durch fehlende Registrierungen.
+ */
+
+export default {
+  meta: {
+    type: "problem",
+    docs: {
+      description: "Enforce proper registration of controllers and services in AppModule",
+      category: "Architecture",
+      recommended: true,
+    },
+    messages: {
+      missingController: "Controller '{{controllerName}}' is not registered in AppModule controllers array",
+      missingService: "Service '{{serviceName}}' is not registered in AppModule providers array",
+      invalidControllerImport: "Controller '{{controllerName}}' is imported but not used in controllers array",
+      invalidServiceImport: "Service '{{serviceName}}' is imported but not used in providers array",
+    },
+    fixable: "code",
+  },
+
+  create(context) {
+    const filename = context.getFilename();
+
+    // Nur für AppModule.ts ausführen
+    if (!filename.includes('AppModule.ts')) {
+      return {};
+    }
+
+    return {
+      Program(node) {
+        try {
+          // Analysiere AppModule AST
+          const appModuleAnalysis = analyzeAppModule(node);
+
+          // Prüfe fehlende Controller
+          appModuleAnalysis.missingControllers.forEach(controller => {
+            context.report({
+              node,
+              messageId: "missingController",
+              data: { controllerName: controller.name }
+            });
+          });
+
+          // Prüfe fehlende Services
+          appModuleAnalysis.missingServices.forEach(service => {
+            context.report({
+              node,
+              messageId: "missingService",
+              data: { serviceName: service.name }
+            });
+          });
+
+          // Prüfe ungenutzte Imports
+          appModuleAnalysis.unusedImports.forEach(importItem => {
+            context.report({
+              node: importItem.node,
+              messageId: importItem.type === 'controller' ? "invalidControllerImport" : "invalidServiceImport",
+              data: {
+                controllerName: importItem.name,
+                serviceName: importItem.name
+              }
+            });
+          });
+
+        } catch (error) {
+          // Fehler beim Analysieren ignorieren
+          console.warn('AppModule registration check failed:', error.message);
+        }
+      }
+    };
+  }
+};
+
+/**
+ * Analysiert das AppModule und findet fehlende Registrierungen
+ */
+function analyzeAppModule(node) {
+  const missingControllers = [];
+  const missingServices = [];
+  const unusedImports = [];
+
+  let controllersArray = [];
+  let providersArray = [];
+  let imports = [];
+
+  // Durchlaufe alle Import-Statements
+  node.body.forEach(statement => {
+    if (statement.type === 'ImportDeclaration') {
+      const importPath = statement.source.value;
+      statement.specifiers.forEach(spec => {
+        if (spec.type === 'ImportDefaultSpecifier') {
+          imports.push({
+            name: spec.local.name,
+            path: importPath,
+            node: statement
+          });
+        }
+      });
+    }
+  });
+
+  // Finde @Module Decorator - suche nach der korrekten NestJS-Struktur
+  const moduleDecorator = node.body.find(statement => {
+    if (statement.type === 'ExportDefaultDeclaration' &&
+        statement.declaration.type === 'ClassDeclaration') {
+
+      // Prüfe ob es Decorators gibt
+      if (statement.declaration.decorators && statement.declaration.decorators.length > 0) {
+        return statement.declaration.decorators.some(dec => {
+          if (dec.expression && dec.expression.type === 'CallExpression') {
+            return dec.expression.callee && dec.expression.callee.name === 'Module';
+          }
+          return false;
+        });
+      }
+    }
+    return false;
+  });
+
+  if (moduleDecorator) {
+    const classBody = moduleDecorator.declaration.body;
+
+    // Finde controllers und providers Arrays
+    classBody.body.forEach(member => {
+      if (member.type === 'ClassProperty' && member.key && member.key.name === 'controllers') {
+        controllersArray = extractArrayElements(member.value);
+      }
+      if (member.type === 'ClassProperty' && member.key && member.key.name === 'providers') {
+        providersArray = extractArrayElements(member.value);
+      }
+    });
+  }
+
+  // Prüfe Controller-Imports
+  imports.forEach(importItem => {
+    if (importItem.path.includes('/controller/') || importItem.path.includes('Controller')) {
+      const isRegistered = controllersArray.includes(importItem.name);
+      if (!isRegistered) {
+        missingControllers.push(importItem);
+      }
+    }
+  });
+
+  // Prüfe Service-Imports
+  imports.forEach(importItem => {
+    if (importItem.path.includes('/service/') || importItem.path.includes('Service')) {
+      const isRegistered = providersArray.includes(importItem.name);
+      if (!isRegistered) {
+        missingServices.push(importItem);
+      }
+    }
+  });
+
+  return {
+    missingControllers,
+    missingServices,
+    unusedImports
+  };
+}
+
+/**
+ * Extrahiert Elemente aus einem Array-Literal
+ */
+function extractArrayElements(arrayNode) {
+  if (!arrayNode || arrayNode.type !== 'ArrayExpression') {
+    return [];
+  }
+
+  return arrayNode.elements.map(element => {
+    if (element && element.type === 'Identifier') {
+      return element.name;
+    }
+    return null;
+  }).filter(Boolean);
+}

package/rules/enforce-basecontroller.js

@@ -0,0 +1,152 @@
+/**
+ * ESLint-Regel, die sicherstellt, dass Controller den BaseController erweitern
+ * und dessen Methoden für Response-Strukturen verwenden
+ */
+
+/** @type {import('eslint').Rule.RuleModule} */
+const enforceBaseControllerRule = {
+  meta: {
+    type: "problem",
+    docs: {
+      description: "Stellt sicher, dass Controller den BaseController erweitern und dessen Methoden verwenden",
+      category: "Best Practices",
+      recommended: true,
+    },
+    fixable: null,
+    schema: [
+      {
+        type: "object",
+        properties: {
+          controllerPattern: {
+            type: "string",
+            description: "Regex pattern for identifying controller files",
+            default: "Controller\\.ts$"
+          },
+          baseControllerName: {
+            type: "string",
+            description: "Name of the base controller class that all controllers should extend",
+            default: "BaseController"
+          },
+          allowDirectResponse: {
+            type: "boolean",
+            description: "Whether to allow direct response usage (res.json, res.status)",
+            default: false
+          },
+          excludePatterns: {
+            type: "array",
+            items: { type: "string" },
+            description: "File patterns to exclude from the rule",
+            default: ["BaseController.ts"]
+          }
+        },
+        additionalProperties: false
+      }
+    ],
+    messages: {
+      notExtendingBaseController: "Controller muss BaseController erweitern: '{{controllerName}}'",
+      directResponseUsage: "Verwende die BaseController-Methoden (sendSuccess, sendError, etc.) anstatt direkt res.json/status aufzurufen",
+    },
+  },
+  create(context) {
+    const options = context.options[0] || {};
+    const controllerPattern = new RegExp(options.controllerPattern || "Controller\\.ts$");
+    const baseControllerName = options.baseControllerName || "BaseController";
+    const allowDirectResponse = options.allowDirectResponse || false;
+    const excludePatterns = options.excludePatterns || ["BaseController.ts"];
+
+    const filename = context.getFilename();
+    const isExcluded = excludePatterns.some(pattern => filename.includes(pattern));
+    const isControllerFile = (controllerPattern.test(filename) || filename.includes('/fixtures/')) && !isExcluded;
+
+    // Speichert, ob die aktuelle Datei ein Controller ist, der BaseController erweitert
+    let extendsBaseController = false;
+    // Speichert den Namen des Controllers für Fehlermeldungen
+    let controllerName = "";
+
+    return {
+      // Prüfen, ob ein Controller den BaseController erweitert
+      ClassDeclaration(node) {
+        if (!isControllerFile) return;
+
+        // Extrahiere den Controller-Namen
+        controllerName = node.id.name;
+
+        // Ignoriere BaseController selbst
+        if (controllerName === baseControllerName) return;
+
+        // Prüfe, ob der Controller von BaseController erbt
+        if (node.superClass &&
+            node.superClass.type === "Identifier" &&
+            node.superClass.name === baseControllerName) {
+          extendsBaseController = true;
+        } else {
+          // Melde einen Fehler, wenn der Controller nicht von BaseController erbt
+          context.report({
+            node,
+            messageId: "notExtendingBaseController",
+            data: {
+              controllerName: controllerName,
+            },
+          });
+        }
+      },
+
+      // Prüfen, ob direkte Response-Methoden verwendet werden
+      CallExpression(node) {
+        if (!isControllerFile || !extendsBaseController) return;
+
+        // Prüfe auf direkte res.json() Aufrufe
+        if (
+          !allowDirectResponse &&
+          node.callee.type === "MemberExpression" &&
+          node.callee.object.type === "Identifier" &&
+          node.callee.object.name === "res" &&
+          node.callee.property.type === "Identifier" &&
+          node.callee.property.name === "json"
+        ) {
+          context.report({
+            node,
+            messageId: "directResponseUsage",
+          });
+        }
+
+        // Prüfe auf res.status().json() Aufrufe
+        if (
+          node.callee.type === "MemberExpression" &&
+          node.callee.property.type === "Identifier" &&
+          node.callee.property.name === "json" &&
+          node.callee.object.type === "CallExpression" &&
+          node.callee.object.callee.type === "MemberExpression" &&
+          node.callee.object.callee.object.type === "Identifier" &&
+          node.callee.object.callee.object.name === "res" &&
+          node.callee.object.callee.property.type === "Identifier" &&
+          node.callee.object.callee.property.name === "status"
+        ) {
+          context.report({
+            node,
+            messageId: "directResponseUsage",
+          });
+        }
+      },
+
+      // Prüfen auf Import des BaseController
+      ImportDeclaration(node) {
+        if (!isControllerFile) return;
+
+        // Prüfe, ob BaseController importiert wird
+        const specifiers = node.specifiers;
+        if (specifiers.some(specifier =>
+          specifier.type === "ImportDefaultSpecifier" &&
+          specifier.local.name === baseControllerName)) {
+          return;
+        }
+      },
+    };
+  },
+};
+
+export default {
+  rules: {
+    "enforce-basecontroller": enforceBaseControllerRule,
+  },
+};