@flusys/nestjs-task-manager 6.0.2 → 6.1.0

package/fesm/services/task-label.service.spec.js

@@ -0,0 +1,134 @@
+import { Test } from '@nestjs/testing';
+import { UtilsService } from '@flusys/nestjs-shared/modules';
+import { createMockDataSourceProvider, createMockQueryBuilder, createMockRepository } from '@test-utils/mocks/repository.mock';
+import { buildMockUser } from '@test-utils/mocks/logged-user.mock';
+import { TaskLabelService } from './task-label.service';
+import { TaskManagerDataSourceProvider } from './task-manager-datasource.provider';
+function buildTaskLabel(overrides = {}) {
+    return {
+        id: 'label-uuid-1',
+        boardId: 'board-uuid-1',
+        name: 'Bug',
+        color: '#10B981',
+        createdAt: new Date(),
+        updatedAt: new Date(),
+        deletedAt: null,
+        createdById: null,
+        updatedById: null,
+        deletedById: null,
+        ...overrides
+    };
+}
+function mockQueryRunner(repo) {
+    const qr = {
+        connect: jest.fn().mockResolvedValue(undefined),
+        startTransaction: jest.fn().mockResolvedValue(undefined),
+        commitTransaction: jest.fn().mockResolvedValue(undefined),
+        rollbackTransaction: jest.fn().mockResolvedValue(undefined),
+        release: jest.fn().mockResolvedValue(undefined),
+        manager: {
+            save: jest.fn((_target, entities)=>Promise.resolve(entities))
+        }
+    };
+    repo.manager.connection.createQueryRunner.mockReturnValue(qr);
+    return qr;
+}
+describe('TaskLabelService', ()=>{
+    let service;
+    let mockRepo;
+    beforeEach(async ()=>{
+        mockRepo = createMockRepository();
+        const mockDataSourceProvider = createMockDataSourceProvider(mockRepo);
+        const module = await Test.createTestingModule({
+            providers: [
+                TaskLabelService,
+                {
+                    provide: 'CACHE_INSTANCE',
+                    useValue: {}
+                },
+                {
+                    provide: UtilsService,
+                    useValue: {
+                        clearCache: jest.fn(),
+                        getCacheKey: jest.fn(),
+                        trackCacheKey: jest.fn()
+                    }
+                },
+                {
+                    provide: TaskManagerDataSourceProvider,
+                    useValue: mockDataSourceProvider
+                }
+            ]
+        }).compile();
+        service = await module.resolve(TaskLabelService);
+    });
+    describe('convertSingleDtoToEntity (via insert/update)', ()=>{
+        it('creates a label applying the default color when none is given', async ()=>{
+            mockQueryRunner(mockRepo);
+            const result = await service.insert({
+                boardId: 'board-1',
+                name: 'Bug'
+            }, buildMockUser());
+            expect(result).toEqual(expect.objectContaining({
+                boardId: 'board-1',
+                name: 'Bug',
+                color: '#10B981'
+            }));
+        });
+        it('respects an explicit color on create', async ()=>{
+            mockQueryRunner(mockRepo);
+            const result = await service.insert({
+                boardId: 'board-1',
+                name: 'Urgent',
+                color: '#EF4444'
+            }, buildMockUser());
+            expect(result).toEqual(expect.objectContaining({
+                color: '#EF4444'
+            }));
+        });
+        it('throws NotFoundException when updating a non-existent label', async ()=>{
+            mockQueryRunner(mockRepo);
+            mockRepo.findOne.mockResolvedValue(null);
+            await expect(service.update({
+                id: 'missing',
+                name: 'Renamed'
+            }, buildMockUser())).rejects.toThrow();
+        });
+        it('merges update fields onto the existing entity', async ()=>{
+            mockQueryRunner(mockRepo);
+            const existing = buildTaskLabel({
+                id: 'label-1',
+                name: 'Old',
+                color: '#000000'
+            });
+            mockRepo.findOne.mockResolvedValue(existing);
+            const result = await service.update({
+                id: 'label-1',
+                name: 'New'
+            }, buildMockUser());
+            expect(result).toEqual(expect.objectContaining({
+                id: 'label-1',
+                name: 'New',
+                color: '#000000'
+            }));
+        });
+    });
+    describe('getFilterQuery', ()=>{
+        it('filters by boardId when supplied', async ()=>{
+            const qb = createMockQueryBuilder();
+            const { query, isRaw } = await service.getFilterQuery(qb, {
+                boardId: 'board-1'
+            }, buildMockUser());
+            expect(qb.andWhere).toHaveBeenCalledWith('task_label.boardId = :boardId', {
+                boardId: 'board-1'
+            });
+            expect(isRaw).toBe(false);
+            expect(query).toBe(qb);
+        });
+        it('applies no filter when boardId is absent', async ()=>{
+            const qb = createMockQueryBuilder();
+            await service.getFilterQuery(qb, {}, buildMockUser());
+            expect(qb.andWhere).not.toHaveBeenCalled();
+        });
+    });
+});

package/fesm/services/task-list.service.spec.js

@@ -0,0 +1,210 @@
+import { Test } from '@nestjs/testing';
+import { UtilsService } from '@flusys/nestjs-shared/modules';
+import { createMockDataSourceProvider, createMockQueryBuilder, createMockRepository } from '@test-utils/mocks/repository.mock';
+import { buildMockUser } from '@test-utils/mocks/logged-user.mock';
+import { TaskListService } from './task-list.service';
+import { TaskManagerDataSourceProvider } from './task-manager-datasource.provider';
+function buildTaskList(overrides = {}) {
+    return {
+        id: 'list-uuid-1',
+        boardId: 'board-uuid-1',
+        name: 'To Do',
+        color: '#6B7280',
+        position: 0,
+        isActive: true,
+        isDoneList: false,
+        createdAt: new Date(),
+        updatedAt: new Date(),
+        deletedAt: null,
+        createdById: null,
+        updatedById: null,
+        deletedById: null,
+        ...overrides
+    };
+}
+function mockQueryRunner(repo) {
+    const qr = {
+        connect: jest.fn().mockResolvedValue(undefined),
+        startTransaction: jest.fn().mockResolvedValue(undefined),
+        commitTransaction: jest.fn().mockResolvedValue(undefined),
+        rollbackTransaction: jest.fn().mockResolvedValue(undefined),
+        release: jest.fn().mockResolvedValue(undefined),
+        manager: {
+            save: jest.fn((_target, entities)=>Promise.resolve(entities))
+        }
+    };
+    repo.manager.connection.createQueryRunner.mockReturnValue(qr);
+    return qr;
+}
+describe('TaskListService', ()=>{
+    let service;
+    let mockRepo;
+    beforeEach(async ()=>{
+        mockRepo = createMockRepository();
+        const mockDataSourceProvider = createMockDataSourceProvider(mockRepo);
+        const module = await Test.createTestingModule({
+            providers: [
+                TaskListService,
+                {
+                    provide: 'CACHE_INSTANCE',
+                    useValue: {}
+                },
+                {
+                    provide: UtilsService,
+                    useValue: {
+                        clearCache: jest.fn(),
+                        getCacheKey: jest.fn(),
+                        trackCacheKey: jest.fn()
+                    }
+                },
+                {
+                    provide: TaskManagerDataSourceProvider,
+                    useValue: mockDataSourceProvider
+                }
+            ]
+        }).compile();
+        service = await module.resolve(TaskListService);
+    });
+    describe('convertSingleDtoToEntity (via insert)', ()=>{
+        it('creates a list applying default color, position and flags', async ()=>{
+            mockQueryRunner(mockRepo);
+            const result = await service.insert({
+                boardId: 'board-1',
+                name: 'Backlog'
+            }, buildMockUser());
+            expect(result).toEqual(expect.objectContaining({
+                boardId: 'board-1',
+                name: 'Backlog',
+                color: '#6B7280',
+                position: 0,
+                isDoneList: false,
+                isActive: true
+            }));
+        });
+        it('respects explicit color, position and isDoneList on create', async ()=>{
+            mockQueryRunner(mockRepo);
+            const result = await service.insert({
+                boardId: 'board-1',
+                name: 'Done',
+                color: '#22C55E',
+                position: 3,
+                isDoneList: true
+            }, buildMockUser());
+            expect(result).toEqual(expect.objectContaining({
+                color: '#22C55E',
+                position: 3,
+                isDoneList: true
+            }));
+        });
+        it('throws NotFoundException on update when the list does not exist', async ()=>{
+            mockQueryRunner(mockRepo);
+            mockRepo.findOne.mockResolvedValue(null);
+            await expect(service.update({
+                id: 'missing-id',
+                name: 'Renamed'
+            }, buildMockUser())).rejects.toThrow();
+        });
+        it('merges update fields onto the existing entity, preserving unspecified fields', async ()=>{
+            mockQueryRunner(mockRepo);
+            const existing = buildTaskList({
+                id: 'list-1',
+                name: 'Old Name',
+                color: '#111111',
+                position: 5
+            });
+            mockRepo.findOne.mockResolvedValue(existing);
+            const result = await service.update({
+                id: 'list-1',
+                name: 'New Name'
+            }, buildMockUser());
+            expect(result).toEqual(expect.objectContaining({
+                id: 'list-1',
+                name: 'New Name',
+                color: '#111111',
+                position: 5
+            }));
+        });
+    });
+    describe('getFilterQuery', ()=>{
+        it('filters by boardId, filters by isActive and always orders by position ascending', async ()=>{
+            const qb = createMockQueryBuilder();
+            const { query, isRaw } = await service.getFilterQuery(qb, {
+                boardId: 'board-1',
+                isActive: true
+            }, buildMockUser());
+            expect(qb.andWhere).toHaveBeenCalledWith('task_list.boardId = :boardId', {
+                boardId: 'board-1'
+            });
+            expect(qb.andWhere).toHaveBeenCalledWith('task_list.isActive = :isActive', {
+                isActive: true
+            });
+            expect(qb.orderBy).toHaveBeenCalledWith('task_list.position', 'ASC');
+            expect(isRaw).toBe(false);
+            expect(query).toBe(qb);
+        });
+        it('ignores a non-boolean isActive filter value', async ()=>{
+            const qb = createMockQueryBuilder();
+            await service.getFilterQuery(qb, {
+                isActive: 'not-a-boolean'
+            }, buildMockUser());
+            expect(qb.andWhere).not.toHaveBeenCalledWith(expect.stringContaining('isActive'), expect.anything());
+        });
+        it('orders by position even without any filters supplied', async ()=>{
+            const qb = createMockQueryBuilder();
+            await service.getFilterQuery(qb, {}, buildMockUser());
+            expect(qb.orderBy).toHaveBeenCalledWith('task_list.position', 'ASC');
+        });
+    });
+    describe('reorderLists', ()=>{
+        it('assigns positions in steps of 100 following the given order', async ()=>{
+            await service.reorderLists({
+                boardId: 'board-1',
+                orderedIds: [
+                    'list-a',
+                    'list-b',
+                    'list-c'
+                ]
+            });
+            expect(mockRepo.update).toHaveBeenNthCalledWith(1, {
+                id: 'list-a',
+                boardId: 'board-1'
+            }, {
+                position: 0
+            });
+            expect(mockRepo.update).toHaveBeenNthCalledWith(2, {
+                id: 'list-b',
+                boardId: 'board-1'
+            }, {
+                position: 100
+            });
+            expect(mockRepo.update).toHaveBeenNthCalledWith(3, {
+                id: 'list-c',
+                boardId: 'board-1'
+            }, {
+                position: 200
+            });
+        });
+        it('handles reordering a single-item list (position 0)', async ()=>{
+            await service.reorderLists({
+                boardId: 'board-1',
+                orderedIds: [
+                    'only-list'
+                ]
+            });
+            expect(mockRepo.update).toHaveBeenCalledWith({
+                id: 'only-list',
+                boardId: 'board-1'
+            }, {
+                position: 0
+            });
+            expect(mockRepo.update).toHaveBeenCalledTimes(1);
+        });
+        it('does nothing (no updates) for an empty ordered list', async ()=>{
+            await service.reorderLists({
+                boardId: 'board-1',
+                orderedIds: []
+            });
+            expect(mockRepo.update).not.toHaveBeenCalled();
+        });
+    });
+});

package/fesm/services/task-manager-config.service.spec.js

@@ -0,0 +1,94 @@
+import { TaskManagerConfigService } from './task-manager-config.service';
+function buildOptions(overrides = {}) {
+    return {
+        bootstrapAppConfig: undefined,
+        config: undefined,
+        ...overrides
+    };
+}
+describe('TaskManagerConfigService', ()=>{
+    describe('isCompanyFeatureEnabled', ()=>{
+        it('returns true when bootstrapAppConfig enables the company feature', ()=>{
+            const service = new TaskManagerConfigService(buildOptions({
+                bootstrapAppConfig: {
+                    databaseMode: 'single',
+                    enableCompanyFeature: true
+                }
+            }));
+            expect(service.isCompanyFeatureEnabled()).toBe(true);
+        });
+        it('defaults to false when bootstrapAppConfig is missing', ()=>{
+            const service = new TaskManagerConfigService(buildOptions({
+                bootstrapAppConfig: undefined
+            }));
+            expect(service.isCompanyFeatureEnabled()).toBe(false);
+        });
+        it('defaults to false when enableCompanyFeature is not set on bootstrapAppConfig', ()=>{
+            const service = new TaskManagerConfigService(buildOptions({
+                bootstrapAppConfig: {}
+            }));
+            expect(service.isCompanyFeatureEnabled()).toBe(false);
+        });
+    });
+    describe('getDatabaseMode', ()=>{
+        it('returns the configured database mode', ()=>{
+            const service = new TaskManagerConfigService(buildOptions({
+                bootstrapAppConfig: {
+                    databaseMode: 'multi-tenant'
+                }
+            }));
+            expect(service.getDatabaseMode()).toBe('multi-tenant');
+        });
+        it('defaults to "single" when bootstrapAppConfig is missing', ()=>{
+            const service = new TaskManagerConfigService(buildOptions({
+                bootstrapAppConfig: undefined
+            }));
+            expect(service.getDatabaseMode()).toBe('single');
+        });
+    });
+    describe('isMultiTenant', ()=>{
+        it('returns true when database mode is multi-tenant', ()=>{
+            const service = new TaskManagerConfigService(buildOptions({
+                bootstrapAppConfig: {
+                    databaseMode: 'multi-tenant'
+                }
+            }));
+            expect(service.isMultiTenant()).toBe(true);
+        });
+        it('returns false when database mode is single', ()=>{
+            const service = new TaskManagerConfigService(buildOptions({
+                bootstrapAppConfig: {
+                    databaseMode: 'single'
+                }
+            }));
+            expect(service.isMultiTenant()).toBe(false);
+        });
+    });
+    describe('getJwtSecret', ()=>{
+        it('returns the configured jwt secret', ()=>{
+            const service = new TaskManagerConfigService(buildOptions({
+                config: {
+                    jwtSecret: 'super-secret'
+                }
+            }));
+            expect(service.getJwtSecret()).toBe('super-secret');
+        });
+        it('returns undefined when config is missing', ()=>{
+            const service = new TaskManagerConfigService(buildOptions({
+                config: undefined
+            }));
+            expect(service.getJwtSecret()).toBeUndefined();
+        });
+    });
+    describe('getOptions', ()=>{
+        it('returns the exact options object it was constructed with', ()=>{
+            const options = buildOptions({
+                config: {
+                    jwtSecret: 'secret'
+                }
+            });
+            const service = new TaskManagerConfigService(options);
+            expect(service.getOptions()).toBe(options);
+        });
+    });
+});

package/fesm/services/task-manager-datasource.provider.spec.js

@@ -0,0 +1,127 @@
+import { TaskManagerDataSourceProvider } from './task-manager-datasource.provider';
+import { getTaskManagerEntitiesByConfig } from '../entities';
+function buildConfigService(overrides = {}) {
+    const options = {
+        bootstrapAppConfig: {
+            databaseMode: 'single',
+            enableCompanyFeature: false
+        },
+        config: {
+            defaultDatabaseConfig: {
+                type: 'mysql',
+                host: 'localhost',
+                port: 3306,
+                username: 'root',
+                password: 'password',
+                database: 'flusys_test'
+            },
+            tenantDefaultDatabaseConfig: undefined,
+            tenants: []
+        },
+        ...overrides
+    };
+    return {
+        getOptions: jest.fn().mockReturnValue(options),
+        isCompanyFeatureEnabled: jest.fn().mockReturnValue(options.bootstrapAppConfig?.enableCompanyFeature ?? false)
+    };
+}
+describe('TaskManagerDataSourceProvider', ()=>{
+    afterEach(()=>{
+        // Reset the isolated static caches this provider owns so tests don't leak state between runs.
+        TaskManagerDataSourceProvider.tenantConnections = new Map();
+        TaskManagerDataSourceProvider.singleDataSource = null;
+        TaskManagerDataSourceProvider.tenantsRegistry = new Map();
+        TaskManagerDataSourceProvider.initialized = false;
+        TaskManagerDataSourceProvider.connectionLocks = new Map();
+        TaskManagerDataSourceProvider.singleConnectionLock = null;
+    });
+    it('constructs and forwards bootstrap/database config to the base class', ()=>{
+        const configService = buildConfigService();
+        const provider = new TaskManagerDataSourceProvider(configService, undefined);
+        expect(configService.getOptions).toHaveBeenCalled();
+        expect(provider.getDatabaseMode()).toBe('single');
+        expect(provider.isMultiTenant()).toBe(false);
+    });
+    it('reflects multi-tenant mode from bootstrapAppConfig', ()=>{
+        const configService = buildConfigService({
+            bootstrapAppConfig: {
+                databaseMode: 'multi-tenant'
+            }
+        });
+        const provider = new TaskManagerDataSourceProvider(configService, undefined);
+        expect(provider.isMultiTenant()).toBe(true);
+    });
+    it('owns isolated static caches, separate from the base MultiTenantDataSourceService', ()=>{
+        // Each DataSource Provider must override BOTH static cache properties and the
+        // methods that read them — otherwise modules would share connections (see FLUSYS_NEST/CLAUDE.md).
+        expect(TaskManagerDataSourceProvider.tenantConnections).not.toBe(Object.getPrototypeOf(TaskManagerDataSourceProvider).tenantConnections);
+    });
+    describe('getEnableCompanyFeatureForTenant', ()=>{
+        it('uses the tenant override when the tenant explicitly sets enableCompanyFeature', ()=>{
+            const configService = buildConfigService();
+            configService.isCompanyFeatureEnabled.mockReturnValue(false);
+            const provider = new TaskManagerDataSourceProvider(configService, undefined);
+            const result = provider.getEnableCompanyFeatureForTenant({
+                enableCompanyFeature: true
+            });
+            expect(result).toBe(true);
+        });
+        it('falls back to the module-level config when tenant does not override', ()=>{
+            const configService = buildConfigService();
+            configService.isCompanyFeatureEnabled.mockReturnValue(true);
+            const provider = new TaskManagerDataSourceProvider(configService, undefined);
+            const result = provider.getEnableCompanyFeatureForTenant(undefined);
+            expect(result).toBe(true);
+            expect(configService.isCompanyFeatureEnabled).toHaveBeenCalled();
+        });
+        it('falls back to module-level config when tenant is provided without the flag set', ()=>{
+            const configService = buildConfigService();
+            configService.isCompanyFeatureEnabled.mockReturnValue(false);
+            const provider = new TaskManagerDataSourceProvider(configService, undefined);
+            const result = provider.getEnableCompanyFeatureForTenant({});
+            expect(result).toBe(false);
+        });
+    });
+    describe('createDataSourceFromConfig', ()=>{
+        it('builds a DataSource using core entities when company feature is disabled', async ()=>{
+            const configService = buildConfigService();
+            configService.isCompanyFeatureEnabled.mockReturnValue(false);
+            const provider = new TaskManagerDataSourceProvider(configService, undefined);
+            const fakeDataSource = {
+                isInitialized: true
+            };
+            const superSpy = jest.spyOn(Object.getPrototypeOf(Object.getPrototypeOf(provider)), 'createDataSourceFromConfig').mockResolvedValue(fakeDataSource);
+            const config = {
+                type: 'mysql',
+                host: 'localhost',
+                port: 3306,
+                username: 'root',
+                password: 'password',
+                database: 'flusys_test'
+            };
+            const result = await provider.createDataSourceFromConfig(config);
+            expect(superSpy).toHaveBeenCalledWith(config, getTaskManagerEntitiesByConfig(false));
+            expect(result).toBe(fakeDataSource);
+            superSpy.mockRestore();
+        });
+        it('builds a DataSource using company entities when the tenant enables the company feature', async ()=>{
+            const configService = buildConfigService();
+            configService.isCompanyFeatureEnabled.mockReturnValue(false);
+            const provider = new TaskManagerDataSourceProvider(configService, undefined);
+            jest.spyOn(provider, 'getCurrentTenant').mockReturnValue({
+                enableCompanyFeature: true
+            });
+            const fakeDataSource = {
+                isInitialized: true
+            };
+            const superSpy = jest.spyOn(Object.getPrototypeOf(Object.getPrototypeOf(provider)), 'createDataSourceFromConfig').mockResolvedValue(fakeDataSource);
+            const config = {
+                type: 'mysql',
+                database: 'flusys_test'
+            };
+            await provider.createDataSourceFromConfig(config);
+            expect(superSpy).toHaveBeenCalledWith(config, getTaskManagerEntitiesByConfig(true));
+            superSpy.mockRestore();
+        });
+    });
+});