@flusys/nestjs-core 6.0.2 → 6.1.0

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

@@ -0,0 +1,113 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+const _datasourcefactory = require("./datasource.factory");
+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'
+            }))
+    }));
+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 = (0, _datasourcefactory.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'
+                    }
+                ]
+            };
+            (0, _datasourcefactory.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
+            };
+            (0, _datasourcefactory.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 (0, _datasourcefactory.initializeDataSource)({
+                config: baseConfig
+            });
+            expect(mockInitialize).toHaveBeenCalledTimes(1);
+            expect(ds).toBeDefined();
+        });
+        it('should propagate initialization errors', async ()=>{
+            mockInitialize.mockRejectedValue(new Error('connection refused'));
+            await expect((0, _datasourcefactory.initializeDataSource)({
+                config: baseConfig
+            })).rejects.toThrow('connection refused');
+        });
+    });
+});

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

@@ -0,0 +1,293 @@
+"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.spec.js

@@ -0,0 +1,268 @@
+"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([]);
+        });
+    });
+});