@flusys/nestjs-core 1.1.0-beta → 1.2.0-rc.1

package/fesm/seeders/cli.js

@@ -1,366 +0,0 @@
-#!/usr/bin/env node
-/**
- * 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() {
-    console.log(`
-Seed Data CLI
-
-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
-  status               Show seeding status
-
-Options:
-  --config=<path>      Migration config file (default: src/persistence/migration.config.ts)
-  --count=<number>     Number of records per entity (default: from seed-config)
-  --clear              Clear existing data before seeding
-  --entity=<name>      Seed only specific entity
-  --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() {
-    const args = process.argv.slice(2);
-    let command;
-    let count;
-    let clear = false;
-    let entity;
-    let hard = false;
-    let tenant;
-    let configPath;
-    for(let i = 0; i < args.length; i++){
-        const arg = args[i];
-        if (arg.startsWith('--count=')) {
-            count = parseInt(arg.split('=')[1], 10);
-        } else if (arg === '--clear') {
-            clear = true;
-        } else if (arg.startsWith('--entity=')) {
-            entity = arg.split('=')[1];
-        } else if (arg === '--hard') {
-            hard = true;
-        } else if (arg.startsWith('--tenant=')) {
-            tenant = arg.split('=')[1];
-        } else if (arg.startsWith('--config=')) {
-            configPath = arg.split('=')[1];
-        } else if (!arg.startsWith('-') && !command) {
-            command = arg;
-        }
-    }
-    return {
-        command,
-        count,
-        clear,
-        entity,
-        hard,
-        tenant,
-        configPath
-    };
-}
-// Resolved config path (set once during CLI initialization)
-let resolvedConfigPath;
-/**
- * Resolve migration config path with auto-detection
- */ 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'
-    ].filter(Boolean);
-    for (const tryPath of defaultPaths){
-        const absolutePath = path.isAbsolute(tryPath) ? tryPath : path.resolve(process.cwd(), tryPath);
-        try {
-            await import(absolutePath);
-            resolvedConfigPath = absolutePath;
-            return absolutePath;
-        } catch  {
-        // Try next path
-        }
-    }
-    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) {
-    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;
-    }
-}
-/**
- * Get all tenant IDs from configuration
- */ 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();
-    }
-}
-/**
- * Run seeds for single database
- */ async function runCommand(options, configPath) {
-    const dataSource = await loadDataSource(undefined, configPath);
-    try {
-        const runner = new SeedRunner(dataSource);
-        if (options.entity) {
-            console.log(`🌱 Seeding entity: ${options.entity}\n`);
-            const result = await runner.runSingle(options.entity, options);
-            if (result.success) {
-                console.log(`\n✓ ${result.entity}: ${result.count} records created\n`);
-            } else {
-                console.error(`\n✗ ${result.entity}: ${result.error}\n`);
-                process.exit(1);
-            }
-        } else {
-            const results = await runner.runAll(options);
-            const failedCount = results.filter((r)=>!r.success).length;
-            if (failedCount > 0) {
-                process.exit(1);
-            }
-        }
-    } finally{
-        await dataSource.destroy();
-    }
-}
-/**
- * Run seeds for all tenants
- */ async function runAllTenantsCommand(options, configPath) {
-    console.log('🏢 Running seeds for all tenants...\n');
-    const tenantIds = await getAllTenantIds(configPath);
-    let successCount = 0;
-    let failCount = 0;
-    for (const tenantId of tenantIds){
-        console.log(`\n📦 Tenant: ${tenantId}`);
-        console.log('─'.repeat(50));
-        const dataSource = await loadDataSource(tenantId, configPath);
-        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++;
-            }
-        } catch (error) {
-            console.error(`✗ Failed to seed tenant ${tenantId}:`, error);
-            failCount++;
-        } finally{
-            await dataSource.destroy();
-        }
-    }
-    console.log('\n' + '='.repeat(50));
-    console.log(`\n✓ Completed: ${successCount} tenants seeded`);
-    if (failCount > 0) {
-        console.log(`✗ Failed: ${failCount} tenants\n`);
-        process.exit(1);
-    }
-}
-/**
- * Clear all seeded data
- */ async function clearCommand(hard = false, configPath) {
-    const dataSource = await loadDataSource(undefined, configPath);
-    try {
-        const runner = new SeedRunner(dataSource);
-        await runner.clearAll(hard);
-    } finally{
-        await dataSource.destroy();
-    }
-}
-/**
- * Show seeding status
- */ async function statusCommand(configPath) {
-    const dataSource = await loadDataSource(undefined, configPath);
-    try {
-        const runner = new SeedRunner(dataSource);
-        const status = await runner.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('└────────────────────────────┴───────────┴─────────┘\n');
-    } finally{
-        await dataSource.destroy();
-    }
-}
-/**
- * Main CLI entry point
- */ 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);
-    }
-}
-// Run CLI if called directly
-if (require.main === module) {
-    main().catch((error)=>{
-        console.error('Fatal error:', error);
-        process.exit(1);
-    });
-}
-export { main as runSeedCli };

package/fesm/seeders/data-generator.js

@@ -1,249 +0,0 @@
-import { faker } from '@faker-js/faker';
-/**
- * Data Generator Service
- *
- * Generates realistic sample data based on column metadata.
- * Uses @faker-js/faker for data generation with intelligent field detection.
- *
- * Usage:
- * ```typescript
- * const generator = new DataGenerator();
- * const value = generator.generateValue(columnInfo);
- * const entity = generator.generateEntity(columns);
- * ```
- */ export class DataGenerator {
-    /**
-   * Generate value for a single column based on its metadata
-   */ generateValue(column) {
-        // Skip generated fields
-        if (column.isGenerated) {
-            return undefined;
-        }
-        // Handle nullable fields (50% chance of null)
-        if (column.isNullable && faker.datatype.boolean()) {
-            return null;
-        }
-        // Check for enum
-        if (column.enum && column.enum.length > 0) {
-            return faker.helpers.arrayElement(column.enum);
-        }
-        // Generate based on column name pattern
-        const nameLower = column.propertyName.toLowerCase();
-        const value = this.generateByName(nameLower, column);
-        if (value !== undefined) {
-            return value;
-        }
-        // Generate based on column type
-        return this.generateByType(column);
-    }
-    /**
-   * Generate entity object from column definitions
-   */ generateEntity(columns) {
-        const entity = {};
-        for (const column of columns){
-            const value = this.generateValue(column);
-            if (value !== undefined) {
-                entity[column.propertyName] = value;
-            }
-        }
-        return entity;
-    }
-    /**
-   * Generate value based on column name patterns
-   */ generateByName(nameLower, column) {
-        // Identity fields (skip, handled by database)
-        if ([
-            'id',
-            'createdat',
-            'updatedat',
-            'deletedat'
-        ].includes(nameLower)) {
-            return undefined;
-        }
-        // Audit fields (skip, handled by interceptors)
-        if ([
-            'createdbyid',
-            'updatedbyid',
-            'deletedbyid'
-        ].includes(nameLower)) {
-            return null;
-        }
-        // Name fields
-        if (nameLower.includes('firstname')) return faker.person.firstName();
-        if (nameLower.includes('lastname')) return faker.person.lastName();
-        if (nameLower.includes('fullname') || nameLower === 'name') {
-            return faker.person.fullName();
-        }
-        // Contact fields
-        if (nameLower.includes('email')) return faker.internet.email().toLowerCase();
-        if (nameLower.includes('phone')) return faker.phone.number();
-        if (nameLower.includes('mobile')) return faker.phone.number();
-        // Location fields
-        if (nameLower.includes('address')) return faker.location.streetAddress();
-        if (nameLower.includes('street')) return faker.location.street();
-        if (nameLower.includes('city')) return faker.location.city();
-        if (nameLower.includes('state')) return faker.location.state();
-        if (nameLower.includes('country')) return faker.location.country();
-        if (nameLower.includes('zipcode') || nameLower.includes('postalcode')) {
-            return faker.location.zipCode();
-        }
-        // URL/Web fields
-        if (nameLower.includes('url')) return faker.internet.url();
-        if (nameLower.includes('website')) return faker.internet.url();
-        if (nameLower.includes('domain')) return faker.internet.domainName();
-        if (nameLower.includes('slug')) {
-            return faker.helpers.slugify(faker.lorem.words(3)).toLowerCase();
-        }
-        // Text fields
-        if (nameLower.includes('description')) return faker.lorem.paragraph();
-        if (nameLower.includes('summary')) return faker.lorem.sentence();
-        if (nameLower.includes('content')) return faker.lorem.paragraphs(3);
-        if (nameLower.includes('title')) return faker.lorem.sentence();
-        // User fields
-        if (nameLower.includes('username')) return faker.internet.username();
-        if (nameLower.includes('password')) return '$2b$12$dummy.hashed.password.value'; // Dummy bcrypt hash
-        // Status/Active fields
-        if (nameLower.includes('isactive')) return faker.datatype.boolean();
-        if (nameLower.includes('isenabled')) return faker.datatype.boolean();
-        if (nameLower.includes('ispublic')) return faker.datatype.boolean();
-        if (nameLower.includes('isverified')) return faker.datatype.boolean();
-        // Date fields
-        if (nameLower.includes('birthdate') || nameLower.includes('dateofbirth')) {
-            return faker.date.birthdate({
-                min: 18,
-                max: 80,
-                mode: 'age'
-            });
-        }
-        if (nameLower.includes('expiresat') || nameLower.includes('expirydate')) {
-            return faker.date.future();
-        }
-        if (nameLower.includes('verifiedat')) {
-            return faker.datatype.boolean() ? faker.date.recent() : null;
-        }
-        // Serial/Order fields
-        if (nameLower.includes('serial') || nameLower.includes('order')) {
-            return faker.number.int({
-                min: 1,
-                max: 100
-            });
-        }
-        // Company/Organization
-        if (nameLower.includes('company') && !nameLower.includes('id')) {
-            return faker.company.name();
-        }
-        return undefined;
-    }
-    /**
-   * Generate value based on column type
-   */ generateByType(column) {
-        const type = column.type.toLowerCase();
-        switch(type){
-            // String types
-            case 'varchar':
-            case 'character varying':
-            case 'text':
-            case 'string':
-                return this.generateString(column);
-            // Number types
-            case 'int':
-            case 'integer':
-            case 'smallint':
-            case 'bigint':
-                return faker.number.int({
-                    min: 1,
-                    max: 1000
-                });
-            case 'decimal':
-            case 'numeric':
-            case 'float':
-            case 'double':
-            case 'real':
-                return faker.number.float({
-                    min: 0,
-                    max: 10000,
-                    fractionDigits: column.scale || 2
-                });
-            // Boolean
-            case 'boolean':
-            case 'bool':
-                return faker.datatype.boolean();
-            // Date/Time
-            case 'date':
-                return faker.date.recent({
-                    days: 30
-                });
-            case 'timestamp':
-            case 'datetime':
-                return faker.date.recent({
-                    days: 30
-                });
-            case 'time':
-                return faker.date.recent().toTimeString().split(' ')[0];
-            // UUID
-            case 'uuid':
-                return faker.string.uuid();
-            // JSON
-            case 'json':
-            case 'jsonb':
-                return {
-                    key1: faker.lorem.word(),
-                    key2: faker.number.int({
-                        min: 1,
-                        max: 100
-                    })
-                };
-            // Array
-            case 'array':
-                return [
-                    faker.lorem.word(),
-                    faker.lorem.word()
-                ];
-            // Default
-            default:
-                return faker.lorem.word();
-        }
-    }
-    /**
-   * Generate string value respecting length constraints
-   */ generateString(column) {
-        const maxLength = typeof column.length === 'number' ? column.length : 255;
-        if (maxLength <= 50) {
-            return faker.lorem.word().substring(0, maxLength);
-        } else if (maxLength <= 255) {
-            return faker.lorem.sentence().substring(0, maxLength);
-        } else {
-            return faker.lorem.paragraph().substring(0, maxLength);
-        }
-    }
-    /**
-   * Generate related entity ID (for foreign keys)
-   * @param relatedEntities Array of entities to pick from
-   */ generateRelationId(relatedEntities) {
-        if (relatedEntities.length === 0) {
-            return null;
-        }
-        return faker.helpers.arrayElement(relatedEntities).id;
-    }
-    /**
-   * Generate multiple related entity IDs (for many-to-many)
-   * @param relatedEntities Array of entities to pick from
-   * @param min Minimum number of relations
-   * @param max Maximum number of relations
-   */ generateRelationIds(relatedEntities, min = 1, max = 3) {
-        if (relatedEntities.length === 0) {
-            return [];
-        }
-        const count = faker.number.int({
-            min,
-            max: Math.min(max, relatedEntities.length)
-        });
-        const selected = faker.helpers.arrayElements(relatedEntities, count);
-        return selected.map((e)=>e.id);
-    }
-    constructor(locale = 'en'){
-    // Note: faker v8+ uses faker.locale instead of setLocale
-    // For v8+: faker.locale = locale;
-    // Locale is set globally, not needed for basic usage
-    }
-}