@flusys/nestjs-task-manager 6.0.2 → 6.1.0

package/cjs/controllers/task-board.controller.spec.js

@@ -0,0 +1,132 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+const _loggedusermock = require("@test-utils/mocks/logged-user.mock");
+const _taskboardcontroller = require("./task-board.controller");
+function buildBoard(overrides = {}) {
+    return {
+        id: 'board-uuid-1',
+        name: 'Sprint Board',
+        description: null,
+        isActive: true,
+        readOnly: false,
+        createdAt: new Date(),
+        updatedAt: new Date(),
+        ...overrides
+    };
+}
+describe('TaskBoardController', ()=>{
+    let controller;
+    let mockBoardService;
+    beforeEach(()=>{
+        mockBoardService = {
+            insert: jest.fn(),
+            findById: jest.fn(),
+            getAll: jest.fn(),
+            update: jest.fn(),
+            delete: jest.fn(),
+            addMember: jest.fn(),
+            removeMember: jest.fn(),
+            getMembers: jest.fn()
+        };
+        controller = new _taskboardcontroller.TaskBoardController(mockBoardService);
+    });
+    describe('insert', ()=>{
+        it('creates a board and returns the mapped response', async ()=>{
+            const user = (0, _loggedusermock.buildMockUser)();
+            mockBoardService.insert.mockResolvedValue(buildBoard());
+            const result = await controller.insert({
+                name: 'Sprint Board'
+            }, user);
+            expect(mockBoardService.insert).toHaveBeenCalledWith({
+                name: 'Sprint Board'
+            }, user);
+            expect(result.success).toBe(true);
+            expect(result.data).toEqual(expect.objectContaining({
+                id: 'board-uuid-1'
+            }));
+        });
+    });
+    describe('getAll', ()=>{
+        it('paginates boards and maps the response list', async ()=>{
+            mockBoardService.getAll.mockResolvedValue({
+                data: [
+                    buildBoard()
+                ],
+                total: 1
+            });
+            const result = await controller.getAll({}, (0, _loggedusermock.buildMockUser)(), '');
+            expect(mockBoardService.getAll).toHaveBeenCalledWith('', {}, (0, _loggedusermock.buildMockUser)());
+            expect(result.data).toHaveLength(1);
+        });
+    });
+    describe('addMember', ()=>{
+        it('adds a member to the board and maps the response', async ()=>{
+            const user = (0, _loggedusermock.buildMockUser)();
+            mockBoardService.addMember.mockResolvedValue({
+                id: 'member-1',
+                boardId: 'board-uuid-1',
+                userId: 'user-2',
+                role: 'member'
+            });
+            const result = await controller.addMember({
+                boardId: 'board-uuid-1',
+                userId: 'user-2'
+            }, user);
+            expect(mockBoardService.addMember).toHaveBeenCalledWith({
+                boardId: 'board-uuid-1',
+                userId: 'user-2'
+            }, user);
+            expect(result.success).toBe(true);
+            expect(result.data).toEqual(expect.objectContaining({
+                userId: 'user-2'
+            }));
+        });
+    });
+    describe('removeMember', ()=>{
+        it('removes a member from the board', async ()=>{
+            mockBoardService.removeMember.mockResolvedValue(undefined);
+            const result = await controller.removeMember({
+                boardId: 'board-uuid-1',
+                userId: 'user-2'
+            });
+            expect(mockBoardService.removeMember).toHaveBeenCalledWith({
+                boardId: 'board-uuid-1',
+                userId: 'user-2'
+            });
+            expect(result.success).toBe(true);
+        });
+    });
+    describe('getMembers', ()=>{
+        it('returns all members for a board with a computed pagination meta', async ()=>{
+            mockBoardService.getMembers.mockResolvedValue([
+                {
+                    id: 'member-1',
+                    userId: 'user-2',
+                    role: 'member'
+                }
+            ]);
+            const result = await controller.getMembers({
+                boardId: 'board-uuid-1'
+            });
+            expect(mockBoardService.getMembers).toHaveBeenCalledWith('board-uuid-1');
+            expect(result.data).toHaveLength(1);
+            expect(result.meta).toEqual(expect.objectContaining({
+                total: 1,
+                count: 1
+            }));
+        });
+        it('returns an empty list with zeroed meta when the board has no members', async ()=>{
+            mockBoardService.getMembers.mockResolvedValue([]);
+            const result = await controller.getMembers({
+                boardId: 'board-uuid-1'
+            });
+            expect(result.data).toEqual([]);
+            expect(result.meta).toEqual(expect.objectContaining({
+                total: 0,
+                count: 0
+            }));
+        });
+    });
+});

package/cjs/controllers/task-comment.controller.spec.js

@@ -0,0 +1,86 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+const _loggedusermock = require("@test-utils/mocks/logged-user.mock");
+const _taskcommentcontroller = require("./task-comment.controller");
+function buildComment(overrides = {}) {
+    return {
+        id: 'comment-1',
+        taskId: 'task-uuid-1',
+        userId: 'user-uuid-1',
+        body: 'Looks good to me',
+        readOnly: false,
+        createdAt: new Date(),
+        updatedAt: new Date(),
+        ...overrides
+    };
+}
+describe('TaskCommentController', ()=>{
+    let controller;
+    let mockCommentService;
+    beforeEach(()=>{
+        mockCommentService = {
+            insert: jest.fn(),
+            findById: jest.fn(),
+            getAll: jest.fn(),
+            update: jest.fn(),
+            delete: jest.fn()
+        };
+        controller = new _taskcommentcontroller.TaskCommentController(mockCommentService);
+    });
+    it('wires the injected service onto the generated controller base', ()=>{
+        expect(controller.service).toBe(mockCommentService);
+    });
+    describe('insert', ()=>{
+        it('creates a comment and returns the mapped response', async ()=>{
+            const user = (0, _loggedusermock.buildMockUser)();
+            mockCommentService.insert.mockResolvedValue(buildComment());
+            const result = await controller.insert({
+                taskId: 'task-uuid-1',
+                body: 'Looks good to me'
+            }, user);
+            expect(mockCommentService.insert).toHaveBeenCalledWith({
+                taskId: 'task-uuid-1',
+                body: 'Looks good to me'
+            }, user);
+            expect(result.success).toBe(true);
+            expect(result.data).toEqual(expect.objectContaining({
+                id: 'comment-1'
+            }));
+        });
+    });
+    describe('getAll', ()=>{
+        it('paginates comments and maps the response list', async ()=>{
+            mockCommentService.getAll.mockResolvedValue({
+                data: [
+                    buildComment()
+                ],
+                total: 1
+            });
+            const result = await controller.getAll({}, (0, _loggedusermock.buildMockUser)(), '');
+            expect(mockCommentService.getAll).toHaveBeenCalledWith('', {}, (0, _loggedusermock.buildMockUser)());
+            expect(result.data).toHaveLength(1);
+        });
+    });
+    describe('delete', ()=>{
+        it('delegates soft-delete to the service', async ()=>{
+            mockCommentService.delete.mockResolvedValue({
+                count: 1
+            });
+            const result = await controller.delete({
+                id: [
+                    'comment-1'
+                ],
+                type: 'delete'
+            }, (0, _loggedusermock.buildMockUser)());
+            expect(mockCommentService.delete).toHaveBeenCalledWith({
+                id: [
+                    'comment-1'
+                ],
+                type: 'delete'
+            }, (0, _loggedusermock.buildMockUser)());
+            expect(result.success).toBe(true);
+        });
+    });
+});

package/cjs/controllers/task-label.controller.spec.js

@@ -0,0 +1,88 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+const _loggedusermock = require("@test-utils/mocks/logged-user.mock");
+const _tasklabelcontroller = require("./task-label.controller");
+function buildLabel(overrides = {}) {
+    return {
+        id: 'label-1',
+        boardId: 'board-uuid-1',
+        name: 'Bug',
+        color: '#ff0000',
+        readOnly: false,
+        createdAt: new Date(),
+        updatedAt: new Date(),
+        ...overrides
+    };
+}
+describe('TaskLabelController', ()=>{
+    let controller;
+    let mockLabelService;
+    beforeEach(()=>{
+        mockLabelService = {
+            insert: jest.fn(),
+            findById: jest.fn(),
+            getAll: jest.fn(),
+            update: jest.fn(),
+            delete: jest.fn()
+        };
+        controller = new _tasklabelcontroller.TaskLabelController(mockLabelService);
+    });
+    it('wires the injected service onto the generated controller base', ()=>{
+        expect(controller.service).toBe(mockLabelService);
+    });
+    describe('insert', ()=>{
+        it('creates a label and returns the mapped response', async ()=>{
+            const user = (0, _loggedusermock.buildMockUser)();
+            mockLabelService.insert.mockResolvedValue(buildLabel());
+            const result = await controller.insert({
+                boardId: 'board-uuid-1',
+                name: 'Bug',
+                color: '#ff0000'
+            }, user);
+            expect(mockLabelService.insert).toHaveBeenCalledWith({
+                boardId: 'board-uuid-1',
+                name: 'Bug',
+                color: '#ff0000'
+            }, user);
+            expect(result.success).toBe(true);
+            expect(result.data).toEqual(expect.objectContaining({
+                id: 'label-1'
+            }));
+        });
+    });
+    describe('getAll', ()=>{
+        it('paginates labels and maps the response list', async ()=>{
+            mockLabelService.getAll.mockResolvedValue({
+                data: [
+                    buildLabel()
+                ],
+                total: 1
+            });
+            const result = await controller.getAll({}, (0, _loggedusermock.buildMockUser)(), '');
+            expect(mockLabelService.getAll).toHaveBeenCalledWith('', {}, (0, _loggedusermock.buildMockUser)());
+            expect(result.data).toHaveLength(1);
+        });
+    });
+    describe('delete', ()=>{
+        it('delegates soft-delete to the service', async ()=>{
+            mockLabelService.delete.mockResolvedValue({
+                count: 1
+            });
+            const result = await controller.delete({
+                id: [
+                    'label-1'
+                ],
+                type: 'delete'
+            }, (0, _loggedusermock.buildMockUser)());
+            expect(mockLabelService.delete).toHaveBeenCalledWith({
+                id: [
+                    'label-1'
+                ],
+                type: 'delete'
+            }, (0, _loggedusermock.buildMockUser)());
+            expect(result.success).toBe(true);
+        });
+    });
+});

package/cjs/controllers/task-list.controller.spec.js

@@ -0,0 +1,112 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+const _loggedusermock = require("@test-utils/mocks/logged-user.mock");
+const _tasklistcontroller = require("./task-list.controller");
+function buildList(overrides = {}) {
+    return {
+        id: 'list-uuid-1',
+        boardId: 'board-uuid-1',
+        name: 'To Do',
+        position: 0,
+        readOnly: false,
+        createdAt: new Date(),
+        updatedAt: new Date(),
+        ...overrides
+    };
+}
+describe('TaskListController', ()=>{
+    let controller;
+    let mockListService;
+    let mockGateway;
+    beforeEach(()=>{
+        mockListService = {
+            insert: jest.fn(),
+            findById: jest.fn(),
+            getAll: jest.fn(),
+            update: jest.fn(),
+            delete: jest.fn(),
+            reorderLists: jest.fn()
+        };
+        mockGateway = {
+            emitToBoardRoom: jest.fn()
+        };
+        controller = new _tasklistcontroller.TaskListController(mockListService, mockGateway);
+    });
+    it('wires the injected service onto the generated controller base', ()=>{
+        expect(controller.service).toBe(mockListService);
+    });
+    describe('insert', ()=>{
+        it('creates a list and returns the mapped response', async ()=>{
+            const user = (0, _loggedusermock.buildMockUser)();
+            mockListService.insert.mockResolvedValue(buildList());
+            const result = await controller.insert({
+                boardId: 'board-uuid-1',
+                name: 'To Do'
+            }, user);
+            expect(mockListService.insert).toHaveBeenCalledWith({
+                boardId: 'board-uuid-1',
+                name: 'To Do'
+            }, user);
+            expect(result.success).toBe(true);
+            expect(result.data).toEqual(expect.objectContaining({
+                id: 'list-uuid-1'
+            }));
+        });
+    });
+    describe('getAll', ()=>{
+        it('paginates lists and maps the response list', async ()=>{
+            mockListService.getAll.mockResolvedValue({
+                data: [
+                    buildList()
+                ],
+                total: 1
+            });
+            const result = await controller.getAll({}, (0, _loggedusermock.buildMockUser)(), '');
+            expect(mockListService.getAll).toHaveBeenCalledWith('', {}, (0, _loggedusermock.buildMockUser)());
+            expect(result.data).toHaveLength(1);
+        });
+    });
+    describe('reorder', ()=>{
+        it('reorders lists and broadcasts a list:reordered event to the board room', async ()=>{
+            mockListService.reorderLists.mockResolvedValue(undefined);
+            const result = await controller.reorder({
+                boardId: 'board-uuid-1',
+                orderedIds: [
+                    'list-2',
+                    'list-1'
+                ]
+            });
+            expect(mockListService.reorderLists).toHaveBeenCalledWith({
+                boardId: 'board-uuid-1',
+                orderedIds: [
+                    'list-2',
+                    'list-1'
+                ]
+            });
+            expect(mockGateway.emitToBoardRoom).toHaveBeenCalledWith('board-uuid-1', expect.objectContaining({
+                type: 'list:reordered',
+                boardId: 'board-uuid-1',
+                payload: {
+                    orderedIds: [
+                        'list-2',
+                        'list-1'
+                    ]
+                }
+            }));
+            expect(result.success).toBe(true);
+        });
+        it('still succeeds when no gateway is wired (optional dependency)', async ()=>{
+            const controllerNoGateway = new _tasklistcontroller.TaskListController(mockListService, undefined);
+            mockListService.reorderLists.mockResolvedValue(undefined);
+            const result = await controllerNoGateway.reorder({
+                boardId: 'board-uuid-1',
+                orderedIds: [
+                    'list-1'
+                ]
+            });
+            expect(result.success).toBe(true);
+        });
+    });
+});

package/cjs/controllers/task.controller.spec.js

@@ -0,0 +1,131 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+const _loggedusermock = require("@test-utils/mocks/logged-user.mock");
+const _entities = require("../entities");
+const _taskcontroller = require("./task.controller");
+function buildTask(overrides = {}) {
+    return {
+        id: 'task-uuid-1',
+        boardId: 'board-uuid-1',
+        listId: 'list-uuid-1',
+        title: 'Fix bug',
+        description: null,
+        priority: _entities.TaskPriority.MEDIUM,
+        dueDate: null,
+        position: 0,
+        assignees: [],
+        reporterId: 'user-uuid-1',
+        parentTaskId: null,
+        estimatedHours: null,
+        createdAt: new Date(),
+        updatedAt: new Date(),
+        ...overrides
+    };
+}
+describe('TaskController', ()=>{
+    let controller;
+    let mockTaskService;
+    let mockGateway;
+    beforeEach(async ()=>{
+        mockTaskService = {
+            moveTask: jest.fn(),
+            assignTask: jest.fn(),
+            insert: jest.fn(),
+            update: jest.fn(),
+            getAll: jest.fn(),
+            findById: jest.fn(),
+            delete: jest.fn()
+        };
+        mockGateway = {
+            emitToBoardRoom: jest.fn()
+        };
+        controller = new _taskcontroller.TaskController(mockTaskService, mockGateway);
+    });
+    describe('moveTask', ()=>{
+        it('moves the task and broadcasts a task:moved event to the board room', async ()=>{
+            const task = buildTask({
+                listId: 'list-new',
+                position: 2
+            });
+            mockTaskService.moveTask.mockResolvedValue(task);
+            const user = (0, _loggedusermock.buildMockUser)();
+            const result = await controller.moveTask({
+                taskId: 'task-uuid-1',
+                targetListId: 'list-new',
+                position: 2
+            }, user);
+            expect(mockTaskService.moveTask).toHaveBeenCalledWith({
+                taskId: 'task-uuid-1',
+                targetListId: 'list-new',
+                position: 2
+            }, user);
+            expect(result.success).toBe(true);
+            expect(result.data).toEqual(expect.objectContaining({
+                id: 'task-uuid-1',
+                listId: 'list-new'
+            }));
+            expect(mockGateway.emitToBoardRoom).toHaveBeenCalledWith('board-uuid-1', expect.objectContaining({
+                type: 'task:moved',
+                boardId: 'board-uuid-1'
+            }));
+        });
+        it('still returns successfully when no gateway is wired (optional dependency)', async ()=>{
+            const controllerNoGateway = new _taskcontroller.TaskController(mockTaskService, undefined);
+            mockTaskService.moveTask.mockResolvedValue(buildTask());
+            const result = await controllerNoGateway.moveTask({
+                taskId: 'task-uuid-1',
+                targetListId: 'list-1'
+            }, (0, _loggedusermock.buildMockUser)());
+            expect(result.success).toBe(true);
+        });
+        it('propagates a NotFoundException from the service when the task does not exist', async ()=>{
+            mockTaskService.moveTask.mockRejectedValue(new Error('Task not found'));
+            await expect(controller.moveTask({
+                taskId: 'missing',
+                targetListId: 'list-1'
+            }, (0, _loggedusermock.buildMockUser)())).rejects.toThrow('Task not found');
+            expect(mockGateway.emitToBoardRoom).not.toHaveBeenCalled();
+        });
+    });
+    describe('assignTask', ()=>{
+        it('assigns the task and broadcasts a task:updated event to the board room', async ()=>{
+            const task = buildTask({
+                assignees: [
+                    {
+                        userId: 'user-2',
+                        userName: 'Bob'
+                    }
+                ]
+            });
+            mockTaskService.assignTask.mockResolvedValue(task);
+            const user = (0, _loggedusermock.buildMockUser)();
+            const result = await controller.assignTask({
+                taskId: 'task-uuid-1',
+                assigneeIds: [
+                    'user-2'
+                ]
+            }, user);
+            expect(mockTaskService.assignTask).toHaveBeenCalledWith({
+                taskId: 'task-uuid-1',
+                assigneeIds: [
+                    'user-2'
+                ]
+            }, user);
+            expect(result.success).toBe(true);
+            expect(mockGateway.emitToBoardRoom).toHaveBeenCalledWith('board-uuid-1', expect.objectContaining({
+                type: 'task:updated'
+            }));
+        });
+        it('propagates a BadRequestException when an assignee is not a board member', async ()=>{
+            mockTaskService.assignTask.mockRejectedValue(new Error('Assignee is not a board member'));
+            await expect(controller.assignTask({
+                taskId: 'task-uuid-1',
+                assigneeIds: [
+                    'stranger'
+                ]
+            }, (0, _loggedusermock.buildMockUser)())).rejects.toThrow('Assignee is not a board member');
+        });
+    });
+});

package/cjs/docs/task-manager-swagger.config.spec.js

@@ -0,0 +1,28 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+const _taskmanagerswaggerconfig = require("./task-manager-swagger.config");
+describe('taskManagerSwaggerConfig', ()=>{
+    it('should build a static swagger config with the expected identity fields', ()=>{
+        const config = (0, _taskmanagerswaggerconfig.taskManagerSwaggerConfig)();
+        expect(config.title).toBe('Task Manager API');
+        expect(config.path).toBe('api/docs/task-manager');
+        expect(config.version).toBe('1.0');
+        expect(config.bearerAuth).toBe(true);
+    });
+    it('should describe every top-level resource endpoint group', ()=>{
+        const config = (0, _taskmanagerswaggerconfig.taskManagerSwaggerConfig)();
+        expect(config.description).toContain('/task-manager/board/*');
+        expect(config.description).toContain('/task-manager/list/*');
+        expect(config.description).toContain('/task-manager/task/*');
+        expect(config.description).toContain('/task-manager/label/*');
+        expect(config.description).toContain('/task-manager/comment/*');
+    });
+    it('should return a fresh object on every call rather than a shared mutable singleton', ()=>{
+        const first = (0, _taskmanagerswaggerconfig.taskManagerSwaggerConfig)();
+        const second = (0, _taskmanagerswaggerconfig.taskManagerSwaggerConfig)();
+        expect(first).not.toBe(second);
+        expect(first).toEqual(second);
+    });
+});

package/cjs/entities/index.spec.js

@@ -0,0 +1,30 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+const _index = require("./index");
+const _taskboardentity = require("./task-board.entity");
+const _taskboardwithcompanyentity = require("./task-board-with-company.entity");
+const _tasklistentity = require("./task-list.entity");
+const _taskentity = require("./task.entity");
+describe('getTaskManagerEntitiesByConfig', ()=>{
+    it('returns the core entities when the company feature is disabled', ()=>{
+        expect((0, _index.getTaskManagerEntitiesByConfig)(false)).toBe(_index.TaskManagerCoreEntities);
+        expect((0, _index.getTaskManagerEntitiesByConfig)(false)).toContain(_taskboardentity.TaskBoard);
+        expect((0, _index.getTaskManagerEntitiesByConfig)(false)).not.toContain(_taskboardwithcompanyentity.TaskBoardWithCompany);
+    });
+    it('returns the company-scoped entities when the company feature is enabled', ()=>{
+        expect((0, _index.getTaskManagerEntitiesByConfig)(true)).toBe(_index.TaskManagerCompanyEntities);
+        expect((0, _index.getTaskManagerEntitiesByConfig)(true)).toContain(_taskboardwithcompanyentity.TaskBoardWithCompany);
+        expect((0, _index.getTaskManagerEntitiesByConfig)(true)).not.toContain(_taskboardentity.TaskBoard);
+    });
+    it('shares non-board entities (TaskList, Task, ...) between core and company sets', ()=>{
+        expect((0, _index.getTaskManagerEntitiesByConfig)(false)).toContain(_tasklistentity.TaskList);
+        expect((0, _index.getTaskManagerEntitiesByConfig)(true)).toContain(_tasklistentity.TaskList);
+        expect((0, _index.getTaskManagerEntitiesByConfig)(false)).toContain(_taskentity.Task);
+        expect((0, _index.getTaskManagerEntitiesByConfig)(true)).toContain(_taskentity.Task);
+    });
+    it('both entity sets have the same length (only the board entity swaps)', ()=>{
+        expect(_index.TaskManagerCoreEntities).toHaveLength(_index.TaskManagerCompanyEntities.length);
+    });
+});