@echoes-of-order/eslint-config 1.121.0

package/rules/enforce-translations-required.js

@@ -0,0 +1,203 @@
+export default {
+  meta: {
+    type: "problem",
+    docs: {
+      description: "Enforce that translations field is always required XxxTranslation*[] array (e.g., ItemTranslationEntityDto[]) - never optional, nullable, or non-Translation type",
+      category: "Best Practices",
+      recommended: true,
+    },
+    messages: {
+      translationsOptional: "Field 'translations' must not be optional. Translations are mandatory - use empty array (e.g., ItemTranslationEntityDto[]) instead of undefined.",
+      translationsNullable: "Field 'translations' must not be nullable. Translations are mandatory - use empty array (e.g., ItemTranslationEntityDto[]) instead of null.",
+      translationsMissingRequired: "Field 'translations' must be required. Remove @IsOptional decorator - translations are mandatory.",
+      translationsWrongType: "Field 'translations' must be of type XxxTranslation*[] (e.g., ItemTranslationEntityDto[], CharacterTranslationDto[]), not '{{actualType}}'. Type name must contain 'Translation'.",
+    },
+    schema: [],
+  },
+  create (context) {
+    // Helper function to check if a type is *Translation* array (e.g., ItemTranslationEntityDto[], CharacterTranslationDto[])
+    function isTranslationType(typeAnnotation) {
+      if (!typeAnnotation) return false;
+
+      const type = typeAnnotation.typeAnnotation || typeAnnotation;
+
+      // Check for XxxTranslation*[] array (e.g., ItemTranslationEntityDto[])
+      if (type.type === "TSArrayType" &&
+          type.elementType &&
+          type.elementType.type === "TSTypeReference" &&
+          type.elementType.typeName &&
+          type.elementType.typeName.type === "Identifier" &&
+          type.elementType.typeName.name.includes("Translation")) {
+        return true;
+      }
+
+      // Check for Array<XxxTranslation*> (e.g., Array<ItemTranslationEntityDto>)
+      if (type.type === "TSTypeReference" &&
+          type.typeName &&
+          type.typeName.type === "Identifier" &&
+          type.typeName.name === "Array" &&
+          type.typeParameters &&
+          type.typeParameters.params &&
+          type.typeParameters.params.length === 1 &&
+          type.typeParameters.params[0].type === "TSTypeReference" &&
+          type.typeParameters.params[0].typeName &&
+          type.typeParameters.params[0].typeName.type === "Identifier" &&
+          type.typeParameters.params[0].typeName.name.includes("Translation")) {
+        return true;
+      }
+
+      return false;
+    }
+
+    // Helper function to get type name for error messages
+    function getTypeName(typeAnnotation) {
+      if (!typeAnnotation) return "unknown";
+
+      const type = typeAnnotation.typeAnnotation || typeAnnotation;
+
+      if (type.type === "TSTypeReference" && type.typeName) {
+        return type.typeName.name || "unknown";
+      }
+
+      if (type.type === "TSArrayType") {
+        return "Array";
+      }
+
+      return type.type || "unknown";
+    }
+
+    return {
+      PropertyDefinition (node) {
+        if (node.key.type !== "Identifier" || node.key.name !== "translations") {
+          return;
+        }
+
+        const isOptional = node.optional === true;
+        if (isOptional) {
+          context.report({
+            node,
+            messageId: "translationsOptional",
+          });
+
+          return;
+        }
+
+        if (node.typeAnnotation && node.typeAnnotation.typeAnnotation) {
+          const typeAnnotation = node.typeAnnotation.typeAnnotation;
+
+          if (typeAnnotation.type === "TSUnionType") {
+            const hasNull = typeAnnotation.types.some((t) => t.type === "TSNullKeyword");
+            const hasUndefined = typeAnnotation.types.some((t) => t.type === "TSUndefinedKeyword");
+
+            if (hasNull) {
+              context.report({
+                node,
+                messageId: "translationsNullable",
+              });
+            }
+
+            if (hasUndefined) {
+              context.report({
+                node,
+                messageId: "translationsOptional",
+              });
+            }
+          }
+
+          // Check if type is Translation or Translation[]
+          if (!isTranslationType(node.typeAnnotation)) {
+            context.report({
+              node,
+              messageId: "translationsWrongType",
+              data: {
+                actualType: getTypeName(node.typeAnnotation)
+              },
+            });
+          }
+        }
+
+        const decorators = node.decorators || [];
+        const hasIsOptional = decorators.some((decorator) => {
+          if (decorator.expression.type === "CallExpression") {
+            return decorator.expression.callee.name === "IsOptional";
+          }
+
+          return false;
+        });
+
+        if (hasIsOptional) {
+          context.report({
+            node,
+            messageId: "translationsMissingRequired",
+          });
+        }
+      },
+      ClassProperty (node) {
+        if (node.key.type !== "Identifier" || node.key.name !== "translations") {
+          return;
+        }
+
+        const isOptional = node.optional === true;
+        if (isOptional) {
+          context.report({
+            node,
+            messageId: "translationsOptional",
+          });
+
+          return;
+        }
+
+        if (node.typeAnnotation && node.typeAnnotation.typeAnnotation) {
+          const typeAnnotation = node.typeAnnotation.typeAnnotation;
+
+          if (typeAnnotation.type === "TSUnionType") {
+            const hasNull = typeAnnotation.types.some((t) => t.type === "TSNullKeyword");
+            const hasUndefined = typeAnnotation.types.some((t) => t.type === "TSUndefinedKeyword");
+
+            if (hasNull) {
+              context.report({
+                node,
+                messageId: "translationsNullable",
+              });
+            }
+
+            if (hasUndefined) {
+              context.report({
+                node,
+                messageId: "translationsOptional",
+              });
+            }
+          }
+
+          // Check if type is Translation or Translation[]
+          if (!isTranslationType(node.typeAnnotation)) {
+            context.report({
+              node,
+              messageId: "translationsWrongType",
+              data: {
+                actualType: getTypeName(node.typeAnnotation)
+              },
+            });
+          }
+        }
+
+        const decorators = node.decorators || [];
+        const hasIsOptional = decorators.some((decorator) => {
+          if (decorator.expression.type === "CallExpression") {
+            return decorator.expression.callee.name === "IsOptional";
+          }
+
+          return false;
+        });
+
+        if (hasIsOptional) {
+          context.report({
+            node,
+            messageId: "translationsMissingRequired",
+          });
+        }
+      },
+    };
+  },
+};
+

package/rules/enforce-typeorm-naming-conventions.js

@@ -0,0 +1,366 @@
+/**
+ * @fileoverview TypeORM Naming Conventions Enforcement
+ * Stellt sicher, dass:
+ * 1. Tabellennamen im snake_case Format sind (@Entity)
+ * 2. Spaltennamen explizit im snake_case Format angegeben werden (@Column, @PrimaryGeneratedColumn, etc.)
+ */
+
+/**
+ * Konvertiert PascalCase/camelCase zu snake_case
+ */
+function toSnakeCase(str) {
+  return str
+    .replace(/([A-Z])/g, "_$1")
+    .toLowerCase()
+    .replace(/^_/, "");
+}
+
+/**
+ * Prüft ob ein String im snake_case Format ist
+ */
+function isSnakeCase(str) {
+  return /^[a-z][a-z0-9]*(_[a-z0-9]+)*$/.test(str);
+}
+
+/**
+ * Extrahiert den Tabellennamen aus @Entity Decorator
+ */
+function getEntityTableName(decorator) {
+  if (!decorator.expression.arguments || decorator.expression.arguments.length === 0) {
+    return null;
+  }
+
+  const firstArg = decorator.expression.arguments[0];
+
+  // @Entity("TableName")
+  if (firstArg.type === "Literal") {
+    return firstArg.value;
+  }
+
+  // @Entity({ name: "TableName" })
+  if (firstArg.type === "ObjectExpression") {
+    const nameProp = firstArg.properties.find(
+      prop => prop.key && prop.key.name === "name"
+    );
+    if (nameProp && nameProp.value.type === "Literal") {
+      return nameProp.value.value;
+    }
+  }
+
+  return null;
+}
+
+/**
+ * Extrahiert den Spaltennamen aus Column-Decorator
+ */
+function getColumnName(decorator) {
+  if (!decorator.expression.arguments || decorator.expression.arguments.length === 0) {
+    return null;
+  }
+
+  const firstArg = decorator.expression.arguments[0];
+
+  // @Column({ name: "column_name" })
+  if (firstArg.type === "ObjectExpression") {
+    const nameProp = firstArg.properties.find(
+      prop => prop.key && prop.key.name === "name"
+    );
+    if (nameProp && nameProp.value.type === "Literal") {
+      return nameProp.value.value;
+    }
+  }
+
+  // @PrimaryGeneratedColumn("uuid", { name: "column_name" })
+  if (firstArg.type === "Literal" && decorator.expression.arguments.length > 1) {
+    const secondArg = decorator.expression.arguments[1];
+    if (secondArg.type === "ObjectExpression") {
+      const nameProp = secondArg.properties.find(
+        prop => prop.key && prop.key.name === "name"
+      );
+      if (nameProp && nameProp.value.type === "Literal") {
+        return nameProp.value.value;
+      }
+    }
+  }
+
+  return null;
+}
+
+/**
+ * Prüft ob ein Decorator ein Column-Decorator ist
+ */
+function isColumnDecorator(decorator) {
+  const columnDecorators = [
+    "Column",
+    "PrimaryColumn",
+    "PrimaryGeneratedColumn",
+    "CreateDateColumn",
+    "UpdateDateColumn",
+    "DeleteDateColumn",
+    "VersionColumn",
+  ];
+
+  return columnDecorators.includes(decorator.expression.callee?.name);
+}
+
+/**
+ * Prüft ob ein Decorator ein Relation-Decorator ist
+ */
+function isRelationDecorator(decorator) {
+  const relationDecorators = [
+    "ManyToOne",
+    "OneToOne",
+    "OneToMany",
+    "ManyToMany",
+    "JoinColumn",
+    "JoinTable",
+  ];
+
+  return relationDecorators.includes(decorator.expression.callee?.name);
+}
+
+/** @type {import('eslint').Rule.RuleModule} */
+const enforceTypeormNamingConventionsRule = {
+  meta: {
+    type: "problem",
+    docs: {
+      description: "Enforce snake_case naming conventions for TypeORM table and column names",
+      category: "TypeORM",
+      recommended: true,
+    },
+    fixable: "code",
+    schema: [],
+    messages: {
+      tableNotSnakeCase: "Table name '{{tableName}}' must be in snake_case format. Use '{{suggestedName}}' instead.",
+      columnNameRequired: "Column '{{propertyName}}' must have an explicit 'name' parameter in snake_case format. Add: name: '{{suggestedName}}'",
+      columnNotSnakeCase: "Column name '{{columnName}}' for property '{{propertyName}}' must be in snake_case format. Use '{{suggestedName}}' instead.",
+      relationColumnRequired: "Relation column '{{propertyName}}' should have an explicit 'name' parameter in snake_case format if it maps to a database column.",
+    },
+  },
+
+  create(context) {
+    const filename = context.getFilename();
+    const isEntityFile = filename.includes("/entity/") && filename.endsWith(".ts") && !filename.includes("test");
+
+    if (!isEntityFile) return {};
+
+    const sourceCode = context.getSourceCode();
+
+    return {
+      /**
+       * Prüfe @Entity Decorator für Tabellennamen
+       */
+      ClassDeclaration(node) {
+        if (!node.decorators) return;
+
+        const entityDecorator = node.decorators.find(
+          decorator => decorator.expression.callee?.name === "Entity"
+        );
+
+        if (!entityDecorator) return;
+
+        const tableName = getEntityTableName(entityDecorator);
+
+        if (tableName && !isSnakeCase(tableName)) {
+          const suggestedName = toSnakeCase(tableName);
+
+          context.report({
+            node: entityDecorator,
+            messageId: "tableNotSnakeCase",
+            data: {
+              tableName,
+              suggestedName,
+            },
+            fix(fixer) {
+              // Ersetze den Tabellennamen im Decorator
+              const decoratorText = sourceCode.getText(entityDecorator.expression);
+
+              // Fall 1: @Entity("TableName")
+              if (decoratorText.includes(`"${tableName}"`)) {
+                const newText = decoratorText.replace(`"${tableName}"`, `"${suggestedName}"`);
+                return fixer.replaceText(entityDecorator.expression, newText);
+              }
+
+              // Fall 2: @Entity('TableName')
+              if (decoratorText.includes(`'${tableName}'`)) {
+                const newText = decoratorText.replace(`'${tableName}'`, `'${suggestedName}'`);
+                return fixer.replaceText(entityDecorator.expression, newText);
+              }
+
+              // Fall 3: @Entity({ name: "TableName" })
+              const newText = decoratorText.replace(
+                new RegExp(`name:\\s*["']${tableName}["']`),
+                `name: "${suggestedName}"`
+              );
+              return fixer.replaceText(entityDecorator.expression, newText);
+            },
+          });
+        }
+      },
+
+      /**
+       * Prüfe Column-Decorators für Spaltennamen
+       */
+      PropertyDefinition(node) {
+        if (!node.decorators || node.decorators.length === 0) return;
+
+        const propertyName = node.key.name;
+
+        // Prüfe alle Column-Decorators
+        node.decorators.forEach(decorator => {
+          if (isColumnDecorator(decorator)) {
+            const columnName = getColumnName(decorator);
+            const suggestedName = toSnakeCase(propertyName);
+
+            // Fall 1: Kein name-Parameter angegeben
+            if (!columnName) {
+              context.report({
+                node: decorator,
+                messageId: "columnNameRequired",
+                data: {
+                  propertyName,
+                  suggestedName,
+                },
+                fix(fixer) {
+                  const decoratorName = decorator.expression.callee.name;
+                  const decoratorText = sourceCode.getText(decorator.expression);
+
+                  // @Column() -> @Column({ name: "column_name" })
+                  if (!decorator.expression.arguments || decorator.expression.arguments.length === 0) {
+                    return fixer.replaceText(
+                      decorator.expression,
+                      `${decoratorName}({ name: "${suggestedName}" })`
+                    );
+                  }
+
+                  const firstArg = decorator.expression.arguments[0];
+
+                  // @PrimaryGeneratedColumn("uuid") -> @PrimaryGeneratedColumn("uuid", { name: "column_name" })
+                  if (firstArg.type === "Literal") {
+                    const typeValue = sourceCode.getText(firstArg);
+                    return fixer.replaceText(
+                      decorator.expression,
+                      `${decoratorName}(${typeValue}, { name: "${suggestedName}" })`
+                    );
+                  }
+
+                  // @Column({ type: "varchar" }) -> @Column({ name: "column_name", type: "varchar" })
+                  if (firstArg.type === "ObjectExpression") {
+                    const isMultiline = decoratorText.includes('\n');
+
+                    if (isMultiline) {
+                      // Mehrzeilig: Extrahiere Einrückung und füge name schön formatiert ein
+                      const lines = decoratorText.split('\n');
+                      const firstPropertyLine = lines.find(line => line.trim() && !line.trim().startsWith('{'));
+                      const indent = firstPropertyLine ? firstPropertyLine.match(/^\s*/)[0] : '    ';
+
+                      const newText = decoratorText.replace(
+                        /\{\s*\n?\s*/,
+                        `{\n${indent}name: "${suggestedName}",\n${indent}`
+                      );
+                      return fixer.replaceText(decorator.expression, newText);
+                    } else {
+                      // Einzeilig: Füge name am Anfang ein
+                      const newText = decoratorText.replace(
+                        /\{\s*/,
+                        `{ name: "${suggestedName}", `
+                      );
+                      return fixer.replaceText(decorator.expression, newText);
+                    }
+                  }
+
+                  return null;
+                },
+              });
+            }
+            // Fall 2: name-Parameter ist nicht im snake_case Format
+            else if (!isSnakeCase(columnName)) {
+              context.report({
+                node: decorator,
+                messageId: "columnNotSnakeCase",
+                data: {
+                  columnName,
+                  propertyName,
+                  suggestedName,
+                },
+                fix(fixer) {
+                  const decoratorText = sourceCode.getText(decorator.expression);
+                  const newText = decoratorText.replace(
+                    new RegExp(`name:\\s*["']${columnName}["']`),
+                    `name: "${suggestedName}"`
+                  );
+                  return fixer.replaceText(decorator.expression, newText);
+                },
+              });
+            }
+          }
+
+          // Prüfe auch JoinColumn in Relationen
+          if (decorator.expression.callee?.name === "JoinColumn") {
+            const columnName = getColumnName(decorator);
+            const suggestedName = toSnakeCase(propertyName) + "_id";
+
+            if (!columnName) {
+              context.report({
+                node: decorator,
+                messageId: "relationColumnRequired",
+                data: {
+                  propertyName,
+                  suggestedName,
+                },
+                fix(fixer) {
+                  const decoratorText = sourceCode.getText(decorator.expression);
+
+                  // @JoinColumn() -> @JoinColumn({ name: "property_name_id" })
+                  if (!decorator.expression.arguments || decorator.expression.arguments.length === 0) {
+                    return fixer.replaceText(
+                      decorator.expression,
+                      `JoinColumn({ name: "${suggestedName}" })`
+                    );
+                  }
+
+                  // @JoinColumn({ referencedColumnName: "id" }) -> @JoinColumn({ name: "property_name_id", referencedColumnName: "id" })
+                  const firstArg = decorator.expression.arguments[0];
+                  if (firstArg.type === "ObjectExpression") {
+                    const newText = decoratorText.replace(
+                      /\{\s*/,
+                      `{ name: "${suggestedName}", `
+                    );
+                    return fixer.replaceText(decorator.expression, newText);
+                  }
+
+                  return null;
+                },
+              });
+            } else if (!isSnakeCase(columnName)) {
+              context.report({
+                node: decorator,
+                messageId: "columnNotSnakeCase",
+                data: {
+                  columnName,
+                  propertyName,
+                  suggestedName,
+                },
+                fix(fixer) {
+                  const decoratorText = sourceCode.getText(decorator.expression);
+                  const newText = decoratorText.replace(
+                    new RegExp(`name:\\s*["']${columnName}["']`),
+                    `name: "${suggestedName}"`
+                  );
+                  return fixer.replaceText(decorator.expression, newText);
+                },
+              });
+            }
+          }
+        });
+      },
+    };
+  },
+};
+
+export default {
+  rules: {
+    "enforce-typeorm-naming-conventions": enforceTypeormNamingConventionsRule,
+  },
+};
+