@flusys/nestjs-core 7.1.0 → 8.0.0

package/fesm/migration/migration.runner.js

@@ -1,202 +0,0 @@
-import { execSync } from 'child_process';
-import * as fs from 'fs';
-import * as path from 'path';
-import { DataSource } from 'typeorm';
-import { envConfig } from '../config';
-import { getActiveTenants, getDatabaseForTenant, getMigrationsFolderPath, resolveDatabaseConnection } 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)) {
-        fs.mkdirSync(folder, {
-            recursive: true
-        });
-        console.log(`📁 Created: ${folder}`);
-    }
-    return folder;
-}
-export async function generateMigration(config, name, tenantId, datasourcePath) {
-    const label = tenantId ? `[${tenantId}]` : '[default]';
-    const folder = ensureMigrationsFolder(config.migrationsPath, tenantId);
-    console.log(`${label} Generating migration: ${name}`);
-    console.log(`${label} Target folder: ${folder}`);
-    const dsPath = datasourcePath || findDatasourcePath();
-    const migrationFile = path.join(folder, name);
-    const command = `ts-node -r tsconfig-paths/register ./node_modules/typeorm/cli migration:generate "${migrationFile}" -d "${dsPath}"`;
-    execSync(command, {
-        stdio: 'inherit',
-        env: {
-            ...envConfig.getEnv(),
-            TENANT_ID: tenantId || ''
-        },
-        cwd: process.cwd()
-    });
-    console.log(`${label} ✓ Generated!`);
-}
-function findDatasourcePath() {
-    const possiblePaths = [
-        'src/persistence/migration.config.ts',
-        'projects/flusysnest/src/persistence/migration.config.ts'
-    ];
-    for (const p of possiblePaths){
-        if (fs.existsSync(path.join(process.cwd(), p))) {
-            return p;
-        }
-    }
-    throw new Error('Could not find datasource file. Specify with --datasource=<path>');
-}
-export async function runMigrations(config, tenantId) {
-    return withDataSource(config, tenantId, async (ds, label)=>{
-        const migrations = await ds.runMigrations();
-        if (migrations.length === 0) {
-            console.log(`${label} No pending migrations.`);
-        } else {
-            console.log(`${label} ✓ Executed ${migrations.length} migration(s):`);
-            migrations.forEach((m)=>console.log(`   - ${m.name}`));
-        }
-        return {
-            migrationsRun: migrations.map((m)=>m.name)
-        };
-    });
-}
-export async function revertMigration(config, tenantId) {
-    return withDataSource(config, tenantId, async (ds, label)=>{
-        await ds.undoLastMigration();
-        console.log(`${label} ✓ Reverted!`);
-        return {};
-    });
-}
-function clearMigrationFiles(basePath, tenantId, label) {
-    const folder = getMigrationsFolderPath(basePath, tenantId);
-    if (!fs.existsSync(folder)) return;
-    const files = fs.readdirSync(folder).filter((f)=>f.endsWith('.ts') || f.endsWith('.js'));
-    files.forEach((file)=>fs.rmSync(path.join(folder, file)));
-    console.log(`${label} ✓ Removed ${files.length} migration file(s) from ${folder}`);
-}
-async function dropAndRecreateDatabase(dbConfig, label) {
-    const { type, database } = dbConfig;
-    if (type === 'sqlite') {
-        if (database && fs.existsSync(database)) fs.rmSync(database);
-        console.log(`${label} ✓ Deleted sqlite file`);
-        return;
-    }
-    if (type !== 'mysql' && type !== 'mariadb' && type !== 'postgres') {
-        throw new Error(`Database reset is not supported for type '${type}'`);
-    }
-    const adminDs = new DataSource({
-        type,
-        host: dbConfig.host,
-        port: dbConfig.port,
-        username: dbConfig.username,
-        password: dbConfig.password,
-        database: type === 'postgres' ? 'postgres' : undefined
-    });
-    await adminDs.initialize();
-    try {
-        if (type === 'postgres') {
-            await adminDs.query(`SELECT pg_terminate_backend(pid) FROM pg_stat_activity WHERE datname = $1 AND pid <> pg_backend_pid()`, [
-                database
-            ]);
-            await adminDs.query(`DROP DATABASE IF EXISTS "${database}"`);
-            await adminDs.query(`CREATE DATABASE "${database}"`);
-        } else {
-            await adminDs.query(`DROP DATABASE IF EXISTS \`${database}\``);
-            await adminDs.query(`CREATE DATABASE \`${database}\` CHARACTER SET utf8mb4`);
-        }
-        console.log(`${label} ✓ Database '${database}' dropped and recreated`);
-    } finally{
-        await adminDs.destroy();
-    }
-}
-export async function resetDatabase(config, tenantId) {
-    const { database } = getDatabaseForTenant(config, tenantId);
-    const label = getLabel(tenantId);
-    try {
-        clearMigrationFiles(config.migrationsPath, tenantId, label);
-        const dbConfig = resolveDatabaseConnection(config, tenantId);
-        await dropAndRecreateDatabase(dbConfig, label);
-        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
-        };
-    }
-}
-export async function migrationStatus(config, tenantId) {
-    return withDataSource(config, tenantId, async (ds, label)=>{
-        const hasPending = await ds.showMigrations();
-        console.log(`${label} Pending: ${hasPending ? 'Yes' : 'No'}`);
-        return {
-            migrationsRun: [
-                hasPending ? 'Has pending' : 'Up to date'
-            ]
-        };
-    });
-}
-export async function runForAllTenants(config, command) {
-    const tenants = getActiveTenants(config);
-    console.log(`\n🔄 Running '${command}' for ${tenants.length} tenant(s)...\n`);
-    const results = [];
-    for (const tenant of tenants){
-        let result;
-        switch(command){
-            case 'run':
-                result = await runMigrations(config, tenant.id);
-                break;
-            case 'revert':
-                result = await revertMigration(config, tenant.id);
-                break;
-            case 'status':
-                result = await migrationStatus(config, tenant.id);
-                break;
-        }
-        results.push(result);
-        console.log('');
-    }
-    console.log('\n=== Summary ===');
-    results.forEach((r)=>{
-        const icon = r.success ? '✓' : '✗';
-        const msg = r.error ? ` - ${r.error}` : '';
-        console.log(`${icon} ${r.tenantId || 'default'}${msg}`);
-    });
-    return results;
-}

package/fesm/migration/migration.runner.spec.js

@@ -1,264 +0,0 @@
-const mockExistsSync = jest.fn();
-const mockMkdirSync = jest.fn();
-const mockReaddirSync = jest.fn();
-const mockRmSync = jest.fn();
-const mockExecSync = jest.fn();
-jest.mock('fs', ()=>({
-        existsSync: (...args)=>mockExistsSync(...args),
-        mkdirSync: (...args)=>mockMkdirSync(...args),
-        readdirSync: (...args)=>mockReaddirSync(...args),
-        rmSync: (...args)=>mockRmSync(...args)
-    }));
-jest.mock('child_process', ()=>({
-        execSync: (...args)=>mockExecSync(...args)
-    }));
-jest.mock('../config', ()=>({
-        envConfig: {
-            getEnv: jest.fn().mockReturnValue({
-                NODE_ENV: 'test'
-            })
-        }
-    }));
-const mockRunMigrations = jest.fn();
-const mockUndoLastMigration = jest.fn();
-const mockShowMigrations = jest.fn();
-const mockDestroy = jest.fn();
-const mockDsInitialize = jest.fn();
-const mockAdminInitialize = jest.fn();
-const mockAdminQuery = jest.fn();
-const mockAdminDestroy = jest.fn();
-jest.mock('./datasource.factory', ()=>({
-        initializeDataSource: jest.fn()
-    }));
-jest.mock('typeorm', ()=>({
-        DataSource: jest.fn().mockImplementation(()=>({
-                initialize: mockAdminInitialize,
-                query: mockAdminQuery,
-                destroy: mockAdminDestroy
-            }))
-    }));
-import { ensureMigrationsFolder, generateMigration, runMigrations, revertMigration, resetDatabase, migrationStatus, runForAllTenants } from './migration.runner';
-import { initializeDataSource } from './datasource.factory';
-describe('migration.runner', ()=>{
-    const baseConfig = {
-        defaultDatabaseConfig: {
-            type: 'postgres',
-            database: 'flusys_default'
-        },
-        migrationsPath: 'migrations',
-        entities: []
-    };
-    let logSpy;
-    let errorSpy;
-    beforeEach(()=>{
-        jest.clearAllMocks();
-        logSpy = jest.spyOn(console, 'log').mockImplementation(()=>undefined);
-        errorSpy = jest.spyOn(console, 'error').mockImplementation(()=>undefined);
-        initializeDataSource.mockResolvedValue({
-            runMigrations: mockRunMigrations,
-            undoLastMigration: mockUndoLastMigration,
-            showMigrations: mockShowMigrations,
-            destroy: mockDestroy,
-            initialize: mockDsInitialize
-        });
-    });
-    afterEach(()=>{
-        logSpy.mockRestore();
-        errorSpy.mockRestore();
-    });
-    describe('ensureMigrationsFolder', ()=>{
-        it('should create the folder when it does not exist', ()=>{
-            mockExistsSync.mockReturnValue(false);
-            const folder = ensureMigrationsFolder('migrations', 'tenant-a');
-            expect(folder).toBe('migrations/tenant-a');
-            expect(mockMkdirSync).toHaveBeenCalledWith('migrations/tenant-a', {
-                recursive: true
-            });
-        });
-        it('should not create the folder when it already exists', ()=>{
-            mockExistsSync.mockReturnValue(true);
-            ensureMigrationsFolder('migrations');
-            expect(mockMkdirSync).not.toHaveBeenCalled();
-        });
-    });
-    describe('generateMigration', ()=>{
-        it('should shell out to the typeorm CLI with the resolved datasource path', async ()=>{
-            mockExistsSync.mockImplementation((p)=>p.includes('flusysnest'));
-            await generateMigration(baseConfig, 'AddProductTable', 'tenant-a');
-            expect(mockExecSync).toHaveBeenCalledTimes(1);
-            const [command, options] = mockExecSync.mock.calls[0];
-            expect(command).toContain('migration:generate');
-            expect(command).toContain('migrations/tenant-a/AddProductTable');
-            expect(command).toContain('projects/flusysnest/src/persistence/migration.config.ts');
-            expect(options.env.TENANT_ID).toBe('tenant-a');
-        });
-        it('should use an explicit datasource path when provided', async ()=>{
-            mockExistsSync.mockReturnValue(false);
-            await generateMigration(baseConfig, 'AddProductTable', undefined, 'custom/datasource.ts');
-            const [command] = mockExecSync.mock.calls[0];
-            expect(command).toContain('-d "custom/datasource.ts"');
-        });
-        it('should throw when no datasource file can be found and none is specified', async ()=>{
-            mockExistsSync.mockReturnValue(false);
-            await expect(generateMigration(baseConfig, 'AddProductTable')).rejects.toThrow('Could not find datasource file. Specify with --datasource=<path>');
-        });
-    });
-    describe('runMigrations', ()=>{
-        it('should report success with the list of executed migrations', async ()=>{
-            mockRunMigrations.mockResolvedValue([
-                {
-                    name: 'M1'
-                },
-                {
-                    name: 'M2'
-                }
-            ]);
-            const result = await runMigrations(baseConfig);
-            expect(result).toEqual({
-                tenantId: undefined,
-                database: 'flusys_default',
-                success: true,
-                migrationsRun: [
-                    'M1',
-                    'M2'
-                ]
-            });
-            expect(mockDestroy).toHaveBeenCalled();
-        });
-        it('should report no pending migrations when none run', async ()=>{
-            mockRunMigrations.mockResolvedValue([]);
-            const result = await runMigrations(baseConfig);
-            expect(result.migrationsRun).toEqual([]);
-            expect(result.success).toBe(true);
-        });
-        it('should capture errors and mark the result as failed', async ()=>{
-            initializeDataSource.mockRejectedValue(new Error('connection refused'));
-            const result = await runMigrations(baseConfig, 'tenant-a');
-            expect(result).toEqual({
-                tenantId: 'tenant-a',
-                database: 'flusys_default',
-                success: false,
-                error: 'connection refused'
-            });
-            expect(errorSpy).toHaveBeenCalled();
-        });
-    });
-    describe('revertMigration', ()=>{
-        it('should undo the last migration and close the connection', async ()=>{
-            const result = await revertMigration(baseConfig);
-            expect(mockUndoLastMigration).toHaveBeenCalled();
-            expect(mockDestroy).toHaveBeenCalled();
-            expect(result.success).toBe(true);
-        });
-        it('should capture revert errors', async ()=>{
-            mockUndoLastMigration.mockRejectedValue(new Error('no migrations to revert'));
-            const result = await revertMigration(baseConfig);
-            expect(result.success).toBe(false);
-            expect(result.error).toBe('no migrations to revert');
-        });
-    });
-    describe('migrationStatus', ()=>{
-        it('should report pending status', async ()=>{
-            mockShowMigrations.mockResolvedValue(true);
-            const result = await migrationStatus(baseConfig);
-            expect(result.migrationsRun).toEqual([
-                'Has pending'
-            ]);
-        });
-        it('should report up-to-date status', async ()=>{
-            mockShowMigrations.mockResolvedValue(false);
-            const result = await migrationStatus(baseConfig);
-            expect(result.migrationsRun).toEqual([
-                'Up to date'
-            ]);
-        });
-    });
-    describe('resetDatabase', ()=>{
-        it('should remove migration files then drop/recreate a postgres database', async ()=>{
-            mockExistsSync.mockReturnValue(true);
-            mockReaddirSync.mockReturnValue([
-                '1-init.ts',
-                '2-add.js',
-                'readme.md'
-            ]);
-            mockAdminQuery.mockResolvedValue(undefined);
-            const config = {
-                defaultDatabaseConfig: {
-                    type: 'postgres',
-                    host: 'localhost',
-                    port: 5432,
-                    username: 'root',
-                    password: 'pw',
-                    database: 'flusys_default'
-                },
-                migrationsPath: 'migrations',
-                entities: []
-            };
-            const result = await resetDatabase(config);
-            expect(mockRmSync).toHaveBeenCalledTimes(2);
-            expect(mockAdminQuery).toHaveBeenCalledWith(expect.stringContaining('DROP DATABASE IF EXISTS "flusys_default"'));
-            expect(mockAdminDestroy).toHaveBeenCalled();
-            expect(result.success).toBe(true);
-        });
-        it('should delete the sqlite file directly for sqlite databases', async ()=>{
-            mockExistsSync.mockReturnValue(true);
-            mockReaddirSync.mockReturnValue([]);
-            const config = {
-                defaultDatabaseConfig: {
-                    type: 'sqlite',
-                    database: 'flusys.sqlite'
-                },
-                migrationsPath: 'migrations',
-                entities: []
-            };
-            const result = await resetDatabase(config);
-            expect(mockRmSync).toHaveBeenCalledWith('flusys.sqlite');
-            expect(mockAdminInitialize).not.toHaveBeenCalled();
-            expect(result.success).toBe(true);
-        });
-        it('should fail for unsupported database types', async ()=>{
-            mockExistsSync.mockReturnValue(false);
-            const config = {
-                defaultDatabaseConfig: {
-                    type: 'mssql',
-                    database: 'flusys'
-                },
-                migrationsPath: 'migrations',
-                entities: []
-            };
-            const result = await resetDatabase(config);
-            expect(result.success).toBe(false);
-            expect(result.error).toContain("Database reset is not supported for type 'mssql'");
-        });
-    });
-    describe('runForAllTenants', ()=>{
-        it('should run the given command across all configured tenants and summarize results', async ()=>{
-            mockRunMigrations.mockResolvedValue([
-                {
-                    name: 'M1'
-                }
-            ]);
-            const config = {
-                ...baseConfig,
-                tenants: [
-                    {
-                        id: 'tenant-a',
-                        database: 'db_a'
-                    },
-                    {
-                        id: 'tenant-b',
-                        database: 'db_b'
-                    }
-                ]
-            };
-            const results = await runForAllTenants(config, 'run');
-            expect(results).toHaveLength(2);
-            expect(results.every((r)=>r.success)).toBe(true);
-            expect(initializeDataSource).toHaveBeenCalledTimes(2);
-        });
-        it('should return an empty result set when no tenants are configured', async ()=>{
-            const results = await runForAllTenants(baseConfig, 'status');
-            expect(results).toEqual([]);
-        });
-    });
-});

package/fesm/utils/datasource-config.builder.js

@@ -1,84 +0,0 @@
-/**
- * Build DataSource options from database config
- */ export function buildDataSourceOptions(config, entities, migrationsPath, migrationsTableName = 'migrations') {
-    return {
-        type: config.type,
-        host: config.host,
-        port: config.port,
-        username: config.username,
-        password: config.password,
-        database: config.database || '',
-        entities,
-        migrations: [
-            migrationsPath
-        ],
-        migrationsTableName,
-        synchronize: false
-    };
-}
-/**
- * Get migration folder path for a tenant
- */ export function getMigrationsFolderPath(basePath, tenantId) {
-    const folder = tenantId || 'default';
-    return `${basePath}/${folder}`;
-}
-/**
- * Get migrations glob pattern for a tenant
- */ export function getMigrationsGlobPattern(basePath, tenantId) {
-    return `${getMigrationsFolderPath(basePath, tenantId)}/*{.ts,.js}`;
-}
-/**
- * Get database and config for a tenant (or default)
- */ export function getDatabaseForTenant(config, tenantId) {
-    if (tenantId && config.tenants) {
-        const tenant = config.tenants.find((t)=>t.id === tenantId);
-        if (!tenant) {
-            throw new Error(`Tenant '${tenantId}' not found. Available: ${config.tenants.map((t)=>t.id).join(', ')}`);
-        }
-        return {
-            database: tenant.database,
-            tenant,
-            tenantConfig: tenant
-        };
-    }
-    // Default config - use bootstrapAppConfig for feature flags
-    const defaultTenantConfig = {
-        id: 'default',
-        database: config.defaultDatabaseConfig.database || 'default',
-        enableCompanyFeature: config.bootstrapAppConfig?.enableCompanyFeature ?? false,
-        permissionMode: config.bootstrapAppConfig?.permissionMode ?? 'FULL'
-    };
-    return {
-        database: defaultTenantConfig.database,
-        tenantConfig: defaultTenantConfig
-    };
-}
-/**
- * Resolve full connection details for a tenant.
- */ export function resolveDatabaseConnection(config, tenantId) {
-    const { database, tenant } = getDatabaseForTenant(config, tenantId);
-    return tenant ? {
-        ...config.defaultDatabaseConfig,
-        host: tenant.host ?? config.defaultDatabaseConfig.host,
-        port: tenant.port ?? config.defaultDatabaseConfig.port,
-        username: tenant.username ?? config.defaultDatabaseConfig.username,
-        password: tenant.password ?? config.defaultDatabaseConfig.password,
-        database: tenant.database
-    } : {
-        ...config.defaultDatabaseConfig,
-        database
-    };
-}
-/**
- * Resolve entities based on tenant config
- */ export function resolveEntities(config, tenantConfig) {
-    if (typeof config.entities === 'function') {
-        return config.entities(tenantConfig);
-    }
-    return config.entities;
-}
-/**
- * Get active tenants from config
- */ export function getActiveTenants(config) {
-    return config.tenants || [];
-}