@echoes-of-order/eslint-config 1.121.0

package/rules/no-tsyringe.js

@@ -0,0 +1,181 @@
+const noTsyringeRule = {
+  meta: {
+    type: "problem",
+    docs: {
+      description: "Verbietet die Verwendung von TSyringe und erzwingt NestJS Dependency Injection",
+      category: "Best Practices",
+      recommended: true,
+    },
+    fixable: "code",
+    schema: [],
+    messages: {
+      noTsyringeImport: "TSyringe-Imports sind verboten. Verwende stattdessen NestJS Dependency Injection mit @Injectable() aus '@nestjs/common'",
+      noTsyringeContainer: "TSyringe Container ist verboten. Verwende NestJS Module und Constructor Injection",
+      noTsyringeDecorator: "TSyringe @injectable() ist verboten. Verwende @Injectable() aus '@nestjs/common'",
+      requireNestjsInjectable: "Controller und Services müssen @Injectable() aus '@nestjs/common' verwenden",
+      noTsyringeResolve: "container.resolve() ist verboten. Verwende NestJS Constructor Injection",
+    },
+  },
+
+  create(context) {
+
+    let hasNestjsInjectableImport = false;
+    let hasInjectableDecorator = false;
+    let isControllerOrService = false;
+
+    return {
+      // Überprüfe Imports
+      ImportDeclaration(node) {
+        const source = node.source.value;
+
+        // Verbiete TSyringe-Imports
+        if (source === "tsyringe") {
+          context.report({
+            node,
+            messageId: "noTsyringeImport",
+            fix(fixer) {
+              // Entferne TSyringe-Import und ersetze durch NestJS
+              const specifiers = node.specifiers
+                .map(spec => spec.imported?.name || spec.local?.name)
+                .filter(name => name === "injectable" || name === "Injectable");
+
+              if (specifiers.includes("injectable") || specifiers.includes("Injectable")) {
+                return fixer.replaceText(
+                  node,
+                  'import { Injectable } from "@nestjs/common";'
+                );
+              }
+
+              return fixer.remove(node);
+            },
+          });
+        }
+
+        // Überprüfe NestJS Injectable Import
+        if (source === "@nestjs/common") {
+          const injectableImport = node.specifiers.find(
+            spec => spec.imported?.name === "Injectable"
+          );
+          if (injectableImport) {
+            hasNestjsInjectableImport = true;
+          }
+        }
+      },
+
+      // Überprüfe Dekoratoren
+      Decorator(node) {
+        if (node.expression?.name === "injectable") {
+          context.report({
+            node,
+            messageId: "noTsyringeDecorator",
+            fix(fixer) {
+              return fixer.replaceText(node, "@Injectable()");
+            },
+          });
+        }
+
+        if (node.expression?.name === "Injectable" ||
+            (node.expression?.callee?.name === "Injectable")) {
+          hasInjectableDecorator = true;
+        }
+
+        if (node.expression?.name === "Controller" ||
+            node.expression?.name === "Service" ||
+            (node.expression?.callee?.name === "Controller")) {
+          isControllerOrService = true;
+        }
+      },
+
+      // Überprüfe TSyringe Container-Verwendung
+      MemberExpression(node) {
+        if (
+          node.object?.name === "container" &&
+          (node.property?.name === "resolve" ||
+           node.property?.name === "register" ||
+           node.property?.name === "registerInstance")
+        ) {
+          context.report({
+            node,
+            messageId: "noTsyringeContainer",
+          });
+        }
+      },
+
+      // Überprüfe am Ende der Datei
+      "Program:exit"() {
+        const filename = context.getFilename();
+        const isControllerFile = filename.includes("Controller.ts") && !filename.includes("test");
+        const isServiceFile = filename.includes("Service.ts") && !filename.includes("test");
+
+        // BaseController ausschließen
+        if (filename.includes("BaseController.ts")) {
+          return;
+        }
+
+        if ((isControllerFile || isServiceFile || isControllerOrService) &&
+            !hasInjectableDecorator &&
+            !filename.includes("test") &&
+            !filename.includes("spec")) {
+
+          // Finde die erste Klassen-Deklaration
+          const program = context.getSourceCode().ast;
+          const classDeclaration = program.body.find(node =>
+            node.type === "ExportDefaultDeclaration" &&
+            node.declaration?.type === "ClassDeclaration"
+          );
+
+          if (classDeclaration) {
+            context.report({
+              node: classDeclaration,
+              messageId: "requireNestjsInjectable",
+              fix(fixer) {
+                const fixes = [];
+
+                // Füge Injectable Import hinzu, falls nicht vorhanden
+                if (!hasNestjsInjectableImport) {
+                  const imports = program.body.filter(node => node.type === "ImportDeclaration");
+                  const nestjsImport = imports.find(imp => imp.source.value === "@nestjs/common");
+
+                  if (nestjsImport) {
+                    // Erweitere existierenden NestJS Import
+                    const specifiers = nestjsImport.specifiers.map(spec => spec.imported?.name || spec.local?.name);
+                    if (!specifiers.includes("Injectable")) {
+                      const newSpecifiers = [...specifiers, "Injectable"].join(", ");
+                      fixes.push(fixer.replaceText(
+                        nestjsImport,
+                        `import { ${newSpecifiers} } from "@nestjs/common";`
+                      ));
+                    }
+                  } else {
+                    // Füge neuen Injectable Import hinzu
+                    const firstImport = imports[0];
+                    if (firstImport) {
+                      fixes.push(fixer.insertTextBefore(
+                        firstImport,
+                        'import { Injectable } from "@nestjs/common";\n'
+                      ));
+                    }
+                  }
+                }
+
+                // Füge @Injectable() Dekorator hinzu
+                fixes.push(fixer.insertTextBefore(
+                  classDeclaration,
+                  "@Injectable()\n"
+                ));
+
+                return fixes;
+              },
+            });
+          }
+        }
+      },
+    };
+  },
+};
+
+export default {
+  rules: {
+    "no-tsyringe": noTsyringeRule,
+  },
+};

package/rules/no-type-assertion.js

@@ -0,0 +1,175 @@
+export default {
+  rules: {
+    "no-type-assertion": {
+      meta: {
+        type: "problem",
+        docs: {
+          description: "Verbietet Type Assertions mit 'as'",
+          category: "Best Practices",
+          recommended: true,
+        },
+        schema: [],
+        messages: {
+          noTypeAssertion: "Type Assertions mit 'as' sind verboten. Verwende stattdessen Typ-Guards oder Validierung.",
+        },
+      },
+
+      create(context) {
+        // Prüfe, ob wir in einer Validierungsfunktion sind
+        const isInValidationFunction = (node) => {
+          let current = node;
+          while (current) {
+            if (current.type === 'MethodDefinition' && current.key.name && current.key.name.includes('Valid')) {
+              return true;
+            }
+            if (current.type === 'FunctionDeclaration' && current.id.name && current.id.name.includes('Valid')) {
+              return true;
+            }
+            current = current.parent;
+          }
+          return false;
+        };
+
+        // Prüfe, ob wir in einer DTO-Entity-Mapping-Methode sind
+        const isInDtoEntityMappingMethod = (node) => {
+          let current = node;
+          while (current) {
+            if (current.type === 'MethodDefinition' && current.key.name &&
+                (current.key.name === 'fromEntity' || current.key.name === 'toEntity' || current.key.name === 'fromEntityArray')) {
+              return true;
+            }
+            if (current.type === 'FunctionDeclaration' && current.id.name &&
+                (current.id.name === 'fromEntity' || current.id.name === 'toEntity' || current.id.name === 'fromEntityArray')) {
+              return true;
+            }
+            current = current.parent;
+          }
+          return false;
+        };
+
+        // Prüfe, ob es sich um eine Conditional Type Assertion handelt
+        const isConditionalTypeAssertion = (node) => {
+          if (node.typeAnnotation && node.typeAnnotation.type === 'TSConditionalType') {
+            return true;
+          }
+          return false;
+        };
+
+        // Prüfe, ob es sich um eine Generic Type Assertion handelt
+        const isGenericTypeAssertion = (node) => {
+          if (node.typeAnnotation && node.typeAnnotation.type === 'TSTypeReference') {
+            // Prüfe auf generische Parameter
+            if (node.typeAnnotation.typeParameters && node.typeAnnotation.typeParameters.params) {
+              return true;
+            }
+          }
+          return false;
+        };
+
+        // Prüfe, ob es sich um eine DTO-Entity-Mapping Type Assertion handelt
+        const isDtoEntityMappingAssertion = (node) => {
+          if (node.typeAnnotation) {
+            const typeAnnotation = node.typeAnnotation;
+
+            // Prüfe auf Conditional Types mit "extends"
+            if (typeAnnotation.type === 'TSConditionalType') {
+              return true;
+            }
+
+            // Prüfe auf Type References mit generischen Parametern
+            if (typeAnnotation.type === 'TSTypeReference') {
+              // Prüfe auf "T extends" Pattern
+              if (typeAnnotation.typeName && typeAnnotation.typeName.name === 'T') {
+                return true;
+              }
+
+              // Prüfe auf EntityDto oder EntityDto<...> Pattern
+              if (typeAnnotation.typeName &&
+                  typeAnnotation.typeName.name &&
+                  (typeAnnotation.typeName.name.includes('EntityDto') ||
+                   typeAnnotation.typeName.name.includes('Entity'))) {
+                return true;
+              }
+            }
+          }
+          return false;
+        };
+
+        return {
+          TSAsExpression(node) {
+            const filename = context.getFilename();
+
+            // Erlaube Type Assertions in bestimmten Dateien
+            if (filename.includes('BaseController.ts') ||
+                filename.includes('openapi.ts') ||
+                filename.includes('/setup/') ||
+                filename.includes('/config/')) {
+              return;
+            }
+
+            // Erlaube Type Assertions in Validierungsfunktionen
+            if (isInValidationFunction(node)) {
+              return;
+            }
+
+            // Erlaube Type Assertions in DTO-Entity-Mapping-Methoden
+            if (isInDtoEntityMappingMethod(node)) {
+              return;
+            }
+
+            // Erlaube Conditional Type Assertions (für Generics)
+            if (isConditionalTypeAssertion(node)) {
+              return;
+            }
+
+            // Erlaube Generic Type Assertions (für Generics)
+            if (isGenericTypeAssertion(node)) {
+              return;
+            }
+
+            // Erlaube DTO-Entity-Mapping Type Assertions (für Generics)
+            if (isDtoEntityMappingAssertion(node)) {
+              return;
+            }
+
+            context.report({
+              node,
+              messageId: "noTypeAssertion",
+            });
+          },
+          TSTypeAssertion(node) {
+            // Erlaube Type Assertions in Validierungsfunktionen
+            if (isInValidationFunction(node)) {
+              return;
+            }
+
+            // Erlaube Type Assertions in DTO-Entity-Mapping-Methoden
+            if (isInDtoEntityMappingMethod(node)) {
+              return;
+            }
+
+            // Erlaube Conditional Type Assertions (für Generics)
+            if (isConditionalTypeAssertion(node)) {
+              return;
+            }
+
+            // Erlaube Generic Type Assertions (für Generics)
+            if (isGenericTypeAssertion(node)) {
+              return;
+            }
+
+            // Erlaube DTO-Entity-Mapping Type Assertions (für Generics)
+            if (isDtoEntityMappingAssertion(node)) {
+              return;
+            }
+
+            context.report({
+              node,
+              messageId: "noTypeAssertion",
+            });
+          },
+        };
+      },
+    },
+  },
+};

package/rules/no-undefined-entity-properties.js

@@ -0,0 +1,121 @@
+/**
+ * @fileoverview Verhindert undefined Properties in Entity-Klassen
+ * Entities sollten niemals undefined Properties haben - verwende stattdessen null oder entferne das Property
+ */
+
+/** @type {import('eslint').Rule.RuleModule} */
+const noUndefinedEntityPropertiesRule = {
+  meta: {
+    type: "problem",
+    docs: {
+      description: "Verhindert undefined Properties in Entity-Klassen",
+      category: "TypeORM",
+      recommended: true,
+    },
+    hasSuggestions: true,
+    schema: [],
+    messages: {
+      undefinedPropertyInEntity: "Entity '{{entityName}}' hat undefined Property '{{propertyName}}'. Verwende stattdessen '{{propertyName}}: {{type}} | null' oder entferne das Property.",
+      suggestUseNull: "Verwende '| null' statt 'undefined'",
+      suggestRemoveOptional: "Entferne das '?' und verwende '| null'",
+    },
+  },
+
+  create(context) {
+    const filename = context.getFilename();
+
+    // Nur Entity-Dateien prüfen
+    const isEntityFile = filename.includes("/entity/") || filename.includes("fixtures/");
+    const hasEntityExtension = filename.includes("Entity") && filename.endsWith(".ts");
+
+    if (!isEntityFile || !hasEntityExtension) {
+      return {};
+    }
+
+    return {
+      ClassDeclaration(node) {
+        const className = node.id?.name;
+
+        // Nur Entity-Klassen prüfen
+        if (!className || !className.endsWith("Entity")) {
+          return;
+        }
+
+        // Durchsuche alle Properties der Klasse
+        node.body.body.forEach(member => {
+          if (member.type === "PropertyDefinition" || member.type === "TSParameterProperty") {
+            const propertyName = member.key?.name;
+            const propertyType = member.typeAnnotation?.typeAnnotation;
+
+            if (!propertyName || !propertyType) {
+              return;
+            }
+
+            // Prüfe auf undefined in Union Types
+            if (propertyType.type === "TSUnionType") {
+              const hasUndefined = propertyType.types.some(type =>
+                type.type === "TSUndefinedKeyword"
+              );
+
+              if (hasUndefined) {
+                const typeString = context.getSourceCode().getText(propertyType);
+                const correctedType = typeString.replace(/\|\s*undefined/g, " | null");
+
+                context.report({
+                  node: member,
+                  messageId: "undefinedPropertyInEntity",
+                  data: {
+                    entityName: className,
+                    propertyName,
+                    type: correctedType.replace(/\|\s*null/g, "").trim()
+                  },
+                  suggest: [
+                    {
+                      desc: "Verwende '| null' statt 'undefined'",
+                      fix(fixer) {
+                        return fixer.replaceText(propertyType, correctedType);
+                      }
+                    }
+                  ]
+                });
+              }
+            }
+
+            // Prüfe auf optional Properties (?) - diese sollten in Entities vermieden werden
+            if (member.optional) {
+              const typeString = context.getSourceCode().getText(propertyType);
+
+              context.report({
+                node: member,
+                messageId: "undefinedPropertyInEntity",
+                data: {
+                  entityName: className,
+                  propertyName,
+                  type: typeString
+                },
+                suggest: [
+                  {
+                    desc: "Entferne das '?' und verwende '| null'",
+                    fix(fixer) {
+                      const newType = `${typeString} | null`;
+                      return fixer.replaceTextRange(
+                        [member.typeAnnotation.range[0], member.typeAnnotation.range[1]],
+                        `: ${newType}`
+                      );
+                    }
+                  }
+                ]
+              });
+            }
+          }
+        });
+      }
+    };
+  },
+};
+
+export default {
+  rules: {
+    "no-undefined-entity-properties": noUndefinedEntityPropertiesRule,
+  },
+};

package/rules/node.js

@@ -0,0 +1,44 @@
+// Node.js Rules
+export default {
+  env: {
+    node: true
+  },
+
+  rules: {
+    // enforce return after a callback
+    'callback-return': 'off',
+
+    // require all requires be top-level
+    // https://eslint.org/docs/rules/global-require
+    'global-require': 'error',
+
+    // enforces error handling in callbacks (node environment)
+    'handle-callback-err': 'off',
+
+    // disallow use of the Buffer() constructor
+    // https://eslint.org/docs/rules/no-buffer-constructor
+    'no-buffer-constructor': 'error',
+
+    // disallow mixing regular variable and require declarations
+    'no-mixed-requires': ['off', false],
+
+    // disallow use of new operator with the require function
+    'no-new-require': 'error',
+
+    // disallow string concatenation with __dirname and __filename
+    // https://eslint.org/docs/rules/no-path-concat
+    'no-path-concat': 'error',
+
+    // disallow use of process.env
+    'no-process-env': 'off',
+
+    // disallow process.exit()
+    'no-process-exit': 'off',
+
+    // restrict usage of specified node modules
+    'no-restricted-modules': 'off',
+
+    // disallow use of synchronous methods (off by default)
+    'no-sync': 'off',
+  }
+};

package/rules/perfectionist.js

@@ -0,0 +1,50 @@
+/**
+ * Perfectionist Rules
+ *
+ * Perfectionist-Regeln für konsistente Code-Formatierung
+ */
+
+export default {
+  rules: {
+    // Perfectionist-Regeln
+    "perfectionist/sort-imports": ["error", {
+      type: "alphabetical",
+      order: "asc",
+      ignoreCase: true,
+      newlinesBetween: "always",
+      maxLineLength: undefined,
+      groups: [
+        "type",
+        ["builtin", "external"],
+        "internal-type",
+        "internal",
+        ["parent-type", "sibling-type", "index-type"],
+        ["parent", "sibling", "index"],
+        "object",
+        "unknown",
+      ],
+    }],
+    "perfectionist/sort-object-types": ["error", {
+      type: "alphabetical",
+      order: "asc",
+      ignoreCase: true,
+    }],
+    "perfectionist/sort-interfaces": ["error", {
+      type: "alphabetical",
+      order: "asc",
+      ignoreCase: true,
+    }],
+    "perfectionist/sort-enums": ["error", {
+      type: "alphabetical",
+      order: "asc",
+      ignoreCase: true,
+    }],
+    "perfectionist/sort-array-includes": ["error", {
+      type: "alphabetical",
+      order: "asc",
+      ignoreCase: true,
+    }],
+  },
+};
+
+