@flusys/nestjs-core 7.1.0 → 8.0.0

package/fesm/interfaces/app-config.interfaces.js

@@ -1 +0,0 @@
-/** DataSource service options for multi-tenant datasource */ export { };

package/fesm/interfaces/base-entity.interface.js

@@ -1,6 +0,0 @@
-/**
- * Entity Contract Interfaces
- *
- * These interfaces define the standard fields that entities should have.
- * Use them as contracts when implementing new entities.
- */ /** Base entity with UUID, timestamps, and soft delete */ /** Entity with company relation (for multi-company support) */ export { };

package/fesm/interfaces/database.interface.js

@@ -1 +0,0 @@
-export { };

package/fesm/interfaces/migration.interface.js

@@ -1 +0,0 @@
-export { };

package/fesm/migration/datasource.factory.js

@@ -1,25 +0,0 @@
-import { DataSource } from 'typeorm';
-import { SnakeNamingStrategy } from 'typeorm-naming-strategies';
-import { buildDataSourceOptions, getDatabaseForTenant, getMigrationsGlobPattern, resolveDatabaseConnection, resolveEntities } from '../utils/datasource-config.builder';
-export function createMigrationDataSource(options) {
-    const { config, tenantId } = options;
-    const { database, tenant, tenantConfig } = getDatabaseForTenant(config, tenantId);
-    console.log(`\n📦 Database: ${database}${tenant ? ` [${tenant.name}]` : ' [default]'}`);
-    console.log(`📁 Migrations: migrations/${tenantId || 'default'}/`);
-    if (config.bootstrapAppConfig?.databaseMode === 'multi-tenant' && !tenantId && config.tenants && config.tenants.length > 0) {
-        console.log(`\n💡 Multi-tenant mode. Available tenants:`);
-        config.tenants.forEach((t)=>console.log(`   - TENANT_ID=${t.id} → ${t.database}`));
-    }
-    const dbConfig = resolveDatabaseConnection(config, tenantId);
-    const entities = resolveEntities(config, tenantConfig);
-    const dsOptions = buildDataSourceOptions(dbConfig, entities, getMigrationsGlobPattern(config.migrationsPath, tenantId), config.migrationsTableName);
-    return new DataSource({
-        ...dsOptions,
-        namingStrategy: new SnakeNamingStrategy()
-    });
-}
-export async function initializeDataSource(options) {
-    const ds = createMigrationDataSource(options);
-    await ds.initialize();
-    return ds;
-}

package/fesm/migration/datasource.factory.spec.js

@@ -1,109 +0,0 @@
-const mockInitialize = jest.fn();
-const dataSourceCtor = jest.fn().mockImplementation((options)=>({
-        options,
-        initialize: mockInitialize
-    }));
-jest.mock('typeorm', ()=>({
-        DataSource: jest.fn().mockImplementation((options)=>dataSourceCtor(options))
-    }));
-jest.mock('typeorm-naming-strategies', ()=>({
-        SnakeNamingStrategy: jest.fn().mockImplementation(()=>({
-                __brand: 'SnakeNamingStrategy'
-            }))
-    }));
-import { createMigrationDataSource, initializeDataSource } from './datasource.factory';
-describe('datasource.factory', ()=>{
-    const baseConfig = {
-        defaultDatabaseConfig: {
-            type: 'postgres',
-            host: 'localhost',
-            port: 5432,
-            username: 'root',
-            password: 'pw',
-            database: 'flusys_default'
-        },
-        migrationsPath: 'migrations',
-        entities: [
-            Object
-        ]
-    };
-    beforeEach(()=>{
-        jest.clearAllMocks();
-        mockInitialize.mockResolvedValue(undefined);
-    });
-    describe('createMigrationDataSource', ()=>{
-        it('should build a DataSource with the resolved connection and a snake naming strategy', ()=>{
-            const ds = createMigrationDataSource({
-                config: baseConfig
-            });
-            expect(dataSourceCtor).toHaveBeenCalledWith(expect.objectContaining({
-                type: 'postgres',
-                host: 'localhost',
-                database: 'flusys_default',
-                synchronize: false,
-                migrations: [
-                    'migrations/default/*{.ts,.js}'
-                ]
-            }));
-            expect(ds.options.namingStrategy).toEqual({
-                __brand: 'SnakeNamingStrategy'
-            });
-        });
-        it('should resolve tenant-specific database and migrations path', ()=>{
-            const config = {
-                ...baseConfig,
-                tenants: [
-                    {
-                        id: 'tenant-a',
-                        database: 'db_a'
-                    }
-                ]
-            };
-            createMigrationDataSource({
-                config,
-                tenantId: 'tenant-a'
-            });
-            expect(dataSourceCtor).toHaveBeenCalledWith(expect.objectContaining({
-                database: 'db_a',
-                migrations: [
-                    'migrations/tenant-a/*{.ts,.js}'
-                ]
-            }));
-        });
-        it('should resolve entities via an entity resolver function when provided', ()=>{
-            const resolver = jest.fn().mockReturnValue([
-                Number,
-                String
-            ]);
-            const config = {
-                ...baseConfig,
-                entities: resolver
-            };
-            createMigrationDataSource({
-                config
-            });
-            expect(resolver).toHaveBeenCalled();
-            expect(dataSourceCtor).toHaveBeenCalledWith(expect.objectContaining({
-                entities: [
-                    Number,
-                    String
-                ]
-            }));
-        });
-    });
-    describe('initializeDataSource', ()=>{
-        it('should create and initialize the DataSource', async ()=>{
-            const ds = await initializeDataSource({
-                config: baseConfig
-            });
-            expect(mockInitialize).toHaveBeenCalledTimes(1);
-            expect(ds).toBeDefined();
-        });
-        it('should propagate initialization errors', async ()=>{
-            mockInitialize.mockRejectedValue(new Error('connection refused'));
-            await expect(initializeDataSource({
-                config: baseConfig
-            })).rejects.toThrow('connection refused');
-        });
-    });
-});

package/fesm/migration/migration.cli.js

@@ -1,180 +0,0 @@
-import * as path from 'path';
-import { envConfig } from '../config';
-import { getDatabaseForTenant, getMigrationsFolderPath } from '../utils';
-import { generateMigration, migrationStatus, resetDatabase, revertMigration, runForAllTenants, runMigrations } from './migration.runner';
-function showHelp() {
-    console.log(`
-Migration CLI
-
-Usage:
-  npm run migration <command> [options]
-
-Commands:
-  generate --name=<Name>   Generate migration
-  run                      Run pending migrations
-  revert                   Revert last migration
-  reset                    Drop db, wipe migration files, recreate db, generate + run initial migration (dev only)
-  status                   Show migration status
-  run:all                  Run for all tenants
-  revert:all               Revert for all tenants
-  status:all               Status for all tenants
-
-Options:
-  --config=<path>    Migration config file (default: src/persistence/migration.config.ts)
-  --name=<Name>      Migration name (for generate command)
-  --force            Required to run 'reset' when MODE is not 'dev'
-
-Environment:
-  TENANT_ID          Target tenant (default: uses default database)
-  MIGRATION_CONFIG   Default config path (overrides auto-detection)
-
-Examples:
-  npm run migration generate --name=CreateUsers
-  npm run migration -- generate --name=CreateUsers --config=src/persistence/migration.config.ts
-  TENANT_ID=tenant1 npm run migration run
-  npm run migration run:all
-  npm run migration reset
-`);
-}
-function parseArgs() {
-    const args = process.argv.slice(2);
-    let command;
-    let name;
-    let configPath;
-    let datasourcePath;
-    let force = false;
-    for(let i = 0; i < args.length; i++){
-        const arg = args[i];
-        if (arg.startsWith('--name=')) {
-            name = arg.split('=')[1];
-        } else if (arg.startsWith('--config=')) {
-            configPath = arg.split('=')[1];
-        } else if (arg.startsWith('--datasource=')) {
-            datasourcePath = arg.split('=')[1];
-        } else if (arg === '--force') {
-            force = true;
-        } else if (!arg.startsWith('-') && !command) {
-            command = arg;
-        }
-    }
-    return {
-        command,
-        name,
-        configPath,
-        datasourcePath,
-        force
-    };
-}
-async function loadConfig(configPath) {
-    const absolutePath = path.isAbsolute(configPath) ? configPath : path.resolve(process.cwd(), configPath);
-    // Use require() for CommonJS compatibility with ts-node
-    // eslint-disable-next-line @typescript-eslint/no-require-imports
-    const module = require(absolutePath);
-    return module.migrationConfig || module.default?.migrationConfig || module;
-}
-export async function runMigrationCli(configOrPath) {
-    const { command, name, configPath: argConfigPath, datasourcePath, force } = parseArgs();
-    const tenantId = envConfig.getTenantId() ?? undefined;
-    // npm passes --name=X as npm_config_name
-    const migrationName = envConfig.tryGetValue('npm_config_name') || envConfig.tryGetValue('MIGRATION_NAME') || name;
-    // Resolve config
-    let config;
-    let dsPath = datasourcePath;
-    if (typeof configOrPath === 'string') {
-        config = await loadConfig(configOrPath);
-        dsPath = dsPath || configOrPath;
-    } else if (configOrPath) {
-        config = configOrPath;
-    } else if (argConfigPath) {
-        config = await loadConfig(argConfigPath);
-        dsPath = dsPath || argConfigPath;
-    } else {
-        // Try paths in order: env var, then common defaults
-        const envConfigPath = envConfig.tryGetValue('MIGRATION_CONFIG');
-        const defaultPaths = [
-            envConfigPath,
-            'src/persistence/migration.config.ts',
-            'src/persistence/migration.config.js',
-            'persistence/migration.config.ts',
-            'persistence/migration.config.js'
-        ].filter(Boolean);
-        let loaded = false;
-        for (const tryPath of defaultPaths){
-            try {
-                config = await loadConfig(tryPath);
-                dsPath = dsPath || tryPath;
-                loaded = true;
-                break;
-            } catch  {
-            // Try next path
-            }
-        }
-        if (!loaded) {
-            console.error('❌ Config not found. Use --config=<path> or set MIGRATION_CONFIG env var');
-            console.error('   Tried paths:', defaultPaths.join(', '));
-            showHelp();
-            process.exit(1);
-        }
-    }
-    if (!command) {
-        showHelp();
-        return;
-    }
-    // Multi-tenant batch commands
-    if (command.endsWith(':all')) {
-        if (config.bootstrapAppConfig?.databaseMode === 'single') {
-            console.error('❌ Multi-tenant mode not enabled');
-            process.exit(1);
-        }
-        const action = command.split(':')[0];
-        const results = await runForAllTenants(config, action);
-        if (results.some((r)=>!r.success)) process.exit(1);
-        return;
-    }
-    // Show target info
-    const { database } = getDatabaseForTenant(config, tenantId);
-    const folder = getMigrationsFolderPath(config.migrationsPath, tenantId);
-    console.log(`\n📦 Database: ${database}`);
-    console.log(`📁 Migrations: ${path.relative(process.cwd(), folder)}`);
-    switch(command){
-        case 'generate':
-            if (!migrationName) {
-                console.error('❌ Migration name required. Use --name=<Name>');
-                process.exit(1);
-            }
-            await generateMigration(config, migrationName, tenantId, dsPath);
-            break;
-        case 'run':
-            {
-                const result = await runMigrations(config, tenantId);
-                if (!result.success) process.exit(1);
-                break;
-            }
-        case 'revert':
-            {
-                const result = await revertMigration(config, tenantId);
-                if (!result.success) process.exit(1);
-                break;
-            }
-        case 'reset':
-            {
-                if (envConfig.isProduction() && !force) {
-                    console.error('❌ Refusing to reset database outside dev mode. Pass --force to override.');
-                    process.exit(1);
-                }
-                const result = await resetDatabase(config, tenantId);
-                if (!result.success) process.exit(1);
-                await generateMigration(config, migrationName || 'Init', tenantId, dsPath);
-                const runResult = await runMigrations(config, tenantId);
-                if (!runResult.success) process.exit(1);
-                break;
-            }
-        case 'status':
-            await migrationStatus(config, tenantId);
-            break;
-        default:
-            console.error(`❌ Unknown command: ${command}`);
-            showHelp();
-            process.exit(1);
-    }
-}

package/fesm/migration/migration.cli.spec.js

@@ -1,289 +0,0 @@
-const mockGetTenantId = jest.fn();
-const mockTryGetValue = jest.fn();
-const mockIsProduction = jest.fn();
-jest.mock('../config', ()=>({
-        envConfig: {
-            getTenantId: (...args)=>mockGetTenantId(...args),
-            tryGetValue: (...args)=>mockTryGetValue(...args),
-            isProduction: (...args)=>mockIsProduction(...args)
-        }
-    }));
-const mockGetDatabaseForTenant = jest.fn();
-const mockGetMigrationsFolderPath = jest.fn();
-jest.mock('../utils', ()=>({
-        getDatabaseForTenant: (...args)=>mockGetDatabaseForTenant(...args),
-        getMigrationsFolderPath: (...args)=>mockGetMigrationsFolderPath(...args)
-    }));
-const mockGenerateMigration = jest.fn();
-const mockRunMigrations = jest.fn();
-const mockRevertMigration = jest.fn();
-const mockResetDatabase = jest.fn();
-const mockMigrationStatus = jest.fn();
-const mockRunForAllTenants = jest.fn();
-jest.mock('./migration.runner', ()=>({
-        generateMigration: (...args)=>mockGenerateMigration(...args),
-        runMigrations: (...args)=>mockRunMigrations(...args),
-        revertMigration: (...args)=>mockRevertMigration(...args),
-        resetDatabase: (...args)=>mockResetDatabase(...args),
-        migrationStatus: (...args)=>mockMigrationStatus(...args),
-        runForAllTenants: (...args)=>mockRunForAllTenants(...args)
-    }));
-import { runMigrationCli } from './migration.cli';
-describe('runMigrationCli', ()=>{
-    const baseConfig = {
-        defaultDatabaseConfig: {
-            type: 'postgres',
-            database: 'flusys_default'
-        },
-        migrationsPath: 'migrations',
-        entities: []
-    };
-    let logSpy;
-    let errorSpy;
-    let exitSpy;
-    let originalArgv;
-    beforeEach(()=>{
-        jest.clearAllMocks();
-        originalArgv = process.argv;
-        logSpy = jest.spyOn(console, 'log').mockImplementation(()=>undefined);
-        errorSpy = jest.spyOn(console, 'error').mockImplementation(()=>undefined);
-        exitSpy = jest.spyOn(process, 'exit').mockImplementation(()=>{
-            throw new Error('process.exit called');
-        });
-        mockGetTenantId.mockReturnValue(null);
-        mockTryGetValue.mockReturnValue('');
-        mockIsProduction.mockReturnValue(false);
-        mockGetDatabaseForTenant.mockReturnValue({
-            database: 'flusys_default'
-        });
-        mockGetMigrationsFolderPath.mockReturnValue('migrations/default');
-    });
-    afterEach(()=>{
-        process.argv = originalArgv;
-        logSpy.mockRestore();
-        errorSpy.mockRestore();
-        exitSpy.mockRestore();
-    });
-    function setArgv(...args) {
-        process.argv = [
-            'node',
-            'cli.js',
-            ...args
-        ];
-    }
-    it('should print help and return when no command is given', async ()=>{
-        setArgv();
-        await runMigrationCli(baseConfig);
-        expect(logSpy).toHaveBeenCalledWith(expect.stringContaining('Migration CLI'));
-        expect(mockRunMigrations).not.toHaveBeenCalled();
-    });
-    it('should run migrations for the default tenant', async ()=>{
-        setArgv('run');
-        mockRunMigrations.mockResolvedValue({
-            success: true,
-            migrationsRun: []
-        });
-        await runMigrationCli(baseConfig);
-        expect(mockRunMigrations).toHaveBeenCalledWith(baseConfig, undefined);
-        expect(exitSpy).not.toHaveBeenCalled();
-    });
-    it('should exit with code 1 when run fails', async ()=>{
-        setArgv('run');
-        mockRunMigrations.mockResolvedValue({
-            success: false,
-            error: 'boom'
-        });
-        await expect(runMigrationCli(baseConfig)).rejects.toThrow('process.exit called');
-        expect(exitSpy).toHaveBeenCalledWith(1);
-    });
-    it('should revert the last migration', async ()=>{
-        setArgv('revert');
-        mockRevertMigration.mockResolvedValue({
-            success: true
-        });
-        await runMigrationCli(baseConfig);
-        expect(mockRevertMigration).toHaveBeenCalledWith(baseConfig, undefined);
-    });
-    it('should exit with code 1 when revert fails', async ()=>{
-        setArgv('revert');
-        mockRevertMigration.mockResolvedValue({
-            success: false,
-            error: 'nothing to revert'
-        });
-        await expect(runMigrationCli(baseConfig)).rejects.toThrow('process.exit called');
-        expect(exitSpy).toHaveBeenCalledWith(1);
-    });
-    it('should report migration status', async ()=>{
-        setArgv('status');
-        mockMigrationStatus.mockResolvedValue({
-            success: true,
-            migrationsRun: [
-                'Up to date'
-            ]
-        });
-        await runMigrationCli(baseConfig);
-        expect(mockMigrationStatus).toHaveBeenCalledWith(baseConfig, undefined);
-    });
-    it('should generate a migration using the --name flag', async ()=>{
-        setArgv('generate', '--name=AddProducts');
-        mockGenerateMigration.mockResolvedValue(undefined);
-        await runMigrationCli(baseConfig);
-        expect(mockGenerateMigration).toHaveBeenCalledWith(baseConfig, 'AddProducts', undefined, undefined);
-    });
-    it('should prefer npm_config_name over --name', async ()=>{
-        setArgv('generate', '--name=Ignored');
-        mockTryGetValue.mockImplementation((key)=>key === 'npm_config_name' ? 'FromNpm' : '');
-        mockGenerateMigration.mockResolvedValue(undefined);
-        await runMigrationCli(baseConfig);
-        expect(mockGenerateMigration).toHaveBeenCalledWith(baseConfig, 'FromNpm', undefined, undefined);
-    });
-    it('should exit with code 1 when generate is missing a name', async ()=>{
-        setArgv('generate');
-        await expect(runMigrationCli(baseConfig)).rejects.toThrow('process.exit called');
-        expect(exitSpy).toHaveBeenCalledWith(1);
-        expect(mockGenerateMigration).not.toHaveBeenCalled();
-    });
-    it('should pass the resolved tenant id through to sub-commands', async ()=>{
-        setArgv('run');
-        mockGetTenantId.mockReturnValue('tenant-a');
-        mockRunMigrations.mockResolvedValue({
-            success: true,
-            migrationsRun: []
-        });
-        await runMigrationCli(baseConfig);
-        expect(mockRunMigrations).toHaveBeenCalledWith(baseConfig, 'tenant-a');
-    });
-    it('should reject reset in production without --force', async ()=>{
-        setArgv('reset');
-        mockIsProduction.mockReturnValue(true);
-        await expect(runMigrationCli(baseConfig)).rejects.toThrow('process.exit called');
-        expect(exitSpy).toHaveBeenCalledWith(1);
-        expect(mockResetDatabase).not.toHaveBeenCalled();
-    });
-    it('should allow reset in production when --force is passed', async ()=>{
-        setArgv('reset', '--force');
-        mockIsProduction.mockReturnValue(true);
-        mockResetDatabase.mockResolvedValue({
-            success: true
-        });
-        mockGenerateMigration.mockResolvedValue(undefined);
-        mockRunMigrations.mockResolvedValue({
-            success: true,
-            migrationsRun: []
-        });
-        await runMigrationCli(baseConfig);
-        expect(mockResetDatabase).toHaveBeenCalledWith(baseConfig, undefined);
-        expect(mockGenerateMigration).toHaveBeenCalledWith(baseConfig, 'Init', undefined, undefined);
-        expect(mockRunMigrations).toHaveBeenCalledWith(baseConfig, undefined);
-    });
-    it('should use provided migration name as the reset init migration name', async ()=>{
-        setArgv('reset', '--name=InitialSetup');
-        mockResetDatabase.mockResolvedValue({
-            success: true
-        });
-        mockGenerateMigration.mockResolvedValue(undefined);
-        mockRunMigrations.mockResolvedValue({
-            success: true,
-            migrationsRun: []
-        });
-        await runMigrationCli(baseConfig);
-        expect(mockGenerateMigration).toHaveBeenCalledWith(baseConfig, 'InitialSetup', undefined, undefined);
-    });
-    it('should exit with code 1 when reset fails', async ()=>{
-        setArgv('reset');
-        mockResetDatabase.mockResolvedValue({
-            success: false,
-            error: 'cannot drop'
-        });
-        await expect(runMigrationCli(baseConfig)).rejects.toThrow('process.exit called');
-        expect(exitSpy).toHaveBeenCalledWith(1);
-        expect(mockGenerateMigration).not.toHaveBeenCalled();
-    });
-    it('should reject unknown commands', async ()=>{
-        setArgv('frobnicate');
-        await expect(runMigrationCli(baseConfig)).rejects.toThrow('process.exit called');
-        expect(exitSpy).toHaveBeenCalledWith(1);
-        expect(errorSpy).toHaveBeenCalledWith(expect.stringContaining('Unknown command'));
-    });
-    describe(':all commands', ()=>{
-        it('should run for all tenants when multi-tenant mode is enabled', async ()=>{
-            setArgv('run:all');
-            const multiTenantConfig = {
-                ...baseConfig,
-                bootstrapAppConfig: {
-                    databaseMode: 'multi-tenant'
-                }
-            };
-            mockRunForAllTenants.mockResolvedValue([
-                {
-                    success: true
-                }
-            ]);
-            await runMigrationCli(multiTenantConfig);
-            expect(mockRunForAllTenants).toHaveBeenCalledWith(multiTenantConfig, 'run');
-        });
-        it('should reject :all commands when database mode is single', async ()=>{
-            setArgv('run:all');
-            const singleConfig = {
-                ...baseConfig,
-                bootstrapAppConfig: {
-                    databaseMode: 'single'
-                }
-            };
-            await expect(runMigrationCli(singleConfig)).rejects.toThrow('process.exit called');
-            expect(exitSpy).toHaveBeenCalledWith(1);
-            expect(mockRunForAllTenants).not.toHaveBeenCalled();
-        });
-        it('should exit with code 1 when any tenant fails during :all commands', async ()=>{
-            setArgv('status:all');
-            mockRunForAllTenants.mockResolvedValue([
-                {
-                    success: true
-                },
-                {
-                    success: false
-                }
-            ]);
-            await expect(runMigrationCli(baseConfig)).rejects.toThrow('process.exit called');
-            expect(exitSpy).toHaveBeenCalledWith(1);
-        });
-        it('should parse the action prefix from the :all command', async ()=>{
-            setArgv('revert:all');
-            mockRunForAllTenants.mockResolvedValue([
-                {
-                    success: true
-                }
-            ]);
-            await runMigrationCli(baseConfig);
-            expect(mockRunForAllTenants).toHaveBeenCalledWith(baseConfig, 'revert');
-        });
-    });
-    describe('config resolution', ()=>{
-        it('should load config from an explicit string path argument', async ()=>{
-            setArgv('status');
-            const loadedConfig = {
-                ...baseConfig,
-                migrationsPath: 'custom-migrations'
-            };
-            jest.doMock(require('path').resolve(process.cwd(), 'custom-config.ts'), ()=>({
-                    migrationConfig: loadedConfig
-                }), {
-                virtual: true
-            });
-            mockMigrationStatus.mockResolvedValue({
-                success: true,
-                migrationsRun: [
-                    'Up to date'
-                ]
-            });
-            await runMigrationCli('custom-config.ts');
-            expect(mockMigrationStatus).toHaveBeenCalledWith(loadedConfig, undefined);
-        });
-        it('should exit with code 1 and show help when no config can be resolved', async ()=>{
-            setArgv('status');
-            await expect(runMigrationCli()).rejects.toThrow('process.exit called');
-            expect(exitSpy).toHaveBeenCalledWith(1);
-            expect(errorSpy).toHaveBeenCalledWith(expect.stringContaining('Config not found'));
-        });
-    });
-});