@flusys/nestjs-task-manager 6.0.2 → 6.1.0

package/fesm/gateways/task-board.gateway.spec.js

@@ -0,0 +1,239 @@
+import { TaskBoardGateway } from './task-board.gateway';
+function buildSocket(overrides = {}) {
+    return {
+        id: overrides.id ?? 'socket-1',
+        handshake: {
+            auth: overrides.authToken !== undefined ? {
+                token: overrides.authToken
+            } : {},
+            query: overrides.queryToken !== undefined ? {
+                token: overrides.queryToken
+            } : {},
+            headers: overrides.authHeader !== undefined ? {
+                authorization: overrides.authHeader
+            } : {}
+        },
+        data: {},
+        join: jest.fn(),
+        leave: jest.fn(),
+        disconnect: jest.fn()
+    };
+}
+describe('TaskBoardGateway', ()=>{
+    let gateway;
+    let mockConfigService;
+    let mockJwtService;
+    let mockServer;
+    beforeEach(()=>{
+        mockConfigService = {
+            getJwtSecret: jest.fn().mockReturnValue('test-secret')
+        };
+        mockJwtService = {
+            verify: jest.fn()
+        };
+        gateway = new TaskBoardGateway(mockConfigService, mockJwtService);
+        mockServer = {
+            to: jest.fn().mockReturnThis(),
+            emit: jest.fn()
+        };
+        gateway.server = mockServer;
+    });
+    describe('handleConnection', ()=>{
+        it('authenticates via handshake.auth.token, joins the user room and tracks the socket', async ()=>{
+            const socket = buildSocket({
+                id: 'socket-1',
+                authToken: 'valid-token'
+            });
+            mockJwtService.verify.mockReturnValue({
+                id: 'user-1',
+                companyId: 'company-1'
+            });
+            await gateway.handleConnection(socket);
+            expect(mockJwtService.verify).toHaveBeenCalledWith('valid-token', {
+                secret: 'test-secret',
+                algorithms: [
+                    'HS256'
+                ]
+            });
+            expect(socket.data.userId).toBe('user-1');
+            expect(socket.data.companyId).toBe('company-1');
+            expect(socket.join).toHaveBeenCalledWith('user:user-1');
+            expect(gateway.isUserOnline('user-1')).toBe(true);
+            expect(socket.disconnect).not.toHaveBeenCalled();
+        });
+        it('falls back to handshake.query.token when auth.token is absent', async ()=>{
+            const socket = buildSocket({
+                queryToken: 'query-token'
+            });
+            mockJwtService.verify.mockReturnValue({
+                id: 'user-2'
+            });
+            await gateway.handleConnection(socket);
+            expect(mockJwtService.verify).toHaveBeenCalledWith('query-token', expect.anything());
+            expect(socket.data.userId).toBe('user-2');
+        });
+        it('falls back to the Authorization header (Bearer token) when other sources are absent', async ()=>{
+            const socket = buildSocket({
+                authHeader: 'Bearer header-token'
+            });
+            mockJwtService.verify.mockReturnValue({
+                id: 'user-3'
+            });
+            await gateway.handleConnection(socket);
+            expect(mockJwtService.verify).toHaveBeenCalledWith('header-token', expect.anything());
+            expect(socket.data.userId).toBe('user-3');
+        });
+        it('disconnects the socket when no token is present on the handshake', async ()=>{
+            const socket = buildSocket();
+            await gateway.handleConnection(socket);
+            expect(socket.disconnect).toHaveBeenCalled();
+            expect(mockJwtService.verify).not.toHaveBeenCalled();
+        });
+        it('disconnects the socket when the JWT secret is not configured', async ()=>{
+            mockConfigService.getJwtSecret.mockReturnValue(undefined);
+            const socket = buildSocket({
+                authToken: 'some-token'
+            });
+            await gateway.handleConnection(socket);
+            expect(socket.disconnect).toHaveBeenCalled();
+        });
+        it('disconnects the socket when token verification throws (invalid/expired token)', async ()=>{
+            const socket = buildSocket({
+                authToken: 'garbage-token'
+            });
+            mockJwtService.verify.mockImplementation(()=>{
+                throw new Error('invalid signature');
+            });
+            await gateway.handleConnection(socket);
+            expect(socket.disconnect).toHaveBeenCalled();
+        });
+        it('tracks multiple concurrent sockets for the same authenticated user', async ()=>{
+            const socketA = buildSocket({
+                id: 'socket-a',
+                authToken: 'token'
+            });
+            const socketB = buildSocket({
+                id: 'socket-b',
+                authToken: 'token'
+            });
+            mockJwtService.verify.mockReturnValue({
+                id: 'user-multi'
+            });
+            await gateway.handleConnection(socketA);
+            await gateway.handleConnection(socketB);
+            expect(gateway.isUserOnline('user-multi')).toBe(true);
+        });
+    });
+    describe('handleDisconnect', ()=>{
+        it('removes the socket from the connected-users map and marks the user offline once all sockets are gone', async ()=>{
+            const socket = buildSocket({
+                id: 'socket-1',
+                authToken: 'valid-token'
+            });
+            mockJwtService.verify.mockReturnValue({
+                id: 'user-1'
+            });
+            await gateway.handleConnection(socket);
+            expect(gateway.isUserOnline('user-1')).toBe(true);
+            gateway.handleDisconnect(socket);
+            expect(gateway.isUserOnline('user-1')).toBe(false);
+        });
+        it('keeps the user marked online while other sockets for that user remain connected', async ()=>{
+            const socketA = buildSocket({
+                id: 'socket-a',
+                authToken: 'token'
+            });
+            const socketB = buildSocket({
+                id: 'socket-b',
+                authToken: 'token'
+            });
+            mockJwtService.verify.mockReturnValue({
+                id: 'user-1'
+            });
+            await gateway.handleConnection(socketA);
+            await gateway.handleConnection(socketB);
+            gateway.handleDisconnect(socketA);
+            expect(gateway.isUserOnline('user-1')).toBe(true);
+        });
+        it('does nothing when the disconnecting socket has no tracked userId', ()=>{
+            const socket = buildSocket({
+                id: 'never-connected'
+            });
+            expect(()=>gateway.handleDisconnect(socket)).not.toThrow();
+        });
+    });
+    describe('handleJoinBoard / handleLeaveBoard', ()=>{
+        it('joins the board room when a boardId is provided', ()=>{
+            const socket = buildSocket();
+            gateway.handleJoinBoard(socket, {
+                boardId: 'board-1'
+            });
+            expect(socket.join).toHaveBeenCalledWith('board:board-1');
+        });
+        it('does not attempt to join a room when boardId is missing', ()=>{
+            const socket = buildSocket();
+            gateway.handleJoinBoard(socket, {});
+            expect(socket.join).not.toHaveBeenCalled();
+        });
+        it('leaves the board room when a boardId is provided', ()=>{
+            const socket = buildSocket();
+            gateway.handleLeaveBoard(socket, {
+                boardId: 'board-1'
+            });
+            expect(socket.leave).toHaveBeenCalledWith('board:board-1');
+        });
+        it('does not attempt to leave a room when boardId is missing', ()=>{
+            const socket = buildSocket();
+            gateway.handleLeaveBoard(socket, {});
+            expect(socket.leave).not.toHaveBeenCalled();
+        });
+    });
+    describe('emitToBoardRoom', ()=>{
+        it('broadcasts the event to the board room', ()=>{
+            gateway.emitToBoardRoom('board-1', {
+                type: 'task:moved',
+                boardId: 'board-1',
+                payload: {
+                    taskId: 'task-1'
+                }
+            });
+            expect(mockServer.to).toHaveBeenCalledWith('board:board-1');
+            expect(mockServer.emit).toHaveBeenCalledWith('board:event', {
+                type: 'task:moved',
+                boardId: 'board-1',
+                payload: {
+                    taskId: 'task-1'
+                }
+            });
+        });
+        it('broadcasts a list:reordered event', ()=>{
+            gateway.emitToBoardRoom('board-2', {
+                type: 'list:reordered',
+                boardId: 'board-2',
+                payload: {
+                    orderedIds: [
+                        'a',
+                        'b'
+                    ]
+                }
+            });
+            expect(mockServer.to).toHaveBeenCalledWith('board:board-2');
+            expect(mockServer.emit).toHaveBeenCalledWith('board:event', expect.objectContaining({
+                type: 'list:reordered'
+            }));
+        });
+        it('does not throw when the server instance is not yet attached', ()=>{
+            gateway.server = undefined;
+            expect(()=>gateway.emitToBoardRoom('board-1', {
+                    type: 'task:updated',
+                    boardId: 'board-1',
+                    payload: {}
+                })).not.toThrow();
+        });
+    });
+    describe('isUserOnline', ()=>{
+        it('returns false for a user that never connected', ()=>{
+            expect(gateway.isUserOnline('never-seen')).toBe(false);
+        });
+    });
+});

package/fesm/modules/task-manager.module.spec.js

@@ -0,0 +1,140 @@
+function _define_property(obj, key, value) {
+    if (key in obj) {
+        Object.defineProperty(obj, key, {
+            value: value,
+            enumerable: true,
+            configurable: true,
+            writable: true
+        });
+    } else {
+        obj[key] = value;
+    }
+    return obj;
+}
+import { TaskManagerModule } from './task-manager.module';
+import { TASK_MANAGER_MODULE_OPTIONS } from '../config/task-manager.constants';
+import { TaskBoardController, TaskCommentController, TaskLabelController, TaskListController, TaskController } from '../controllers';
+import { TaskBoardGateway } from '../gateways/task-board.gateway';
+function providerTokens(providers) {
+    return providers.map((p)=>typeof p === 'function' ? p : p.provide);
+}
+describe('TaskManagerModule', ()=>{
+    describe('forRoot', ()=>{
+        it('should default to a non-global module with all controllers registered', ()=>{
+            const dynamicModule = TaskManagerModule.forRoot({});
+            expect(dynamicModule.module).toBe(TaskManagerModule);
+            expect(dynamicModule.global).toBe(false);
+            expect(dynamicModule.controllers).toEqual([
+                TaskBoardController,
+                TaskListController,
+                TaskController,
+                TaskLabelController,
+                TaskCommentController
+            ]);
+        });
+        it('should respect global: true', ()=>{
+            expect(TaskManagerModule.forRoot({
+                global: true
+            }).global).toBe(true);
+        });
+        it('should register no controllers when includeController is false', ()=>{
+            expect(TaskManagerModule.forRoot({
+                includeController: false
+            }).controllers).toEqual([]);
+        });
+        it('should register TaskBoardGateway as both a provider and an export', ()=>{
+            const dynamicModule = TaskManagerModule.forRoot({});
+            expect(providerTokens(dynamicModule.providers)).toContain(TaskBoardGateway);
+            expect(dynamicModule.exports).toContain(TaskBoardGateway);
+        });
+        it('should register a TASK_MANAGER_MODULE_OPTIONS provider carrying the given options', ()=>{
+            const options = {
+                bootstrapAppConfig: {}
+            };
+            const dynamicModule = TaskManagerModule.forRoot(options);
+            const provider = dynamicModule.providers.find((p)=>p.provide === TASK_MANAGER_MODULE_OPTIONS);
+            expect(provider.useValue).toBe(options);
+        });
+    });
+    describe('forRootAsync', ()=>{
+        it('should forward external imports alongside CacheModule/UtilsModule', ()=>{
+            let FakeImportedModule = class FakeImportedModule {
+            };
+            const dynamicModule = TaskManagerModule.forRootAsync({
+                imports: [
+                    FakeImportedModule
+                ]
+            });
+            expect(dynamicModule.imports).toEqual(expect.arrayContaining([
+                FakeImportedModule
+            ]));
+        });
+        it('should still register TaskBoardGateway when using async registration', ()=>{
+            const dynamicModule = TaskManagerModule.forRootAsync({
+                useFactory: jest.fn()
+            });
+            expect(providerTokens(dynamicModule.providers)).toContain(TaskBoardGateway);
+            expect(dynamicModule.exports).toContain(TaskBoardGateway);
+        });
+        it('useFactory: builds a TASK_MANAGER_MODULE_OPTIONS provider merging resolved config', async ()=>{
+            const useFactory = jest.fn().mockResolvedValue({
+                foo: 'bar'
+            });
+            const dynamicModule = TaskManagerModule.forRootAsync({
+                useFactory,
+                inject: [
+                    'SOME_TOKEN'
+                ]
+            });
+            const provider = dynamicModule.providers.find((p)=>p.provide === TASK_MANAGER_MODULE_OPTIONS);
+            expect(provider.inject).toEqual([
+                'SOME_TOKEN'
+            ]);
+            const resolved = await provider.useFactory('injected');
+            expect(useFactory).toHaveBeenCalledWith('injected');
+            expect(resolved.config).toEqual({
+                foo: 'bar'
+            });
+        });
+        it('useClass: registers both the class provider and an options provider calling createTaskManagerOptions()', async ()=>{
+            let MyOptionsFactory = class MyOptionsFactory {
+                constructor(){
+                    _define_property(this, "createTaskManagerOptions", jest.fn().mockResolvedValue({
+                        foo: 'from-class'
+                    }));
+                }
+            };
+            const dynamicModule = TaskManagerModule.forRootAsync({
+                useClass: MyOptionsFactory
+            });
+            const classProvider = dynamicModule.providers.find((p)=>p.provide === MyOptionsFactory);
+            expect(classProvider.useClass).toBe(MyOptionsFactory);
+            const optionsProvider = dynamicModule.providers.find((p)=>p.provide === TASK_MANAGER_MODULE_OPTIONS);
+            const instance = new MyOptionsFactory();
+            const resolved = await optionsProvider.useFactory(instance);
+            expect(instance.createTaskManagerOptions).toHaveBeenCalled();
+            expect(resolved.config).toEqual({
+                foo: 'from-class'
+            });
+        });
+        it('useExisting: registers a single options provider without a duplicate class registration', ()=>{
+            let MyOptionsFactory = class MyOptionsFactory {
+                constructor(){
+                    _define_property(this, "createTaskManagerOptions", jest.fn());
+                }
+            };
+            const dynamicModule = TaskManagerModule.forRootAsync({
+                useExisting: MyOptionsFactory
+            });
+            expect(dynamicModule.providers.filter((p)=>p.provide === MyOptionsFactory)).toHaveLength(0);
+            const optionsProvider = dynamicModule.providers.find((p)=>p.provide === TASK_MANAGER_MODULE_OPTIONS);
+            expect(optionsProvider.inject).toEqual([
+                MyOptionsFactory
+            ]);
+        });
+        it('should register no TASK_MANAGER_MODULE_OPTIONS provider when neither useFactory, useClass, nor useExisting is given', ()=>{
+            const dynamicModule = TaskManagerModule.forRootAsync({});
+            expect(providerTokens(dynamicModule.providers)).not.toContain(TASK_MANAGER_MODULE_OPTIONS);
+        });
+    });
+});

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

@@ -0,0 +1,121 @@
+import { Test } from '@nestjs/testing';
+import { TaskActivity } from '../entities';
+import { TaskActivityService } from './task-activity.service';
+import { TaskManagerDataSourceProvider } from './task-manager-datasource.provider';
+describe('TaskActivityService', ()=>{
+    let service;
+    let mockRepo;
+    let mockDataSourceProvider;
+    beforeEach(async ()=>{
+        mockRepo = {
+            create: jest.fn((data)=>({
+                    id: 'activity-uuid-1',
+                    ...data
+                })),
+            save: jest.fn().mockResolvedValue(undefined)
+        };
+        mockDataSourceProvider = {
+            getRepository: jest.fn().mockResolvedValue(mockRepo)
+        };
+        const module = await Test.createTestingModule({
+            providers: [
+                TaskActivityService,
+                {
+                    provide: TaskManagerDataSourceProvider,
+                    useValue: mockDataSourceProvider
+                }
+            ]
+        }).compile();
+        service = await module.resolve(TaskActivityService);
+    });
+    it('lazily resolves the TaskActivity repository from the DataSource provider', async ()=>{
+        await service.log('task-1', 'board-1', 'user-1', 'task.created', null, {
+            title: 'New task'
+        });
+        expect(mockDataSourceProvider.getRepository).toHaveBeenCalledWith(TaskActivity);
+        expect(mockDataSourceProvider.getRepository).toHaveBeenCalledTimes(1);
+    });
+    it('caches the repository across multiple log calls (only resolved once)', async ()=>{
+        await service.log('task-1', 'board-1', 'user-1', 'task.created', null, {
+            title: 'New task'
+        });
+        await service.log('task-1', 'board-1', 'user-1', 'task.moved', {
+            listId: 'a'
+        }, {
+            listId: 'b'
+        });
+        expect(mockDataSourceProvider.getRepository).toHaveBeenCalledTimes(1);
+        expect(mockRepo.save).toHaveBeenCalledTimes(2);
+    });
+    it('records "task.created" activity with title in newValue and null oldValue', async ()=>{
+        await service.log('task-1', 'board-1', 'user-1', 'task.created', null, {
+            title: 'New task'
+        });
+        expect(mockRepo.create).toHaveBeenCalledWith({
+            taskId: 'task-1',
+            boardId: 'board-1',
+            userId: 'user-1',
+            action: 'task.created',
+            oldValue: null,
+            newValue: {
+                title: 'New task'
+            }
+        });
+        expect(mockRepo.save).toHaveBeenCalledWith(expect.objectContaining({
+            action: 'task.created',
+            newValue: {
+                title: 'New task'
+            }
+        }));
+    });
+    it('records "task.moved" activity with old and new listId', async ()=>{
+        await service.log('task-1', 'board-1', 'user-1', 'task.moved', {
+            listId: 'list-old'
+        }, {
+            listId: 'list-new'
+        });
+        expect(mockRepo.create).toHaveBeenCalledWith(expect.objectContaining({
+            action: 'task.moved',
+            oldValue: {
+                listId: 'list-old'
+            },
+            newValue: {
+                listId: 'list-new'
+            }
+        }));
+    });
+    it('records "task.assigned" activity with old and new assigneeIds', async ()=>{
+        await service.log('task-1', 'board-1', 'user-1', 'task.assigned', {
+            assigneeIds: [
+                'u1'
+            ]
+        }, {
+            assigneeIds: [
+                'u1',
+                'u2'
+            ]
+        });
+        expect(mockRepo.create).toHaveBeenCalledWith(expect.objectContaining({
+            action: 'task.assigned',
+            oldValue: {
+                assigneeIds: [
+                    'u1'
+                ]
+            },
+            newValue: {
+                assigneeIds: [
+                    'u1',
+                    'u2'
+                ]
+            }
+        }));
+    });
+    it('records an activity with a null userId (system-initiated action)', async ()=>{
+        await service.log('task-1', 'board-1', null, 'task.created', null, {
+            title: 'System task'
+        });
+        expect(mockRepo.create).toHaveBeenCalledWith(expect.objectContaining({
+            userId: null
+        }));
+    });
+});