@echoes-of-order/eslint-config 1.121.0

package/rules/__tests__/integration-test-typeorm-naming-conventions.js

@@ -0,0 +1,501 @@
+#!/usr/bin/env node
+
+import { execSync } from 'child_process';
+import fs from 'fs';
+
+console.log('🧪 ESLint-Plugin Integrationstests für enforce-typeorm-naming-conventions Regel');
+console.log('====================================================================================');
+console.log('');
+
+// Test 1: Tabellennamen müssen snake_case sein
+console.log('📋 Test 1: @Entity - Tabellennamen müssen snake_case sein');
+console.log('----------------------------------------------------------');
+
+try {
+  const badEntityContent = `
+import {
+  Column,
+  Entity,
+  PrimaryGeneratedColumn,
+} from "typeorm";
+
+@Entity("UserProfileData")
+export default class UserEntity {
+  @PrimaryGeneratedColumn("uuid")
+  id: string;
+
+  @Column()
+  name: string;
+}`;
+
+  fs.writeFileSync('/app/backend/src/entity/BadTableNameEntity.ts', badEntityContent);
+
+  const result = execSync('cd /app/backend && yarn run eslint -c eslint.config.js src/entity/BadTableNameEntity.ts --no-color', {
+    encoding: 'utf8',
+    stdio: 'pipe'
+  });
+
+  console.log('❌ Unerwartet: Keine Fehler bei PascalCase-Tabellennamen gefunden');
+
+} catch (error) {
+  if (error.stdout && error.stdout.includes('enforce-typeorm-naming-conventions')) {
+    console.log('✅ Regel erkennt PascalCase-Tabellennamen korrekt:');
+    const errorLines = error.stdout.split('\n').filter(line =>
+      line.includes('enforce-typeorm-naming-conventions') || line.includes('tableNotSnakeCase')
+    );
+    errorLines.slice(0, 2).forEach(line => {
+      console.log('   ', line.trim());
+    });
+    console.log('   ✓ Vorschlag: "UserProfileData" → "user_profile_data"');
+  } else {
+    console.log('❌ Regel meldet keine Fehler bei PascalCase-Tabellennamen');
+  }
+}
+
+console.log('');
+
+// Test 2: Spaltennamen müssen explizit mit name-Parameter angegeben werden
+console.log('📋 Test 2: @Column - Spaltennamen müssen explizit angegeben werden');
+console.log('----------------------------------------------------------------');
+
+try {
+  const missingColumnNameContent = `
+import {
+  Column,
+  Entity,
+  PrimaryGeneratedColumn,
+} from "typeorm";
+
+@Entity("user_profile")
+export default class UserEntity {
+  @PrimaryGeneratedColumn("uuid")
+  id: string;
+
+  @Column({ type: "varchar" })
+  firstName: string;
+
+  @Column()
+  lastName: string;
+
+  @Column({ nullable: true })
+  middleName: string;
+}`;
+
+  fs.writeFileSync('/app/backend/src/entity/MissingColumnNameEntity.ts', missingColumnNameContent);
+
+  const result = execSync('cd /app/backend && yarn run eslint -c eslint.config.js src/entity/MissingColumnNameEntity.ts --no-color', {
+    encoding: 'utf8',
+    stdio: 'pipe'
+  });
+
+  console.log('❌ Unerwartet: Keine Fehler bei fehlenden Spaltennamen gefunden');
+
+} catch (error) {
+  if (error.stdout && error.stdout.includes('columnNameRequired')) {
+    console.log('✅ Regel erkennt fehlende Spaltennamen korrekt:');
+    const errorLines = error.stdout.split('\n').filter(line =>
+      line.includes('columnNameRequired')
+    );
+    console.log(`   - ${errorLines.length} Fehler gefunden (erwartet: 4 - id, firstName, lastName, middleName)`);
+    errorLines.slice(0, 3).forEach(line => {
+      console.log('   ', line.trim());
+    });
+  } else {
+    console.log('❌ Regel meldet keine Fehler bei fehlenden Spaltennamen');
+  }
+}
+
+console.log('');
+
+// Test 3: Spaltennamen müssen snake_case sein
+console.log('📋 Test 3: @Column - Spaltennamen müssen snake_case Format haben');
+console.log('----------------------------------------------------------------');
+
+try {
+  const wrongCaseColumnContent = `
+import {
+  Column,
+  Entity,
+  PrimaryGeneratedColumn,
+} from "typeorm";
+
+@Entity("user_profile")
+export default class UserEntity {
+  @PrimaryGeneratedColumn("uuid", { name: "userId" })
+  id: string;
+
+  @Column({ type: "varchar", name: "FirstName" })
+  firstName: string;
+
+  @Column({ name: "LastName" })
+  lastName: string;
+}`;
+
+  fs.writeFileSync('/app/backend/src/entity/WrongCaseColumnEntity.ts', wrongCaseColumnContent);
+
+  const result = execSync('cd /app/backend && yarn run eslint -c eslint.config.js src/entity/WrongCaseColumnEntity.ts --no-color', {
+    encoding: 'utf8',
+    stdio: 'pipe'
+  });
+
+  console.log('❌ Unerwartet: Keine Fehler bei falschen Spaltennamen gefunden');
+
+} catch (error) {
+  if (error.stdout && error.stdout.includes('columnNotSnakeCase')) {
+    console.log('✅ Regel erkennt falsche Spaltennamen-Formate korrekt:');
+    const errorLines = error.stdout.split('\n').filter(line =>
+      line.includes('columnNotSnakeCase')
+    );
+    console.log(`   - ${errorLines.length} Fehler gefunden (erwartet: 3)`);
+    errorLines.slice(0, 3).forEach(line => {
+      console.log('   ', line.trim());
+    });
+    console.log('   ✓ "userId" → "id"');
+    console.log('   ✓ "FirstName" → "first_name"');
+    console.log('   ✓ "LastName" → "last_name"');
+  } else {
+    console.log('❌ Regel meldet keine Fehler bei falschen Spaltennamen');
+  }
+}
+
+console.log('');
+
+// Test 4: JoinColumn Decorator für Relationen
+console.log('📋 Test 4: @JoinColumn - Relation-Spalten müssen explizit angegeben werden');
+console.log('----------------------------------------------------------------------------');
+
+try {
+  const joinColumnContent = `
+import {
+  Column,
+  Entity,
+  JoinColumn,
+  ManyToOne,
+  PrimaryGeneratedColumn,
+} from "typeorm";
+import AreaEntity from "@/entity/Eoo/World/AreaEntity";
+
+@Entity("monster")
+export default class MonsterEntity {
+  @PrimaryGeneratedColumn("uuid", { name: "id" })
+  id: string;
+
+  @ManyToOne(() => AreaEntity)
+  @JoinColumn()
+  area: AreaEntity;
+
+  @ManyToOne(() => AreaEntity)
+  @JoinColumn({ referencedColumnName: "id" })
+  spawnArea: AreaEntity;
+}`;
+
+  fs.writeFileSync('/app/backend/src/entity/JoinColumnTestEntity.ts', joinColumnContent);
+
+  const result = execSync('cd /app/backend && yarn run eslint -c eslint.config.js src/entity/JoinColumnTestEntity.ts --no-color', {
+    encoding: 'utf8',
+    stdio: 'pipe'
+  });
+
+  console.log('❌ Unerwartet: Keine Fehler bei fehlenden JoinColumn-Namen gefunden');
+
+} catch (error) {
+  if (error.stdout && error.stdout.includes('relationColumnRequired')) {
+    console.log('✅ Regel erkennt fehlende JoinColumn-Namen korrekt:');
+    const errorLines = error.stdout.split('\n').filter(line =>
+      line.includes('relationColumnRequired')
+    );
+    console.log(`   - ${errorLines.length} Fehler gefunden (erwartet: 2)`);
+    errorLines.slice(0, 2).forEach(line => {
+      console.log('   ', line.trim());
+    });
+    console.log('   ✓ Vorschlag für "area": name: "area_id"');
+    console.log('   ✓ Vorschlag für "spawnArea": name: "spawn_area_id"');
+  } else {
+    console.log('❌ Regel meldet keine Fehler bei fehlenden JoinColumn-Namen');
+  }
+}
+
+console.log('');
+
+// Test 5: Korrekte Entity sollte keine Fehler verursachen
+console.log('📋 Test 5: Korrekte Entity - Keine Fehler bei korrekter Verwendung');
+console.log('----------------------------------------------------------------------');
+
+try {
+  const correctEntityContent = `
+import {
+  Column,
+  CreateDateColumn,
+  Entity,
+  JoinColumn,
+  ManyToOne,
+  PrimaryGeneratedColumn,
+  UpdateDateColumn,
+} from "typeorm";
+import AreaEntity from "@/entity/Eoo/World/AreaEntity";
+
+@Entity("character_stats")
+export default class CharacterStatsEntity {
+  @PrimaryGeneratedColumn("uuid", { name: "id" })
+  id: string;
+
+  @Column({ type: "varchar", name: "character_name" })
+  characterName: string;
+
+  @Column({ type: "int", name: "level" })
+  level: number;
+
+  @Column({ type: "int", name: "experience_points" })
+  experiencePoints: number;
+
+  @ManyToOne(() => AreaEntity)
+  @JoinColumn({ name: "current_area_id" })
+  currentArea: AreaEntity;
+
+  @CreateDateColumn({ name: "created_at" })
+  createdAt: Date;
+
+  @UpdateDateColumn({ name: "updated_at" })
+  updatedAt: Date;
+}`;
+
+  fs.writeFileSync('/app/backend/src/entity/CorrectEntity.ts', correctEntityContent);
+
+  const result = execSync('cd /app/backend && yarn run eslint -c eslint.config.js src/entity/CorrectEntity.ts --no-color', {
+    encoding: 'utf8',
+    stdio: 'pipe'
+  });
+
+  console.log('✅ Korrekte Entity: Keine Fehler bei korrekter Verwendung');
+  console.log('   ✓ Tabellenname im snake_case: "character_stats"');
+  console.log('   ✓ Alle Spalten haben explizite snake_case Namen');
+  console.log('   ✓ JoinColumn hat expliziten Namen: "current_area_id"');
+
+} catch (error) {
+  if (error.stdout && error.stdout.includes('enforce-typeorm-naming-conventions')) {
+    console.log('❌ Korrekte Entity meldet False Positives:');
+    const errorLines = error.stdout.split('\n').filter(line =>
+      line.includes('enforce-typeorm-naming-conventions')
+    );
+    errorLines.slice(0, 3).forEach(line => {
+      console.log('   ', line.trim());
+    });
+  } else {
+    console.log('✅ Korrekte Entity: Keine Fehler');
+  }
+}
+
+console.log('');
+
+// Test 6: Auto-Fix Funktionalität
+console.log('📋 Test 6: Auto-Fix - Automatische Korrektur der Naming Conventions');
+console.log('---------------------------------------------------------------------');
+
+try {
+  const autoFixContent = `
+import {
+  Column,
+  Entity,
+  PrimaryGeneratedColumn,
+} from "typeorm";
+
+@Entity("UserAccount")
+export default class UserEntity {
+  @PrimaryGeneratedColumn("uuid")
+  id: string;
+
+  @Column({ type: "varchar" })
+  firstName: string;
+
+  @Column({ type: "varchar", name: "LastName" })
+  lastName: string;
+}`;
+
+  fs.writeFileSync('/app/backend/src/entity/AutoFixTestEntity.ts', autoFixContent);
+
+  // Führe Auto-Fix aus
+  execSync('cd /app/backend && yarn run eslint -c eslint.config.js src/entity/AutoFixTestEntity.ts --fix --no-color', {
+    encoding: 'utf8',
+    stdio: 'pipe'
+  });
+
+  // Lese korrigierte Datei
+  const fixedContent = fs.readFileSync('/app/backend/src/entity/AutoFixTestEntity.ts', 'utf8');
+
+  // Prüfe ob Korrekturen angewendet wurden
+  const hasSnakeCaseTable = fixedContent.includes('"user_account"');
+  const hasFirstNameColumn = fixedContent.includes('name: "first_name"') || fixedContent.includes("name: 'first_name'");
+  const hasLastNameColumn = fixedContent.includes('name: "last_name"') || fixedContent.includes("name: 'last_name'");
+  const hasIdColumn = fixedContent.includes('name: "id"') || fixedContent.includes("name: 'id'");
+
+  if (hasSnakeCaseTable && hasFirstNameColumn && hasLastNameColumn && hasIdColumn) {
+    console.log('✅ Auto-Fix funktioniert korrekt:');
+    console.log('   ✓ "UserAccount" → "user_account"');
+    console.log('   ✓ PrimaryGeneratedColumn erhielt: name: "id"');
+    console.log('   ✓ firstName Column erhielt: name: "first_name"');
+    console.log('   ✓ "LastName" → "last_name"');
+  } else {
+    console.log('❌ Auto-Fix nicht vollständig:');
+    if (!hasSnakeCaseTable) console.log('   ✗ Tabellenname nicht korrigiert');
+    if (!hasIdColumn) console.log('   ✗ ID-Spalte nicht korrigiert');
+    if (!hasFirstNameColumn) console.log('   ✗ firstName-Spalte nicht korrigiert');
+    if (!hasLastNameColumn) console.log('   ✗ lastName-Spalte nicht korrigiert');
+  }
+
+} catch (error) {
+  console.log('❌ Auto-Fix Fehler:', error.message);
+}
+
+console.log('');
+
+// Test 7: Verschiedene Decorator-Typen
+console.log('📋 Test 7: Verschiedene Decorator-Typen - CreateDateColumn, UpdateDateColumn, etc.');
+console.log('------------------------------------------------------------------------------------');
+
+try {
+  const decoratorTypesContent = `
+import {
+  Column,
+  CreateDateColumn,
+  DeleteDateColumn,
+  Entity,
+  PrimaryGeneratedColumn,
+  UpdateDateColumn,
+  VersionColumn,
+} from "typeorm";
+
+@Entity("audit_log")
+export default class AuditEntity {
+  @PrimaryGeneratedColumn("uuid")
+  id: string;
+
+  @Column({ type: "varchar" })
+  action: string;
+
+  @CreateDateColumn()
+  createdAt: Date;
+
+  @UpdateDateColumn()
+  updatedAt: Date;
+
+  @DeleteDateColumn()
+  deletedAt: Date;
+
+  @VersionColumn()
+  version: number;
+}`;
+
+  fs.writeFileSync('/app/backend/src/entity/DecoratorTypesTestEntity.ts', decoratorTypesContent);
+
+  const result = execSync('cd /app/backend && yarn run eslint -c eslint.config.js src/entity/DecoratorTypesTestEntity.ts --no-color', {
+    encoding: 'utf8',
+    stdio: 'pipe'
+  });
+
+  console.log('❌ Unerwartet: Keine Fehler bei fehlenden Namen in verschiedenen Decorators');
+
+} catch (error) {
+  if (error.stdout && error.stdout.includes('columnNameRequired')) {
+    console.log('✅ Regel erkennt alle Decorator-Typen korrekt:');
+    const errorLines = error.stdout.split('\n').filter(line =>
+      line.includes('columnNameRequired')
+    );
+    console.log(`   - ${errorLines.length} Fehler gefunden`);
+    console.log('   ✓ PrimaryGeneratedColumn benötigt name: "id"');
+    console.log('   ✓ Column benötigt name: "action"');
+    console.log('   ✓ CreateDateColumn benötigt name: "created_at"');
+    console.log('   ✓ UpdateDateColumn benötigt name: "updated_at"');
+    console.log('   ✓ DeleteDateColumn benötigt name: "deleted_at"');
+    console.log('   ✓ VersionColumn benötigt name: "version"');
+  } else {
+    console.log('❌ Regel erkennt nicht alle Decorator-Typen');
+  }
+}
+
+console.log('');
+
+// Test 8: Echte Entity-Datei testen
+console.log('📋 Test 8: Echte Entity - CharacterRefEquippedItemEntity.ts testen');
+console.log('---------------------------------------------------------------------');
+
+try {
+  const result = execSync('cd /app/backend && yarn run eslint -c eslint.config.js src/entity/Eoo/Profile/Character/CharacterRefEquippedItemEntity.ts --no-color', {
+    encoding: 'utf8',
+    stdio: 'pipe'
+  });
+
+  console.log('✅ CharacterRefEquippedItemEntity.ts: Keine Fehler');
+  console.log('   - Naming Conventions sind bereits korrekt');
+
+} catch (error) {
+  if (error.stdout && error.stdout.includes('enforce-typeorm-naming-conventions')) {
+    console.log('❌ CharacterRefEquippedItemEntity.ts hat Naming Convention Fehler:');
+    const errorLines = error.stdout.split('\n').filter(line =>
+      line.includes('enforce-typeorm-naming-conventions') ||
+      line.includes('tableNotSnakeCase') ||
+      line.includes('columnNameRequired') ||
+      line.includes('columnNotSnakeCase')
+    );
+    console.log(`   - ${errorLines.length} Fehler gefunden`);
+    errorLines.slice(0, 5).forEach(line => {
+      console.log('   ', line.trim());
+    });
+  } else {
+    console.log('✅ CharacterRefEquippedItemEntity.ts: Keine Naming Convention Fehler');
+  }
+}
+
+console.log('');
+
+// Cleanup
+console.log('🧹 Cleanup - Entferne Test-Dateien');
+console.log('------------------------------------');
+
+const testFiles = [
+  '/app/backend/src/entity/BadTableNameEntity.ts',
+  '/app/backend/src/entity/MissingColumnNameEntity.ts',
+  '/app/backend/src/entity/WrongCaseColumnEntity.ts',
+  '/app/backend/src/entity/JoinColumnTestEntity.ts',
+  '/app/backend/src/entity/CorrectEntity.ts',
+  '/app/backend/src/entity/AutoFixTestEntity.ts',
+  '/app/backend/src/entity/DecoratorTypesTestEntity.ts',
+];
+
+let cleanedCount = 0;
+testFiles.forEach(file => {
+  try {
+    fs.unlinkSync(file);
+    cleanedCount++;
+  } catch (cleanupError) {
+    // Datei existiert möglicherweise nicht
+  }
+});
+
+console.log(`✅ ${cleanedCount} Test-Dateien erfolgreich entfernt`);
+
+console.log('');
+console.log('🎯 Integrationstest für enforce-typeorm-naming-conventions Regel abgeschlossen');
+console.log('===================================================================================');
+console.log('');
+console.log('📊 Test-Zusammenfassung:');
+console.log('  ✓ Test 1: Tabellennamen snake_case Validierung');
+console.log('  ✓ Test 2: Explizite Spaltennamen-Anforderung');
+console.log('  ✓ Test 3: Spaltennamen snake_case Validierung');
+console.log('  ✓ Test 4: JoinColumn Validierung');
+console.log('  ✓ Test 5: Korrekte Entity ohne Fehler');
+console.log('  ✓ Test 6: Auto-Fix Funktionalität');
+console.log('  ✓ Test 7: Verschiedene Decorator-Typen');
+console.log('  ✓ Test 8: Echte Entity-Datei');
+
+
+
+
+
+
+
+
+
+
+
+
+

package/rules/__tests__/test-config.js

@@ -0,0 +1,33 @@
+import typescriptParser from '@typescript-eslint/parser';
+import { RuleTester } from 'eslint';
+
+// Standard-Konfiguration für alle Tests
+export const createRuleTester = (options = {}) => {
+  return new RuleTester({
+    languageOptions: {
+      ecmaVersion: 2024,
+      sourceType: 'module',
+      parser: typescriptParser,
+      parserOptions: {
+        ecmaFeatures: {
+          experimentalDecorators: true,
+        },
+        project: './tsconfig.json',
+      },
+    },
+    ...options,
+  });
+};
+
+// Vereinfachte Konfiguration für Tests ohne TypeScript
+export const createSimpleRuleTester = (options = {}) => {
+  return new RuleTester({
+    languageOptions: {
+      ecmaVersion: 2024,
+      sourceType: 'module',
+    },
+    ...options,
+  });
+};
+
+export default createRuleTester;