@echoes-of-order/eslint-config 1.121.0

package/rules/prefer-dto-create-method.js

@@ -0,0 +1,225 @@
+// Neue Regel für DTOs (erzwingt create Methode)
+import { ESLintUtils } from "@typescript-eslint/utils";
+
+const createRule = ESLintUtils.RuleCreator(
+  (name) => `https://github.com/echoes-of-order/Echoes of Order/blob/main/docs/eslint-rules.md#${name}`
+);
+
+export const enforceDtoCreateMethod = createRule({
+  name: "enforce-dto-create-method",
+  meta: {
+    type: "problem",
+    docs: {
+      description: "Enforce create method for DTOs",
+      recommended: "error",
+    },
+    messages: {
+      missingCreateMethod: "DTOs must have a static create() method",
+      useCreateMethod: "DTOs must use create() method for initialization, not constructors or fromEntity()",
+    },
+    schema: [],
+    fixable: null,
+  },
+  defaultOptions: [],
+  create(context) {
+    const filename = context.getFilename();
+
+    // Apply to DTOs outside Entity folder
+    const isDtoFile = filename.includes("/dto/") && filename.endsWith("Dto.ts");
+    const isEntityDtoFile = filename.includes("/dto/Entity/");
+
+    // console.log(`File: ${filename}, isDtoFile: ${isDtoFile}, isEntityDtoFile: ${isEntityDtoFile}`);
+
+    if (!isDtoFile || isEntityDtoFile) {
+      return {};
+    }
+
+    // console.log(`Applying DTO rules to ${filename}`);
+
+    return {
+      ClassDeclaration(node) {
+        const className = node.id.name;
+
+        // Ausnahme für BaseEntityDto (abstrakte Base-Klasse)
+        if (className === "BaseEntityDto" && filename.endsWith("/dto/BaseEntityDto.ts")) {
+          return;
+        }
+
+        // console.log(`Processing class: ${className}`);
+
+        // Check for create method - simple approach
+        const createMethod = node.body.body.find(member =>
+          member.type === "MethodDefinition" &&
+          member.static === true &&
+          member.key.name === "create"
+        );
+
+        // console.log(`Create method for ${className}: ${!!createMethod}`);
+
+        if (createMethod) {
+          // console.log(`✅ Allowing ${className} - has create method`);
+          // Don't report any errors for DTOs with create method
+          return;
+        }
+
+        // Only report error if no create method exists
+        console.log(`❌ ${className} missing create method`);
+        context.report({
+          node: node.id,
+          messageId: "missingCreateMethod",
+        });
+      },
+
+      // Allow all constructor calls in DTO files
+      NewExpression(node) {
+        const callee = node.callee;
+        if (callee.type === "Identifier" && callee.name.endsWith("Dto")) {
+          // Don't report any errors for DTO constructors
+          return;
+        }
+      },
+    };
+  },
+});
+
+// Entity-DTO Regel: Erzwingt fromEntity-Methode und verbietet Default-Werte
+export const enforceDtoFromEntityMethod = createRule({
+  name: "enforce-dto-from-entity-method",
+  meta: {
+    type: "problem",
+    docs: {
+      description: "Enforce fromEntity method for Entity-DTOs and forbid default values",
+      recommended: "error",
+    },
+    messages: {
+      missingFromEntityMethod: "Entity-DTOs must have a static fromEntity(entity: EntityType) method",
+      noDefaultValues: "Entity-DTO properties must not have default values (use fromEntity() for initialization)",
+      noConstructor: "Entity-DTOs must not have constructors",
+      noCreateMethod: "Entity-DTOs must not have create() methods (use fromEntity() instead) - except for entity creation",
+      noHelperMethods: "Entity-DTOs must not have helper methods (use direct property assignment in fromEntity)",
+      useFromEntityMethod: "Entity-DTOs must use fromEntity() for initialization, not constructors or create()",
+    },
+    schema: [],
+    fixable: null,
+  },
+  defaultOptions: [],
+  create(context) {
+    const filename = context.getFilename();
+
+    // Nur für Entity-DTOs anwenden
+    const isEntityDtoFile = filename.includes("/dto/Entity/");
+
+    if (!isEntityDtoFile) {
+      return {};
+    }
+
+    return {
+      ClassDeclaration(node) {
+        const className = node.id.name;
+
+        // Prüfe auf fromEntity-Methode
+        const fromEntityMethod = node.body.body.find(member =>
+          member.type === "MethodDefinition" &&
+          member.static === true &&
+          member.key.name === "fromEntity"
+        );
+
+        // Prüfe auf create-Methode (verboten)
+        const createMethod = node.body.body.find(member =>
+          member.type === "MethodDefinition" &&
+          member.static === true &&
+          member.key.name === "create"
+        );
+
+        // Prüfe auf Constructor (verboten)
+        const constructor = node.body.body.find(member =>
+          member.type === "MethodDefinition" &&
+          member.kind === "constructor"
+        );
+
+        // Prüfe auf Helper-Methoden (verboten)
+        const helperMethods = node.body.body.filter(member =>
+          member.type === "MethodDefinition" &&
+          member.static === true &&
+          member.key.name !== "fromEntity" &&
+          member.key.name !== "fromEntityArray" &&
+          member.key.name !== "toEntity" &&
+          member.key.name !== "fromRequestDto" && // Explicitly allowed
+          member.key.name !== "create" && // Explicitly allowed for entity creation
+          !member.key.name.startsWith("set") &&
+          !member.key.name.startsWith("get")
+        );
+
+        // Fehlende fromEntity-Methode
+        if (!fromEntityMethod) {
+          context.report({
+            node: node.id,
+            messageId: "missingFromEntityMethod",
+          });
+        }
+
+        // create-Methode ist jetzt erlaubt für Entity-Erstellung
+
+        // Verbotener Constructor
+        if (constructor) {
+          context.report({
+            node: constructor,
+            messageId: "noConstructor",
+          });
+        }
+
+        // Verbotene Helper-Methoden
+        helperMethods.forEach(helperMethod => {
+          context.report({
+            node: helperMethod,
+            messageId: "noHelperMethods",
+          });
+        });
+      },
+
+      // Prüfe auf Default-Werte in Properties
+      PropertyDefinition(node) {
+        if (node.value !== null) {
+          context.report({
+            node: node,
+            messageId: "noDefaultValues",
+          });
+        }
+      },
+
+      // Prüfe auf direkte Constructor-Calls außerhalb von fromEntity und toEntity
+      NewExpression(node) {
+        const callee = node.callee;
+        if (callee.type === "Identifier" && callee.name.endsWith("EntityDto")) {
+          // Prüfe ob wir in einer fromEntity oder toEntity-Methode sind
+          let current = node;
+          let inAllowedMethod = false;
+
+          while (current && current.parent) {
+            if (current.type === "MethodDefinition" &&
+                current.static === true &&
+                (current.key.name === "fromEntity" || current.key.name === "toEntity" || current.key.name === "fromRequestDto" || current.key.name === "create")) {
+              inAllowedMethod = true;
+              break;
+            }
+            current = current.parent;
+          }
+
+          if (!inAllowedMethod) {
+            context.report({
+              node: node,
+              messageId: "useFromEntityMethod",
+            });
+          }
+        }
+      },
+    };
+  },
+});
+
+export default {
+  rules: {
+    "enforce-dto-create-method": enforceDtoCreateMethod,
+    "enforce-dto-from-entity-method": enforceDtoFromEntityMethod,
+  },
+};

package/rules/promises.js

@@ -0,0 +1,17 @@
+export default {
+  rules: {
+    "no-console": ["error", {
+      allow: ["warn", "error", "info"],
+    }],
+    "prefer-promise-reject-errors": ["error", { allowEmptyReject: false }],
+    "require-await": "error",
+    "no-return-await": "error",
+    "no-async-promise-executor": "error",
+    "no-await-in-loop": "error",
+    "no-promise-executor-return": "error",
+    "prefer-object-has-own": "error",
+    "logical-assignment-operators": ["error", "always"],
+    "no-unreachable-loop": "error",
+    "no-constant-binary-expression": "error",
+  },
+};

package/rules/react-hooks.js

@@ -0,0 +1,15 @@
+/**
+ * React Hooks Rules
+ *
+ * React-Hooks-spezifische Regeln für Frontend-Projekte
+ */
+
+export default {
+  rules: {
+    // React-Hooks-Regeln
+    "react-hooks/rules-of-hooks": "error",
+    "react-hooks/exhaustive-deps": "error",
+  },
+};
+
+

package/rules/react.js

@@ -0,0 +1,28 @@
+export default {
+  rules: {
+    "react-hooks/exhaustive-deps": "off",
+    "react/jsx-indent": [2, 2],
+    "react/display-name": "off",
+    "react/prefer-stateless-function": "error",
+    "react/prefer-es6-class": "error",
+    "react/jsx-closing-bracket-location": "error",
+    "react/jsx-closing-tag-location": "error",
+    "react/jsx-pascal-case": "error",
+    "react/jsx-tag-spacing": "error",
+    "react/jsx-boolean-value": "error",
+    "react/no-array-index-key": "error",
+    "react/no-string-refs": "error",
+    "react/jsx-wrap-multilines": "error",
+    "react/self-closing-comp": "error",
+    "react/require-render-return": "error",
+    "react/sort-comp": "error",
+    "react/no-is-mounted": "error",
+    "react/forbid-prop-types": "error",
+
+    // Dead Code Detection für React
+    "react/jsx-no-useless-fragment": ["error", {
+      "allowExpressions": true
+    }],
+  },
+};
+

package/rules/regexp.js

@@ -0,0 +1,70 @@
+/**
+ * Regexp Rules
+ *
+ * Performance und Sicherheit für reguläre Ausdrücke
+ * Ursprünglich aus dem Image-Server
+ */
+
+export default {
+  rules: {
+    // Regexp-Regeln für Performance
+    "regexp/confusing-quantifier": "error",
+    "regexp/control-character-escape": "error",
+    "regexp/negation": "error",
+    "regexp/no-dupe-characters-character-class": "error",
+    "regexp/no-dupe-disjunctions": "error",
+    "regexp/no-empty-alternative": "error",
+    "regexp/no-empty-capturing-group": "error",
+    "regexp/no-empty-character-class": "error",
+    "regexp/no-empty-group": "error",
+    "regexp/no-empty-lookarounds-assertion": "error",
+    "regexp/no-escape-backspace": "error",
+    "regexp/no-invalid-regexp": "error",
+    "regexp/no-lazy-ends": "error",
+    "regexp/no-misleading-capturing-group": "error",
+    "regexp/no-misleading-unicode-character": "error",
+    "regexp/no-missing-g-flag": "error",
+    "regexp/no-potentially-useless-backreference": "error",
+    "regexp/no-super-linear-backtracking": "error",
+    "regexp/no-super-linear-move": "error",
+    "regexp/no-trivially-nested-assertion": "error",
+    "regexp/no-trivially-nested-quantifier": "error",
+    "regexp/no-unused-capturing-group": "error",
+    "regexp/no-useless-assertions": "error",
+    "regexp/no-useless-backreference": "error",
+    "regexp/no-useless-character-class": "error",
+    "regexp/no-useless-dollar-replacements": "error",
+    "regexp/no-useless-escape": "error",
+    "regexp/no-useless-flag": "error",
+    "regexp/no-useless-lazy": "error",
+    "regexp/no-useless-quantifier": "error",
+    "regexp/no-useless-range": "error",
+    "regexp/no-useless-two-nums-quantifier": "error",
+    "regexp/no-zero-quantifier": "error",
+    "regexp/optimal-lookaround-quantifier": "error",
+    "regexp/optimal-quantifier-concatenation": "error",
+    "regexp/prefer-lookaround": "error",
+    "regexp/prefer-named-backreference": "error",
+    "regexp/prefer-named-capture-group": "error",
+    "regexp/prefer-named-replacement": "error",
+    "regexp/prefer-plus-quantifier": "error",
+    "regexp/prefer-predefined-assertion": "error",
+    "regexp/prefer-quantifier": "error",
+    "regexp/prefer-range": "error",
+    "regexp/prefer-regexp-exec": "error",
+    "regexp/prefer-regexp-test": "error",
+    "regexp/prefer-result-array-groups": "error",
+    "regexp/prefer-set-operation": "error",
+    "regexp/prefer-star-quantifier": "error",
+    "regexp/prefer-unicode-codepoint-escapes": "error",
+    "regexp/require-unicode-regexp": "error",
+    "regexp/simplify-set-operations": "error",
+    "regexp/sort-alternatives": "error",
+    "regexp/sort-character-class-elements": "error",
+    "regexp/sort-flags": "error",
+    "regexp/strict": "error",
+    "regexp/use-ignore-case": "error",
+  },
+};
+
+

package/rules/require-dto-response.js

@@ -0,0 +1,81 @@
+/**
+ * @fileoverview Verhindert die direkte Verwendung von Entities in Controller-Responses und erzwingt DTOs
+ */
+
+"use strict";
+
+const requireDtoResponseRule = {
+  meta: {
+    type: "problem",
+    docs: {
+      description: "Verhindert die direkte Verwendung von Entities in Controller-Responses und erzwingt DTOs",
+      category: "Security",
+      recommended: true,
+    },
+    fixable: null,
+    schema: [],
+    messages: {
+      entityInResponse: "Entity-Variable '{{variableName}}' darf nicht direkt in sendSuccess() verwendet werden. Controller müssen Entities zu DTOs konvertieren bevor sie als API-Response zurückgegeben werden.",
+    },
+  },
+
+  create(context) {
+    const filename = context.getFilename();
+
+    // Nur Controller-Dateien prüfen, außer Tests
+    if (!filename.includes("Controller.ts") || filename.includes("test") || filename.includes("spec")) {
+      return {};
+    }
+
+    // Entity-Pattern erkennen
+    function isEntityPattern(variableName) {
+      return (
+        variableName.endsWith("Definition") ||
+        variableName.endsWith("Entity") ||
+        variableName.endsWith("Model") ||
+        variableName.endsWith("Record") ||
+        variableName.endsWith("Instance") ||
+        variableName.startsWith("new") ||
+        variableName.includes("Entity") ||
+        variableName.includes("Definition")
+      );
+    }
+
+    return {
+      CallExpression(node) {
+        // Prüfe auf this.sendSuccess() Aufrufe
+        if (node.callee?.type === "MemberExpression" &&
+            node.callee.object?.type === "ThisExpression" &&
+            node.callee.property?.name === "sendSuccess") {
+
+          // Prüfe das zweite Argument (Response-Objekt)
+          if (node.arguments.length >= 2 &&
+              node.arguments[1]?.type === "ObjectExpression") {
+
+            const responseObject = node.arguments[1];
+
+            // Prüfe alle Properties im Response-Objekt
+            responseObject.properties.forEach(property => {
+              if (property.type === "Property" &&
+                  property.value?.type === "Identifier") {
+
+                const variableName = property.value.name;
+
+                // Melde Entity-Patterns
+                if (isEntityPattern(variableName)) {
+                  context.report({
+                    node: property.value,
+                    messageId: "entityInResponse",
+                    data: { variableName }
+                  });
+                }
+              }
+            });
+          }
+        }
+      }
+    };
+  }
+};
+
+export default requireDtoResponseRule;