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

package/cjs/seeders/cli.js

@@ -1,291 +0,0 @@
-#!/usr/bin/env node
-"use strict";
-Object.defineProperty(exports, "__esModule", {
-    value: true
-});
-Object.defineProperty(exports, "runSeedCli", {
-    enumerable: true,
-    get: function() {
-        return main;
-    }
-});
-const _path = /*#__PURE__*/ _interop_require_wildcard(require("path"));
-const _typeorm = require("typeorm");
-const _config = require("../config");
-const _seedrunner = require("./seed-runner");
-function _getRequireWildcardCache(nodeInterop) {
-    if (typeof WeakMap !== "function") return null;
-    var cacheBabelInterop = new WeakMap();
-    var cacheNodeInterop = new WeakMap();
-    return (_getRequireWildcardCache = function(nodeInterop) {
-        return nodeInterop ? cacheNodeInterop : cacheBabelInterop;
-    })(nodeInterop);
-}
-function _interop_require_wildcard(obj, nodeInterop) {
-    if (!nodeInterop && obj && obj.__esModule) {
-        return obj;
-    }
-    if (obj === null || typeof obj !== "object" && typeof obj !== "function") {
-        return {
-            default: obj
-        };
-    }
-    var cache = _getRequireWildcardCache(nodeInterop);
-    if (cache && cache.has(obj)) {
-        return cache.get(obj);
-    }
-    var newObj = {
-        __proto__: null
-    };
-    var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor;
-    for(var key in obj){
-        if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) {
-            var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null;
-            if (desc && (desc.get || desc.set)) {
-                Object.defineProperty(newObj, key, desc);
-            } else {
-                newObj[key] = obj[key];
-            }
-        }
-    }
-    newObj.default = obj;
-    if (cache) {
-        cache.set(obj, newObj);
-    }
-    return newObj;
-}
-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 = _config.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 Promise.resolve(absolutePath).then((p)=>/*#__PURE__*/ _interop_require_wildcard(require(p)));
-            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 Promise.resolve(resolvedPath).then((p)=>/*#__PURE__*/ _interop_require_wildcard(require(p)));
-    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 _typeorm.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 Promise.resolve(resolvedPath).then((p)=>/*#__PURE__*/ _interop_require_wildcard(require(p)));
-    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.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.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.SeedRunner(dataSource).clearAll(hard);
-    } finally{
-        await dataSource.destroy();
-    }
-}
-async function statusCommand(configPath) {
-    const dataSource = await loadDataSource(undefined, configPath);
-    try {
-        const status = await new _seedrunner.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);
-    });
-}

package/cjs/seeders/data-generator.js

@@ -1,215 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", {
-    value: true
-});
-Object.defineProperty(exports, "DataGenerator", {
-    enumerable: true,
-    get: function() {
-        return DataGenerator;
-    }
-});
-const _faker = require("@faker-js/faker");
-const _fieldpatterns = require("./field-patterns");
-let DataGenerator = 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.faker.datatype.boolean()) return null;
-        // Check for enum
-        if (column.enum && column.enum.length > 0) {
-            return _faker.faker.helpers.arrayElement(column.enum);
-        }
-        // Generate based on field pattern
-        const pattern = (0, _fieldpatterns.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.faker.datatype.boolean();
-            case 'token':
-                return _faker.faker.string.alphanumeric((0, _fieldpatterns.getTokenLength)(column));
-            case 'firstName':
-                return _faker.faker.person.firstName();
-            case 'lastName':
-                return _faker.faker.person.lastName();
-            case 'fullName':
-                return _faker.faker.person.fullName();
-            case 'email':
-                return _faker.faker.internet.email().toLowerCase();
-            case 'phone':
-                return _faker.faker.phone.number();
-            case 'address':
-                return _faker.faker.location.streetAddress();
-            case 'street':
-                return _faker.faker.location.street();
-            case 'city':
-                return _faker.faker.location.city();
-            case 'state':
-                return _faker.faker.location.state();
-            case 'country':
-                return _faker.faker.location.country();
-            case 'zipCode':
-                return _faker.faker.location.zipCode();
-            case 'url':
-                return _faker.faker.internet.url();
-            case 'domain':
-                return _faker.faker.internet.domainName();
-            case 'slug':
-                return _faker.faker.helpers.slugify(_faker.faker.lorem.words(3)).toLowerCase();
-            case 'description':
-                return _faker.faker.lorem.paragraph();
-            case 'summary':
-                return _faker.faker.lorem.sentence();
-            case 'content':
-                return _faker.faker.lorem.paragraphs(3);
-            case 'title':
-                return _faker.faker.lorem.sentence();
-            case 'username':
-                return _faker.faker.internet.username();
-            case 'password':
-                return '$2b$12$dummy.hashed.password.value';
-            case 'birthdate':
-                return _faker.faker.date.birthdate({
-                    min: 18,
-                    max: 80,
-                    mode: 'age'
-                });
-            case 'futureDate':
-                return _faker.faker.date.future();
-            case 'recentDateOrNull':
-                return _faker.faker.datatype.boolean() ? _faker.faker.date.recent() : null;
-            case 'serial':
-                return _faker.faker.number.int({
-                    min: 1,
-                    max: 100
-                });
-            case 'company':
-                return _faker.faker.company.name();
-            case 'emailProvider':
-                return _faker.faker.helpers.arrayElement([
-                    'smtp',
-                    'sendgrid',
-                    'mailgun',
-                    'ses',
-                    'postmark'
-                ]);
-            case 'formAccessType':
-                return _faker.faker.helpers.arrayElement([
-                    'public',
-                    'authenticated',
-                    'permission'
-                ]);
-            default:
-                return undefined;
-        }
-    }
-    /**
-   * Generate value based on column type
-   */ generateByType(column) {
-        const category = (0, _fieldpatterns.detectTypeCategory)(column.type);
-        switch(category){
-            case 'string':
-                return this.generateString(column);
-            case 'integer':
-                return _faker.faker.number.int({
-                    min: 1,
-                    max: 1000
-                });
-            case 'decimal':
-                return _faker.faker.number.float({
-                    min: 0,
-                    max: 10000,
-                    fractionDigits: column.scale || 2
-                });
-            case 'boolean':
-                return _faker.faker.datatype.boolean();
-            case 'date':
-            case 'timestamp':
-                return _faker.faker.date.recent({
-                    days: 30
-                });
-            case 'time':
-                return _faker.faker.date.recent().toTimeString().split(' ')[0];
-            case 'uuid':
-                return _faker.faker.string.uuid();
-            case 'json':
-                return {
-                    key1: _faker.faker.lorem.word(),
-                    key2: _faker.faker.number.int({
-                        min: 1,
-                        max: 100
-                    })
-                };
-            case 'array':
-                return [
-                    _faker.faker.lorem.word(),
-                    _faker.faker.lorem.word()
-                ];
-            default:
-                return _faker.faker.lorem.word();
-        }
-    }
-    /**
-   * Generate string value respecting length constraints
-   */ generateString(column) {
-        const maxLength = typeof column.length === 'number' ? column.length : 255;
-        const category = (0, _fieldpatterns.getStringLengthCategory)(column.length);
-        switch(category){
-            case 'word':
-                return _faker.faker.lorem.word().substring(0, maxLength);
-            case 'sentence':
-                return _faker.faker.lorem.sentence().substring(0, maxLength);
-            case 'paragraph':
-                return _faker.faker.lorem.paragraph().substring(0, maxLength);
-        }
-    }
-    /**
-   * Generate related entity ID (for foreign keys)
-   */ generateRelationId(relatedEntities) {
-        if (relatedEntities.length === 0) return null;
-        return _faker.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.faker.number.int({
-            min,
-            max: Math.min(max, relatedEntities.length)
-        });
-        return _faker.faker.helpers.arrayElements(relatedEntities, count).map((e)=>e.id);
-    }
-    constructor(locale = 'en'){
-        _faker.faker.setDefaultRefDate(new Date());
-        if (locale !== 'en') {
-            // @ts-expect-error - faker locale property access
-            _faker.faker.locale = locale;
-        }
-    }
-};

package/cjs/seeders/entity-reader.js

@@ -1,151 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", {
-    value: true
-});
-Object.defineProperty(exports, "EntityReader", {
-    enumerable: true,
-    get: function() {
-        return EntityReader;
-    }
-});
-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;
-}
-let EntityReader = 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;
-    }
-};