@echoes-of-order/eslint-config 1.121.0

package/rules/service-architecture.js

@@ -0,0 +1,148 @@
+/**
+ * ESLint-Regel: service-architecture
+ * Stellt sicher, dass Services niemals Entities, sondern nur DTOs zurückgeben
+ */
+
+/** @type {import('eslint').Rule.RuleModule} */
+const enforceServiceDtoRule = {
+  meta: {
+    type: "problem",
+    docs: {
+      description: "Services müssen DTOs statt Entities zurückgeben",
+      category: "Architecture",
+      recommended: true,
+    },
+    schema: [],
+    messages: {
+      serviceReturnsEntity: "Service-Methode '{{methodName}}' darf keine Entity '{{entityName}}' zurückgeben. Verwende stattdessen ein DTO.",
+      resultContainsEntity: "Result<{{entityName}}> ist nicht erlaubt. Services müssen Result<{{suggestedDto}}> zurückgeben.",
+      entityInPromiseResult: "Promise<Result<{{entityName}}>> ist nicht erlaubt. Verwende Promise<Result<{{suggestedDto}}>>.",
+    },
+  },
+  create(context) {
+    const filename = context.getFilename();
+    const isServiceFile = filename.includes("/service/") &&
+                         filename.endsWith(".ts") &&
+                         !filename.includes("test") &&
+                         !filename.includes("BaseService");
+
+    if (!isServiceFile) return {};
+
+    function isEntityType(typeName) {
+      if (!typeName || typeof typeName !== "string") return false;
+
+      // Prüfe auf Entity-Suffix
+      if (typeName.endsWith("Entity")) return true;
+
+      // Prüfe auf bekannte Entity-Patterns
+      const entityPatterns = [
+        /.*Entity$/,
+        /.*Model$/,  // Falls Models als Entities verwendet werden
+      ];
+
+      return entityPatterns.some(pattern => pattern.test(typeName));
+    }
+
+    function extractTypeFromResult(typeAnnotation) {
+      if (!typeAnnotation) return null;
+
+      const sourceCode = context.getSourceCode();
+      const typeText = sourceCode.getText(typeAnnotation);
+
+      // Extract type from Result<Type> or Promise<Result<Type>>
+      const resultMatch = typeText.match(/Result<([^>]+)>/);
+      if (resultMatch) {
+        let innerType = resultMatch[1].trim();
+
+        // Handle arrays like MonsterEntity[]
+        if (innerType.endsWith("[]")) {
+          innerType = innerType.slice(0, -2);
+        }
+
+        // Handle union types like MonsterEntity | null
+        if (innerType.includes("|")) {
+          const types = innerType.split("|").map(t => t.trim());
+          innerType = types.find(t => t !== "null" && t !== "undefined") || innerType;
+        }
+
+        return innerType;
+      }
+
+      return null;
+    }
+
+    function suggestDtoName(entityName) {
+      if (!entityName) return "SomeDto";
+
+      // Transform EntityName to EntityNameDto
+      let baseName = entityName;
+      if (baseName.endsWith("Entity")) {
+        baseName = baseName.slice(0, -6); // Remove "Entity"
+      }
+
+      return `${baseName}Dto`;
+    }
+
+    function checkMethodReturnType(node) {
+      if (!node.returnType || !node.returnType.typeAnnotation) return;
+
+      const extractedType = extractTypeFromResult(node.returnType.typeAnnotation);
+      if (!extractedType) return;
+
+      if (isEntityType(extractedType)) {
+        const methodName = node.parent?.key?.name || "unknown";
+        const suggestedDto = suggestDtoName(extractedType);
+
+        const sourceCode = context.getSourceCode();
+        const fullReturnType = sourceCode.getText(node.returnType.typeAnnotation);
+
+        if (fullReturnType.includes("Promise<Result<")) {
+          context.report({
+            node: node.returnType.typeAnnotation,
+            messageId: "entityInPromiseResult",
+            data: {
+              entityName: extractedType,
+              suggestedDto: suggestedDto,
+            },
+          });
+        } else if (fullReturnType.includes("Result<")) {
+          context.report({
+            node: node.returnType.typeAnnotation,
+            messageId: "resultContainsEntity",
+            data: {
+              entityName: extractedType,
+              suggestedDto: suggestedDto,
+            },
+          });
+        }
+      }
+    }
+
+    return {
+      MethodDefinition(node) {
+        // Prüfe nur öffentliche Methoden in Service-Klassen
+        if (node.accessibility === "public" &&
+            node.kind === "method" &&
+            node.key?.name !== "constructor") {
+
+          checkMethodReturnType(node.value);
+        }
+      },
+
+      // Prüfe auch Arrow Functions als Methoden
+      Property(node) {
+        if (node.value &&
+            (node.value.type === "ArrowFunctionExpression" ||
+             node.value.type === "FunctionExpression")) {
+          checkMethodReturnType(node.value);
+        }
+      },
+    };
+  },
+};
+
+export default {
+  rules: {
+    "enforce-service-dto": enforceServiceDtoRule,
+  },
+};

package/rules/sonarjs.js

@@ -0,0 +1,26 @@
+/**
+ * SonarJS Rules
+ *
+ * SonarJS-Regeln für Code-Qualität und Sicherheit
+ */
+
+export default {
+  rules: {
+    // SonarJS-Regeln (erweitert)
+    "sonarjs/no-all-duplicated-branches": "error",
+    "sonarjs/no-element-overwrite": "error",
+    "sonarjs/no-empty-collection": "error",
+    "sonarjs/no-extra-arguments": "error",
+    "sonarjs/no-identical-conditions": "error",
+    "sonarjs/no-identical-expressions": "error",
+    "sonarjs/no-ignored-return": "error",
+    "sonarjs/no-one-iteration-loop": "error",
+    "sonarjs/no-redundant-boolean": "error",
+    "sonarjs/no-redundant-jump": "error",
+    "sonarjs/no-same-line-conditional": "error",
+    "sonarjs/no-small-switch": "error",
+    "sonarjs/no-unused-collection": "error",
+  },
+};
+
+

package/rules/strict.js

@@ -0,0 +1,7 @@
+// Strict Mode Rules
+export default {
+  rules: {
+    // babel inserts `'use strict';` for us
+    strict: ["error", "never"],
+  },
+};