@echoes-of-order/eslint-config 1.121.0

package/rules/require-valid-relations.js

@@ -0,0 +1,388 @@
+import fs from "fs";
+import { globSync } from "glob";
+import path from "path";
+
+/** @type {import('eslint').Rule.RuleModule} */
+const requireValidRelations = {
+  meta: {
+    type: "problem",
+    docs: {
+      description: "Ensure relations in find*() calls match entity relations",
+    },
+    schema: [],
+    messages: {
+      invalidRelation:
+        "Relation '{{relation}}' does not exist in entity '{{entityName}}'. Available relations: {{availableRelations}}",
+      noEntityFile:
+        "Could not find entity file for '{{entityName}}'. Expected at: {{expectedPath}}",
+    },
+  },
+
+  create(context) {
+    const filename = context.getFilename();
+    const sourceCode = context.getSourceCode();
+
+    function getEntityRelations(entityClassName) {
+      // Nutze die funktionierende getAllRelationsWithTargets() Funktion
+      // und gib nur die Property-Namen zurück
+      const relationsMap = getAllRelationsWithTargets(entityClassName);
+
+      if (!relationsMap || Object.keys(relationsMap).length === 0) {
+        return null;
+      }
+
+      return Object.keys(relationsMap);
+    }
+
+    function getAllRelationsWithTargets(entityClassName) {
+      try {
+        const workspaceRoot =
+          filename.split("/backend/src/")[0] ||
+          filename.split("\\backend\\src\\")[0];
+        if (!workspaceRoot) return {};
+
+        const entityPath = path.join(
+          workspaceRoot,
+          "backend",
+          "src",
+          "entity",
+          `**/${entityClassName}.ts`,
+        );
+
+        const entityFiles = globSync(entityPath);
+        if (entityFiles.length === 0) return {};
+
+        // Wenn mehrere Dateien gefunden werden, durchsuche alle und merge die Relations
+        const relationsMap = {};
+
+        for (const entityFile of entityFiles) {
+          try {
+            const entityContent = fs.readFileSync(entityFile, "utf8");
+
+            if (entityClassName === "PlayableRaceEntity") {
+              console.log(
+              );
+            }
+
+            const lines = entityContent.split("\n");
+            let i = 0;
+
+            if (entityClassName === "PlayableRaceEntity") {
+              console.log(
+              );
+            }
+
+            while (i < lines.length) {
+              const line = lines[i].trim();
+
+              // Suche nach Relation-Decorator mit Target-Entity
+              const relationMatch = line.match(
+                /@(?:OneToMany|ManyToOne|OneToOne|ManyToMany)\s*\(\s*\(\)\s*=>\s*(\w+)/,
+              );
+
+              if (
+                entityClassName === "PlayableRaceEntity" &&
+                line.includes("@OneToMany")
+              ) {
+                console.log(
+                );
+                console.log(
+                  relationMatch,
+                );
+              }
+
+              if (relationMatch) {
+                const targetEntity = relationMatch[1];
+
+                if (entityClassName === "PlayableRaceEntity") {
+                  console.log(
+                  );
+                  console.log(
+                  );
+                }
+
+                let j = i;
+                let parenCount = 0;
+                let inDecoratorParams = true;
+
+                // Zähle Klammern in der ersten Zeile
+                if (!lines[j]) {
+                  i++;
+                  continue;
+                }
+                parenCount += (lines[j].match(/\(/g) || []).length;
+                parenCount -= (lines[j].match(/\)/g) || []).length;
+
+                if (entityClassName === "PlayableRaceEntity") {
+                  console.log(
+                  );
+                }
+
+                if (parenCount === 0) {
+                  inDecoratorParams = false;
+                }
+                j++;
+
+                // Überspringe Decorator-Parameter
+                while (j < lines.length && inDecoratorParams) {
+                  const currentLine = lines[j];
+                  parenCount += (currentLine.match(/\(/g) || []).length;
+                  parenCount -= (currentLine.match(/\)/g) || []).length;
+
+                  if (entityClassName === "PlayableRaceEntity") {
+                    console.log(
+                    );
+                  }
+
+                  if (parenCount === 0) {
+                    inDecoratorParams = false;
+                  }
+                  j++;
+                }
+
+                if (entityClassName === "PlayableRaceEntity") {
+                  console.log(
+                  );
+                }
+
+                // Jetzt suche nach dem Property-Namen
+                let foundProperty = false;
+                while (j < lines.length && !foundProperty) {
+                  const nextLine = lines[j].trim();
+
+                  if (entityClassName === "PlayableRaceEntity") {
+                    console.log(
+                    );
+                  }
+
+                  // Überspringe leere Zeilen und @JoinColumn
+                  if (!nextLine || nextLine.includes("@JoinColumn")) {
+                    j++;
+                    continue;
+                  }
+
+                  // Wenn es ein anderer Decorator ist (nicht @JoinColumn), stoppen
+                  if (nextLine.startsWith("@")) {
+                    if (entityClassName === "PlayableRaceEntity") {
+                      console.log(
+                      );
+                    }
+                    break;
+                  }
+
+                  // Suche nach Property-Namen
+                  const propertyMatch = nextLine.match(/^(\w+)\s*:/);
+                  if (propertyMatch) {
+                    const propertyName = propertyMatch[1];
+                    relationsMap[propertyName] = targetEntity;
+
+                    if (entityClassName === "PlayableRaceEntity") {
+                      console.log(
+                      );
+                    }
+
+                    foundProperty = true;
+                  }
+
+                  j++;
+                }
+
+                i = j;
+              } else {
+                i++;
+              }
+            }
+
+            // relationsMap wird in der Schleife gefüllt
+          } catch (error) {
+            if (entityClassName === "PlayableRaceEntity") {
+              console.log(
+                error,
+              );
+            }
+            // Fahre mit der nächsten Datei fort
+          }
+        }
+
+        if (entityClassName === "PlayableRaceEntity") {
+          console.log(
+            relationsMap,
+          );
+        }
+
+        return relationsMap;
+      } catch (error) {
+        if (entityClassName === "PlayableRaceEntity") {
+          console.log(
+            error,
+          );
+        }
+        return {};
+      }
+    }
+
+    function getRelationTargetEntity(entityClassName, relationName) {
+      const relationsMap = getAllRelationsWithTargets(entityClassName);
+      return relationsMap[relationName] || null;
+    }
+
+    function validateNestedRelation(baseEntityClassName, relationPath) {
+      const parts = relationPath.split(".");
+      let currentEntity = baseEntityClassName;
+
+      for (let i = 0; i < parts.length; i++) {
+        const relationName = parts[i];
+        const relations = getEntityRelations(currentEntity);
+
+        if (!relations || !relations.includes(relationName)) {
+          return {
+            valid: false,
+            error: `Relation '${parts.slice(0, i + 1).join(".")}' does not exist in entity '${currentEntity}'. Available relations: ${relations ? relations.join(", ") : "none"}`,
+          };
+        }
+
+        if (i < parts.length - 1) {
+          const targetEntity = getRelationTargetEntity(
+            currentEntity,
+            relationName,
+          );
+          if (!targetEntity) {
+            return {
+              valid: false,
+              error: `Could not find target entity for relation '${relationName}' in '${currentEntity}'`,
+            };
+          }
+          currentEntity = targetEntity;
+        }
+      }
+
+      return { valid: true };
+    }
+
+    return {
+      CallExpression(node) {
+        const callee = node.callee;
+
+        if (
+          callee.type !== "MemberExpression" ||
+          callee.property.type !== "Identifier" ||
+          !/^find/.test(callee.property.name) ||
+          node.arguments.length !== 1 ||
+          node.arguments[0].type !== "ObjectExpression"
+        ) {
+          return;
+        }
+
+        const relationsProp = node.arguments[0].properties.find(
+          (p) =>
+            p.type === "Property" &&
+            ((p.key.type === "Identifier" && p.key.name === "relations") ||
+              (p.key.type === "Literal" && p.key.value === "relations")),
+        );
+
+        if (!relationsProp || relationsProp.value.type !== "ArrayExpression") {
+          return;
+        }
+
+        let entityClassName = null;
+
+        // Pattern 1: Inline getRepository().find()
+        // this.dataSource.getRepository(Entity).find({...})
+        const calleeObject = callee.object;
+
+        if (calleeObject.type === "CallExpression") {
+          const getRepositoryCall = calleeObject.callee;
+          if (
+            getRepositoryCall.type === "MemberExpression" &&
+            getRepositoryCall.property.type === "Identifier" &&
+            getRepositoryCall.property.name === "getRepository"
+          ) {
+            const repositoryArg = calleeObject.arguments?.[0];
+            if (repositoryArg && repositoryArg.type === "Identifier") {
+              entityClassName = repositoryArg.name;
+            }
+          }
+        }
+
+        // Pattern 2: Variable repository.find()
+        // const repository = getRepository(Entity);
+        // repository.find({...})
+        if (!entityClassName && calleeObject.type === "Identifier") {
+          const repositoryVarName = calleeObject.name;
+
+          const scope = sourceCode.getScope(node);
+          const variable = scope.set.get(repositoryVarName);
+
+          if (variable && variable.defs.length > 0) {
+            const def = variable.defs[0];
+            if (def.node.type === "VariableDeclarator" && def.node.init) {
+              const init = def.node.init;
+              if (
+                init.type === "CallExpression" &&
+                init.callee.type === "MemberExpression" &&
+                init.callee.property.type === "Identifier" &&
+                init.callee.property.name === "getRepository" &&
+                init.arguments.length > 0 &&
+                init.arguments[0].type === "Identifier"
+              ) {
+                entityClassName = init.arguments[0].name;
+              }
+            }
+          }
+        }
+
+        if (!entityClassName) {
+          return;
+        }
+
+        for (const el of relationsProp.value.elements) {
+          if (el.type !== "Literal" || typeof el.value !== "string") continue;
+
+          const relationPath = el.value;
+
+          // Prüfe ob es eine nested relation ist (enthält ".")
+          if (relationPath.includes(".")) {
+            const result = validateNestedRelation(
+              entityClassName,
+              relationPath,
+            );
+            if (!result.valid) {
+              context.report({
+                node: el,
+                messageId: "invalidRelation",
+                data: {
+                  relation: relationPath,
+                  entityName: entityClassName,
+                  availableRelations: result.error || "unknown",
+                },
+              });
+            }
+          } else {
+            // Einfache Relation (keine Verschachtelung)
+            const entityRelations = getEntityRelations(entityClassName);
+
+            if (!entityRelations) return;
+
+            if (!entityRelations.includes(relationPath)) {
+              context.report({
+                node: el,
+                messageId: "invalidRelation",
+                data: {
+                  relation: relationPath,
+                  entityName: entityClassName,
+                  availableRelations:
+                    entityRelations.length > 0
+                      ? entityRelations.join(", ")
+                      : "none",
+                },
+              });
+            }
+          }
+        }
+      },
+    };
+  },
+};
+
+// Export für ESLint v9 Flat Config
+export default requireValidRelations;

package/rules/result-pattern.js

@@ -0,0 +1,162 @@
+/**
+ * ESLint-Regel: Alle nicht-statischen Klassenmethoden müssen Result<T, Error> zurückgeben
+ * 
+ * Diese Regel stellt sicher, dass alle nicht-statischen Methoden einer Klasse
+ * ein Result<T, InfrastructureError | DomainError> Pattern verwenden.
+ */
+
+export default {
+  rules: {
+    "require-result-return-type": {
+      meta: {
+        type: "problem",
+        docs: {
+          description: "Require non-static class methods to return Result<T, Error> type",
+          category: "Best Practices",
+          recommended: true,
+        },
+        schema: [],
+        messages: {
+          missingResultType: "Nicht-statische Klassenmethode '{{methodName}}' muss Promise<Result<T, InfrastructureError | DomainError>> zurückgeben",
+        },
+      },
+      create(context) {
+        return {
+          MethodDefinition(node) {
+            // Ignoriere statische Methoden
+            if (node.static) {
+              return;
+            }
+
+            // Ignoriere Konstruktoren
+            if (node.kind === "constructor") {
+              return;
+            }
+
+            // Ignoriere Getter/Setter
+            if (node.kind === "get" || node.kind === "set") {
+              return;
+            }
+
+            // Prüfe nur Klassen im infrastructure-Verzeichnis
+            const filename = context.getFilename();
+            if (!filename.includes("/infrastructure/")) {
+              return;
+            }
+
+            // Prüfe nur TypeScript-Dateien
+            if (!filename.endsWith(".ts") && !filename.endsWith(".tsx")) {
+              return;
+            }
+
+            const methodNode = node.value;
+            let returnType = null;
+
+            // Prüfe explizite Rückgabetyp-Annotation
+            if (methodNode.returnType && methodNode.returnType.typeAnnotation) {
+              returnType = methodNode.returnType.typeAnnotation;
+            }
+
+            // Wenn keine explizite Typ-Annotation vorhanden ist, überspringe
+            if (!returnType) {
+              return;
+            }
+
+            // Prüfe ob es sich um Promise<Result<T, Error>> handelt
+            const isPromiseResultType = checkIsPromiseResultType(returnType);
+
+            // Für infrastructure-Verzeichnis: Akzeptiere alle Promise-Typen als gültig
+            // (da Result-Pattern über Type-Aliases schwer zu validieren ist)
+            const isPromiseType = returnType.type === "TSTypeReference" && 
+                                 returnType.typeName && 
+                                 returnType.typeName.name === "Promise";
+
+            if (!isPromiseResultType && !isPromiseType) {
+              const methodName = node.key.name || "unknown";
+              context.report({
+                node: methodNode,
+                messageId: "missingResultType",
+                data: {
+                  methodName,
+                },
+              });
+            }
+          },
+        };
+      },
+    },
+  },
+};
+
+/**
+ * Prüft ob der Typ ein Promise<Result<T, Error>> ist
+ */
+function checkIsPromiseResultType(typeNode) {
+  // Muss Promise<Result<...>> sein
+  if (
+    typeNode.type === "TSTypeReference" &&
+    typeNode.typeName &&
+    typeNode.typeName.name === "Promise" &&
+    typeNode.typeParameters &&
+    typeNode.typeParameters.params.length > 0
+  ) {
+    const innerType = typeNode.typeParameters.params[0];
+    return checkIsResultType(innerType) || checkIsResultTypeAlias(innerType);
+  }
+
+  return false;
+}
+
+/**
+ * Prüft ob der Typ ein Result<T, Error> ist
+ */
+function checkIsResultType(typeNode) {
+  // Result<T, Error> Pattern
+  if (
+    typeNode.type === "TSTypeReference" &&
+    typeNode.typeName &&
+    typeNode.typeName.name === "Result" &&
+    typeNode.typeParameters &&
+    typeNode.typeParameters.params.length === 2
+  ) {
+    const errorType = typeNode.typeParameters.params[1];
+    
+    // Prüfe ob der Error-Typ InfrastructureError | DomainError ist
+    if (errorType.type === "TSUnionType") {
+      const errorTypes = errorType.types.map(t => 
+        t.type === "TSTypeReference" ? t.typeName.name : null
+      );
+      
+      return errorTypes.includes("InfrastructureError") && 
+             errorTypes.includes("DomainError");
+    }
+    
+    // Oder nur einer der beiden Error-Typen
+    if (errorType.type === "TSTypeReference") {
+      const errorTypeName = errorType.typeName.name;
+      return errorTypeName === "InfrastructureError" || 
+             errorTypeName === "DomainError";
+    }
+  }
+
+  return false;
+}
+
+/**
+ * Prüft ob der Typ ein Type-Alias ist, der auf Result endet (z.B. ItemResults, CharacterResult)
+ */
+function checkIsResultTypeAlias(typeNode) {
+  if (
+    typeNode.type === "TSTypeReference" &&
+    typeNode.typeName &&
+    typeNode.typeName.name
+  ) {
+    const typeName = typeNode.typeName.name;
+    // Akzeptiere alle Typen, die auf "Result" enden (weniger strikt)
+    return typeName.endsWith("Result") || 
+           typeName.endsWith("Results") ||
+           typeName.includes("Result");
+  }
+
+  return false;
+} 

package/rules/security.js

@@ -0,0 +1,37 @@
+/**
+ * Security Rules
+ *
+ * Sicherheitsregeln für Backend-Projekte
+ */
+
+export default {
+  rules: {
+    // Security-Regeln (erweitert)
+    "security/detect-unsafe-regex": "error",
+    "security/detect-buffer-noassert": "error",
+    "security/detect-child-process": "error",
+    "security/detect-disable-mustache-escape": "error",
+    "security/detect-eval-with-expression": "error",
+    "security/detect-no-csrf-before-method-override": "error",
+    "security/detect-non-literal-fs-filename": "error",
+    "security/detect-non-literal-regexp": "error",
+    "security/detect-non-literal-require": "error",
+    "security/detect-object-injection": "error",
+    "security/detect-possible-timing-attacks": "error",
+    "security/detect-pseudoRandomBytes": "error",
+    "security/detect-bidi-characters": "error",
+    "security/detect-new-buffer": "error",
+
+    // No Secrets Plugin
+    "no-secrets/no-secrets": ["error", {
+      "tolerance": 4.2,
+      "additionalRegexes": {
+        "Basic Auth": "Authorization:\\s*Basic\\s+[A-Za-z0-9+/=]+",
+        "API Key": "(api[_-]?key|apikey)\\s*[:=]\\s*['\"][a-zA-Z0-9_-]{20,}['\"]",
+        "Database URL": "(database[_-]?url|db[_-]?url)\\s*[:=]\\s*['\"][^'\"]+['\"]",
+        "JWT": "eyJ[A-Za-z0-9_-]*\\.[A-Za-z0-9_-]*\\.[A-Za-z0-9_-]*",
+        "Private Key": "-----BEGIN\\s+(RSA\\s+)?PRIVATE\\s+KEY-----"
+      }
+    }],
+  },
+};