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

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 };

package/fesm/seeders/data-generator.js

@@ -1,210 +0,0 @@
-import { faker } from '@faker-js/faker';
-import { detectFieldPattern, detectTypeCategory, getStringLengthCategory, getTokenLength } from './field-patterns';
-/**
- * Data Generator Service
- *
- * Generates realistic sample data based on column metadata.
- * Uses @faker-js/faker for data generation with intelligent field detection.
- */ export class DataGenerator {
-    /**
-   * Generate value for a single column based on its metadata
-   */ generateValue(column) {
-        if (column.isGenerated) return undefined;
-        // Handle nullable fields (50% chance of null)
-        if (column.isNullable && faker.datatype.boolean()) return null;
-        // Check for enum
-        if (column.enum && column.enum.length > 0) {
-            return faker.helpers.arrayElement(column.enum);
-        }
-        // Generate based on field pattern
-        const pattern = detectFieldPattern(column);
-        if (pattern) {
-            const value = this.generateByPattern(pattern, column);
-            if (value !== undefined) return value;
-        }
-        // Generate based on column type
-        return this.generateByType(column);
-    }
-    /**
-   * Generate entity object from column definitions
-   */ generateEntity(columns) {
-        const entity = {};
-        for (const column of columns){
-            const value = this.generateValue(column);
-            if (value !== undefined) {
-                entity[column.propertyName] = value;
-            }
-        }
-        return entity;
-    }
-    /**
-   * Generate value based on detected field pattern
-   */ generateByPattern(pattern, column) {
-        switch(pattern){
-            case 'skip':
-                return undefined;
-            case 'null':
-                return null;
-            case 'boolean':
-                return faker.datatype.boolean();
-            case 'token':
-                return faker.string.alphanumeric(getTokenLength(column));
-            case 'firstName':
-                return faker.person.firstName();
-            case 'lastName':
-                return faker.person.lastName();
-            case 'fullName':
-                return faker.person.fullName();
-            case 'email':
-                return faker.internet.email().toLowerCase();
-            case 'phone':
-                return faker.phone.number();
-            case 'address':
-                return faker.location.streetAddress();
-            case 'street':
-                return faker.location.street();
-            case 'city':
-                return faker.location.city();
-            case 'state':
-                return faker.location.state();
-            case 'country':
-                return faker.location.country();
-            case 'zipCode':
-                return faker.location.zipCode();
-            case 'url':
-                return faker.internet.url();
-            case 'domain':
-                return faker.internet.domainName();
-            case 'slug':
-                return faker.helpers.slugify(faker.lorem.words(3)).toLowerCase();
-            case 'description':
-                return faker.lorem.paragraph();
-            case 'summary':
-                return faker.lorem.sentence();
-            case 'content':
-                return faker.lorem.paragraphs(3);
-            case 'title':
-                return faker.lorem.sentence();
-            case 'username':
-                return faker.internet.username();
-            case 'password':
-                return '$2b$12$dummy.hashed.password.value';
-            case 'birthdate':
-                return faker.date.birthdate({
-                    min: 18,
-                    max: 80,
-                    mode: 'age'
-                });
-            case 'futureDate':
-                return faker.date.future();
-            case 'recentDateOrNull':
-                return faker.datatype.boolean() ? faker.date.recent() : null;
-            case 'serial':
-                return faker.number.int({
-                    min: 1,
-                    max: 100
-                });
-            case 'company':
-                return faker.company.name();
-            case 'emailProvider':
-                return faker.helpers.arrayElement([
-                    'smtp',
-                    'sendgrid',
-                    'mailgun',
-                    'ses',
-                    'postmark'
-                ]);
-            case 'formAccessType':
-                return faker.helpers.arrayElement([
-                    'public',
-                    'authenticated',
-                    'permission'
-                ]);
-            default:
-                return undefined;
-        }
-    }
-    /**
-   * Generate value based on column type
-   */ generateByType(column) {
-        const category = detectTypeCategory(column.type);
-        switch(category){
-            case 'string':
-                return this.generateString(column);
-            case 'integer':
-                return faker.number.int({
-                    min: 1,
-                    max: 1000
-                });
-            case 'decimal':
-                return faker.number.float({
-                    min: 0,
-                    max: 10000,
-                    fractionDigits: column.scale || 2
-                });
-            case 'boolean':
-                return faker.datatype.boolean();
-            case 'date':
-            case 'timestamp':
-                return faker.date.recent({
-                    days: 30
-                });
-            case 'time':
-                return faker.date.recent().toTimeString().split(' ')[0];
-            case 'uuid':
-                return faker.string.uuid();
-            case 'json':
-                return {
-                    key1: faker.lorem.word(),
-                    key2: faker.number.int({
-                        min: 1,
-                        max: 100
-                    })
-                };
-            case 'array':
-                return [
-                    faker.lorem.word(),
-                    faker.lorem.word()
-                ];
-            default:
-                return faker.lorem.word();
-        }
-    }
-    /**
-   * Generate string value respecting length constraints
-   */ generateString(column) {
-        const maxLength = typeof column.length === 'number' ? column.length : 255;
-        const category = getStringLengthCategory(column.length);
-        switch(category){
-            case 'word':
-                return faker.lorem.word().substring(0, maxLength);
-            case 'sentence':
-                return faker.lorem.sentence().substring(0, maxLength);
-            case 'paragraph':
-                return faker.lorem.paragraph().substring(0, maxLength);
-        }
-    }
-    /**
-   * Generate related entity ID (for foreign keys)
-   */ generateRelationId(relatedEntities) {
-        if (relatedEntities.length === 0) return null;
-        return faker.helpers.arrayElement(relatedEntities).id;
-    }
-    /**
-   * Generate multiple related entity IDs (for many-to-many)
-   */ generateRelationIds(relatedEntities, min = 1, max = 3) {
-        if (relatedEntities.length === 0) return [];
-        const count = faker.number.int({
-            min,
-            max: Math.min(max, relatedEntities.length)
-        });
-        return faker.helpers.arrayElements(relatedEntities, count).map((e)=>e.id);
-    }
-    constructor(locale = 'en'){
-        faker.setDefaultRefDate(new Date());
-        if (locale !== 'en') {
-            // @ts-expect-error - faker locale property access
-            faker.locale = locale;
-        }
-    }
-}

package/fesm/seeders/entity-reader.js

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