@echoes-of-order/eslint-config 1.121.0

package/rules/dead-code-detection.js

@@ -0,0 +1,71 @@
+export default {
+  rules: {
+    // Ungenutzte Variablen und Imports
+    "@typescript-eslint/no-unused-vars": ["error", {
+      "vars": "all",
+      "args": "after-used",
+      "ignoreRestSiblings": true,
+      "argsIgnorePattern": "^_",
+      "varsIgnorePattern": "^_",
+      "destructuredArrayIgnorePattern": "^_"
+    }],
+
+    // React-spezifische Dead Code Detection
+    "react/jsx-no-useless-fragment": ["error", {
+      "allowExpressions": true
+    }],
+
+    // Ungenutzte private Klassenmember
+    "no-unused-private-class-members": "error",
+
+    // Ungenutzte Labels
+    "no-unused-labels": "error",
+
+    // Ungenutzte Expressions
+    "no-unused-expressions": ["error", {
+      "allowShortCircuit": true,
+      "allowTernary": true,
+      "allowTaggedTemplates": true
+    }],
+
+    // Import/Export Dead Code Detection
+    "import/no-unused-modules": ["error", {
+      "missingExports": true,
+      "unusedExports": true,
+      "ignoreExports": [
+        "src/main.tsx",
+        "src/App.tsx",
+        "src/AppRouter.tsx",
+        "src/vite-env.d.ts",
+        "**/*.d.ts",
+        "**/test/**",
+        "**/tests/**",
+        "**/*.test.*",
+        "**/*.spec.*"
+      ]
+    }],
+
+    // Typescript-spezifische Dead Code Rules
+    "@typescript-eslint/no-unused-expressions": ["error", {
+      "allowShortCircuit": true,
+      "allowTernary": true,
+      "allowTaggedTemplates": true
+    }],
+
+    // Ungenutzte Importe
+    "import/no-duplicates": "error",
+    "import/no-useless-path-segments": "error",
+
+    // Unreachable Code
+    "no-unreachable": "error",
+    "no-unreachable-loop": "error",
+
+    // Dead Stores
+    "no-self-assign": "error",
+    "no-self-compare": "error",
+    // React-Hooks-Regel wird nur in React-Konfigurationen gesetzt
+
+    // Material-UI spezifische Regeln
+    "mui-unused-classes": "off" // Custom rule falls verfügbar
+  }
+};

package/rules/debug-controller-response-dto.js

@@ -0,0 +1,79 @@
+/**
+ * @fileoverview Debug-Version der Controller-Response-DTO-Regel
+ */
+
+"use strict";
+
+const debugControllerResponseDtoRule = {
+  meta: {
+    type: "problem",
+    docs: {
+      description: "Debug: Controller müssen ResponseDtos verwenden",
+      category: "Architecture",
+      recommended: true,
+    },
+    schema: [],
+    messages: {
+      debugFound: "DEBUG: Gefunden - {{message}}",
+    },
+  },
+
+  create(context) {
+    const filename = context.getFilename();
+    console.log(`DEBUG: Processing file: ${filename}`);
+
+    // Nur Controller-Dateien prüfen
+    if (!filename.includes("Controller.ts") ||
+        filename.includes("test") ||
+        filename.includes("spec") ||
+        filename.includes("BaseController")) {
+      console.log(`DEBUG: Skipping file: ${filename}`);
+      return {};
+    }
+
+    console.log(`DEBUG: Processing Controller file: ${filename}`);
+
+    return {
+      CallExpression(node) {
+        console.log(`DEBUG: Found CallExpression: ${context.getSourceCode().getText(node)}`);
+
+        // Prüfe auf this.sendSuccess() Aufrufe
+        if (node.callee?.type === "MemberExpression" &&
+            node.callee.object?.type === "ThisExpression" &&
+            node.callee.property?.name === "sendSuccess") {
+
+          console.log(`DEBUG: Found sendSuccess call`);
+
+          // Prüfe das zweite Argument (Response-Objekt)
+          if (node.arguments.length >= 2) {
+            const responseArg = node.arguments[1];
+            console.log(`DEBUG: Response argument: ${context.getSourceCode().getText(responseArg)}`);
+
+            // Fall 1: Direktes Entity-Objekt
+            if (responseArg.type === "ObjectExpression") {
+              responseArg.properties.forEach(property => {
+                if (property.type === "Property" && property.value) {
+                  const valueText = context.getSourceCode().getText(property.value);
+                  console.log(`DEBUG: Property value: ${valueText}`);
+
+                  // Prüfe auf Entity-Pattern
+                  if (valueText.includes("entity") || valueText.includes("Entity")) {
+                    console.log(`DEBUG: Found entity pattern: ${valueText}`);
+                    context.report({
+                      node: property.value,
+                      messageId: "debugFound",
+                      data: { message: `Entity gefunden: ${valueText}` },
+                    });
+                  }
+                }
+              });
+            }
+          }
+        }
+      }
+    };
+  },
+};
+
+export default debugControllerResponseDtoRule;
+

package/rules/deprecate.js

@@ -0,0 +1,8 @@
+// Deprecation Rules
+export default {
+  rules: {
+    "deprecate/function": "error",
+    "deprecate/member-expression": "error",
+    "deprecate/import": "error",
+  },
+};

package/rules/dto-annotation-property-consistency.js

@@ -0,0 +1,111 @@
+export default {
+  rules: {
+    "dto-annotation-property-consistency": {
+      meta: {
+        type: "problem",
+        docs: {
+          description: "Ensure consistency between DTO annotations and property optionality",
+          category: "Best Practices",
+          recommended: true,
+        },
+        messages: {
+          inconsistentOptionality: "Property '{{propName}}' has inconsistent optionality: {{annotation}} but property is {{propertyType}}",
+          inconsistentRequired: "Property '{{propName}}' has inconsistent required setting: {{annotation}} but property is {{propertyType}}",
+        },
+        schema: [],
+      },
+
+      create(context) {
+        return {
+          ClassDeclaration(node) {
+            const rawFilename = context.getFilename();
+            const filename = typeof rawFilename === 'string' ? rawFilename.replace(/\\/g, '/') : '';
+
+            // Nur für DTO-Dateien anwenden (auch in Test-Fixtures)
+            const isDtoPath = filename.toLowerCase().includes('/dto/');
+            const isDtoName = filename.endsWith('Dto.ts');
+            const isFixtureDto = filename.includes('/__tests__/fixtures/');
+            if (!(isDtoPath || isDtoName || isFixtureDto)) {
+              return;
+            }
+
+            // Durchlaufe alle Properties der Klasse
+            for (const member of node.body.body) {
+              if (member.type === 'PropertyDefinition') {
+                const propName = member.key.name;
+                const decorators = member.decorators || [];
+
+                // Debug-Logging entfernt für saubere JSON-Ausgabe
+
+                // Finde @IsOptional und @ApiProperty Decorators
+                let hasIsOptional = false;
+                let apiPropertyRequired = null;
+
+                for (const decorator of decorators) {
+                  if (decorator.expression.type === 'CallExpression') {
+                    const callee = decorator.expression.callee;
+
+                    // Prüfe @IsOptional
+                    if (callee.type === 'Identifier' && callee.name === 'IsOptional') {
+                      hasIsOptional = true;
+                    }
+
+                    // Prüfe @ApiProperty
+                    if (callee.type === 'Identifier' && callee.name === 'ApiProperty') {
+                      const args = decorator.expression.arguments;
+                      if (args.length > 0 && args[0].type === 'ObjectExpression') {
+                        for (const prop of args[0].properties) {
+                          if (prop.key.name === 'required' && prop.value.type === 'Literal') {
+                            apiPropertyRequired = prop.value.value;
+                          }
+                        }
+                      }
+                    }
+                  } else if (decorator.expression.type === 'Identifier') {
+                    // Prüfe @IsOptional ohne Argumente
+                    if (decorator.expression.name === 'IsOptional') {
+                      hasIsOptional = true;
+                    }
+                  }
+                }
+
+                // Prüfe Property-Optionalität
+                const isPropertyOptional = member.optional || false;
+                const propertyType = isPropertyOptional ? 'optional (?)' : 'required';
+
+                // Prüfe Konsistenz zwischen @IsOptional und Property-Optionalität
+                if (hasIsOptional && !isPropertyOptional) {
+                  context.report({
+                    node: member,
+                    messageId: 'inconsistentOptionality',
+                    data: {
+                      propName,
+                      annotation: '@IsOptional()',
+                      propertyType,
+                    },
+                  });
+                }
+
+                // Prüfe Konsistenz zwischen required: false/true und Property-Optionalität
+                if (apiPropertyRequired !== null) {
+                  const expectedOptionality = !apiPropertyRequired;
+                  if (expectedOptionality !== isPropertyOptional) {
+                    context.report({
+                      node: member,
+                      messageId: 'inconsistentRequired',
+                      data: {
+                        propName,
+                        annotation: `required: ${apiPropertyRequired}`,
+                        propertyType,
+                      },
+                    });
+                  }
+                }
+              }
+            }
+          },
+        };
+      },
+    },
+  },
+};