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

package/fesm/seeders/field-patterns.js

@@ -1,147 +0,0 @@
-/** System fields that should be skipped during generation */ export const SYSTEM_FIELDS = [
-    'id',
-    'createdAt',
-    'updatedAt',
-    'deletedAt',
-    'createdById',
-    'updatedById',
-    'deletedById'
-];
-/** Audit fields that return null */ export const AUDIT_FIELDS = [
-    'createdbyid',
-    'updatedbyid',
-    'deletedbyid'
-];
-/** Identity fields that are skipped */ export const IDENTITY_FIELDS = [
-    'id',
-    'createdat',
-    'updatedat',
-    'deletedat'
-];
-/** Boolean indicator keywords */ export const BOOLEAN_KEYWORDS = [
-    'verified',
-    'active',
-    'enabled',
-    'public',
-    'readonly',
-    'valid'
-];
-/**
- * Detect field pattern from column name
- */ export function detectFieldPattern(column) {
-    const nameLower = column.propertyName.toLowerCase();
-    const typeLower = column.type.toLowerCase();
-    // Identity fields (skip)
-    if (IDENTITY_FIELDS.includes(nameLower)) return 'skip';
-    // Audit fields (null)
-    if (AUDIT_FIELDS.includes(nameLower)) return 'null';
-    // Boolean fields with specific keywords
-    if ((typeLower === 'boolean' || typeLower === 'bool') && BOOLEAN_KEYWORDS.some((k)=>nameLower.includes(k))) {
-        return 'boolean';
-    }
-    // Token fields
-    if (nameLower.includes('token')) return 'token';
-    // Name fields
-    if (nameLower.includes('firstname')) return 'firstName';
-    if (nameLower.includes('lastname')) return 'lastName';
-    if (nameLower.includes('fullname') || nameLower === 'name') return 'fullName';
-    // Contact fields
-    if (nameLower.includes('email') && typeLower !== 'boolean') return 'email';
-    if (nameLower.includes('phone') || nameLower.includes('mobile')) return 'phone';
-    // Location fields
-    if (nameLower.includes('address')) return 'address';
-    if (nameLower.includes('street')) return 'street';
-    if (nameLower.includes('city')) return 'city';
-    if (nameLower.includes('state')) return 'state';
-    if (nameLower.includes('country')) return 'country';
-    if (nameLower.includes('zipcode') || nameLower.includes('postalcode')) return 'zipCode';
-    // URL/Web fields
-    if (nameLower.includes('url') || nameLower.includes('website')) return 'url';
-    if (nameLower.includes('domain')) return 'domain';
-    if (nameLower.includes('slug')) return 'slug';
-    // Text fields
-    if (nameLower.includes('description')) return 'description';
-    if (nameLower.includes('summary')) return 'summary';
-    if (nameLower.includes('content')) return 'content';
-    if (nameLower.includes('title')) return 'title';
-    // User fields
-    if (nameLower.includes('username')) return 'username';
-    if (nameLower.includes('password')) return 'password';
-    // Boolean status fields (fallback)
-    if (nameLower.includes('isactive') || nameLower.includes('isenabled') || nameLower.includes('ispublic') || nameLower.includes('isverified')) {
-        return 'boolean';
-    }
-    // Date fields
-    if (nameLower.includes('birthdate') || nameLower.includes('dateofbirth')) return 'birthdate';
-    if (nameLower.includes('expiresat') || nameLower.includes('expirydate')) return 'futureDate';
-    if (nameLower.includes('verifiedat')) return 'recentDateOrNull';
-    // Serial/Order fields
-    if (nameLower.includes('serial') || nameLower.includes('order')) return 'serial';
-    // Company
-    if (nameLower.includes('company') && !nameLower.includes('id')) return 'company';
-    // Email provider type
-    if (nameLower === 'provider' || nameLower === 'emailprovider') return 'emailProvider';
-    // Form access type
-    if (nameLower === 'accesstype' || nameLower === 'access_type') return 'formAccessType';
-    return undefined;
-}
-/**
- * Detect column type category
- */ export function detectTypeCategory(type) {
-    const typeLower = type.toLowerCase();
-    if ([
-        'varchar',
-        'character varying',
-        'text',
-        'string'
-    ].includes(typeLower)) return 'string';
-    if ([
-        'int',
-        'integer',
-        'smallint',
-        'bigint'
-    ].includes(typeLower)) return 'integer';
-    if ([
-        'decimal',
-        'numeric',
-        'float',
-        'double',
-        'real'
-    ].includes(typeLower)) return 'decimal';
-    if ([
-        'boolean',
-        'bool'
-    ].includes(typeLower)) return 'boolean';
-    if (typeLower === 'date') return 'date';
-    if ([
-        'timestamp',
-        'datetime'
-    ].includes(typeLower)) return 'timestamp';
-    if (typeLower === 'time') return 'time';
-    if (typeLower === 'uuid') return 'uuid';
-    if ([
-        'json',
-        'jsonb'
-    ].includes(typeLower)) return 'json';
-    if (typeLower === 'array') return 'array';
-    return 'unknown';
-}
-/**
- * Get string length category for faker generation
- */ export function getStringLengthCategory(length) {
-    const maxLength = typeof length === 'number' ? length : 255;
-    if (maxLength <= 50) return 'word';
-    if (maxLength <= 255) return 'sentence';
-    return 'paragraph';
-}
-/**
- * Check if field is a system field
- */ export function isSystemField(fieldName) {
-    return SYSTEM_FIELDS.includes(fieldName);
-}
-/**
- * Get token max length respecting column constraints
- */ export function getTokenLength(column) {
-    const maxLength = typeof column.length === 'number' ? column.length : 64;
-    return Math.min(maxLength, 32);
-}

package/fesm/seeders/index.js

@@ -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/fesm/seeders/seed-config.js

@@ -1,35 +0,0 @@
-export const seedConfig = {
-    counts: {},
-    order: [],
-    skipEntities: [
-        'migrations',
-        'typeorm_metadata',
-        'Migration',
-        'Typeorm_Metadata'
-    ],
-    locale: 'en',
-    respectSoftDelete: true
-};
-export function configureSeedConfig(config) {
-    Object.assign(seedConfig, config);
-}
-export function getEntityCount(entityName, config = seedConfig) {
-    return config.counts[entityName] || 10;
-}
-export function shouldSkipEntity(entityName, config = seedConfig) {
-    return config.skipEntities.some((skip)=>skip.toLowerCase() === entityName.toLowerCase());
-}
-export function getSeedingOrder(availableEntities, config = seedConfig) {
-    const ordered = [];
-    for (const entityName of config.order){
-        if (availableEntities.includes(entityName) && !shouldSkipEntity(entityName, config)) {
-            ordered.push(entityName);
-        }
-    }
-    for (const entityName of availableEntities){
-        if (!ordered.includes(entityName) && !shouldSkipEntity(entityName, config)) {
-            ordered.push(entityName);
-        }
-    }
-    return ordered;
-}

package/fesm/seeders/seed-runner.js

@@ -1,317 +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);
-    }
-    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);
-    }
-    /**
-   * 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`);
-            }
-            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();
-        }
-    }
-    /**
-   * 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`);
-                }
-                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;
-    }
-    /**
-   * 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
-    }
-};

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): any;
-    generateEntity(columns: IColumnInfo[]): Record<string, any>;
-    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?: any;
-    enum?: any[];
-    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';
-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 } 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<any>): 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;
-    }>>;
-}