@flusys/nestjs-core 4.1.0 → 5.0.0

package/cjs/seeders/seed-runner.js

@@ -1,281 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", {
-    value: true
-});
-function _export(target, all) {
-    for(var name in all)Object.defineProperty(target, name, {
-        enumerable: true,
-        get: Object.getOwnPropertyDescriptor(all, name).get
-    });
-}
-_export(exports, {
-    get SeedRunner () {
-        return SeedRunner;
-    },
-    get defaultLogger () {
-        return defaultLogger;
-    }
-});
-const _entityreader = require("./entity-reader");
-const _datagenerator = require("./data-generator");
-const _baseseeder = require("./base-seeder");
-const _seedconfig = require("./seed-config");
-function _define_property(obj, key, value) {
-    if (key in obj) {
-        Object.defineProperty(obj, key, {
-            value: value,
-            enumerable: true,
-            configurable: true,
-            writable: true
-        });
-    } else {
-        obj[key] = value;
-    }
-    return obj;
-}
-const defaultLogger = {
-    log: (message)=>console.log(message),
-    error: (message)=>console.error(message)
-};
-let SeedRunner = class SeedRunner {
-    registerCustomSeeder(entityName, seeder) {
-        this.customSeeders.set(entityName, seeder);
-    }
-    unregisterCustomSeeder(entityName) {
-        this.customSeeders.delete(entityName);
-    }
-    hasCustomSeeder(entityName) {
-        return this.customSeeders.has(entityName);
-    }
-    getSeeder(entityName, entity, dataSource, entityInfo, batchSize) {
-        if (this.customSeeders.has(entityName)) {
-            return this.customSeeders.get(entityName);
-        }
-        return new GenericSeeder(dataSource, entity, this.dataGenerator, entityInfo, batchSize);
-    }
-    async runAll(options = {}) {
-        const results = [];
-        const continueOnError = options.continueOnError ?? true;
-        // Get all entities
-        const allEntities = this.entityReader.getAllEntities();
-        const entityNames = allEntities.map((e)=>e.name).filter((name)=>!(0, _seedconfig.shouldSkipEntity)(name));
-        // Get seeding order
-        const orderedNames = (0, _seedconfig.getSeedingOrder)(entityNames);
-        const mode = options.dryRun ? 'Previewing' : 'Seeding';
-        this.logger.log(`\n🌱 ${mode} ${orderedNames.length} entities...\n`);
-        for(let i = 0; i < orderedNames.length; i++){
-            const entityName = orderedNames[i];
-            // Call progress callback
-            options.onProgress?.(i + 1, orderedNames.length, entityName);
-            const result = await this.runSingle(entityName, options);
-            results.push(result);
-            // Log result
-            if (result.success) {
-                if (result.dryRun) {
-                    this.logger.log(`✓ ${entityName}: ${result.count} records (dry run)`);
-                } else if (result.skipped) {
-                    this.logger.log(`⊘ ${entityName}: skipped (already has data)`);
-                } else {
-                    this.logger.log(`✓ ${entityName}: ${result.count} records`);
-                }
-            } else {
-                this.logger.error(`✗ ${entityName}: ${result.error}`);
-                // Fail-fast if continueOnError is false
-                if (!continueOnError) {
-                    this.logger.error(`\n❌ Seeding failed at ${entityName}, stopping...\n`);
-                    break;
-                }
-            }
-        }
-        const successCount = results.filter((r)=>r.success).length;
-        const failedCount = results.length - successCount;
-        if (failedCount > 0) {
-            this.logger.log(`\n⚠️  Completed with errors: ${successCount}/${results.length} entities seeded (${failedCount} failed)\n`);
-        } else {
-            this.logger.log(`\n✓ Completed: ${successCount}/${results.length} entities seeded\n`);
-        }
-        return results;
-    }
-    async runSingle(entityName, options = {}) {
-        const queryRunner = this.dataSource.createQueryRunner();
-        await queryRunner.connect();
-        await queryRunner.startTransaction();
-        try {
-            // Get entity info
-            const entityInfo = this.entityReader.getEntityInfo(entityName);
-            // Find entity target
-            const entity = this.dataSource.entityMetadatas.find((e)=>e.name === entityName)?.target;
-            if (!entity) {
-                throw new Error(`Entity ${entityName} not found`);
-            }
-            const seeder = this.getSeeder(entityName, entity, queryRunner.manager.connection, entityInfo, options.batchSize);
-            // Dry run mode - preview without executing
-            if (options.dryRun) {
-                const count = options.count ?? (0, _seedconfig.getEntityCount)(entityName);
-                await queryRunner.rollbackTransaction();
-                return {
-                    entity: entityName,
-                    success: true,
-                    count,
-                    dryRun: true
-                };
-            }
-            // Skip if exists
-            if (options.skipIfExists) {
-                const existingCount = await seeder.count();
-                if (existingCount > 0) {
-                    await queryRunner.rollbackTransaction();
-                    return {
-                        entity: entityName,
-                        success: true,
-                        count: 0,
-                        skipped: true
-                    };
-                }
-            }
-            // Clear if requested
-            if (options.clear) {
-                await seeder.clear(options.respectSoftDelete ?? _seedconfig.seedConfig.respectSoftDelete);
-            }
-            // Generate data
-            const count = options.count ?? (0, _seedconfig.getEntityCount)(entityName);
-            const entities = await seeder.generate(count);
-            // Commit transaction
-            await queryRunner.commitTransaction();
-            return {
-                entity: entityName,
-                success: true,
-                count: entities.length
-            };
-        } catch (error) {
-            // Rollback on error
-            await queryRunner.rollbackTransaction();
-            return {
-                entity: entityName,
-                success: false,
-                count: 0,
-                error: error instanceof Error ? error.message : String(error)
-            };
-        } finally{
-            await queryRunner.release();
-        }
-    }
-    async clearAll(hard = false, continueOnError = true) {
-        const results = [];
-        // Get all entities
-        const allEntities = this.entityReader.getAllEntities();
-        const entityNames = allEntities.map((e)=>e.name).filter((name)=>!(0, _seedconfig.shouldSkipEntity)(name));
-        // Reverse order for clearing (delete children before parents)
-        const orderedNames = (0, _seedconfig.getSeedingOrder)(entityNames).reverse();
-        const mode = hard ? 'Hard deleting' : 'Clearing';
-        this.logger.log(`\n🗑️  ${mode} ${orderedNames.length} entities...\n`);
-        for (const entityName of orderedNames){
-            try {
-                const entity = this.dataSource.entityMetadatas.find((e)=>e.name === entityName)?.target;
-                if (!entity) {
-                    throw new Error(`Entity ${entityName} not found`);
-                }
-                const seeder = this.getSeeder(entityName, entity, this.dataSource, this.entityReader.getEntityInfo(entityName));
-                const countBefore = await seeder.count(true);
-                // Skip if already empty
-                if (countBefore === 0) {
-                    results.push({
-                        entity: entityName,
-                        success: true,
-                        count: 0
-                    });
-                    this.logger.log(`⊘ ${entityName}: already empty`);
-                    continue;
-                }
-                await seeder.clear(hard);
-                const countAfter = await seeder.count(true);
-                results.push({
-                    entity: entityName,
-                    success: true,
-                    count: countBefore - countAfter
-                });
-                this.logger.log(`✓ ${entityName}: ${countBefore - countAfter} records cleared`);
-            } catch (error) {
-                const errorMessage = error instanceof Error ? error.message : String(error);
-                results.push({
-                    entity: entityName,
-                    success: false,
-                    count: 0,
-                    error: errorMessage
-                });
-                this.logger.error(`✗ ${entityName}: ${errorMessage}`);
-                // Fail-fast if continueOnError is false
-                if (!continueOnError) {
-                    this.logger.error(`\n❌ Clearing failed at ${entityName}, stopping...\n`);
-                    break;
-                }
-            }
-        }
-        const successCount = results.filter((r)=>r.success).length;
-        const failedCount = results.length - successCount;
-        if (failedCount > 0) {
-            this.logger.log(`\n⚠️  Completed with errors: ${successCount}/${results.length} entities cleared (${failedCount} failed)\n`);
-        } else {
-            this.logger.log(`\n✓ Completed: ${successCount}/${results.length} entities cleared\n`);
-        }
-        return results;
-    }
-    async getStatus() {
-        const allEntities = this.entityReader.getAllEntities();
-        const status = [];
-        for (const metadata of allEntities){
-            if ((0, _seedconfig.shouldSkipEntity)(metadata.name)) {
-                continue;
-            }
-            const repo = this.dataSource.getRepository(metadata.target);
-            const count = await repo.count();
-            const isEmpty = count === 0;
-            const hasSoftDelete = metadata.deleteDateColumn !== undefined;
-            status.push({
-                entity: metadata.name,
-                tableName: metadata.tableName,
-                count,
-                isEmpty,
-                hasSoftDelete
-            });
-        }
-        return status;
-    }
-    constructor(dataSource, logger){
-        _define_property(this, "dataSource", void 0);
-        _define_property(this, "entityReader", void 0);
-        _define_property(this, "dataGenerator", void 0);
-        _define_property(this, "logger", void 0);
-        _define_property(this, "customSeeders", void 0);
-        this.dataSource = dataSource;
-        this.customSeeders = new Map();
-        this.entityReader = new _entityreader.EntityReader(dataSource);
-        this.dataGenerator = new _datagenerator.DataGenerator(_seedconfig.seedConfig.locale);
-        this.logger = logger ?? defaultLogger;
-    }
-};
-let GenericSeeder = class GenericSeeder extends _baseseeder.BaseSeeder {
-    async generate(count) {
-        const allSaved = [];
-        // Process in batches to optimize memory usage for large datasets
-        for(let offset = 0; offset < count; offset += this.batchSize){
-            const currentBatchSize = Math.min(this.batchSize, count - offset);
-            const batch = [];
-            for(let i = 0; i < currentBatchSize; i++){
-                const data = this.generator.generateEntity(this.entityInfo.columns);
-                // TypeORM's create method returns T, but TypeScript needs explicit type assertion
-                const entity = this.repository.create(data);
-                batch.push(entity);
-            }
-            // TypeORM's save method has overloads for T and T[]
-            // We need to explicitly cast to handle the generic type resolution
-            const saved = await this.repository.save(batch);
-            allSaved.push(...saved);
-        }
-        return allSaved;
-    }
-    constructor(dataSource, entity, generator, entityInfo, batchSize){
-        super(dataSource, entity), _define_property(this, "generator", void 0), _define_property(this, "entityInfo", void 0), _define_property(this, "batchSize", void 0), this.generator = generator, this.entityInfo = entityInfo;
-        this.batchSize = batchSize ?? 1000; // Default batch size
-    }
-};

package/fesm/seeders/base-seeder.js

@@ -1,66 +0,0 @@
-function _define_property(obj, key, value) {
-    if (key in obj) {
-        Object.defineProperty(obj, key, {
-            value: value,
-            enumerable: true,
-            configurable: true,
-            writable: true
-        });
-    } else {
-        obj[key] = value;
-    }
-    return obj;
-}
-export class BaseSeeder {
-    async clear(hard = false) {
-        const hasSoftDelete = this.metadata.deleteDateColumn !== undefined;
-        if (hard || !hasSoftDelete) {
-            await this.repository.clear();
-        } else {
-            await this.repository.createQueryBuilder().softDelete().where('id IS NOT NULL').execute();
-        }
-    }
-    async count(includeDeleted = false) {
-        const hasSoftDelete = this.metadata.deleteDateColumn !== undefined;
-        if (hasSoftDelete && !includeDeleted) {
-            return this.repository.count({
-                where: {
-                    deletedAt: null
-                }
-            });
-        }
-        return this.repository.count();
-    }
-    async isEmpty() {
-        return await this.count() === 0;
-    }
-    getEntityName() {
-        return this.metadata.tableName;
-    }
-    async withTransaction(operation) {
-        const queryRunner = this.dataSource.createQueryRunner();
-        await queryRunner.connect();
-        await queryRunner.startTransaction();
-        try {
-            const transactionalRepo = queryRunner.manager.getRepository(this.entity);
-            const result = await operation(transactionalRepo);
-            await queryRunner.commitTransaction();
-            return result;
-        } catch (error) {
-            await queryRunner.rollbackTransaction();
-            throw error;
-        } finally{
-            await queryRunner.release();
-        }
-    }
-    constructor(dataSource, entity){
-        _define_property(this, "dataSource", void 0);
-        _define_property(this, "entity", void 0);
-        _define_property(this, "repository", void 0);
-        _define_property(this, "metadata", void 0);
-        this.dataSource = dataSource;
-        this.entity = entity;
-        this.repository = dataSource.getRepository(entity);
-        this.metadata = this.repository.metadata;
-    }
-}

package/fesm/seeders/cli.js

@@ -1,249 +0,0 @@
-#!/usr/bin/env node
-/**
- * Seed CLI Entry Point
- *
- * Commands:
- * - 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
- */ import * as path from 'path';
-import { DataSource } from 'typeorm';
-import { envConfig } from '../config';
-import { SeedRunner } from './seed-runner';
-function showHelp() {
-    console.log(`
-Seed Data CLI
-
-Usage:
-  npm run seed:<command> [options]
-
-Commands:
-  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)
-
-Examples:
-  npm run seed:run
-  npm run seed:run -- --count=50 --clear
-  npm run seed:run -- --entity=User --count=100
-  npm run seed:clear
-  npm run seed:clear -- --hard
-  npm run seed:status
-  npm run seed:run:all
-`);
-}
-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 (const arg of args){
-        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
-    };
-}
-let resolvedConfigPath;
-async function resolveConfigPath(explicitPath) {
-    if (resolvedConfigPath) return resolvedConfigPath;
-    const envConfigPath = envConfig.tryGetValue('MIGRATION_CONFIG');
-    const defaultPaths = [
-        explicitPath,
-        envConfigPath,
-        'src/persistence/migration.config.ts',
-        'src/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');
-    process.exit(1);
-}
-async function loadDataSource(tenantId, configPath) {
-    const resolvedPath = await resolveConfigPath(configPath);
-    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;
-}
-async function getAllTenantIds(configPath) {
-    const resolvedPath = await resolveConfigPath(configPath);
-    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);
-}
-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);
-            if (results.some((r)=>!r.success)) process.exit(1);
-        }
-    } finally{
-        await dataSource.destroy();
-    }
-}
-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);
-            results.some((r)=>!r.success) ? failCount++ : successCount++;
-        } 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);
-    }
-}
-async function clearCommand(hard = false, configPath) {
-    const dataSource = await loadDataSource(undefined, configPath);
-    try {
-        await new SeedRunner(dataSource).clearAll(hard);
-    } finally{
-        await dataSource.destroy();
-    }
-}
-async function statusCommand(configPath) {
-    const dataSource = await loadDataSource(undefined, configPath);
-    try {
-        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){
-            console.log(`│ ${item.entity.padEnd(26)} │ ${item.count.toString().padEnd(9)} │ ${item.isEmpty ? '⚠ Empty' : '✓ Ready '} │`);
-        }
-        console.log('└────────────────────────────┴───────────┴─────────┘\n');
-    } finally{
-        await dataSource.destroy();
-    }
-}
-async function main() {
-    const args = parseArgs();
-    if (!args.command) {
-        showHelp();
-        return;
-    }
-    if (args.configPath) {
-        await resolveConfigPath(args.configPath);
-    }
-    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);
-    }
-}
-if (require.main === module) {
-    main().catch((error)=>{
-        console.error('Fatal error:', error);
-        process.exit(1);
-    });
-}
-export { main as runSeedCli };