@flusys/nestjs-task-manager 6.0.2 → 6.1.0

package/cjs/services/task-board.service.spec.js

@@ -0,0 +1,429 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+const _testing = require("@nestjs/testing");
+const _modules = require("@flusys/nestjs-shared/modules");
+const _repositorymock = require("@test-utils/mocks/repository.mock");
+const _loggedusermock = require("@test-utils/mocks/logged-user.mock");
+const _entities = require("../entities");
+const _taskboardservice = require("./task-board.service");
+const _taskmanagerconfigservice = require("./task-manager-config.service");
+const _taskmanagerdatasourceprovider = require("./task-manager-datasource.provider");
+function buildBoard(overrides = {}) {
+    return {
+        id: 'board-uuid-1',
+        name: 'Sprint Board',
+        description: null,
+        color: '#3B82F6',
+        isActive: true,
+        settings: null,
+        createdAt: new Date(),
+        updatedAt: new Date(),
+        deletedAt: null,
+        createdById: null,
+        updatedById: null,
+        deletedById: null,
+        ...overrides
+    };
+}
+function buildMember(overrides = {}) {
+    return {
+        id: 'member-uuid-1',
+        boardId: 'board-uuid-1',
+        userId: 'user-uuid-1',
+        role: _entities.BoardMemberRole.MEMBER,
+        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('TaskBoardService', ()=>{
+    let service;
+    let mockRepo;
+    let mockMemberRepo;
+    let mockConfig;
+    let mockDataSourceProvider;
+    beforeEach(async ()=>{
+        mockRepo = (0, _repositorymock.createMockRepository)();
+        mockMemberRepo = (0, _repositorymock.createMockRepository)();
+        mockConfig = {
+            isCompanyFeatureEnabled: jest.fn().mockReturnValue(false)
+        };
+        mockDataSourceProvider = {
+            getRepository: jest.fn((entity)=>{
+                if (entity === _entities.TaskBoardMember) return Promise.resolve(mockMemberRepo);
+                return Promise.resolve(mockRepo);
+            }),
+            getDataSource: jest.fn()
+        };
+        const module = await _testing.Test.createTestingModule({
+            providers: [
+                _taskboardservice.TaskBoardService,
+                {
+                    provide: 'CACHE_INSTANCE',
+                    useValue: {}
+                },
+                {
+                    provide: _modules.UtilsService,
+                    useValue: {
+                        clearCache: jest.fn(),
+                        getCacheKey: jest.fn(),
+                        trackCacheKey: jest.fn()
+                    }
+                },
+                {
+                    provide: _taskmanagerconfigservice.TaskManagerConfigService,
+                    useValue: mockConfig
+                },
+                {
+                    provide: _taskmanagerdatasourceprovider.TaskManagerDataSourceProvider,
+                    useValue: mockDataSourceProvider
+                }
+            ]
+        }).compile();
+        service = await module.resolve(_taskboardservice.TaskBoardService);
+    });
+    describe('resolveEntity', ()=>{
+        it('resolves to plain TaskBoard when company feature is disabled', ()=>{
+            mockConfig.isCompanyFeatureEnabled.mockReturnValue(false);
+            expect(service.resolveEntity()).toBe(_entities.TaskBoard);
+        });
+        it('resolves to TaskBoardWithCompany when company feature is enabled', ()=>{
+            mockConfig.isCompanyFeatureEnabled.mockReturnValue(true);
+            expect(service.resolveEntity()).toBe(_entities.TaskBoardWithCompany);
+        });
+    });
+    describe('convertSingleDtoToEntity (via insert/update)', ()=>{
+        it('creates a board applying default color and active flag', async ()=>{
+            mockQueryRunner(mockRepo);
+            const result = await service.insert({
+                name: 'New Board'
+            }, (0, _loggedusermock.buildMockUser)());
+            expect(result).toEqual(expect.objectContaining({
+                name: 'New Board',
+                color: '#3B82F6',
+                isActive: true
+            }));
+            expect(result.companyId).toBeUndefined();
+        });
+        it('stamps companyId from the user when the company feature is enabled', async ()=>{
+            mockConfig.isCompanyFeatureEnabled.mockReturnValue(true);
+            mockQueryRunner(mockRepo);
+            const result = await service.insert({
+                name: 'Company Board'
+            }, (0, _loggedusermock.buildMockUser)({
+                companyId: 'company-9'
+            }));
+            expect(result.companyId).toBe('company-9');
+        });
+        it('throws NotFoundException when updating a non-existent board', async ()=>{
+            mockQueryRunner(mockRepo);
+            mockRepo.findOne.mockResolvedValue(null);
+            await expect(service.update({
+                id: 'missing',
+                name: 'Renamed'
+            }, (0, _loggedusermock.buildMockUser)())).rejects.toThrow();
+        });
+        it('merges update fields, preserving description as null when explicitly cleared', async ()=>{
+            mockQueryRunner(mockRepo);
+            const existing = buildBoard({
+                id: 'board-1',
+                description: 'Old description'
+            });
+            mockRepo.findOne.mockResolvedValue(existing);
+            const result = await service.update({
+                id: 'board-1',
+                description: null
+            }, (0, _loggedusermock.buildMockUser)());
+            expect(result.description).toBeNull();
+        });
+    });
+    describe('afterInsertOperation', ()=>{
+        it('adds the creating user as an OWNER member of every newly created board', async ()=>{
+            mockQueryRunner(mockRepo);
+            mockMemberRepo.create.mockImplementation((data)=>data);
+            mockMemberRepo.save.mockResolvedValue([]);
+            await service.insert({
+                name: 'New Board'
+            }, (0, _loggedusermock.buildMockUser)({
+                id: 'creator-1'
+            }));
+            expect(mockMemberRepo.save).toHaveBeenCalledWith([
+                expect.objectContaining({
+                    userId: 'creator-1',
+                    role: _entities.BoardMemberRole.OWNER,
+                    createdById: 'creator-1'
+                })
+            ]);
+        });
+        it('does nothing when no user is present (system-created board)', async ()=>{
+            mockQueryRunner(mockRepo);
+            await service.insert({
+                name: 'System Board'
+            }, null);
+            expect(mockMemberRepo.save).not.toHaveBeenCalled();
+        });
+    });
+    describe('getExtraManipulateQuery', ()=>{
+        it('applies the company filter, current-user membership join, and aggregate subselects', async ()=>{
+            const qb = (0, _repositorymock.createMockQueryBuilder)();
+            qb.innerJoin = jest.fn().mockReturnThis();
+            qb.addSelect = jest.fn().mockReturnThis();
+            mockConfig.isCompanyFeatureEnabled.mockReturnValue(true);
+            const user = (0, _loggedusermock.buildMockUser)({
+                id: 'user-1',
+                companyId: 'company-1'
+            });
+            const { isRaw } = await service.getExtraManipulateQuery(qb, {}, user);
+            expect(qb.andWhere).toHaveBeenCalledWith('task_board.companyId = :companyId', {
+                companyId: 'company-1'
+            });
+            expect(qb.innerJoin).toHaveBeenCalledWith('task_board_member', 'tbm_filter', expect.stringContaining('tbm_filter.user_id = :currentUserId'), {
+                currentUserId: 'user-1'
+            });
+            expect(qb.addSelect).toHaveBeenCalledWith(expect.stringContaining('task_board_member'), 'total_members');
+            expect(qb.addSelect).toHaveBeenCalledWith(expect.stringContaining('task_list'), 'total_lists');
+            expect(qb.addSelect).toHaveBeenCalledWith(expect.stringContaining('FROM task t'), 'total_tasks');
+            expect(isRaw).toBe(true);
+        });
+        it('skips the membership join when no user is provided', async ()=>{
+            const qb = (0, _repositorymock.createMockQueryBuilder)();
+            qb.innerJoin = jest.fn().mockReturnThis();
+            qb.addSelect = jest.fn().mockReturnThis();
+            await service.getExtraManipulateQuery(qb, {}, null);
+            expect(qb.innerJoin).not.toHaveBeenCalled();
+        });
+    });
+    describe('convertEntityToResponseDto', ()=>{
+        it('passes through non-raw entities unchanged (default behavior)', ()=>{
+            const board = buildBoard();
+            const result = service.convertEntityToResponseDto(board, false);
+            expect(result).toEqual(board);
+        });
+        it('strips the entity-name prefix and camelCases raw aggregate columns, converting numeric strings', ()=>{
+            const raw = {
+                task_board_id: 'board-1',
+                task_board_name: 'Sprint Board',
+                total_members: '3',
+                total_lists: '2'
+            };
+            const result = service.convertEntityToResponseDto(raw, true);
+            expect(result).toEqual({
+                id: 'board-1',
+                name: 'Sprint Board',
+                totalMembers: 3,
+                totalLists: 2
+            });
+        });
+    });
+    describe('addMember', ()=>{
+        it('adds a new member with the requested role', async ()=>{
+            mockRepo.findOne.mockResolvedValue(buildBoard({
+                id: 'board-1'
+            }));
+            mockMemberRepo.findOne.mockResolvedValueOnce(null); // no active existing member
+            mockMemberRepo.findOne.mockResolvedValueOnce(null); // no soft-deleted member either
+            mockMemberRepo.create.mockImplementation((data)=>data);
+            const created = buildMember({
+                boardId: 'board-1',
+                userId: 'user-2',
+                role: _entities.BoardMemberRole.ADMIN
+            });
+            mockMemberRepo.save.mockResolvedValue(created);
+            const result = await service.addMember({
+                boardId: 'board-1',
+                userId: 'user-2',
+                role: _entities.BoardMemberRole.ADMIN
+            }, (0, _loggedusermock.buildMockUser)({
+                id: 'owner-1'
+            }));
+            expect(mockMemberRepo.create).toHaveBeenCalledWith(expect.objectContaining({
+                boardId: 'board-1',
+                userId: 'user-2',
+                role: _entities.BoardMemberRole.ADMIN,
+                createdById: 'owner-1'
+            }));
+            expect(result).toEqual(created);
+        });
+        it('defaults the role to MEMBER when none is given', async ()=>{
+            mockRepo.findOne.mockResolvedValue(buildBoard({
+                id: 'board-1'
+            }));
+            mockMemberRepo.findOne.mockResolvedValueOnce(null);
+            mockMemberRepo.findOne.mockResolvedValueOnce(null);
+            mockMemberRepo.create.mockImplementation((data)=>data);
+            mockMemberRepo.save.mockResolvedValue(buildMember());
+            await service.addMember({
+                boardId: 'board-1',
+                userId: 'user-2'
+            }, (0, _loggedusermock.buildMockUser)());
+            expect(mockMemberRepo.create).toHaveBeenCalledWith(expect.objectContaining({
+                role: _entities.BoardMemberRole.MEMBER
+            }));
+        });
+        it('throws NotFoundException when the board does not exist', async ()=>{
+            mockRepo.findOne.mockResolvedValue(null);
+            await expect(service.addMember({
+                boardId: 'missing-board',
+                userId: 'user-2'
+            }, (0, _loggedusermock.buildMockUser)())).rejects.toThrow();
+        });
+        it('throws BadRequestException when the user is already an active member', async ()=>{
+            mockRepo.findOne.mockResolvedValue(buildBoard({
+                id: 'board-1'
+            }));
+            mockMemberRepo.findOne.mockResolvedValueOnce(buildMember());
+            await expect(service.addMember({
+                boardId: 'board-1',
+                userId: 'user-uuid-1'
+            }, (0, _loggedusermock.buildMockUser)())).rejects.toThrow();
+        });
+        it('restores a soft-deleted membership instead of creating a duplicate row', async ()=>{
+            mockRepo.findOne.mockResolvedValue(buildBoard({
+                id: 'board-1'
+            }));
+            mockMemberRepo.findOne.mockResolvedValueOnce(null); // no active member
+            const softDeleted = buildMember({
+                id: 'member-old',
+                deletedAt: new Date()
+            });
+            mockMemberRepo.findOne.mockResolvedValueOnce(softDeleted); // soft-deleted row found
+            mockMemberRepo.restore.mockResolvedValue(undefined);
+            mockMemberRepo.update.mockResolvedValue(undefined);
+            const restored = buildMember({
+                id: 'member-old',
+                role: _entities.BoardMemberRole.ADMIN
+            });
+            mockMemberRepo.findOne.mockResolvedValueOnce(restored); // re-fetch after restore
+            const result = await service.addMember({
+                boardId: 'board-1',
+                userId: 'user-uuid-1',
+                role: _entities.BoardMemberRole.ADMIN
+            }, (0, _loggedusermock.buildMockUser)());
+            expect(mockMemberRepo.restore).toHaveBeenCalledWith({
+                id: 'member-old'
+            });
+            expect(mockMemberRepo.update).toHaveBeenCalledWith({
+                id: 'member-old'
+            }, {
+                role: _entities.BoardMemberRole.ADMIN
+            });
+            expect(mockMemberRepo.create).not.toHaveBeenCalled();
+            expect(result).toEqual(restored);
+        });
+    });
+    describe('removeMember', ()=>{
+        it('soft-deletes an existing member', async ()=>{
+            const member = buildMember({
+                id: 'member-1'
+            });
+            mockMemberRepo.findOne.mockResolvedValue(member);
+            await service.removeMember({
+                boardId: 'board-1',
+                userId: 'user-uuid-1'
+            });
+            expect(mockMemberRepo.update).toHaveBeenCalledWith({
+                id: 'member-1'
+            }, {
+                deletedAt: expect.any(Date)
+            });
+        });
+        it('throws NotFoundException when the member is not found', async ()=>{
+            mockMemberRepo.findOne.mockResolvedValue(null);
+            await expect(service.removeMember({
+                boardId: 'board-1',
+                userId: 'unknown-user'
+            })).rejects.toThrow();
+        });
+    });
+    function buildMembersQueryBuilder() {
+        const qb = (0, _repositorymock.createMockQueryBuilder)();
+        qb.leftJoin = jest.fn().mockReturnThis();
+        qb.addSelect = jest.fn().mockReturnThis();
+        qb.getRawAndEntities = jest.fn();
+        return qb;
+    }
+    describe('getMembers', ()=>{
+        it('returns members enriched with joined user name/email', async ()=>{
+            const qb = buildMembersQueryBuilder();
+            qb.getRawAndEntities.mockResolvedValue({
+                entities: [
+                    buildMember({
+                        id: 'member-1',
+                        userId: 'user-1'
+                    })
+                ],
+                raw: [
+                    {
+                        userName: 'Alice',
+                        userEmail: 'alice@example.com'
+                    }
+                ]
+            });
+            mockMemberRepo.createQueryBuilder.mockReturnValue(qb);
+            const result = await service.getMembers('board-1');
+            expect(result).toEqual([
+                expect.objectContaining({
+                    id: 'member-1',
+                    userName: 'Alice',
+                    userEmail: 'alice@example.com'
+                })
+            ]);
+        });
+        it('defaults userName/userEmail to null when the joined user row is missing', async ()=>{
+            const qb = buildMembersQueryBuilder();
+            qb.getRawAndEntities.mockResolvedValue({
+                entities: [
+                    buildMember({
+                        id: 'member-1'
+                    })
+                ],
+                raw: [
+                    {}
+                ]
+            });
+            mockMemberRepo.createQueryBuilder.mockReturnValue(qb);
+            const result = await service.getMembers('board-1');
+            expect(result[0].userName).toBeNull();
+            expect(result[0].userEmail).toBeNull();
+        });
+    });
+    describe('isBoardMember', ()=>{
+        it('returns true when an active membership row exists', async ()=>{
+            mockMemberRepo.count.mockResolvedValue(1);
+            const result = await service.isBoardMember('board-1', 'user-1');
+            expect(result).toBe(true);
+            expect(mockMemberRepo.count).toHaveBeenCalledWith({
+                where: {
+                    boardId: 'board-1',
+                    userId: 'user-1',
+                    deletedAt: expect.anything()
+                }
+            });
+        });
+        it('returns false when no membership row exists', async ()=>{
+            mockMemberRepo.count.mockResolvedValue(0);
+            const result = await service.isBoardMember('board-1', 'stranger');
+            expect(result).toBe(false);
+        });
+    });
+});

package/cjs/services/task-comment.service.spec.js

@@ -0,0 +1,160 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+const _testing = require("@nestjs/testing");
+const _modules = require("@flusys/nestjs-shared/modules");
+const _repositorymock = require("@test-utils/mocks/repository.mock");
+const _loggedusermock = require("@test-utils/mocks/logged-user.mock");
+const _taskcommentservice = require("./task-comment.service");
+const _taskmanagerdatasourceprovider = require("./task-manager-datasource.provider");
+function buildTaskComment(overrides = {}) {
+    return {
+        id: 'comment-uuid-1',
+        taskId: 'task-uuid-1',
+        userId: 'user-uuid-1',
+        content: 'Original comment',
+        parentCommentId: null,
+        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('TaskCommentService', ()=>{
+    let service;
+    let mockRepo;
+    beforeEach(async ()=>{
+        mockRepo = (0, _repositorymock.createMockRepository)();
+        const mockDataSourceProvider = (0, _repositorymock.createMockDataSourceProvider)(mockRepo);
+        const module = await _testing.Test.createTestingModule({
+            providers: [
+                _taskcommentservice.TaskCommentService,
+                {
+                    provide: 'CACHE_INSTANCE',
+                    useValue: {}
+                },
+                {
+                    provide: _modules.UtilsService,
+                    useValue: {
+                        clearCache: jest.fn(),
+                        getCacheKey: jest.fn(),
+                        trackCacheKey: jest.fn()
+                    }
+                },
+                {
+                    provide: _taskmanagerdatasourceprovider.TaskManagerDataSourceProvider,
+                    useValue: mockDataSourceProvider
+                }
+            ]
+        }).compile();
+        service = await module.resolve(_taskcommentservice.TaskCommentService);
+    });
+    describe('convertSingleDtoToEntity (via insert)', ()=>{
+        it('creates a top-level comment authored by the current user', async ()=>{
+            mockQueryRunner(mockRepo);
+            const user = (0, _loggedusermock.buildMockUser)({
+                id: 'author-1'
+            });
+            const result = await service.insert({
+                taskId: 'task-1',
+                content: 'Nice work'
+            }, user);
+            expect(result).toEqual(expect.objectContaining({
+                taskId: 'task-1',
+                userId: 'author-1',
+                content: 'Nice work',
+                parentCommentId: null
+            }));
+        });
+        it('creates a reply comment carrying the parentCommentId', async ()=>{
+            mockQueryRunner(mockRepo);
+            const result = await service.insert({
+                taskId: 'task-1',
+                content: 'Reply',
+                parentCommentId: 'comment-parent-1'
+            }, (0, _loggedusermock.buildMockUser)());
+            expect(result).toEqual(expect.objectContaining({
+                parentCommentId: 'comment-parent-1'
+            }));
+        });
+    });
+    describe('convertSingleDtoToEntity (via update)', ()=>{
+        it('throws NotFoundException when the comment does not exist', async ()=>{
+            mockQueryRunner(mockRepo);
+            mockRepo.findOne.mockResolvedValue(null);
+            await expect(service.update({
+                id: 'missing',
+                content: 'Edited'
+            }, (0, _loggedusermock.buildMockUser)())).rejects.toThrow();
+        });
+        it('throws ForbiddenException when editing a comment authored by another user', async ()=>{
+            mockQueryRunner(mockRepo);
+            const existing = buildTaskComment({
+                id: 'comment-1',
+                userId: 'someone-else'
+            });
+            mockRepo.findOne.mockResolvedValue(existing);
+            await expect(service.update({
+                id: 'comment-1',
+                content: 'Edited'
+            }, (0, _loggedusermock.buildMockUser)({
+                id: 'not-the-author'
+            }))).rejects.toThrow();
+        });
+        it('allows the original author to edit their own comment', async ()=>{
+            mockQueryRunner(mockRepo);
+            const existing = buildTaskComment({
+                id: 'comment-1',
+                userId: 'author-1',
+                content: 'Old'
+            });
+            mockRepo.findOne.mockResolvedValue(existing);
+            const result = await service.update({
+                id: 'comment-1',
+                content: 'Updated content'
+            }, (0, _loggedusermock.buildMockUser)({
+                id: 'author-1'
+            }));
+            expect(result).toEqual(expect.objectContaining({
+                id: 'comment-1',
+                content: 'Updated content'
+            }));
+        });
+    });
+    describe('getFilterQuery', ()=>{
+        it('filters by taskId when supplied', async ()=>{
+            const qb = (0, _repositorymock.createMockQueryBuilder)();
+            const { query, isRaw } = await service.getFilterQuery(qb, {
+                taskId: 'task-1'
+            }, (0, _loggedusermock.buildMockUser)());
+            expect(qb.andWhere).toHaveBeenCalledWith('task_comment.taskId = :taskId', {
+                taskId: 'task-1'
+            });
+            expect(isRaw).toBe(false);
+            expect(query).toBe(qb);
+        });
+        it('applies no filter when taskId is absent', async ()=>{
+            const qb = (0, _repositorymock.createMockQueryBuilder)();
+            await service.getFilterQuery(qb, {}, (0, _loggedusermock.buildMockUser)());
+            expect(qb.andWhere).not.toHaveBeenCalled();
+        });
+    });
+});