@flusys/nestjs-core 1.0.0-beta → 1.0.0

package/fesm/seeders/cli.js

@@ -2,31 +2,16 @@
 /**
  * Seed CLI Entry Point
  *
- * Command-line interface for seed data generation.
- *
  * Commands:
- * - generate: Generate seeder template files
  * - run: Execute seeders for all entities
  * - run:all: Execute seeders for all tenants (multi-tenant mode)
  * - clear: Clear all seeded data
  * - status: Show seeding status
- *
- * Usage:
- * npm run seed:generate
- * npm run seed:run
- * npm run seed:run -- --count=50 --clear
- * npm run seed:clear
- * npm run seed:status
  */ import * as path from 'path';
 import { DataSource } from 'typeorm';
 import { envConfig } from '../config';
-import { EntityReader } from './entity-reader';
-import { TemplateGenerator } from './template-generator';
 import { SeedRunner } from './seed-runner';
-import { shouldSkipEntity } from './seed-config';
-/**
- * Show help message
- */ function showHelp() {
+function showHelp() {
     console.log(`
 Seed Data CLI
 
@@ -34,7 +19,6 @@ Usage:
   npm run seed:<command> [options]
 
 Commands:
-  generate             Generate seeder template files
   run                  Execute seeders for all entities
   run:all              Execute seeders for all tenants (multi-tenant mode)
   clear                Clear all seeded data
@@ -48,24 +32,17 @@ Options:
   --hard               Hard delete when clearing (ignore soft delete)
   --tenant=<id>        Target specific tenant (multi-tenant mode)
 
-Environment:
-  MIGRATION_CONFIG     Default config path (overrides auto-detection)
-
 Examples:
-  npm run seed:generate
   npm run seed:run
   npm run seed:run -- --count=50 --clear
   npm run seed:run -- --entity=User --count=100
-  npm run seed:run -- --config=src/persistence/migration.config.ts
   npm run seed:clear
   npm run seed:clear -- --hard
   npm run seed:status
   npm run seed:run:all
 `);
 }
-/**
- * Parse command-line arguments
- */ function parseArgs() {
+function parseArgs() {
     const args = process.argv.slice(2);
     let command;
     let count;
@@ -74,8 +51,7 @@ Examples:
     let hard = false;
     let tenant;
     let configPath;
-    for(let i = 0; i < args.length; i++){
-        const arg = args[i];
+    for (const arg of args){
         if (arg.startsWith('--count=')) {
             count = parseInt(arg.split('=')[1], 10);
         } else if (arg === '--clear') {
@@ -102,21 +78,15 @@ Examples:
         configPath
     };
 }
-// Resolved config path (set once during CLI initialization)
 let resolvedConfigPath;
-/**
- * Resolve migration config path with auto-detection
- */ async function resolveConfigPath(explicitPath) {
+async function resolveConfigPath(explicitPath) {
     if (resolvedConfigPath) return resolvedConfigPath;
-    // Try paths in order: explicit, env var, then common defaults
     const envConfigPath = envConfig.tryGetValue('MIGRATION_CONFIG');
     const defaultPaths = [
         explicitPath,
         envConfigPath,
         'src/persistence/migration.config.ts',
-        'src/persistence/migration.config.js',
-        'persistence/migration.config.ts',
-        'persistence/migration.config.js'
+        'src/persistence/migration.config.js'
     ].filter(Boolean);
     for (const tryPath of defaultPaths){
         const absolutePath = path.isAbsolute(tryPath) ? tryPath : path.resolve(process.cwd(), tryPath);
@@ -129,97 +99,41 @@ let resolvedConfigPath;
         }
     }
     console.error('❌ Config not found. Use --config=<path> or set MIGRATION_CONFIG env var');
-    console.error('   Tried paths:', defaultPaths.join(', '));
     process.exit(1);
 }
-/**
- * Load DataSource configuration
- */ async function loadDataSource(tenantId, configPath) {
+async function loadDataSource(tenantId, configPath) {
     const resolvedPath = await resolveConfigPath(configPath);
-    try {
-        const module1 = await import(resolvedPath);
-        const migrationConfig = module1.migrationConfig || module1.default?.migrationConfig || module1;
-        // Get database config for tenant
-        const dbConfig = tenantId ? migrationConfig.tenants?.find((t)=>t.tenantId === tenantId || t.id === tenantId) : migrationConfig.defaultDatabaseConfig || migrationConfig.database;
-        if (!dbConfig) {
-            throw new Error(`Database configuration not found${tenantId ? ` for tenant: ${tenantId}` : ''}`);
-        }
-        // Get entities - handle both function and array
-        const entities = typeof migrationConfig.entities === 'function' ? migrationConfig.entities() : migrationConfig.entities || [];
-        // Create DataSource
-        const dataSource = new DataSource({
-            type: dbConfig.type || 'mysql',
-            host: dbConfig.host,
-            port: dbConfig.port,
-            username: dbConfig.username,
-            password: dbConfig.password,
-            database: dbConfig.database,
-            entities,
-            synchronize: false,
-            logging: false
-        });
-        await dataSource.initialize();
-        return dataSource;
-    } catch (error) {
-        console.error('❌ Failed to load DataSource configuration');
-        console.error('   Error:', error instanceof Error ? error.message : String(error));
-        throw error;
+    const module1 = await import(resolvedPath);
+    const migrationConfig = module1.migrationConfig || module1.default?.migrationConfig || module1;
+    const dbConfig = tenantId ? migrationConfig.tenants?.find((t)=>t.tenantId === tenantId || t.id === tenantId) : migrationConfig.defaultDatabaseConfig || migrationConfig.database;
+    if (!dbConfig) {
+        throw new Error(`Database configuration not found${tenantId ? ` for tenant: ${tenantId}` : ''}`);
     }
+    const entities = typeof migrationConfig.entities === 'function' ? migrationConfig.entities() : migrationConfig.entities || [];
+    const dataSource = new DataSource({
+        type: dbConfig.type || 'mysql',
+        host: dbConfig.host,
+        port: dbConfig.port,
+        username: dbConfig.username,
+        password: dbConfig.password,
+        database: dbConfig.database,
+        entities,
+        synchronize: false,
+        logging: false
+    });
+    await dataSource.initialize();
+    return dataSource;
 }
-/**
- * Get all tenant IDs from configuration
- */ async function getAllTenantIds(configPath) {
+async function getAllTenantIds(configPath) {
     const resolvedPath = await resolveConfigPath(configPath);
-    try {
-        const module1 = await import(resolvedPath);
-        const migrationConfig = module1.migrationConfig || module1.default?.migrationConfig || module1;
-        if (migrationConfig.bootstrapAppConfig?.databaseMode !== 'multi-tenant' || !migrationConfig.tenants) {
-            throw new Error('Multi-tenant mode is not configured');
-        }
-        return migrationConfig.tenants.map((t)=>t.tenantId || t.id);
-    } catch (error) {
-        console.error('❌ Failed to load tenant configuration');
-        throw error;
-    }
-}
-/**
- * Generate seeder template files
- */ async function generateCommand(configPath) {
-    console.log('🔍 Discovering entities...\n');
-    const dataSource = await loadDataSource(undefined, configPath);
-    try {
-        const reader = new EntityReader(dataSource);
-        const generator = new TemplateGenerator();
-        const entities = reader.getAllEntities();
-        const outputDir = path.resolve(process.cwd(), 'src/seeders/generators');
-        console.log(`📝 Generating seeder files in ${outputDir}\n`);
-        let generatedCount = 0;
-        const entityInfos = [];
-        for (const metadata of entities){
-            if (shouldSkipEntity(metadata.name)) {
-                continue;
-            }
-            try {
-                const entityInfo = reader.getEntityInfo(metadata.name);
-                entityInfos.push(entityInfo);
-                const filePath = generator.generateSeederFile(entityInfo, outputDir);
-                console.log(`✓ Generated: ${path.basename(filePath)}`);
-                generatedCount++;
-            } catch (error) {
-                console.error(`✗ Failed to generate ${metadata.name}:`, error instanceof Error ? error.message : String(error));
-            }
-        }
-        // Generate index file
-        const indexPath = generator.generateIndexFile(entityInfos, outputDir);
-        console.log(`✓ Generated: ${path.basename(indexPath)}`);
-        console.log(`\n✓ Generated ${generatedCount} seeder files\n`);
-    } finally{
-        await dataSource.destroy();
+    const module1 = await import(resolvedPath);
+    const migrationConfig = module1.migrationConfig || module1.default?.migrationConfig || module1;
+    if (migrationConfig.bootstrapAppConfig?.databaseMode !== 'multi-tenant' || !migrationConfig.tenants) {
+        throw new Error('Multi-tenant mode is not configured');
     }
+    return migrationConfig.tenants.map((t)=>t.tenantId || t.id);
 }
-/**
- * Run seeds for single database
- */ async function runCommand(options, configPath) {
+async function runCommand(options, configPath) {
     const dataSource = await loadDataSource(undefined, configPath);
     try {
         const runner = new SeedRunner(dataSource);
@@ -234,18 +148,13 @@ let resolvedConfigPath;
             }
         } else {
             const results = await runner.runAll(options);
-            const failedCount = results.filter((r)=>!r.success).length;
-            if (failedCount > 0) {
-                process.exit(1);
-            }
+            if (results.some((r)=>!r.success)) process.exit(1);
         }
     } finally{
         await dataSource.destroy();
     }
 }
-/**
- * Run seeds for all tenants
- */ async function runAllTenantsCommand(options, configPath) {
+async function runAllTenantsCommand(options, configPath) {
     console.log('🏢 Running seeds for all tenants...\n');
     const tenantIds = await getAllTenantIds(configPath);
     let successCount = 0;
@@ -257,12 +166,7 @@ let resolvedConfigPath;
         try {
             const runner = new SeedRunner(dataSource);
             const results = await runner.runAll(options);
-            const failed = results.filter((r)=>!r.success).length;
-            if (failed === 0) {
-                successCount++;
-            } else {
-                failCount++;
-            }
+            results.some((r)=>!r.success) ? failCount++ : successCount++;
         } catch (error) {
             console.error(`✗ Failed to seed tenant ${tenantId}:`, error);
             failCount++;
@@ -277,86 +181,65 @@ let resolvedConfigPath;
         process.exit(1);
     }
 }
-/**
- * Clear all seeded data
- */ async function clearCommand(hard = false, configPath) {
+async function clearCommand(hard = false, configPath) {
     const dataSource = await loadDataSource(undefined, configPath);
     try {
-        const runner = new SeedRunner(dataSource);
-        await runner.clearAll(hard);
+        await new SeedRunner(dataSource).clearAll(hard);
     } finally{
         await dataSource.destroy();
     }
 }
-/**
- * Show seeding status
- */ async function statusCommand(configPath) {
+async function statusCommand(configPath) {
     const dataSource = await loadDataSource(undefined, configPath);
     try {
-        const runner = new SeedRunner(dataSource);
-        const status = await runner.getStatus();
+        const status = await new SeedRunner(dataSource).getStatus();
         console.log('\nSeed Status:');
         console.log('┌────────────────────────────┬───────────┬─────────┐');
         console.log('│ Entity                     │ Records   │ Status  │');
         console.log('├────────────────────────────┼───────────┼─────────┤');
         for (const item of status){
-            const entityName = item.entity.padEnd(26);
-            const count = item.count.toString().padEnd(9);
-            const statusIcon = item.isEmpty ? '⚠ Empty' : '✓ Ready ';
-            console.log(`│ ${entityName} │ ${count} │ ${statusIcon} │`);
+            console.log(`│ ${item.entity.padEnd(26)} │ ${item.count.toString().padEnd(9)} │ ${item.isEmpty ? '⚠ Empty' : '✓ Ready '} │`);
         }
         console.log('└────────────────────────────┴───────────┴─────────┘\n');
     } finally{
         await dataSource.destroy();
     }
 }
-/**
- * Main CLI entry point
- */ async function main() {
+async function main() {
     const args = parseArgs();
     if (!args.command) {
         showHelp();
         return;
     }
-    // Initialize config path for all commands
     if (args.configPath) {
         await resolveConfigPath(args.configPath);
     }
-    try {
-        switch(args.command){
-            case 'generate':
-                await generateCommand(args.configPath);
-                break;
-            case 'run':
-                await runCommand({
-                    count: args.count,
-                    clear: args.clear,
-                    entity: args.entity
-                }, args.configPath);
-                break;
-            case 'run:all':
-                await runAllTenantsCommand({
-                    count: args.count,
-                    clear: args.clear
-                }, args.configPath);
-                break;
-            case 'clear':
-                await clearCommand(args.hard, args.configPath);
-                break;
-            case 'status':
-                await statusCommand(args.configPath);
-                break;
-            default:
-                console.error(`❌ Unknown command: ${args.command}`);
-                showHelp();
-                process.exit(1);
-        }
-    } catch (error) {
-        console.error('\n❌ CLI Error:', error instanceof Error ? error.message : String(error));
-        process.exit(1);
+    switch(args.command){
+        case 'run':
+            await runCommand({
+                count: args.count,
+                clear: args.clear,
+                entity: args.entity
+            }, args.configPath);
+            break;
+        case 'run:all':
+            await runAllTenantsCommand({
+                count: args.count,
+                clear: args.clear
+            }, args.configPath);
+            break;
+        case 'clear':
+            await clearCommand(args.hard, args.configPath);
+            break;
+        case 'status':
+            await statusCommand(args.configPath);
+            break;
+        default:
+            console.error(`❌ Unknown command: ${args.command}`);
+            showHelp();
+            process.exit(1);
     }
 }
-// Run CLI if called directly
 if (require.main === module) {
     main().catch((error)=>{
         console.error('Fatal error:', error);