@echoes-of-order/eslint-config 1.121.0

package/rules/no-entity-type-casting.js

@@ -0,0 +1,104 @@
+/**
+ * @fileoverview Verbot von Type-Casting für Entity-Assignments
+ * @author Echoes of Order Team
+ */
+
+export default {
+  meta: {
+    type: "problem",
+    docs: {
+      description: "Verbot von Type-Casting für Entity-Assignments. Verwende echte DB-Lookups statt { id: value } as EntityType",
+      category: "Best Practices",
+      recommended: true,
+    },
+    fixable: null,
+    schema: [],
+    messages: {
+      noEntityTypeCasting: "Type-Casting für Entity-Assignments ist verboten. Verwende echte DB-Lookups statt '{{ pattern }}' als '{{ entityType }}'",
+      suggestDbLookup: "Verwende stattdessen: const entity = await this.getEntityById(id); assignment.entity = entity;",
+    },
+  },
+
+  create(context) {
+    return {
+      // Erkennt Assignment-Expressions mit Type-Casting
+      AssignmentExpression(node) {
+        // Prüfe ob es ein Type-Casting ist
+        if (node.right.type === "TSAsExpression") {
+          const asExpression = node.right;
+          const objectExpression = asExpression.expression;
+          const entityType = asExpression.typeAnnotation;
+
+          // Prüfe ob es ein Object-Literal mit nur 'id' Property ist
+          if (objectExpression.type === "ObjectExpression" &&
+              objectExpression.properties.length === 1) {
+
+            const property = objectExpression.properties[0];
+
+            // Prüfe ob es eine 'id' Property ist
+            if (property.type === "Property" &&
+                property.key.type === "Identifier" &&
+                property.key.name === "id") {
+
+              // Prüfe ob der Type eine Entity ist (endet mit "Entity")
+              if (entityType.type === "TSTypeReference" &&
+                  entityType.typeName.type === "Identifier" &&
+                  entityType.typeName.name.endsWith("Entity")) {
+
+                const entityTypeName = entityType.typeName.name;
+                const pattern = `{ id: ${property.value.name || 'value'} }`;
+
+                context.report({
+                  node,
+                  messageId: "noEntityTypeCasting",
+                  data: {
+                    pattern,
+                    entityType: entityTypeName,
+                  },
+                });
+              }
+            }
+          }
+        }
+      },
+
+      // Erkennt auch Variable-Declarations mit Type-Casting
+      VariableDeclarator(node) {
+        if (node.init && node.init.type === "TSAsExpression") {
+          const asExpression = node.init;
+          const objectExpression = asExpression.expression;
+          const entityType = asExpression.typeAnnotation;
+
+          // Gleiche Logik wie bei AssignmentExpression
+          if (objectExpression.type === "ObjectExpression" &&
+              objectExpression.properties.length === 1) {
+
+            const property = objectExpression.properties[0];
+
+            if (property.type === "Property" &&
+                property.key.type === "Identifier" &&
+                property.key.name === "id") {
+
+              if (entityType.type === "TSTypeReference" &&
+                  entityType.typeName.type === "Identifier" &&
+                  entityType.typeName.name.endsWith("Entity")) {
+
+                const entityTypeName = entityType.typeName.name;
+                const pattern = `{ id: ${property.value.name || 'value'} }`;
+
+                context.report({
+                  node,
+                  messageId: "noEntityTypeCasting",
+                  data: {
+                    pattern,
+                    entityType: entityTypeName,
+                  },
+                });
+              }
+            }
+          }
+        }
+      },
+    };
+  },
+};

package/rules/no-fetch.js

@@ -0,0 +1,77 @@
+/**
+ * ESLint Custom Rule: no-fetch
+ *
+ * Verbietet die direkte Verwendung von fetch() und erzwingt die Nutzung
+ * des ApiClient aus @echoes-of-order/api-client.
+ *
+ * @see https://eslint.org/docs/developer-guide/working-with-rules
+ */
+
+export default {
+  meta: {
+    type: "problem",
+    docs: {
+      description: "Verbietet direkte fetch()-Aufrufe und erzwingt ApiClient-Nutzung",
+      category: "Best Practices",
+      recommended: true,
+    },
+    messages: {
+      noFetch: "Direkte Verwendung von fetch() ist nicht erlaubt. Verwende stattdessen den ApiClient aus @echoes-of-order/api-client oder erstelle einen Repository in /infrastructure/: " +
+              "import { ApiClient } from '@echoes-of-order/api-client'; " +
+              "const client = new ApiClient(); " +
+              "client.get/post/put/delete(url, options).",
+    },
+    schema: [],
+  },
+
+  create (context) {
+    return {
+      CallExpression (node) {
+        // Prüfe, ob es ein fetch()-Aufruf ist
+        if (
+          node.callee.type === "Identifier" &&
+          node.callee.name === "fetch"
+        ) {
+          const filename = context.getFilename();
+
+          // Ausnahmen: Api.ts und Test-Dateien
+          const isApiFile = filename.includes("/utilities/Api/Api.ts") ||
+                           filename.includes("\\utilities\\Api\\Api.ts");
+          const isTestFile = filename.match(/\.(test|spec)\.(ts|tsx)$/);
+
+          if (!isApiFile && !isTestFile) {
+            context.report({
+              node,
+              messageId: "noFetch",
+            });
+          }
+        }
+
+        // Prüfe auch window.fetch() und globalThis.fetch()
+        if (
+          node.callee.type === "MemberExpression" &&
+          node.callee.property.type === "Identifier" &&
+          node.callee.property.name === "fetch" &&
+          (
+            (node.callee.object.type === "Identifier" && node.callee.object.name === "window") ||
+            (node.callee.object.type === "Identifier" && node.callee.object.name === "globalThis")
+          )
+        ) {
+          const filename = context.getFilename();
+
+          const isApiFile = filename.includes("/utilities/Api/Api.ts") ||
+                           filename.includes("\\utilities\\Api\\Api.ts");
+          const isTestFile = filename.match(/\.(test|spec)\.(ts|tsx)$/);
+
+          if (!isApiFile && !isTestFile) {
+            context.report({
+              node,
+              messageId: "noFetch",
+            });
+          }
+        }
+      },
+    };
+  },
+};
+

package/rules/no-import-meta-env.js

@@ -0,0 +1,151 @@
+export default {
+  meta: {
+    type: "problem",
+    docs: {
+      description: "Forbid direct usage of import.meta.env, use ConfigProvider instead",
+      category: "Best Practices",
+      recommended: true,
+    },
+    fixable: "code",
+    schema: [],
+    messages: {
+      noImportMetaEnv: "Direct usage of import.meta.env is forbidden. Use ConfigProvider methods instead to ensure proper validation and error handling.",
+    },
+  },
+  create (context) {
+    let hasConfigProviderImport = false;
+
+    return {
+      ImportDeclaration (node) {
+        // Check if ConfigProvider is already imported
+        if (node.source.value.includes("ConfigProvider")) {
+          hasConfigProviderImport = true;
+        }
+      },
+
+      MemberExpression (node) {
+        if (
+          node.object &&
+          node.object.type === "MetaProperty" &&
+          node.object.meta &&
+          node.object.meta.name === "import" &&
+          node.object.property &&
+          node.object.property.name === "meta" &&
+          node.property &&
+          node.property.name === "env"
+        ) {
+          context.report({
+            node,
+            messageId: "noImportMetaEnv",
+            fix (fixer) {
+              const fixes = [];
+
+              // Add ConfigProvider import if not present
+              if (!hasConfigProviderImport) {
+                const program = context.getSourceCode().ast;
+                const lastImport = program.body.filter(n => n.type === "ImportDeclaration").slice(-1)[0] || null;
+
+                if (lastImport) {
+                  fixes.push(
+                    fixer.insertTextAfter(
+                      lastImport,
+                      '\nimport { ConfigProvider } from "@/config/ConfigProvider";'
+                    )
+                  );
+                } else {
+                  fixes.push(
+                    fixer.insertTextBeforeRange([0, 0], 'import { ConfigProvider } from "@/config/ConfigProvider";\n')
+                  );
+                }
+              }
+
+              // Check if this is accessing a specific environment variable
+              const parent = node.parent;
+              if (parent && parent.type === "MemberExpression" && parent.property) {
+                const rawName = parent.property.name || parent.property.value;
+                const toCamel = (name) => {
+                  const lower = String(name).toLowerCase();
+                  if (lower === "node_env") return "NodeEnv";
+                  if (lower === "db_host") return "DbHost";
+                  if (lower === "db_port") return "DbPort";
+                  if (lower === "db_timeout") return "DbTimeout";
+                  if (lower === "database_url" || lower === "db_url") return "DatabaseUrl";
+                  if (lower === "log_level") return "LogLevel";
+                  if (lower === "api_url") return "ApiUrl";
+                  if (lower === "secret_key") return "SecretKey";
+                  if (lower === "primary_db_url") return "PrimaryDbUrl";
+                  if (lower === "replica_db_url") return "ReplicaDbUrl";
+                  if (lower === "redis_url") return "RedisUrl";
+                  if (lower === "redis_ttl") return "RedisTtl";
+                  const parts = String(name).split(/[_-]+/);
+                  return parts.map((p, i) => i === 0 ? p.charAt(0).toUpperCase() + p.slice(1).toLowerCase() : p.charAt(0).toUpperCase() + p.slice(1).toLowerCase()).join("");
+                };
+                const envVarName = toCamel(rawName);
+                if (envVarName) {
+                  // Convert to ConfigProvider method call
+                  const methodName = `get${envVarName}`;
+                  fixes.push(fixer.replaceText(parent, `ConfigProvider.${methodName}()`));
+                } else {
+                  // Fallback: replace with generic ConfigProvider call
+                  fixes.push(fixer.replaceText(node, "ConfigProvider"));
+                }
+              } else {
+                // Replace the entire import.meta.env with ConfigProvider
+                fixes.push(fixer.replaceText(node, "ConfigProvider"));
+              }
+
+              return fixes;
+            },
+          });
+        }
+      },
+
+      CallExpression (node) {
+        if (
+          node.callee &&
+          node.callee.type === "MemberExpression" &&
+          node.callee.object &&
+          node.callee.object.type === "MetaProperty" &&
+          node.callee.object.meta &&
+          node.callee.object.meta.name === "import" &&
+          node.callee.object.property &&
+          node.callee.object.property.name === "meta" &&
+          node.callee.property &&
+          node.callee.property.name === "env"
+        ) {
+          context.report({
+            node,
+            messageId: "noImportMetaEnv",
+            fix (fixer) {
+              const fixes = [];
+
+              // Add ConfigProvider import if not present
+              if (!hasConfigProviderImport) {
+                const program = context.getSourceCode().ast;
+                const lastImport = program.body.filter(n => n.type === "ImportDeclaration").slice(-1)[0] || null;
+
+                if (lastImport) {
+                  fixes.push(
+                    fixer.insertTextAfter(
+                      lastImport,
+                      '\nimport { ConfigProvider } from "@/config/ConfigProvider";'
+                    )
+                  );
+                } else {
+                  fixes.push(
+                    fixer.insertTextBeforeRange([0, 0], 'import { ConfigProvider } from "@/config/ConfigProvider";\n')
+                  );
+                }
+              }
+
+              // Replace the call with ConfigProvider
+              fixes.push(fixer.replaceText(node.callee, "ConfigProvider"));
+
+              return fixes;
+            },
+          });
+        }
+      },
+    };
+  },
+};

package/rules/no-inline-styles.js

@@ -0,0 +1,5 @@
+export default {
+  rules: {
+    "no-inline-styles/no-inline-styles": "error",
+  },
+};

package/rules/no-magic-values.js

@@ -0,0 +1,85 @@
+export default {
+  rules: {
+    "no-magic-values": {
+          meta: {
+            type: "problem",
+            docs: {
+              description: "Disallow magic numbers and magic strings",
+              category: "Best Practices",
+              recommended: true,
+            },
+            messages: {
+              magicNumber: "Magic Number '{{value}}' found. Use a named constant instead.",
+              magicString: "Magic String '{{value}}' found. Use a named constant instead.",
+            },
+            schema: [
+              {
+                type: "object",
+                properties: {
+                  ignoreNumbers: {
+                    type: "array",
+                    items: { type: "number" },
+                    description: "Numbers to ignore (e.g., 0, 1, -1)",
+                    default: [0, 1, -1]
+                  },
+                  ignoreStrings: {
+                    type: "array",
+                    items: { type: "string" },
+                    description: "Strings to ignore (e.g., empty string)",
+                    default: [""]
+                  }
+                },
+                additionalProperties: false
+              }
+            ]
+          },
+
+      create(context) {
+        const options = context.options[0] || {};
+        const ignoreNumbers = options.ignoreNumbers || [0, 1, -1];
+        const ignoreStrings = options.ignoreStrings || [""];
+
+        function checkLiteral(node) {
+          if (node.type === "Literal") {
+            // Skip if it's inside a variable declaration (constant definition)
+            if (node.parent && node.parent.type === "VariableDeclarator") {
+              return;
+            }
+
+            if (typeof node.value === "number") {
+              // Ignore configured numbers
+              if (ignoreNumbers.includes(node.value)) {
+                return;
+              }
+
+              context.report({
+                node,
+                messageId: "magicNumber",
+                data: {
+                  value: node.value,
+                },
+              });
+            } else if (typeof node.value === "string") {
+              // Ignore configured strings
+              if (ignoreStrings.includes(node.value)) {
+                return;
+              }
+
+              context.report({
+                node,
+                messageId: "magicString",
+                data: {
+                  value: node.value,
+                },
+              });
+            }
+          }
+        }
+
+        return {
+          Literal: checkLiteral,
+        };
+      },
+    },
+  },
+};

package/rules/no-partial-type.js

@@ -0,0 +1,168 @@
+const noPartialTypeRule = {
+  meta: {
+    type: "problem",
+    docs: {
+      description: "Verbietet die Verwendung von Partial<T> Utility Type",
+      category: "Type Safety",
+      recommended: true,
+    },
+    schema: [],
+    messages: {
+      noPartialType: "Partial<T> ist verboten. Verwende stattdessen explizite optionale Properties oder separate DTOs für Update-Operationen.",
+      noPartialTypeInParameter: "Partial<T> in Funktionsparametern ist verboten. Definiere ein explizites Update-DTO mit nur den benötigten Properties.",
+      noPartialTypeInReturnType: "Partial<T> in Rückgabetypen ist verboten. Verwende vollständig typisierte DTOs.",
+      noPartialTypeInProperty: "Partial<T> in Property-Definitionen ist verboten. Definiere Properties explizit als optional.",
+    },
+  },
+  create(context) {
+    const checkTypeAnnotation = (node, messageId) => {
+      if (!node.typeAnnotation) return;
+
+      const typeAnnotation = node.typeAnnotation.typeAnnotation || node.typeAnnotation;
+
+      // Prüfe auf Partial<T>
+      if (
+        typeAnnotation.type === "TSTypeReference" &&
+        typeAnnotation.typeName &&
+        typeAnnotation.typeName.name === "Partial"
+      ) {
+        context.report({
+          node: typeAnnotation,
+          messageId: messageId || "noPartialType",
+        });
+      }
+
+      // Prüfe auf Partial in Union Types (z.B. SomeType | Partial<OtherType>)
+      if (typeAnnotation.type === "TSUnionType") {
+        typeAnnotation.types.forEach((type) => {
+          if (
+            type.type === "TSTypeReference" &&
+            type.typeName &&
+            type.typeName.name === "Partial"
+          ) {
+            context.report({
+              node: type,
+              messageId: messageId || "noPartialType",
+            });
+          }
+        });
+      }
+
+      // Prüfe auf Partial in Intersection Types (z.B. SomeType & Partial<OtherType>)
+      if (typeAnnotation.type === "TSIntersectionType") {
+        typeAnnotation.types.forEach((type) => {
+          if (
+            type.type === "TSTypeReference" &&
+            type.typeName &&
+            type.typeName.name === "Partial"
+          ) {
+            context.report({
+              node: type,
+              messageId: messageId || "noPartialType",
+            });
+          }
+        });
+      }
+    };
+
+    return {
+      // Prüfe Funktionsparameter
+      "FunctionDeclaration > :matches(Identifier, RestElement)"(node) {
+        checkTypeAnnotation(node, "noPartialTypeInParameter");
+      },
+
+      // Prüfe Arrow Function Parameter
+      "ArrowFunctionExpression > :matches(Identifier, RestElement)"(node) {
+        checkTypeAnnotation(node, "noPartialTypeInParameter");
+      },
+
+      // Prüfe Methoden-Parameter
+      "MethodDefinition > FunctionExpression > :matches(Identifier, RestElement)"(node) {
+        checkTypeAnnotation(node, "noPartialTypeInParameter");
+      },
+
+      // Prüfe Rückgabetypen von Funktionen
+      "FunctionDeclaration[returnType]"(node) {
+        if (node.returnType) {
+          const returnTypeAnnotation = node.returnType.typeAnnotation;
+          if (
+            returnTypeAnnotation.type === "TSTypeReference" &&
+            returnTypeAnnotation.typeName &&
+            returnTypeAnnotation.typeName.name === "Partial"
+          ) {
+            context.report({
+              node: returnTypeAnnotation,
+              messageId: "noPartialTypeInReturnType",
+            });
+          }
+        }
+      },
+
+      // Prüfe Rückgabetypen von Arrow Functions
+      "ArrowFunctionExpression[returnType]"(node) {
+        if (node.returnType) {
+          const returnTypeAnnotation = node.returnType.typeAnnotation;
+          if (
+            returnTypeAnnotation.type === "TSTypeReference" &&
+            returnTypeAnnotation.typeName &&
+            returnTypeAnnotation.typeName.name === "Partial"
+          ) {
+            context.report({
+              node: returnTypeAnnotation,
+              messageId: "noPartialTypeInReturnType",
+            });
+          }
+        }
+      },
+
+      // Prüfe Rückgabetypen von Methoden
+      "MethodDefinition[returnType]"(node) {
+        if (node.returnType) {
+          const returnTypeAnnotation = node.returnType.typeAnnotation;
+          if (
+            returnTypeAnnotation.type === "TSTypeReference" &&
+            returnTypeAnnotation.typeName &&
+            returnTypeAnnotation.typeName.name === "Partial"
+          ) {
+            context.report({
+              node: returnTypeAnnotation,
+              messageId: "noPartialTypeInReturnType",
+            });
+          }
+        }
+      },
+
+      // Prüfe Class Properties
+      "PropertyDefinition[typeAnnotation]"(node) {
+        checkTypeAnnotation(node, "noPartialTypeInProperty");
+      },
+
+      // Prüfe Variable Declarations
+      "VariableDeclarator > Identifier[typeAnnotation]"(node) {
+        checkTypeAnnotation(node, "noPartialType");
+      },
+
+      // Prüfe Type Aliases
+      "TSTypeAliasDeclaration"(node) {
+        if (
+          node.typeAnnotation.type === "TSTypeReference" &&
+          node.typeAnnotation.typeName &&
+          node.typeAnnotation.typeName.name === "Partial"
+        ) {
+          context.report({
+            node: node.typeAnnotation,
+            messageId: "noPartialType",
+          });
+        }
+      },
+    };
+  },
+};
+
+export default {
+  rules: {
+    "no-partial-type": noPartialTypeRule,
+  },
+};
+
+

package/rules/no-relative-imports.js

@@ -0,0 +1,31 @@
+export default {
+  meta: {
+    type: "problem",
+    docs: {
+      description: "Disallow relative imports with parent directory references",
+      category: "Best Practices",
+      recommended: true,
+    },
+    fixable: null,
+    schema: [],
+    messages: {
+      noRelativeImport: "Relative imports with parent directory references (../) are not allowed. Use absolute imports with @/ prefix instead.",
+    },
+  },
+
+  create(context) {
+    return {
+      ImportDeclaration(node) {
+        const source = node.source.value;
+
+        // Check if the import path contains parent directory references
+        if (typeof source === "string" && source.includes("../")) {
+          context.report({
+            node: node.source,
+            messageId: "noRelativeImport",
+          });
+        }
+      },
+    };
+  },
+};