@flusys/nestjs-core 4.1.1 → 5.0.1

package/fesm/seeders/seed-runner.js

@@ -1,263 +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';
-export const defaultLogger = {
-    log: (message)=>console.log(message),
-    error: (message)=>console.error(message)
-};
-export 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)=>!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;
-    }
-    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 ?? 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();
-        }
-    }
-    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`);
-                }
-                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 (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;
-    }
-}
-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
-    }
-};

package/seeders/base-seeder.d.ts

@@ -1,14 +0,0 @@
-import { DataSource, Repository, EntityTarget, EntityMetadata, ObjectLiteral } from 'typeorm';
-export declare abstract class BaseSeeder<T extends ObjectLiteral> {
-    protected dataSource: DataSource;
-    protected entity: EntityTarget<T>;
-    protected repository: Repository<T>;
-    protected metadata: EntityMetadata;
-    constructor(dataSource: DataSource, entity: EntityTarget<T>);
-    abstract generate(count: number): Promise<T[]>;
-    clear(hard?: boolean): Promise<void>;
-    count(includeDeleted?: boolean): Promise<number>;
-    isEmpty(): Promise<boolean>;
-    getEntityName(): string;
-    protected withTransaction<R>(operation: (repository: Repository<T>) => Promise<R>): Promise<R>;
-}

package/seeders/cli.d.ts

@@ -1,3 +0,0 @@
-#!/usr/bin/env node
-declare function main(): Promise<void>;
-export { main as runSeedCli };

package/seeders/data-generator.d.ts

@@ -1,15 +0,0 @@
-import { IColumnInfo } from './entity-reader';
-export declare class DataGenerator {
-    constructor(locale?: string);
-    generateValue(column: IColumnInfo): unknown;
-    generateEntity(columns: IColumnInfo[]): Record<string, unknown>;
-    private generateByPattern;
-    private generateByType;
-    private generateString;
-    generateRelationId<T extends {
-        id: string;
-    }>(relatedEntities: T[]): string | null;
-    generateRelationIds<T extends {
-        id: string;
-    }>(relatedEntities: T[], min?: number, max?: number): string[];
-}

package/seeders/entity-reader.d.ts

@@ -1,44 +0,0 @@
-import { DataSource, EntityMetadata } from 'typeorm';
-export interface IColumnInfo {
-    name: string;
-    propertyName: string;
-    type: string;
-    length?: number | string;
-    isNullable: boolean;
-    isUnique: boolean;
-    isPrimary: boolean;
-    isGenerated: boolean;
-    default?: unknown;
-    enum?: unknown[];
-    precision?: number;
-    scale?: number;
-}
-export interface IRelationInfo {
-    propertyName: string;
-    type: 'one-to-one' | 'one-to-many' | 'many-to-one' | 'many-to-many';
-    targetEntity: string;
-    isNullable: boolean;
-    joinColumnName?: string;
-}
-export interface IEntityInfo {
-    name: string;
-    tableName: string;
-    columns: IColumnInfo[];
-    relations: IRelationInfo[];
-    hasSoftDelete: boolean;
-    hasCompany: boolean;
-}
-export declare class EntityReader {
-    private readonly dataSource;
-    constructor(dataSource: DataSource);
-    getAllEntities(): EntityMetadata[];
-    getEntityInfo(entityName: string): IEntityInfo;
-    getSeedingOrder(skipEntities?: string[]): string[];
-    private findEntityMetadata;
-    private extractColumns;
-    private extractRelations;
-    private hasCompanyColumn;
-    private getColumnTypeString;
-    private buildDependencyGraph;
-    private topologicalSort;
-}

package/seeders/field-patterns.d.ts

@@ -1,12 +0,0 @@
-import { IColumnInfo } from './entity-reader';
-export declare const SYSTEM_FIELDS: string[];
-export declare const AUDIT_FIELDS: string[];
-export declare const IDENTITY_FIELDS: string[];
-export declare const BOOLEAN_KEYWORDS: string[];
-export type FieldPatternType = 'skip' | 'null' | 'boolean' | 'token' | 'firstName' | 'lastName' | 'fullName' | 'email' | 'phone' | 'address' | 'street' | 'city' | 'state' | 'country' | 'zipCode' | 'url' | 'domain' | 'slug' | 'description' | 'summary' | 'content' | 'title' | 'username' | 'password' | 'birthdate' | 'futureDate' | 'recentDateOrNull' | 'serial' | 'company' | 'emailProvider' | 'formAccessType' | 'notificationType' | 'languageCode' | 'languageDirection';
-export type ColumnTypeCategory = 'string' | 'integer' | 'decimal' | 'boolean' | 'date' | 'timestamp' | 'time' | 'uuid' | 'json' | 'array' | 'unknown';
-export declare function detectFieldPattern(column: IColumnInfo): FieldPatternType | undefined;
-export declare function detectTypeCategory(type: string): ColumnTypeCategory;
-export declare function getStringLengthCategory(length: number | string | undefined): 'word' | 'sentence' | 'paragraph';
-export declare function isSystemField(fieldName: string): boolean;
-export declare function getTokenLength(column: IColumnInfo): number;

package/seeders/index.d.ts

@@ -1,7 +0,0 @@
-export { BaseSeeder } from './base-seeder';
-export { EntityReader, IEntityInfo, IColumnInfo, IRelationInfo } from './entity-reader';
-export { DataGenerator } from './data-generator';
-export { SeedRunner, ISeedResult, ISeedOptions, ISeederLogger, defaultLogger } from './seed-runner';
-export { seedConfig, ISeedConfig, getEntityCount, shouldSkipEntity, getSeedingOrder, configureSeedConfig } from './seed-config';
-export { SYSTEM_FIELDS, isSystemField, detectFieldPattern, detectTypeCategory } from './field-patterns';
-export { runSeedCli } from './cli';

package/seeders/seed-config.d.ts

@@ -1,12 +0,0 @@
-export interface ISeedConfig {
-    counts: Record<string, number>;
-    order: string[];
-    skipEntities: string[];
-    locale: string;
-    respectSoftDelete: boolean;
-}
-export declare const seedConfig: ISeedConfig;
-export declare function configureSeedConfig(config: Partial<ISeedConfig>): void;
-export declare function getEntityCount(entityName: string, config?: ISeedConfig): number;
-export declare function shouldSkipEntity(entityName: string, config?: ISeedConfig): boolean;
-export declare function getSeedingOrder(availableEntities: string[], config?: ISeedConfig): string[];

package/seeders/seed-runner.d.ts

@@ -1,48 +0,0 @@
-import { DataSource, ObjectLiteral } from 'typeorm';
-import { BaseSeeder } from './base-seeder';
-export interface ISeederLogger {
-    log(message: string): void;
-    error(message: string): void;
-}
-export declare const defaultLogger: ISeederLogger;
-export interface ISeedResult {
-    entity: string;
-    success: boolean;
-    count: number;
-    error?: string;
-    dryRun?: boolean;
-    skipped?: boolean;
-}
-export interface ISeedOptions {
-    count?: number;
-    clear?: boolean;
-    entity?: string;
-    respectSoftDelete?: boolean;
-    dryRun?: boolean;
-    skipIfExists?: boolean;
-    continueOnError?: boolean;
-    onProgress?: (current: number, total: number, entityName: string) => void;
-    batchSize?: number;
-}
-export declare class SeedRunner {
-    private readonly dataSource;
-    private entityReader;
-    private dataGenerator;
-    private logger;
-    private customSeeders;
-    constructor(dataSource: DataSource, logger?: ISeederLogger);
-    registerCustomSeeder(entityName: string, seeder: BaseSeeder<ObjectLiteral>): void;
-    unregisterCustomSeeder(entityName: string): void;
-    hasCustomSeeder(entityName: string): boolean;
-    private getSeeder;
-    runAll(options?: ISeedOptions): Promise<ISeedResult[]>;
-    runSingle(entityName: string, options?: ISeedOptions): Promise<ISeedResult>;
-    clearAll(hard?: boolean, continueOnError?: boolean): Promise<ISeedResult[]>;
-    getStatus(): Promise<Array<{
-        entity: string;
-        tableName: string;
-        count: number;
-        isEmpty: boolean;
-        hasSoftDelete: boolean;
-    }>>;
-}