@echoes-of-order/eslint-config 1.121.0

package/rules/api-response-dto.js

@@ -0,0 +1,174 @@
+/**
+ * ESLint-Regel: API-Methodenaufrufe müssen korrekte Typen verwenden
+ * 
+ * Diese Regel stellt sicher, dass:
+ * 1. API-Methodenaufrufe einen generischen Typ haben
+ * 2. Keine doppelte ApiResponseDto-Verschachtelung verwendet wird (ApiResponseDto<ApiResponseDto<T>>)
+ * 3. Korrekte Error-Handling-Patterns verwendet werden
+ * 
+ * Beispiele:
+ * ✅ Erlaubt: api.get<{ data: SomeType }>()
+ * ❌ Verboten: api.get() (ohne Generics)
+ * ❌ Verboten: api.get<ApiResponseDto<SomeType>>() (doppelte Verschachtelung)
+ */
+
+export default {
+  rules: {
+    "require-api-response-dto": {
+      meta: {
+        type: "problem",
+        docs: {
+          description: "Ensure correct API method call patterns",
+          category: "Best Practices",
+          recommended: true,
+        },
+        schema: [],
+        messages: {
+          noNestedApiResponseDto: "API-Methodenaufruf '{{methodName}}' sollte den Datentyp direkt verwenden, nicht ApiResponseDto<T>. Der ApiClient gibt bereits ApiResponseDto<T> zurück",
+          noGenericType: "API-Methodenaufruf '{{methodName}}' muss einen generischen Typ haben",
+          useIsSuccessMethod: "Verwende nicht '{{pattern}}' für API-Response-Prüfung. Nutze stattdessen 'response.isSuccess()' und behandle Fehler mit 'response.getError()'",
+          noGenericErrorMessage: "Verwende keine generische Fehlermeldung '{{message}}'. Erstelle eine spezifische, kontextualisierte Nachricht",
+        },
+      },
+      create (context) {
+        // API-Methoden, die überwacht werden sollen
+        const apiMethods = ["get", "post", "put", "delete", "patch"];
+
+        // Verbotene Patterns für Datenprüfung (nur ohne vorherige isSuccess() Prüfung)
+        const forbiddenDataPatterns = ["!rawResponse", "!rawData"];
+
+
+
+        // Verbotene generische Fehlermeldungen
+        const forbiddenErrorMessages = [
+          "Keine Daten erhalten",
+          "Unerwarteter Fehler: Keine Daten in erfolgreicher Response",
+          "Fehler aufgetreten"
+        ];
+
+        return {
+          CallExpression (node) {
+            // Prüfe nur API-Methodenaufrufe
+            if (!isApiMethodCall(node, apiMethods)) {
+              return;
+            }
+
+            const methodName = node.callee.property.name;
+
+            // Prüfe auf doppelte ApiResponseDto-Verschachtelung (nur wenn TypeParameter vorhanden)
+            if (hasTypeParameters(node)) {
+              const firstTypeParam = node.typeParameters.params[0];
+              if (isApiResponseDtoType(firstTypeParam)) {
+                context.report({
+                  node,
+                  messageId: "noNestedApiResponseDto",
+                  data: { methodName },
+                });
+              }
+            }
+            // Momentan deaktiviert: Generics-Prüfung, da sie zu viele false positives erzeugt
+            // TODO: Später aktivieren wenn TypeScript-Parser-Integration verbessert ist
+          },
+
+          // Prüfe auf verbotene Data-Checking-Patterns
+          UnaryExpression (node) {
+            if (node.operator === "!" && node.argument) {
+              const source = context.getSourceCode().getText(node.argument);
+
+              // Prüfe nur auf verbotene rawResponse/rawData patterns
+              if (forbiddenDataPatterns.some(pattern => source.includes(pattern.replace("!", "")))) {
+                context.report({
+                  node,
+                  messageId: "useIsSuccessMethod",
+                  data: { pattern: `!${source}` },
+                });
+              }
+
+              // Erlaube !data und !data.property nach einer isSuccess() Prüfung
+              // Diese werden als legitime Validierungen angesehen
+            }
+          },
+
+          // Prüfe auf generische Fehlermeldungen
+          Literal (node) {
+            if (typeof node.value === "string" && forbiddenErrorMessages.includes(node.value)) {
+              context.report({
+                node,
+                messageId: "noGenericErrorMessage",
+                data: { message: node.value },
+              });
+            }
+          },
+        };
+      },
+    },
+  },
+};
+
+/**
+ * Prüft ob es sich um einen API-Methodenaufruf handelt
+ */
+function isApiMethodCall (node, apiMethods) {
+  return (
+    node.callee.type === "MemberExpression" &&
+    node.callee.property &&
+    apiMethods.includes(node.callee.property.name) &&
+    node.callee.object &&
+    node.callee.object.type === "Identifier" &&
+    (node.callee.object.name.toLowerCase().includes("api") ||
+      node.callee.object.name === "api")
+  );
+}
+
+/**
+ * Prüft ob der Aufruf generische Type-Parameter hat
+ */
+function hasTypeParameters (node) {
+  return (
+    node.typeParameters &&
+    node.typeParameters.params &&
+    node.typeParameters.params.length > 0
+  );
+}
+
+/**
+ * Prüft ob der Typ ein ApiResponseDto<T> ist
+ */
+function isApiResponseDtoType (typeNode) {
+  // Muss TSTypeReference sein
+  if (typeNode.type !== "TSTypeReference") {
+    return false;
+  }
+
+  // Muss typeName haben
+  if (!typeNode.typeName) {
+    return false;
+  }
+
+  // Prüfe den Namen
+  const typeName = typeNode.typeName.name;
+  return typeName === "ApiResponseDto";
+}
+
+/**
+ * Extrahiert einen String-Representation des Typs für Fehlermeldungen
+ */
+function getTypeString (typeNode) {
+  if (typeNode.type === "TSTypeReference" && typeNode.typeName) {
+    const baseName = typeNode.typeName.name;
+    if (typeNode.typeParameters && typeNode.typeParameters.params.length > 0) {
+      return `${baseName}<...>`;
+    }
+    return baseName;
+  }
+
+  if (typeNode.type === "TSTypeLiteral") {
+    return "{ ... }";
+  }
+
+  if (typeNode.type === "TSArrayType") {
+    return "Array<...>";
+  }
+
+  return typeNode.type || "unknown";
+} 

package/rules/auth-guard-required.js

@@ -0,0 +1,142 @@
+const authGuardRequiredRule = {
+  meta: {
+    type: "problem",
+    docs: {
+      description: "Erfordert AuthGuard für alle Controller außer konfigurierten Ausnahmen",
+      category: "Security",
+      recommended: true,
+    },
+    fixable: null,
+    schema: [
+      {
+        type: "object",
+        properties: {
+          exemptDirectories: {
+            type: "array",
+            items: {
+              type: "string"
+            },
+            default: ["/Admin/", "/OAuth/"]
+          },
+          exemptControllers: {
+            type: "array",
+            items: {
+              type: "string"
+            },
+            default: ["HealthController.ts", "MetricsController.ts", "BaseController.ts"]
+          }
+        },
+        additionalProperties: false
+      }
+    ],
+    messages: {
+      missingAuthGuard: "Controller '{{controllerName}}' muss @UseGuards(AuthGuard) verwenden. Importiere AuthGuard und füge @UseGuards(AuthGuard) vor der Controller-Klasse hinzu.",
+      missingAuthGuardImport: "Controller '{{controllerName}}' muss AuthGuard importieren: import AuthGuard from '@/guards/AuthGuard';"
+    }
+  },
+
+
+  create(context) {
+    const options = context.options[0] || {};
+    const exemptDirectories = options.exemptDirectories || ["/Admin/", "/OAuth/"];
+    const exemptControllers = options.exemptControllers || ["HealthController.ts", "MetricsController.ts", "BaseController.ts"];
+
+    const filename = context.getFilename();
+
+    // Prüfe ob es sich um einen Controller handelt
+    if (!filename.includes("Controller.ts") || filename.includes("__tests__")) {
+      return {};
+    }
+
+    // Automatisch BaseController ausschließen
+    if (filename.includes("BaseController.ts")) {
+      return {};
+    }
+
+    // Prüfe Ausnahme-Verzeichnisse
+    const isExemptDirectory = exemptDirectories.some(dir => filename.includes(dir));
+    if (isExemptDirectory) {
+      return {};
+    }
+
+    // Prüfe Ausnahme-Controller
+    const isExemptController = exemptControllers.some(controller => filename.endsWith(controller));
+    if (isExemptController) {
+      return {};
+    }
+
+    let hasAuthGuardImport = false;
+    let hasUseGuardsDecorator = false;
+    let hasAuthGuardInUseGuards = false;
+    let controllerClassName = "";
+
+    return {
+      ImportDeclaration(node) {
+        if (node.source.value === "@/guards/AuthGuard") {
+          hasAuthGuardImport = true;
+        }
+      },
+
+      ClassDeclaration(node) {
+        if (node.id && node.id.name.endsWith("Controller")) {
+          controllerClassName = node.id.name;
+
+          // Prüfe @UseGuards Decorator
+          if (node.decorators) {
+            for (const decorator of node.decorators) {
+              if (decorator.expression &&
+                  decorator.expression.type === "CallExpression" &&
+                  decorator.expression.callee &&
+                  decorator.expression.callee.name === "UseGuards") {
+
+                hasUseGuardsDecorator = true;
+
+                // Prüfe ob AuthGuard in den Argumenten ist
+                for (const arg of decorator.expression.arguments) {
+                  if (arg.name === "AuthGuard") {
+                    hasAuthGuardInUseGuards = true;
+                    break;
+                  }
+                }
+                break;
+              }
+            }
+          }
+        }
+      },
+
+      "Program:exit"() {
+        if (controllerClassName) {
+          // Prüfe fehlende Imports
+          if (!hasAuthGuardImport) {
+            context.report({
+              loc: { line: 1, column: 0 },
+              messageId: "missingAuthGuardImport",
+              data: {
+                controllerName: controllerClassName
+              }
+            });
+            return;
+          }
+
+          // Prüfe fehlende @UseGuards(AuthGuard)
+          if (!hasUseGuardsDecorator || !hasAuthGuardInUseGuards) {
+            context.report({
+              loc: { line: 1, column: 0 },
+              messageId: "missingAuthGuard",
+              data: {
+                controllerName: controllerClassName
+              }
+            });
+          }
+        }
+      }
+    };
+  }
+};
+
+export default {
+  rules: {
+    'auth-guard-required': authGuardRequiredRule,
+  },
+};

package/rules/backend-specific.js

@@ -0,0 +1,36 @@
+/**
+ * Backend Specific Rules
+ *
+ * Backend-spezifische Regeln für Restriktionen und Sicherheit
+ */
+
+export default {
+  rules: {
+    // Backend-spezifische Regeln
+    "no-restricted-syntax": [
+      "error",
+      {
+        "selector": "MemberExpression[object.type='MemberExpression'][object.object.type='MetaProperty'][object.object.meta.name='import'][object.object.property.name='meta'][object.object.property.name='env']",
+        "message": "Direkte Verwendung von import.meta.env ist nicht erlaubt. Verwende stattdessen ConfigProvider.getXxx()."
+      },
+      {
+        "selector": "MemberExpression[object.type='MemberExpression'][object.object.name='process'][object.property.name='env']",
+        "message": "Direkte Verwendung von process.env ist nicht erlaubt. Verwende stattdessen ConfigProvider.getXxx()."
+      },
+      {
+        "selector": "MemberExpression[object.name='process'][property.name='env']",
+        "message": "Direkte Verwendung von process.env ist nicht erlaubt. Verwende stattdessen ConfigProvider.getXxx()."
+      }
+    ],
+
+    "no-restricted-globals": [
+      "error",
+      {
+        "name": "fetch",
+        "message": "Direkte Verwendung von fetch ist nicht erlaubt. Verwende stattdessen den ApiClient aus @echoes-of-order/api-client."
+      }
+    ],
+
+    // No-Comments-Regel ist deaktiviert, da sie Probleme verursacht
+  },
+};