@flusys/nestjs-core 7.1.0 → 8.0.0

package/cjs/migration/migration.cli.spec.js

@@ -1,293 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", {
-    value: true
-});
-const _migrationcli = require("./migration.cli");
-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)
-    }));
-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 (0, _migrationcli.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 (0, _migrationcli.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((0, _migrationcli.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 (0, _migrationcli.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((0, _migrationcli.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 (0, _migrationcli.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 (0, _migrationcli.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 (0, _migrationcli.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((0, _migrationcli.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 (0, _migrationcli.runMigrationCli)(baseConfig);
-        expect(mockRunMigrations).toHaveBeenCalledWith(baseConfig, 'tenant-a');
-    });
-    it('should reject reset in production without --force', async ()=>{
-        setArgv('reset');
-        mockIsProduction.mockReturnValue(true);
-        await expect((0, _migrationcli.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 (0, _migrationcli.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 (0, _migrationcli.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((0, _migrationcli.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((0, _migrationcli.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 (0, _migrationcli.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((0, _migrationcli.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((0, _migrationcli.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 (0, _migrationcli.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 (0, _migrationcli.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((0, _migrationcli.runMigrationCli)()).rejects.toThrow('process.exit called');
-            expect(exitSpy).toHaveBeenCalledWith(1);
-            expect(errorSpy).toHaveBeenCalledWith(expect.stringContaining('Config not found'));
-        });
-    });
-});

package/cjs/migration/migration.runner.js

@@ -1,276 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", {
-    value: true
-});
-function _export(target, all) {
-    for(var name in all)Object.defineProperty(target, name, {
-        enumerable: true,
-        get: Object.getOwnPropertyDescriptor(all, name).get
-    });
-}
-_export(exports, {
-    get ensureMigrationsFolder () {
-        return ensureMigrationsFolder;
-    },
-    get generateMigration () {
-        return generateMigration;
-    },
-    get migrationStatus () {
-        return migrationStatus;
-    },
-    get resetDatabase () {
-        return resetDatabase;
-    },
-    get revertMigration () {
-        return revertMigration;
-    },
-    get runForAllTenants () {
-        return runForAllTenants;
-    },
-    get runMigrations () {
-        return runMigrations;
-    }
-});
-const _child_process = require("child_process");
-const _fs = /*#__PURE__*/ _interop_require_wildcard(require("fs"));
-const _path = /*#__PURE__*/ _interop_require_wildcard(require("path"));
-const _typeorm = require("typeorm");
-const _config = require("../config");
-const _utils = require("../utils");
-const _datasourcefactory = require("./datasource.factory");
-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 getLabel(tenantId) {
-    return tenantId ? `[${tenantId}]` : '[default]';
-}
-async function withDataSource(config, tenantId, operation) {
-    const { database } = (0, _utils.getDatabaseForTenant)(config, tenantId);
-    const label = getLabel(tenantId);
-    try {
-        const ds = await (0, _datasourcefactory.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
-        };
-    }
-}
-function ensureMigrationsFolder(basePath, tenantId) {
-    const folder = (0, _utils.getMigrationsFolderPath)(basePath, tenantId);
-    if (!_fs.existsSync(folder)) {
-        _fs.mkdirSync(folder, {
-            recursive: true
-        });
-        console.log(`📁 Created: ${folder}`);
-    }
-    return folder;
-}
-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}"`;
-    (0, _child_process.execSync)(command, {
-        stdio: 'inherit',
-        env: {
-            ..._config.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>');
-}
-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)
-        };
-    });
-}
-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 = (0, _utils.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 _typeorm.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();
-    }
-}
-async function resetDatabase(config, tenantId) {
-    const { database } = (0, _utils.getDatabaseForTenant)(config, tenantId);
-    const label = getLabel(tenantId);
-    try {
-        clearMigrationFiles(config.migrationsPath, tenantId, label);
-        const dbConfig = (0, _utils.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
-        };
-    }
-}
-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'
-            ]
-        };
-    });
-}
-async function runForAllTenants(config, command) {
-    const tenants = (0, _utils.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;
-}