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

package/fesm/seeders/entity-reader.js

@@ -1,170 +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;
-}
-/**
- * Entity Reader Service
- *
- * Extracts metadata from TypeORM entities for seed data generation.
- * Discovers columns, types, constraints, and relationships.
- *
- * Usage:
- * ```typescript
- * const reader = new EntityReader(dataSource);
- * const entities = reader.getAllEntities();
- * const userInfo = reader.getEntityInfo('User');
- * ```
- */ export class EntityReader {
-    /**
-   * Get all entity metadata from DataSource
-   */ getAllEntities() {
-        return this.dataSource.entityMetadatas;
-    }
-    /**
-   * Get detailed entity information
-   * @param entityName Entity class name or table name
-   */ getEntityInfo(entityName) {
-        const metadata = this.findEntityMetadata(entityName);
-        if (!metadata) {
-            throw new Error(`Entity ${entityName} not found in DataSource`);
-        }
-        return {
-            name: metadata.name,
-            tableName: metadata.tableName,
-            columns: this.extractColumns(metadata),
-            relations: this.extractRelations(metadata),
-            hasSoftDelete: metadata.deleteDateColumn !== undefined,
-            hasCompany: this.hasCompanyColumn(metadata)
-        };
-    }
-    /**
-   * Get seeding order based on foreign key dependencies
-   * Returns entity names sorted by dependency (independent entities first)
-   */ getSeedingOrder(skipEntities = []) {
-        const entities = this.getAllEntities().filter((e)=>!skipEntities.includes(e.name) && !skipEntities.includes(e.tableName));
-        const graph = this.buildDependencyGraph(entities);
-        return this.topologicalSort(graph);
-    }
-    /**
-   * Check if entity has required columns populated
-   * Used to determine if entity is ready for seeding
-   */ hasRequiredDependencies(entityName, dataSource) {
-        const info = this.getEntityInfo(entityName);
-        for (const relation of info.relations){
-            if (!relation.isNullable && relation.type === 'many-to-one') {
-                const targetRepo = dataSource.getRepository(relation.targetEntity);
-                if (targetRepo) {
-                    // Check if target entity has data
-                    // Note: This is a simplified check, actual implementation may need async
-                    return true;
-                }
-            }
-        }
-        return true;
-    }
-    /**
-   * Find entity metadata by name or table name
-   */ findEntityMetadata(entityName) {
-        return this.getAllEntities().find((e)=>e.name === entityName || e.tableName === entityName);
-    }
-    /**
-   * Extract column information from entity metadata
-   */ extractColumns(metadata) {
-        return metadata.columns.map((col)=>({
-                name: col.databaseName,
-                propertyName: col.propertyName,
-                type: this.getColumnTypeString(col.type),
-                length: col.length,
-                isNullable: col.isNullable,
-                isUnique: col.isUnique === true || false,
-                isPrimary: col.isPrimary,
-                isGenerated: col.isGenerated,
-                default: col.default,
-                enum: col.enum ? Object.values(col.enum) : undefined,
-                precision: col.precision ?? undefined,
-                scale: col.scale ?? undefined
-            }));
-    }
-    /**
-   * Extract relation information from entity metadata
-   */ extractRelations(metadata) {
-        return metadata.relations.map((rel)=>({
-                propertyName: rel.propertyName,
-                type: rel.relationType,
-                targetEntity: rel.inverseEntityMetadata.name,
-                isNullable: rel.isNullable,
-                joinColumnName: rel.joinColumns?.[0]?.databaseName
-            }));
-    }
-    /**
-   * Check if entity has company-related columns
-   */ hasCompanyColumn(metadata) {
-        return metadata.columns.some((col)=>col.propertyName === 'companyId' || col.databaseName === 'company_id');
-    }
-    /**
-   * Convert TypeORM column type to string
-   */ getColumnTypeString(type) {
-        if (typeof type === 'string') {
-            return type;
-        }
-        if (typeof type === 'function') {
-            return type.name.toLowerCase();
-        }
-        return 'unknown';
-    }
-    /**
-   * Build dependency graph for entities
-   */ buildDependencyGraph(entities) {
-        const graph = new Map();
-        for (const entity of entities){
-            const dependencies = [];
-            for (const relation of entity.relations){
-                if (relation.relationType === 'many-to-one' && !relation.isNullable) {
-                    dependencies.push(relation.inverseEntityMetadata.name);
-                }
-            }
-            graph.set(entity.name, dependencies);
-        }
-        return graph;
-    }
-    /**
-   * Topological sort for dependency resolution
-   */ topologicalSort(graph) {
-        const sorted = [];
-        const visited = new Set();
-        const visiting = new Set();
-        const visit = (node)=>{
-            if (visited.has(node)) return;
-            if (visiting.has(node)) {
-                throw new Error(`Circular dependency detected involving ${node}`);
-            }
-            visiting.add(node);
-            const dependencies = graph.get(node) || [];
-            for (const dep of dependencies){
-                if (graph.has(dep)) {
-                    visit(dep);
-                }
-            }
-            visiting.delete(node);
-            visited.add(node);
-            sorted.push(node);
-        };
-        for (const node of graph.keys()){
-            visit(node);
-        }
-        return sorted;
-    }
-    constructor(dataSource){
-        _define_property(this, "dataSource", void 0);
-        this.dataSource = dataSource;
-    }
-}

package/fesm/seeders/index.js

@@ -1,11 +0,0 @@
-/**
- * Seed System Exports
- *
- * Public API for seed data generation system.
- */ export { BaseSeeder } from './base-seeder';
-export { EntityReader, IEntityInfo, IColumnInfo, IRelationInfo } from './entity-reader';
-export { DataGenerator } from './data-generator';
-export { TemplateGenerator } from './template-generator';
-export { SeedRunner, ISeedResult, ISeedOptions, ISeederLogger, defaultLogger } from './seed-runner';
-export { seedConfig, ISeedConfig, getEntityCount, shouldSkipEntity, getSeedingOrder } from './seed-config';
-export { runSeedCli } from './cli';

package/fesm/seeders/seed-config.js

@@ -1,85 +0,0 @@
-/**
- * Seed Configuration
- *
- * Configuration for seed data generation.
- * Customize record counts, seeding order, and behavior.
- */ /**
- * Default seed configuration
- */ export const seedConfig = {
-    // Default record counts per entity
-    counts: {
-        // Auth entities
-        Company: 10,
-        CompanyBranch: 25,
-        User: 50,
-        // IAM entities
-        Role: 8,
-        Permission: 45,
-        Action: 30,
-        Menu: 20,
-        UserIAMPermission: 50,
-        UserCompanyPermission: 100,
-        // Storage entities
-        StorageConfig: 5,
-        Folder: 20,
-        FileManager: 100
-    },
-    // Entity seeding order (respects FK constraints)
-    // Parent entities must come before child entities
-    order: [
-        // Auth - foundational
-        'Company',
-        'CompanyBranch',
-        'User',
-        // IAM - permissions system
-        'Action',
-        'Role',
-        'Permission',
-        'Menu',
-        'UserIAMPermission',
-        'UserCompanyPermission',
-        // Storage - file system
-        'StorageConfig',
-        'Folder',
-        'FileManager'
-    ],
-    // Skip these entities (system tables, migrations)
-    skipEntities: [
-        'migrations',
-        'typeorm_metadata',
-        'Migration',
-        'Typeorm_Metadata'
-    ],
-    // Faker locale (en, ar, es, fr, de, etc.)
-    locale: 'en',
-    // Respect soft delete when clearing data
-    respectSoftDelete: true
-};
-/**
- * Get count for entity (with default fallback)
- */ export function getEntityCount(entityName, config = seedConfig) {
-    return config.counts[entityName] || 10;
-}
-/**
- * Check if entity should be skipped
- */ export function shouldSkipEntity(entityName, config = seedConfig) {
-    return config.skipEntities.some((skip)=>skip.toLowerCase() === entityName.toLowerCase());
-}
-/**
- * Get seeding order for entities
- */ export function getSeedingOrder(availableEntities, config = seedConfig) {
-    const ordered = [];
-    // Add entities in configured order
-    for (const entityName of config.order){
-        if (availableEntities.includes(entityName) && !shouldSkipEntity(entityName, config)) {
-            ordered.push(entityName);
-        }
-    }
-    // Add remaining entities not in order configuration
-    for (const entityName of availableEntities){
-        if (!ordered.includes(entityName) && !shouldSkipEntity(entityName, config)) {
-            ordered.push(entityName);
-        }
-    }
-    return ordered;
-}

package/fesm/seeders/seed-runner.js

@@ -1,323 +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;
-}
-import { EntityReader } from './entity-reader';
-import { DataGenerator } from './data-generator';
-import { BaseSeeder } from './base-seeder';
-import { seedConfig, getEntityCount, shouldSkipEntity, getSeedingOrder } from './seed-config';
-/**
- * Default console logger implementation
- */ export const defaultLogger = {
-    log: (message)=>console.log(message),
-    error: (message)=>console.error(message)
-};
-/**
- * Seed Runner Service
- *
- * Orchestrates seed data generation across all entities.
- * Handles dependency order, transactions, and error reporting.
- *
- * Usage:
- * ```typescript
- * const runner = new SeedRunner(dataSource);
- * await runner.runAll();
- * await runner.runSingle('User', { count: 50 });
- * await runner.clearAll();
- *
- * // With custom logger
- * const runner = new SeedRunner(dataSource, customLogger);
- *
- * // With custom seeder
- * runner.registerCustomSeeder('User', new UserSeeder(dataSource));
- * ```
- */ export class SeedRunner {
-    /**
-   * Register a custom seeder for specific entity
-   * Custom seeders take precedence over generic seeders
-   * @param entityName Entity name
-   * @param seeder Custom seeder instance
-   */ registerCustomSeeder(entityName, seeder) {
-        this.customSeeders.set(entityName, seeder);
-    }
-    /**
-   * Unregister a custom seeder
-   * @param entityName Entity name
-   */ unregisterCustomSeeder(entityName) {
-        this.customSeeders.delete(entityName);
-    }
-    /**
-   * Check if entity has custom seeder registered
-   * @param entityName Entity name
-   */ hasCustomSeeder(entityName) {
-        return this.customSeeders.has(entityName);
-    }
-    /**
-   * Run seeds for all entities
-   * @param options Seeding options
-   * @returns Array of seed results
-   */ 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)=>!shouldSkipEntity(name));
-        // Get seeding order
-        const orderedNames = 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;
-    }
-    /**
-   * Run seed for a single entity
-   * @param entityName Entity name to seed
-   * @param options Seeding options
-   * @returns Seed result
-   */ 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`);
-            }
-            // Get seeder (custom or generic)
-            let seeder;
-            if (this.customSeeders.has(entityName)) {
-                seeder = this.customSeeders.get(entityName);
-            } else {
-                seeder = new GenericSeeder(queryRunner.manager.connection, entity, this.dataGenerator, entityInfo, options.batchSize);
-            }
-            // Dry run mode - preview without executing
-            if (options.dryRun) {
-                const count = options.count ?? 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.respectSoftDelete);
-            }
-            // Generate data
-            const count = options.count ?? 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();
-        }
-    }
-    /**
-   * Clear all seeded data
-   * @param hard If true, hard delete (ignore soft delete)
-   * @param continueOnError If true, continue even if an entity fails (default: true)
-   * @returns Array of clear results
-   */ 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)=>!shouldSkipEntity(name));
-        // Reverse order for clearing (delete children before parents)
-        const orderedNames = 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`);
-                }
-                // Use custom seeder if available, otherwise generic
-                let seeder;
-                if (this.customSeeders.has(entityName)) {
-                    seeder = this.customSeeders.get(entityName);
-                } else {
-                    seeder = new GenericSeeder(this.dataSource, entity, this.dataGenerator, 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;
-    }
-    /**
-   * Get status for all entities
-   * @returns Array of entity status
-   */ async getStatus() {
-        const allEntities = this.entityReader.getAllEntities();
-        const status = [];
-        for (const metadata of allEntities){
-            if (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(dataSource);
-        this.dataGenerator = new DataGenerator(seedConfig.locale);
-        this.logger = logger ?? defaultLogger;
-    }
-}
-/**
- * Generic Seeder Implementation
- *
- * Used by SeedRunner for entities without custom seeders.
- * Generates data based on entity metadata with batch processing support.
- */ let GenericSeeder = class GenericSeeder extends 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
-    }
-};