@flusys/nestjs-task-manager 7.1.0 → 8.0.0-beta.1

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

@@ -1,461 +0,0 @@
-import { Test } from '@nestjs/testing';
-import { UtilsService } from '@flusys/nestjs-shared/modules';
-import { createMockQueryBuilder, createMockRepository } from '@test-utils/mocks/repository.mock';
-import { buildMockUser } from '@test-utils/mocks/logged-user.mock';
-import { BoardMemberRole, TaskBoard, TaskBoardMember, TaskBoardWithCompany } from '../entities';
-import { TaskBoardService } from './task-board.service';
-import { TaskManagerConfigService } from './task-manager-config.service';
-import { TaskManagerDataSourceProvider } from './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: 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', ()=>{
-    const mockUtilsService = {
-        clearCache: jest.fn(),
-        getCacheKey: jest.fn().mockReturnValue('cache-key'),
-        trackCacheKey: jest.fn()
-    };
-    // Call history is shared across tests in this file; reset it so each cache assertion is exact.
-    beforeEach(()=>{
-        mockUtilsService.clearCache.mockClear();
-    });
-    let service;
-    let module;
-    let mockRepo;
-    let mockMemberRepo;
-    let mockConfig;
-    let mockDataSourceProvider;
-    beforeEach(async ()=>{
-        mockRepo = createMockRepository();
-        mockMemberRepo = createMockRepository();
-        mockConfig = {
-            isCompanyFeatureEnabled: jest.fn().mockReturnValue(false)
-        };
-        mockDataSourceProvider = {
-            getRepository: jest.fn((entity)=>{
-                if (entity === TaskBoardMember) return Promise.resolve(mockMemberRepo);
-                return Promise.resolve(mockRepo);
-            }),
-            getDataSource: jest.fn()
-        };
-        module = await Test.createTestingModule({
-            providers: [
-                TaskBoardService,
-                {
-                    provide: 'CACHE_INSTANCE',
-                    useValue: {}
-                },
-                {
-                    provide: UtilsService,
-                    useValue: mockUtilsService
-                },
-                {
-                    provide: TaskManagerConfigService,
-                    useValue: mockConfig
-                },
-                {
-                    provide: TaskManagerDataSourceProvider,
-                    useValue: mockDataSourceProvider
-                }
-            ]
-        }).compile();
-        service = await module.resolve(TaskBoardService);
-    });
-    describe('entity selection', ()=>{
-        it('uses TaskBoard when the company feature is disabled', async ()=>{
-            mockConfig.isCompanyFeatureEnabled.mockReturnValue(false);
-            const built = await module.resolve(TaskBoardService);
-            expect(built['_entity']).toBe(TaskBoard);
-        });
-        it('uses TaskBoardWithCompany when the company feature is enabled', async ()=>{
-            mockConfig.isCompanyFeatureEnabled.mockReturnValue(true);
-            const built = await module.resolve(TaskBoardService);
-            expect(built['_entity']).toBe(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'
-            }, 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'
-            }, 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'
-            }, 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
-            }, 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'
-            }, buildMockUser({
-                id: 'creator-1'
-            }));
-            expect(mockMemberRepo.save).toHaveBeenCalledWith([
-                expect.objectContaining({
-                    userId: 'creator-1',
-                    role: 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 = createMockQueryBuilder();
-            qb.innerJoin = jest.fn().mockReturnThis();
-            qb.addSelect = jest.fn().mockReturnThis();
-            mockConfig.isCompanyFeatureEnabled.mockReturnValue(true);
-            const user = 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 = 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: BoardMemberRole.ADMIN
-            });
-            mockMemberRepo.save.mockResolvedValue(created);
-            const result = await service.addMember({
-                boardId: 'board-1',
-                userId: 'user-2',
-                role: BoardMemberRole.ADMIN
-            }, buildMockUser({
-                id: 'owner-1'
-            }));
-            expect(mockMemberRepo.create).toHaveBeenCalledWith(expect.objectContaining({
-                boardId: 'board-1',
-                userId: 'user-2',
-                role: BoardMemberRole.ADMIN,
-                createdById: 'owner-1'
-            }));
-            expect(result).toEqual(created);
-        });
-        it('invalidates the board list cache and the board entry (membership drives visibility and total_members)', 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({
-                boardId: 'board-1'
-            }));
-            await service.addMember({
-                boardId: 'board-1',
-                userId: 'user-2'
-            }, buildMockUser());
-            expect(mockUtilsService.clearCache).toHaveBeenCalledWith('task_board', expect.anything());
-            expect(mockUtilsService.clearCache).toHaveBeenCalledWith('task_board', expect.anything(), 'board-1');
-        });
-        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'
-            }, buildMockUser());
-            expect(mockMemberRepo.create).toHaveBeenCalledWith(expect.objectContaining({
-                role: 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'
-            }, 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'
-            }, 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: BoardMemberRole.ADMIN
-            });
-            mockMemberRepo.findOne.mockResolvedValueOnce(restored); // re-fetch after restore
-            const result = await service.addMember({
-                boardId: 'board-1',
-                userId: 'user-uuid-1',
-                role: BoardMemberRole.ADMIN
-            }, buildMockUser());
-            expect(mockMemberRepo.restore).toHaveBeenCalledWith({
-                id: 'member-old'
-            });
-            expect(mockMemberRepo.update).toHaveBeenCalledWith({
-                id: 'member-old'
-            }, {
-                role: 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('invalidates the board list cache and the board entry', async ()=>{
-            mockMemberRepo.findOne.mockResolvedValue(buildMember({
-                id: 'member-1'
-            }));
-            await service.removeMember({
-                boardId: 'board-1',
-                userId: 'user-uuid-1'
-            });
-            expect(mockUtilsService.clearCache).toHaveBeenCalledWith('task_board', expect.anything());
-            expect(mockUtilsService.clearCache).toHaveBeenCalledWith('task_board', expect.anything(), 'board-1');
-        });
-        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 = 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/fesm/services/task-comment.service.js

@@ -1,93 +0,0 @@
-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;
-}
-function _ts_decorate(decorators, target, key, desc) {
-    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
-    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
-    else for(var i = decorators.length - 1; i >= 0; i--)if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
-    return c > 3 && r && Object.defineProperty(target, key, r), r;
-}
-function _ts_metadata(k, v) {
-    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
-}
-function _ts_param(paramIndex, decorator) {
-    return function(target, key) {
-        decorator(target, key, paramIndex);
-    };
-}
-import { HybridCache, ApiService } from '@flusys/nestjs-shared/classes';
-import { UtilsService } from '@flusys/nestjs-shared/modules';
-import { ForbiddenException, Inject, Injectable, NotFoundException, Scope } from '@nestjs/common';
-import { TASK_COMMENT_MESSAGES, TASK_MANAGER_EVENT_ENTITIES, TASK_MANAGER_EVENT_MODULE } from '../config';
-import { TaskComment } from '../entities';
-import { TaskManagerDataSourceProvider } from './task-manager-datasource.provider';
-export class TaskCommentService extends ApiService {
-    async convertSingleDtoToEntity(dto, user) {
-        await this.ensureDataSourceRepository();
-        let entity = {};
-        if ('id' in dto && dto.id) {
-            const existing = await this.repository.findOne({
-                where: {
-                    id: dto.id
-                }
-            });
-            if (!existing) throw new NotFoundException({
-                message: 'Comment not found',
-                messageKey: TASK_COMMENT_MESSAGES.NOT_FOUND
-            });
-            if (existing.userId !== user?.id) throw new ForbiddenException({
-                message: 'Cannot edit another user comment',
-                messageKey: TASK_COMMENT_MESSAGES.FORBIDDEN
-            });
-            entity = existing;
-        }
-        const taskId = ('taskId' in dto ? dto.taskId : undefined) ?? entity.taskId;
-        return {
-            ...entity,
-            taskId,
-            userId: entity.userId !== undefined ? entity.userId : user?.id ?? null,
-            content: dto.content,
-            parentCommentId: 'parentCommentId' in dto ? dto.parentCommentId ?? null : entity.parentCommentId ?? null
-        };
-    }
-    async getFilterQuery(query, filter, _user) {
-        for (const [key, value] of Object.entries(filter)){
-            if (key === 'taskId') {
-                query.andWhere('task_comment.taskId = :taskId', {
-                    taskId: value
-                });
-            }
-        }
-        return {
-            query,
-            isRaw: false
-        };
-    }
-    constructor(cacheManager, utilsService, dataSourceProvider){
-        super(TASK_MANAGER_EVENT_ENTITIES.TASK_COMMENT, cacheManager, utilsService, TaskCommentService.name, false, TASK_MANAGER_EVENT_MODULE, dataSourceProvider, TaskComment), _define_property(this, "cacheManager", void 0), _define_property(this, "utilsService", void 0), _define_property(this, "dataSourceProvider", void 0), this.cacheManager = cacheManager, this.utilsService = utilsService, this.dataSourceProvider = dataSourceProvider;
-    }
-}
-TaskCommentService = _ts_decorate([
-    Injectable({
-        scope: Scope.REQUEST
-    }),
-    _ts_param(0, Inject('CACHE_INSTANCE')),
-    _ts_param(1, Inject(UtilsService)),
-    _ts_param(2, Inject(TaskManagerDataSourceProvider)),
-    _ts_metadata("design:type", Function),
-    _ts_metadata("design:paramtypes", [
-        typeof HybridCache === "undefined" ? Object : HybridCache,
-        typeof UtilsService === "undefined" ? Object : UtilsService,
-        typeof TaskManagerDataSourceProvider === "undefined" ? Object : TaskManagerDataSourceProvider
-    ])
-], TaskCommentService);