@flusys/nestjs-core 1.0.0-rc → 2.0.0

package/fesm/docs/docs.config.js

@@ -84,6 +84,65 @@ import { DocumentBuilder, SwaggerModule } from '@nestjs/swagger';
         paths: filteredPaths
     };
 }
+/**
+ * Filter OpenAPI document to exclude examples from endpoint responses
+ */ function filterExamples(document, exclusions) {
+    if (!exclusions?.length || !document.paths) {
+        return document;
+    }
+    const filteredPaths = {};
+    for (const [path, pathItem] of Object.entries(document.paths)){
+        const filteredPathItem = {};
+        for (const [method, operation] of Object.entries(pathItem)){
+            // Skip non-operation properties
+            if (!operation || typeof operation !== 'object') {
+                filteredPathItem[method] = operation;
+                continue;
+            }
+            // Check if this endpoint matches any exclusion pattern
+            const matchingExclusions = exclusions.filter((exclusion)=>{
+                const pathMatches = pathMatchesPattern(path, exclusion.pathPattern);
+                const methodMatches = !exclusion.method || exclusion.method === method;
+                return pathMatches && methodMatches;
+            });
+            if (matchingExclusions.length > 0) {
+                // Collect all examples to exclude
+                const examplesToExclude = new Set();
+                matchingExclusions.forEach((exclusion)=>{
+                    exclusion.examples.forEach((example)=>examplesToExclude.add(example));
+                });
+                // Deep clone the operation to avoid mutating original
+                const filteredOperation = JSON.parse(JSON.stringify(operation));
+                // Filter examples from responses
+                if (filteredOperation.responses) {
+                    for (const [statusCode, response] of Object.entries(filteredOperation.responses)){
+                        const responseObj = response;
+                        if (responseObj?.content) {
+                            const content = responseObj.content;
+                            for (const [mediaType, mediaTypeObj] of Object.entries(content)){
+                                const media = mediaTypeObj;
+                                if (media?.examples && typeof media.examples === 'object') {
+                                    const examples = media.examples;
+                                    for (const exampleName of examplesToExclude){
+                                        delete examples[exampleName];
+                                    }
+                                }
+                            }
+                        }
+                    }
+                }
+                filteredPathItem[method] = filteredOperation;
+            } else {
+                filteredPathItem[method] = operation;
+            }
+        }
+        filteredPaths[path] = filteredPathItem;
+    }
+    return {
+        ...document,
+        paths: filteredPaths
+    };
+}
 /**
  * Check if a path matches a pattern (supports wildcards)
  */ function pathMatchesPattern(path, pattern) {
@@ -179,6 +238,15 @@ import { DocumentBuilder, SwaggerModule } from '@nestjs/swagger';
         if (config.excludeQueryParameters?.length) {
             document = filterQueryParameters(document, config.excludeQueryParameters);
         }
+        // Filter out excluded examples
+        if (config.excludeExamples?.length) {
+            document = filterExamples(document, config.excludeExamples);
+        }
         SwaggerModule.setup(config.path, app, document);
     });
 }
+/**
+ * Setup Swagger docs with variadic module configs
+ */ export function setupSwaggerDocs(app, ...modules) {
+    setupModuleSwaggerDocs(app, modules);
+}

package/fesm/docs/index.js

@@ -1,2 +1 @@
 export * from './docs.config';
-export * from './docs.setup';

package/fesm/migration/migration.runner.js

@@ -4,6 +4,36 @@ import * as path from 'path';
 import { envConfig } from '../config';
 import { getActiveTenants, getDatabaseForTenant, getMigrationsFolderPath } from '../utils';
 import { initializeDataSource } from './datasource.factory';
+function getLabel(tenantId) {
+    return tenantId ? `[${tenantId}]` : '[default]';
+}
+async function withDataSource(config, tenantId, operation) {
+    const { database } = getDatabaseForTenant(config, tenantId);
+    const label = getLabel(tenantId);
+    try {
+        const ds = await initializeDataSource({
+            config,
+            tenantId
+        });
+        const partial = await operation(ds, label);
+        await ds.destroy();
+        return {
+            tenantId,
+            database,
+            success: true,
+            ...partial
+        };
+    } catch (error) {
+        const errorMessage = error instanceof Error ? error.message : String(error);
+        console.error(`${label} ✗ Failed: ${errorMessage}`);
+        return {
+            tenantId,
+            database,
+            success: false,
+            error: errorMessage
+        };
+    }
+}
 export function ensureMigrationsFolder(basePath, tenantId) {
     const folder = getMigrationsFolderPath(basePath, tenantId);
     if (!fs.existsSync(folder)) {
@@ -45,15 +75,8 @@ function findDatasourcePath() {
     throw new Error('Could not find datasource file. Specify with --datasource=<path>');
 }
 export async function runMigrations(config, tenantId) {
-    const { database } = getDatabaseForTenant(config, tenantId);
-    const label = tenantId ? `[${tenantId}]` : '[default]';
-    try {
-        const ds = await initializeDataSource({
-            config,
-            tenantId
-        });
+    return withDataSource(config, tenantId, async (ds, label)=>{
         const migrations = await ds.runMigrations();
-        await ds.destroy();
         if (migrations.length === 0) {
             console.log(`${label} No pending migrations.`);
         } else {
@@ -61,78 +84,27 @@ export async function runMigrations(config, tenantId) {
             migrations.forEach((m)=>console.log(`   - ${m.name}`));
         }
         return {
-            tenantId,
-            database,
-            success: true,
             migrationsRun: migrations.map((m)=>m.name)
         };
-    } catch (error) {
-        const errorMessage = error instanceof Error ? error.message : String(error);
-        console.error(`${label} ✗ Failed: ${errorMessage}`);
-        return {
-            tenantId,
-            database,
-            success: false,
-            error: errorMessage
-        };
-    }
+    });
 }
 export async function revertMigration(config, tenantId) {
-    const { database } = getDatabaseForTenant(config, tenantId);
-    const label = tenantId ? `[${tenantId}]` : '[default]';
-    try {
-        const ds = await initializeDataSource({
-            config,
-            tenantId
-        });
+    return withDataSource(config, tenantId, async (ds, label)=>{
         await ds.undoLastMigration();
-        await ds.destroy();
         console.log(`${label} ✓ Reverted!`);
-        return {
-            tenantId,
-            database,
-            success: true
-        };
-    } catch (error) {
-        const errorMessage = error instanceof Error ? error.message : String(error);
-        console.error(`${label} ✗ Failed: ${errorMessage}`);
-        return {
-            tenantId,
-            database,
-            success: false,
-            error: errorMessage
-        };
-    }
+        return {};
+    });
 }
 export async function migrationStatus(config, tenantId) {
-    const { database } = getDatabaseForTenant(config, tenantId);
-    const label = tenantId ? `[${tenantId}]` : '[default]';
-    try {
-        const ds = await initializeDataSource({
-            config,
-            tenantId
-        });
+    return withDataSource(config, tenantId, async (ds, label)=>{
         const hasPending = await ds.showMigrations();
-        await ds.destroy();
         console.log(`${label} Pending: ${hasPending ? 'Yes' : 'No'}`);
         return {
-            tenantId,
-            database,
-            success: true,
             migrationsRun: [
                 hasPending ? 'Has pending' : 'Up to date'
             ]
         };
-    } catch (error) {
-        const errorMessage = error instanceof Error ? error.message : String(error);
-        console.error(`${label} ✗ Failed: ${errorMessage}`);
-        return {
-            tenantId,
-            database,
-            success: false,
-            error: errorMessage
-        };
-    }
+    });
 }
 export async function runForAllTenants(config, command) {
     const tenants = getActiveTenants(config);

package/fesm/seeders/cli.js

@@ -2,31 +2,16 @@
 /**
  * Seed CLI Entry Point
  *
- * Command-line interface for seed data generation.
- *
  * Commands:
- * - generate: Generate seeder template files
  * - 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
- *
- * Usage:
- * npm run seed:generate
- * npm run seed:run
- * npm run seed:run -- --count=50 --clear
- * npm run seed:clear
- * npm run seed:status
  */ import * as path from 'path';
 import { DataSource } from 'typeorm';
 import { envConfig } from '../config';
-import { EntityReader } from './entity-reader';
-import { TemplateGenerator } from './template-generator';
 import { SeedRunner } from './seed-runner';
-import { shouldSkipEntity } from './seed-config';
-/**
- * Show help message
- */ function showHelp() {
+function showHelp() {
     console.log(`
 Seed Data CLI
 
@@ -34,7 +19,6 @@ Usage:
   npm run seed:<command> [options]
 
 Commands:
-  generate             Generate seeder template files
   run                  Execute seeders for all entities
   run:all              Execute seeders for all tenants (multi-tenant mode)
   clear                Clear all seeded data
@@ -48,24 +32,17 @@ Options:
   --hard               Hard delete when clearing (ignore soft delete)
   --tenant=<id>        Target specific tenant (multi-tenant mode)
 
-Environment:
-  MIGRATION_CONFIG     Default config path (overrides auto-detection)
-
 Examples:
-  npm run seed:generate
   npm run seed:run
   npm run seed:run -- --count=50 --clear
   npm run seed:run -- --entity=User --count=100
-  npm run seed:run -- --config=src/persistence/migration.config.ts
   npm run seed:clear
   npm run seed:clear -- --hard
   npm run seed:status
   npm run seed:run:all
 `);
 }
-/**
- * Parse command-line arguments
- */ function parseArgs() {
+function parseArgs() {
     const args = process.argv.slice(2);
     let command;
     let count;
@@ -74,8 +51,7 @@ Examples:
     let hard = false;
     let tenant;
     let configPath;
-    for(let i = 0; i < args.length; i++){
-        const arg = args[i];
+    for (const arg of args){
         if (arg.startsWith('--count=')) {
             count = parseInt(arg.split('=')[1], 10);
         } else if (arg === '--clear') {
@@ -102,21 +78,15 @@ Examples:
         configPath
     };
 }
-// Resolved config path (set once during CLI initialization)
 let resolvedConfigPath;
-/**
- * Resolve migration config path with auto-detection
- */ async function resolveConfigPath(explicitPath) {
+async function resolveConfigPath(explicitPath) {
     if (resolvedConfigPath) return resolvedConfigPath;
-    // Try paths in order: explicit, env var, then common defaults
     const envConfigPath = envConfig.tryGetValue('MIGRATION_CONFIG');
     const defaultPaths = [
         explicitPath,
         envConfigPath,
         'src/persistence/migration.config.ts',
-        'src/persistence/migration.config.js',
-        'persistence/migration.config.ts',
-        'persistence/migration.config.js'
+        'src/persistence/migration.config.js'
     ].filter(Boolean);
     for (const tryPath of defaultPaths){
         const absolutePath = path.isAbsolute(tryPath) ? tryPath : path.resolve(process.cwd(), tryPath);
@@ -129,97 +99,41 @@ let resolvedConfigPath;
         }
     }
     console.error('❌ Config not found. Use --config=<path> or set MIGRATION_CONFIG env var');
-    console.error('   Tried paths:', defaultPaths.join(', '));
     process.exit(1);
 }
-/**
- * Load DataSource configuration
- */ async function loadDataSource(tenantId, configPath) {
+async function loadDataSource(tenantId, configPath) {
     const resolvedPath = await resolveConfigPath(configPath);
-    try {
-        const module1 = await import(resolvedPath);
-        const migrationConfig = module1.migrationConfig || module1.default?.migrationConfig || module1;
-        // Get database config for tenant
-        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}` : ''}`);
-        }
-        // Get entities - handle both function and array
-        const entities = typeof migrationConfig.entities === 'function' ? migrationConfig.entities() : migrationConfig.entities || [];
-        // Create DataSource
-        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;
-    } catch (error) {
-        console.error('❌ Failed to load DataSource configuration');
-        console.error('   Error:', error instanceof Error ? error.message : String(error));
-        throw error;
+    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;
 }
-/**
- * Get all tenant IDs from configuration
- */ async function getAllTenantIds(configPath) {
+async function getAllTenantIds(configPath) {
     const resolvedPath = await resolveConfigPath(configPath);
-    try {
-        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);
-    } catch (error) {
-        console.error('❌ Failed to load tenant configuration');
-        throw error;
-    }
-}
-/**
- * Generate seeder template files
- */ async function generateCommand(configPath) {
-    console.log('🔍 Discovering entities...\n');
-    const dataSource = await loadDataSource(undefined, configPath);
-    try {
-        const reader = new EntityReader(dataSource);
-        const generator = new TemplateGenerator();
-        const entities = reader.getAllEntities();
-        const outputDir = path.resolve(process.cwd(), 'src/seeders/generators');
-        console.log(`📝 Generating seeder files in ${outputDir}\n`);
-        let generatedCount = 0;
-        const entityInfos = [];
-        for (const metadata of entities){
-            if (shouldSkipEntity(metadata.name)) {
-                continue;
-            }
-            try {
-                const entityInfo = reader.getEntityInfo(metadata.name);
-                entityInfos.push(entityInfo);
-                const filePath = generator.generateSeederFile(entityInfo, outputDir);
-                console.log(`✓ Generated: ${path.basename(filePath)}`);
-                generatedCount++;
-            } catch (error) {
-                console.error(`✗ Failed to generate ${metadata.name}:`, error instanceof Error ? error.message : String(error));
-            }
-        }
-        // Generate index file
-        const indexPath = generator.generateIndexFile(entityInfos, outputDir);
-        console.log(`✓ Generated: ${path.basename(indexPath)}`);
-        console.log(`\n✓ Generated ${generatedCount} seeder files\n`);
-    } finally{
-        await dataSource.destroy();
+    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);
 }
-/**
- * Run seeds for single database
- */ async function runCommand(options, configPath) {
+async function runCommand(options, configPath) {
     const dataSource = await loadDataSource(undefined, configPath);
     try {
         const runner = new SeedRunner(dataSource);
@@ -234,18 +148,13 @@ let resolvedConfigPath;
             }
         } else {
             const results = await runner.runAll(options);
-            const failedCount = results.filter((r)=>!r.success).length;
-            if (failedCount > 0) {
-                process.exit(1);
-            }
+            if (results.some((r)=>!r.success)) process.exit(1);
         }
     } finally{
         await dataSource.destroy();
     }
 }
-/**
- * Run seeds for all tenants
- */ async function runAllTenantsCommand(options, configPath) {
+async function runAllTenantsCommand(options, configPath) {
     console.log('🏢 Running seeds for all tenants...\n');
     const tenantIds = await getAllTenantIds(configPath);
     let successCount = 0;
@@ -257,12 +166,7 @@ let resolvedConfigPath;
         try {
             const runner = new SeedRunner(dataSource);
             const results = await runner.runAll(options);
-            const failed = results.filter((r)=>!r.success).length;
-            if (failed === 0) {
-                successCount++;
-            } else {
-                failCount++;
-            }
+            results.some((r)=>!r.success) ? failCount++ : successCount++;
         } catch (error) {
             console.error(`✗ Failed to seed tenant ${tenantId}:`, error);
             failCount++;
@@ -277,86 +181,65 @@ let resolvedConfigPath;
         process.exit(1);
     }
 }
-/**
- * Clear all seeded data
- */ async function clearCommand(hard = false, configPath) {
+async function clearCommand(hard = false, configPath) {
     const dataSource = await loadDataSource(undefined, configPath);
     try {
-        const runner = new SeedRunner(dataSource);
-        await runner.clearAll(hard);
+        await new SeedRunner(dataSource).clearAll(hard);
     } finally{
         await dataSource.destroy();
     }
 }
-/**
- * Show seeding status
- */ async function statusCommand(configPath) {
+async function statusCommand(configPath) {
     const dataSource = await loadDataSource(undefined, configPath);
     try {
-        const runner = new SeedRunner(dataSource);
-        const status = await runner.getStatus();
+        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){
-            const entityName = item.entity.padEnd(26);
-            const count = item.count.toString().padEnd(9);
-            const statusIcon = item.isEmpty ? '⚠ Empty' : '✓ Ready ';
-            console.log(`│ ${entityName} │ ${count} │ ${statusIcon} │`);
+            console.log(`│ ${item.entity.padEnd(26)} │ ${item.count.toString().padEnd(9)} │ ${item.isEmpty ? '⚠ Empty' : '✓ Ready '} │`);
         }
         console.log('└────────────────────────────┴───────────┴─────────┘\n');
     } finally{
         await dataSource.destroy();
     }
 }
-/**
- * Main CLI entry point
- */ async function main() {
+async function main() {
     const args = parseArgs();
     if (!args.command) {
         showHelp();
         return;
     }
-    // Initialize config path for all commands
     if (args.configPath) {
         await resolveConfigPath(args.configPath);
     }
-    try {
-        switch(args.command){
-            case 'generate':
-                await generateCommand(args.configPath);
-                break;
-            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);
-        }
-    } catch (error) {
-        console.error('\n❌ CLI Error:', error instanceof Error ? error.message : String(error));
-        process.exit(1);
+    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);
     }
 }
-// Run CLI if called directly
 if (require.main === module) {
     main().catch((error)=>{
         console.error('Fatal error:', error);