@echoes-of-order/eslint-config 1.121.0

package/rules/no-dto-duplicates.js

@@ -0,0 +1,127 @@
+import fs from "fs";
+import path from "path";
+
+const noDtoDuplicatesRule = {
+  meta: {
+    type: "problem",
+    docs: {
+      description: "Prevents duplicate DTO class names across the dto directory",
+      category: "Architecture",
+      recommended: true,
+    },
+    schema: [],
+    messages: {
+      dtoDuplicateFound: "DTO-Klasse '{{className}}' existiert bereits in '{{existingFile}}'. Duplikate sind nicht erlaubt. Aktuelle Datei: '{{currentFile}}'. Entscheide selbst, welche Datei wir behalten! Lösche alle unnötigen - passe ggf. den Namen der Datei+Klasse an und korrigiere die Imports.",
+    },
+  },
+  create(context) {
+    return {
+      ClassDeclaration(node) {
+        const filename = context.getFilename();
+        const className = node.id?.name;
+
+        if (!className) return;
+
+        // Prüfe nur Dateien im dto-Verzeichnis
+        if (!filename.includes("/dto/") || !filename.endsWith(".ts")) {
+          return;
+        }
+
+        // Prüfe, ob es sich um eine DTO-Klasse handelt (endet mit "Dto")
+        if (!className.endsWith("Dto")) {
+          return;
+        }
+
+        // In Tests verwenden wir gemockte Dateien
+
+        // Suche nach anderen Dateien mit dem gleichen Klassennamen
+        const dtoDirectory = findDtoDirectory(filename);
+        if (!dtoDirectory) {
+          return;
+        }
+
+        const duplicateFiles = findDuplicateFiles(dtoDirectory, className, filename);
+
+        if (duplicateFiles.length > 0) {
+          // Berichte den ersten gefundenen Duplikat
+          const existingFile = duplicateFiles[0];
+          context.report({
+            node: node,
+            messageId: "dtoDuplicateFound",
+            data: {
+              className: className,
+              currentFile: filename,
+              existingFile: existingFile
+            },
+          });
+        }
+      },
+    };
+  },
+};
+
+// Hilfsmethode um das dto-Verzeichnis zu finden
+function findDtoDirectory(filename) {
+    const pathParts = filename.split(path.sep);
+    const dtoIndex = pathParts.findIndex(part => part === "dto");
+
+    if (dtoIndex === -1) {
+      return null;
+    }
+
+    // Konstruiere den Pfad bis zum dto-Verzeichnis
+    return pathParts.slice(0, dtoIndex + 1).join(path.sep);
+}
+
+// Hilfsmethode um Duplikate zu finden
+function findDuplicateFiles(dtoDirectory, className, currentFile) {
+    const duplicateFiles = [];
+
+    try {
+      // Rekursiv durchsuche das dto-Verzeichnis
+      const searchDirectory = (dir) => {
+        if (!fs.existsSync(dir)) {
+          return;
+        }
+
+        const items = fs.readdirSync(dir);
+
+        for (const item of items) {
+          const fullPath = path.join(dir, item);
+          const stat = fs.statSync(fullPath);
+
+          if (stat.isDirectory()) {
+            // Rekursiv in Unterverzeichnisse suchen
+            searchDirectory(fullPath);
+          } else if (stat.isFile() && item.endsWith('.ts')) {
+            // Überspringe die aktuelle Datei
+            if (fullPath === currentFile) {
+              continue;
+            }
+
+            try {
+              const content = fs.readFileSync(fullPath, "utf8");
+
+              // Suche nach der Klasse mit dem gleichen Namen
+              const classRegex = new RegExp(`export\\s+(default\\s+)?class\\s+${className}\\b`);
+              if (classRegex.test(content)) {
+                duplicateFiles.push(fullPath);
+              }
+            } catch (error) {
+              // Ignoriere Dateien, die nicht gelesen werden können
+              continue;
+            }
+          }
+        }
+      };
+
+      searchDirectory(dtoDirectory);
+    } catch (error) {
+      // Ignoriere Fehler beim Durchsuchen der Dateien
+      return [];
+    }
+
+    return duplicateFiles;
+}
+
+export default noDtoDuplicatesRule;

package/rules/no-dto-in-entity.js

@@ -0,0 +1,99 @@
+
+/**
+ * ESLint-Regel: Verhindert die Verwendung von DTOs in Entity-Dateien
+ * Für JSONB-Felder müssen eigene Typen definiert werden
+ */
+export default {
+  meta: {
+    type: "problem",
+    docs: {
+      description: "Verhindert die Verwendung von DTOs in Entity-Dateien. Für JSONB-Felder müssen eigene Typen definiert werden.",
+      category: "Architecture",
+      recommended: true,
+    },
+    hasSuggestions: true,
+    schema: [],
+    messages: {
+      dtoInEntity: "Entity '{{entityName}}' verwendet DTO '{{dtoName}}' in Property '{{propertyName}}'. Für JSONB-Felder müssen eigene Typen definiert werden.",
+      suggestType: "Definiere einen eigenen Typ für '{{propertyName}}' anstatt '{{dtoName}}' zu verwenden.",
+    },
+  },
+
+  create(context) {
+    const filename = context.getFilename();
+
+    // Regel nur auf Entity-Dateien im backend anwenden
+    if (!filename.includes("/backend/src/entity/") || !filename.endsWith(".ts")) {
+      return {};
+    }
+
+    // Prüfe, ob es sich um eine Entity-Datei handelt
+    const isEntityFile = filename.includes("/entity/") &&
+                        !filename.includes("/dto/") &&
+                        !filename.includes("/service/") &&
+                        !filename.includes("/controller/");
+
+    if (!isEntityFile) {
+      return {};
+    }
+
+    return {
+      ClassDeclaration(node) {
+        if (!node.id?.name) return;
+
+        const className = node.id.name;
+
+        // Prüfe alle Properties der Klasse
+        node.body.body.forEach(member => {
+          if (member.type === "PropertyDefinition" && member.key?.name) {
+            const propertyName = member.key.name;
+
+            // Prüfe Type-Annotation
+            if (member.typeAnnotation?.typeAnnotation) {
+              const typeAnnotation = member.typeAnnotation.typeAnnotation;
+
+              // Prüfe auf DTO-Verwendung
+              if (typeAnnotation.type === "TSTypeReference") {
+                const typeName = typeAnnotation.typeName?.name;
+
+                // Prüfe, ob der Typ ein DTO ist (endet mit "Dto" oder "EntityDto")
+                if (typeName && (typeName.endsWith("Dto") || typeName.endsWith("EntityDto"))) {
+                  context.report({
+                    node: member,
+                    messageId: "dtoInEntity",
+                    data: {
+                      entityName: className,
+                      dtoName: typeName,
+                      propertyName: propertyName,
+                    },
+                  });
+                }
+              }
+
+              // Prüfe Union-Types
+              if (typeAnnotation.type === "TSUnionType") {
+                typeAnnotation.types.forEach(unionType => {
+                  if (unionType.type === "TSTypeReference") {
+                    const typeName = unionType.typeName?.name;
+
+                    if (typeName && (typeName.endsWith("Dto") || typeName.endsWith("EntityDto"))) {
+                      context.report({
+                        node: member,
+                        messageId: "dtoInEntity",
+                        data: {
+                          entityName: className,
+                          dtoName: typeName,
+                          propertyName: propertyName,
+                        },
+                      });
+                    }
+                  }
+                });
+              }
+            }
+          }
+        });
+      },
+    };
+  },
+};

package/rules/no-dynamic-import-in-types.js

@@ -0,0 +1,71 @@
+/**
+ * @fileoverview Verbietet import("...").Type Syntax in Typ-Annotationen
+ * @author Echoes of Order Team
+ */
+
+export default {
+  meta: {
+    type: "problem",
+    docs: {
+      description: "Verbietet import(\"...\").Type Syntax in Typ-Annotationen. Verwende stattdessen explizite Imports.",
+      category: "Best Practices",
+      recommended: true,
+    },
+    messages: {
+      noDynamicImportInType: "import(\"{{path}}\").{{type}} ist verboten. Importiere '{{type}}' stattdessen direkt: import {{type}} from \"{{path}}\";",
+    },
+    schema: [],
+  },
+
+  create (context) {
+    function checkForDynamicImport (node) {
+      if (
+        node.type === "TSImportType" &&
+        node.argument &&
+        node.argument.type === "Literal" &&
+        typeof node.argument.value === "string"
+      ) {
+        const importPath = node.argument.value;
+        const typeName = node.qualifier?.name || node.qualifier?.right?.name || "Type";
+
+        context.report({
+          messageId: "noDynamicImportInType",
+          node,
+          data: {
+            path: importPath,
+            type: typeName,
+          },
+        });
+      }
+    }
+
+    return {
+      TSImportType (node) {
+        checkForDynamicImport(node);
+      },
+      TSTypeReference (node) {
+        if (node.typeName && node.typeName.type === "TSQualifiedName") {
+          const current = node.typeName;
+          if (
+            current.left.type === "TSImportType" &&
+            current.left.argument &&
+            current.left.argument.type === "Literal"
+          ) {
+            const importPath = current.left.argument.value;
+            const typeName = current.right.name;
+
+            context.report({
+              messageId: "noDynamicImportInType",
+              node,
+              data: {
+                path: importPath,
+                type: typeName,
+              },
+            });
+          }
+        }
+      },
+    };
+  },
+};
+

package/rules/no-dynamic-imports-in-controllers.js

@@ -0,0 +1,95 @@
+/**
+ * ESLint-Regel: no-dynamic-imports-in-controllers
+ * Verbotet dynamische Imports in Controller-Dateien
+ */
+
+/** @type {import('eslint').Rule.RuleModule} */
+const noDynamicImportsInControllersRule = {
+  meta: {
+    type: "problem",
+    docs: {
+      description: "Verbotet dynamische Imports in Controller-Dateien",
+      category: "Best Practices",
+      recommended: true,
+    },
+    schema: [],
+    messages: {
+      noDynamicImport: "Dynamic imports inside classes are not allowed. Import the class at top level and instantiate it with 'new' instead.",
+    },
+  },
+  create(context) {
+    let classDepth = 0;
+    const reported = new WeakSet();
+
+    const isImportCall = (node) => {
+      return (
+        node &&
+        node.type === "CallExpression" &&
+        ((node.callee && node.callee.type === "Identifier" && node.callee.name === "import") ||
+          (node.callee && node.callee.type === "Import"))
+      );
+    };
+
+    const isImportExpression = (node) => {
+      return node && (node.type === "ImportExpression" || isImportCall(node));
+    };
+
+    const findInnerImport = (node) => {
+      if (!node) return null;
+      if (node.type === "ImportExpression") return node;
+      if (isImportCall(node)) return node;
+      if (node.type === "AwaitExpression") return findInnerImport(node.argument);
+      if (node.type === "ParenthesizedExpression") return findInnerImport(node.expression);
+      if (node.type === "MemberExpression") return findInnerImport(node.object);
+      return null;
+    };
+
+    const reportOnceIfInsideClass = (importNode) => {
+      if (!importNode) return;
+      if (classDepth <= 0) return;
+      if (reported.has(importNode)) return;
+      reported.add(importNode);
+      context.report({ node: importNode, messageId: "noDynamicImport" });
+    };
+
+    return {
+      ClassBody () {
+        classDepth += 1;
+      },
+      "ClassBody:exit" () {
+        classDepth -= 1;
+      },
+
+      ImportExpression (node) {
+        reportOnceIfInsideClass(node);
+      },
+
+      CallExpression (node) {
+        if (isImportCall(node)) {
+          reportOnceIfInsideClass(node);
+        }
+      },
+
+      AwaitExpression (node) {
+        const inner = findInnerImport(node);
+        reportOnceIfInsideClass(inner);
+      },
+
+      ParenthesizedExpression (node) {
+        const inner = findInnerImport(node);
+        reportOnceIfInsideClass(inner);
+      },
+
+      MemberExpression (node) {
+        const inner = findInnerImport(node);
+        reportOnceIfInsideClass(inner);
+      },
+    };
+  },
+};
+
+export default {
+  rules: {
+    "no-dynamic-imports-in-controllers": noDynamicImportsInControllersRule,
+  },
+};

package/rules/no-entity-imports-in-controllers.js

@@ -0,0 +1,101 @@
+/**
+ * ESLint-Regel: Verbietet den Import von Entities in Controllern
+ * Controller sollten nur DTOs verwenden, nie direkt mit Entities arbeiten
+ */
+
+/** @type {import('eslint').Rule.RuleModule} */
+const noEntityImportsInControllersRule = {
+  meta: {
+    type: "problem",
+    docs: {
+      description: "Controller dürfen keine Entities importieren, nur DTOs verwenden",
+      category: "Architecture",
+      recommended: true,
+    },
+    hasSuggestions: true,
+    schema: [],
+    messages: {
+      noEntityImport: "Controller dürfen keine Entities importieren. Verwende stattdessen DTOs: '{{entityPath}}'",
+      useDto: "Ersetze den Entity-Import durch den entsprechenden DTO aus @/dto/",
+    },
+  },
+  create(context) {
+    const controllerFiles = /Controller\.ts$/;
+    const filename = context.getFilename();
+    const isControllerFile = controllerFiles.test(filename) &&
+                            !/BaseController\.ts$/.test(filename) &&
+                            filename.includes("/controller/");
+
+    if (!isControllerFile) return {};
+
+    return {
+      ImportDeclaration(node) {
+        const importPath = node.source.value;
+
+        // Prüfe auf Imports aus @/entity
+        if (typeof importPath === 'string' && importPath.startsWith('@/entity')) {
+          context.report({
+            node,
+            messageId: "noEntityImport",
+            data: {
+              entityPath: importPath,
+            },
+            suggest: [
+              {
+                desc: "Verwende stattdessen einen DTO aus @/dto/",
+                fix(fixer) {
+                  // Extrahiere den Entity-Namen und schlage DTO-Import vor
+                  const entityName = importPath.split('/').pop();
+                  const dtoPath = importPath.replace('@/entity', '@/dto');
+                  const suggestedDtoPath = dtoPath.replace(/Entity$/, 'Dto');
+
+                  return fixer.replaceText(
+                    node.source,
+                    `"${suggestedDtoPath}"`
+                  );
+                },
+              },
+            ],
+          });
+          return; // Verhindert doppelte Meldungen
+        }
+
+        // Prüfe auch auf relative Imports zu Entities (nur wenn nicht bereits @/entity gefunden)
+        if (typeof importPath === 'string' &&
+            (importPath.includes('../entity/') ||
+             importPath.includes('./entity/'))) {
+          context.report({
+            node,
+            messageId: "noEntityImport",
+            data: {
+              entityPath: importPath,
+            },
+          });
+        }
+      },
+
+      // Prüfe auch auf dynamische Imports
+      ImportExpression(node) {
+        if (node.source.type === 'Literal') {
+          const importPath = node.source.value;
+
+          if (typeof importPath === 'string' && importPath.startsWith('@/entity')) {
+            context.report({
+              node,
+              messageId: "noEntityImport",
+              data: {
+                entityPath: importPath,
+              },
+            });
+          }
+        }
+      },
+    };
+  },
+};
+
+export default {
+  rules: {
+    "no-entity-imports-in-controllers": noEntityImportsInControllersRule,
+  },
+};

package/rules/no-entity-in-swagger-docs.js

@@ -0,0 +1,139 @@
+export default {
+  meta: {
+    type: "problem",
+    docs: {
+      description: "Prevent usage of Entity references in Swagger documentation",
+      category: "Best Practices",
+      recommended: true,
+    },
+    fixable: null,
+    schema: [],
+    messages: {
+      entityInSwaggerSchema: "Swagger schema reference '{{reference}}' should use DTO instead of Entity. Replace '{{entityName}}' with '{{dtoName}}'",
+      entityInApiProperty: "ApiProperty type '{{type}}' should use DTO instead of Entity. Replace '{{entityName}}' with '{{dtoName}}'",
+      entityInApiBody: "ApiBody type '{{type}}' should use DTO instead of Entity. Replace '{{entityName}}' with '{{dtoName}}'",
+    },
+  },
+  create(context) {
+    const entityPattern = /Entity$/;
+    const dtoPattern = /Dto$/;
+
+    function getEntityName(reference) {
+      const match = reference.match(/#\/components\/schemas\/(.+)/);
+      return match ? match[1] : reference;
+    }
+
+    function getDtoName(entityName) {
+      return entityName.replace(/Entity$/, "Dto");
+    }
+
+    function checkStringLiteral(node, messageId) {
+      if (node.type === "Literal" && typeof node.value === "string") {
+        const value = node.value;
+
+        // Check for schema references like "#/components/schemas/AbilityEntity"
+        if (value.includes("#/components/schemas/") && value.includes("Entity")) {
+          const entityName = getEntityName(value);
+          if (entityPattern.test(entityName)) {
+            const dtoName = getDtoName(entityName);
+            context.report({
+              node,
+              messageId,
+              data: {
+                reference: value,
+                entityName,
+                dtoName,
+              },
+            });
+          }
+        }
+      }
+    }
+
+    function checkTypeReference(node, messageId) {
+      // Check for type references in ApiProperty, ApiBody decorators
+      if (node.type === "Identifier" && entityPattern.test(node.name)) {
+        const dtoName = getDtoName(node.name);
+        context.report({
+          node,
+          messageId,
+          data: {
+            type: node.name,
+            entityName: node.name,
+            dtoName,
+          },
+        });
+      }
+    }
+
+    function checkObjectExpression(node) {
+      if (node.type === "ObjectExpression") {
+        node.properties.forEach((prop) => {
+          if (prop.type === "Property") {
+            // Check schema references in object properties
+            if (prop.key && prop.key.name === "$ref") {
+              checkStringLiteral(prop.value, "entityInSwaggerSchema");
+            }
+
+            // Check items property in arrays
+            if (prop.key && prop.key.name === "items" && prop.value.type === "ObjectExpression") {
+              prop.value.properties.forEach((itemProp) => {
+                if (itemProp.key && itemProp.key.name === "$ref") {
+                  checkStringLiteral(itemProp.value, "entityInSwaggerSchema");
+                }
+              });
+            }
+          }
+        });
+      }
+    }
+
+    return {
+      Decorator(node) {
+        if (node.expression && node.expression.type === "CallExpression") {
+          const callee = node.expression.callee;
+
+          // Check ApiResponse, ApiBody, ApiProperty decorators
+          if (callee.type === "Identifier") {
+            const decoratorName = callee.name;
+
+            if (["ApiResponse", "ApiBody", "ApiProperty"].includes(decoratorName)) {
+              node.expression.arguments.forEach((arg) => {
+                if (arg.type === "ObjectExpression") {
+                  arg.properties.forEach((prop) => {
+                    if (prop.type === "Property") {
+                      // Check type property
+                      if (prop.key && prop.key.name === "type") {
+                        checkTypeReference(prop.value, "entityInApiProperty");
+                      }
+
+                      // Check schema property
+                      if (prop.key && prop.key.name === "schema") {
+                        checkObjectExpression(prop.value);
+                      }
+                    }
+                  });
+                }
+              });
+            }
+          }
+        }
+      },
+
+      // Check for $ref in any string literal
+      Literal(node) {
+        if (typeof node.value === "string" && node.value.includes("Entity")) {
+          const parent = node.parent;
+
+          // Check if this is in a swagger context
+          if (parent && parent.type === "Property" && parent.key) {
+            if (parent.key.name === "$ref" ||
+                (parent.key.type === "Literal" && parent.key.value === "$ref")) {
+              checkStringLiteral(node, "entityInSwaggerSchema");
+            }
+          }
+        }
+      },
+    };
+  },
+};