@flusys/nestjs-core 7.0.2 → 8.0.0-beta.1

package/cjs/migration/migration.runner.spec.js

@@ -1,268 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", {
-    value: true
-});
-const _migrationrunner = require("./migration.runner");
-const _datasourcefactory = require("./datasource.factory");
-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
-            }))
-    }));
-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);
-        _datasourcefactory.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 = (0, _migrationrunner.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);
-            (0, _migrationrunner.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 (0, _migrationrunner.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 (0, _migrationrunner.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((0, _migrationrunner.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 (0, _migrationrunner.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 (0, _migrationrunner.runMigrations)(baseConfig);
-            expect(result.migrationsRun).toEqual([]);
-            expect(result.success).toBe(true);
-        });
-        it('should capture errors and mark the result as failed', async ()=>{
-            _datasourcefactory.initializeDataSource.mockRejectedValue(new Error('connection refused'));
-            const result = await (0, _migrationrunner.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 (0, _migrationrunner.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 (0, _migrationrunner.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 (0, _migrationrunner.migrationStatus)(baseConfig);
-            expect(result.migrationsRun).toEqual([
-                'Has pending'
-            ]);
-        });
-        it('should report up-to-date status', async ()=>{
-            mockShowMigrations.mockResolvedValue(false);
-            const result = await (0, _migrationrunner.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 (0, _migrationrunner.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 (0, _migrationrunner.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 (0, _migrationrunner.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 (0, _migrationrunner.runForAllTenants)(config, 'run');
-            expect(results).toHaveLength(2);
-            expect(results.every((r)=>r.success)).toBe(true);
-            expect(_datasourcefactory.initializeDataSource).toHaveBeenCalledTimes(2);
-        });
-        it('should return an empty result set when no tenants are configured', async ()=>{
-            const results = await (0, _migrationrunner.runForAllTenants)(baseConfig, 'status');
-            expect(results).toEqual([]);
-        });
-    });
-});

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

@@ -1,103 +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 buildDataSourceOptions () {
-        return buildDataSourceOptions;
-    },
-    get getActiveTenants () {
-        return getActiveTenants;
-    },
-    get getDatabaseForTenant () {
-        return getDatabaseForTenant;
-    },
-    get getMigrationsFolderPath () {
-        return getMigrationsFolderPath;
-    },
-    get getMigrationsGlobPattern () {
-        return getMigrationsGlobPattern;
-    },
-    get resolveDatabaseConnection () {
-        return resolveDatabaseConnection;
-    },
-    get resolveEntities () {
-        return resolveEntities;
-    }
-});
-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
-    };
-}
-function getMigrationsFolderPath(basePath, tenantId) {
-    const folder = tenantId || 'default';
-    return `${basePath}/${folder}`;
-}
-function getMigrationsGlobPattern(basePath, tenantId) {
-    return `${getMigrationsFolderPath(basePath, tenantId)}/*{.ts,.js}`;
-}
-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
-    };
-}
-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
-    };
-}
-function resolveEntities(config, tenantConfig) {
-    if (typeof config.entities === 'function') {
-        return config.entities(tenantConfig);
-    }
-    return config.entities;
-}
-function getActiveTenants(config) {
-    return config.tenants || [];
-}

package/cjs/utils/datasource-config.builder.spec.js

@@ -1,232 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", {
-    value: true
-});
-const _datasourceconfigbuilder = require("./datasource-config.builder");
-describe('datasource-config.builder', ()=>{
-    describe('buildDataSourceOptions', ()=>{
-        it('should build options with synchronize disabled', ()=>{
-            const config = {
-                type: 'postgres',
-                host: 'localhost',
-                port: 5432,
-                username: 'root',
-                password: 'pw',
-                database: 'flusys'
-            };
-            const options = (0, _datasourceconfigbuilder.buildDataSourceOptions)(config, [
-                Object
-            ], 'migrations/default', 'custom_migrations');
-            expect(options).toEqual({
-                type: 'postgres',
-                host: 'localhost',
-                port: 5432,
-                username: 'root',
-                password: 'pw',
-                database: 'flusys',
-                entities: [
-                    Object
-                ],
-                migrations: [
-                    'migrations/default'
-                ],
-                migrationsTableName: 'custom_migrations',
-                synchronize: false
-            });
-        });
-        it('should default database to an empty string and table name to "migrations"', ()=>{
-            const config = {
-                type: 'sqlite'
-            };
-            const options = (0, _datasourceconfigbuilder.buildDataSourceOptions)(config, [], 'migrations/default');
-            expect(options.database).toBe('');
-            expect(options.migrationsTableName).toBe('migrations');
-        });
-    });
-    describe('getMigrationsFolderPath', ()=>{
-        it('should use "default" when no tenantId is given', ()=>{
-            expect((0, _datasourceconfigbuilder.getMigrationsFolderPath)('migrations')).toBe('migrations/default');
-        });
-        it('should namespace the folder by tenant', ()=>{
-            expect((0, _datasourceconfigbuilder.getMigrationsFolderPath)('migrations', 'tenant-a')).toBe('migrations/tenant-a');
-        });
-    });
-    describe('getMigrationsGlobPattern', ()=>{
-        it('should build a glob matching ts and js migration files', ()=>{
-            expect((0, _datasourceconfigbuilder.getMigrationsGlobPattern)('migrations', 'tenant-a')).toBe('migrations/tenant-a/*{.ts,.js}');
-        });
-        it('should fall back to the default folder', ()=>{
-            expect((0, _datasourceconfigbuilder.getMigrationsGlobPattern)('migrations')).toBe('migrations/default/*{.ts,.js}');
-        });
-    });
-    describe('getDatabaseForTenant', ()=>{
-        const baseConfig = {
-            defaultDatabaseConfig: {
-                type: 'postgres',
-                database: 'flusys_default'
-            },
-            migrationsPath: 'migrations',
-            entities: []
-        };
-        it('should return the default tenant config when tenantId is omitted', ()=>{
-            const result = (0, _datasourceconfigbuilder.getDatabaseForTenant)(baseConfig);
-            expect(result.database).toBe('flusys_default');
-            expect(result.tenant).toBeUndefined();
-            expect(result.tenantConfig).toEqual({
-                id: 'default',
-                database: 'flusys_default',
-                enableCompanyFeature: false,
-                permissionMode: 'FULL'
-            });
-        });
-        it('should apply bootstrap feature flags to the default tenant config', ()=>{
-            const config = {
-                ...baseConfig,
-                bootstrapAppConfig: {
-                    databaseMode: 'single',
-                    enableCompanyFeature: true,
-                    permissionMode: 'RBAC'
-                }
-            };
-            const result = (0, _datasourceconfigbuilder.getDatabaseForTenant)(config);
-            expect(result.tenantConfig.enableCompanyFeature).toBe(true);
-            expect(result.tenantConfig.permissionMode).toBe('RBAC');
-        });
-        it('should resolve an explicit tenant by id', ()=>{
-            const config = {
-                ...baseConfig,
-                tenants: [
-                    {
-                        id: 'tenant-a',
-                        database: 'db_a'
-                    },
-                    {
-                        id: 'tenant-b',
-                        database: 'db_b'
-                    }
-                ]
-            };
-            const result = (0, _datasourceconfigbuilder.getDatabaseForTenant)(config, 'tenant-b');
-            expect(result.database).toBe('db_b');
-            expect(result.tenant?.id).toBe('tenant-b');
-            expect(result.tenantConfig.id).toBe('tenant-b');
-        });
-        it('should throw a descriptive error for an unknown tenant id', ()=>{
-            const config = {
-                ...baseConfig,
-                tenants: [
-                    {
-                        id: 'tenant-a',
-                        database: 'db_a'
-                    }
-                ]
-            };
-            expect(()=>(0, _datasourceconfigbuilder.getDatabaseForTenant)(config, 'unknown')).toThrow("Tenant 'unknown' not found. Available: tenant-a");
-        });
-    });
-    describe('resolveDatabaseConnection', ()=>{
-        const baseConfig = {
-            defaultDatabaseConfig: {
-                type: 'postgres',
-                host: 'default-host',
-                port: 5432,
-                username: 'default-user',
-                password: 'default-pw',
-                database: 'flusys_default'
-            },
-            migrationsPath: 'migrations',
-            entities: []
-        };
-        it('should return the default connection when no tenant matches', ()=>{
-            const result = (0, _datasourceconfigbuilder.resolveDatabaseConnection)(baseConfig);
-            expect(result).toEqual(baseConfig.defaultDatabaseConfig);
-        });
-        it('should overlay tenant-specific fields onto the default connection', ()=>{
-            const config = {
-                ...baseConfig,
-                tenants: [
-                    {
-                        id: 'tenant-a',
-                        database: 'db_a',
-                        host: 'tenant-host'
-                    }
-                ]
-            };
-            const result = (0, _datasourceconfigbuilder.resolveDatabaseConnection)(config, 'tenant-a');
-            expect(result).toEqual({
-                type: 'postgres',
-                host: 'tenant-host',
-                port: 5432,
-                username: 'default-user',
-                password: 'default-pw',
-                database: 'db_a'
-            });
-        });
-        it('should fall back to default connection fields when tenant omits them', ()=>{
-            const config = {
-                ...baseConfig,
-                tenants: [
-                    {
-                        id: 'tenant-a',
-                        database: 'db_a'
-                    }
-                ]
-            };
-            const result = (0, _datasourceconfigbuilder.resolveDatabaseConnection)(config, 'tenant-a');
-            expect(result.host).toBe('default-host');
-            expect(result.port).toBe(5432);
-            expect(result.username).toBe('default-user');
-        });
-    });
-    describe('resolveEntities', ()=>{
-        it('should return the entities array directly when not a function', ()=>{
-            const config = {
-                entities: [
-                    Object,
-                    String
-                ]
-            };
-            expect((0, _datasourceconfigbuilder.resolveEntities)(config)).toEqual([
-                Object,
-                String
-            ]);
-        });
-        it('should invoke the resolver function with tenant config', ()=>{
-            const resolver = jest.fn().mockReturnValue([
-                Number
-            ]);
-            const config = {
-                entities: resolver
-            };
-            const tenantConfig = {
-                id: 'tenant-a',
-                database: 'db_a'
-            };
-            const result = (0, _datasourceconfigbuilder.resolveEntities)(config, tenantConfig);
-            expect(resolver).toHaveBeenCalledWith(tenantConfig);
-            expect(result).toEqual([
-                Number
-            ]);
-        });
-    });
-    describe('getActiveTenants', ()=>{
-        it('should return an empty array when no tenants are configured', ()=>{
-            const config = {
-                tenants: undefined
-            };
-            expect((0, _datasourceconfigbuilder.getActiveTenants)(config)).toEqual([]);
-        });
-        it('should return the configured tenants', ()=>{
-            const tenants = [
-                {
-                    id: 'a',
-                    database: 'db_a'
-                }
-            ];
-            const config = {
-                tenants
-            };
-            expect((0, _datasourceconfigbuilder.getActiveTenants)(config)).toBe(tenants);
-        });
-    });
-});

package/cjs/utils/index.js

@@ -1,18 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", {
-    value: true
-});
-_export_star(require("./datasource-config.builder"), exports);
-function _export_star(from, to) {
-    Object.keys(from).forEach(function(k) {
-        if (k !== "default" && !Object.prototype.hasOwnProperty.call(to, k)) {
-            Object.defineProperty(to, k, {
-                enumerable: true,
-                get: function() {
-                    return from[k];
-                }
-            });
-        }
-    });
-    return from;
-}