@flusys/nestjs-task-manager 7.1.0 → 8.0.0

package/fesm/config/event-actions.js

@@ -1,16 +0,0 @@
-/**
- * Domain event actions published by the task manager module, alongside the CRUD
- * lifecycle actions every ApiService emits.
- */ export const TASK_MANAGER_EVENT_ACTIONS = {
-    MOVED: 'moved',
-    ASSIGNED: 'assigned',
-    REORDERED: 'reordered'
-};
-/** Every entity the task manager module publishes under */ export const TASK_MANAGER_EVENT_ENTITIES = {
-    TASK: 'task',
-    TASK_BOARD: 'task_board',
-    TASK_LIST: 'task_list',
-    TASK_LABEL: 'task_label',
-    TASK_COMMENT: 'task_comment'
-};
-export const TASK_MANAGER_EVENT_MODULE = 'task-manager';

package/fesm/config/message-keys.js

@@ -1,65 +0,0 @@
-export const TASK_BOARD_MESSAGES = {
-    NOT_FOUND: 'task.board.not.found',
-    CREATE_SUCCESS: 'task.board.create.success',
-    CREATE_MANY_SUCCESS: 'task.board.create.many.success',
-    GET_SUCCESS: 'task.board.get.success',
-    GET_ALL_SUCCESS: 'task.board.get.all.success',
-    UPDATE_SUCCESS: 'task.board.update.success',
-    UPDATE_MANY_SUCCESS: 'task.board.update.many.success',
-    DELETE_SUCCESS: 'task.board.delete.success',
-    RESTORE_SUCCESS: 'task.board.restore.success',
-    MEMBER_ADDED: 'task.board.member.added',
-    MEMBER_REMOVED: 'task.board.member.removed',
-    MEMBER_NOT_FOUND: 'task.board.member.not.found',
-    MEMBER_ALREADY_EXISTS: 'task.board.member.already.exists',
-    MEMBER_GET_ALL_SUCCESS: 'task.board.member.get.all.success'
-};
-export const TASK_LIST_MESSAGES = {
-    NOT_FOUND: 'task.list.not.found',
-    CREATE_SUCCESS: 'task.list.create.success',
-    CREATE_MANY_SUCCESS: 'task.list.create.many.success',
-    GET_SUCCESS: 'task.list.get.success',
-    GET_ALL_SUCCESS: 'task.list.get.all.success',
-    UPDATE_SUCCESS: 'task.list.update.success',
-    UPDATE_MANY_SUCCESS: 'task.list.update.many.success',
-    DELETE_SUCCESS: 'task.list.delete.success',
-    RESTORE_SUCCESS: 'task.list.restore.success',
-    REORDER_SUCCESS: 'task.list.reorder.success'
-};
-export const TASK_MESSAGES = {
-    NOT_FOUND: 'task.not.found',
-    CREATE_SUCCESS: 'task.create.success',
-    CREATE_MANY_SUCCESS: 'task.create.many.success',
-    GET_SUCCESS: 'task.get.success',
-    GET_ALL_SUCCESS: 'task.get.all.success',
-    UPDATE_SUCCESS: 'task.update.success',
-    UPDATE_MANY_SUCCESS: 'task.update.many.success',
-    DELETE_SUCCESS: 'task.delete.success',
-    RESTORE_SUCCESS: 'task.restore.success',
-    MOVE_SUCCESS: 'task.move.success',
-    ASSIGN_SUCCESS: 'task.assign.success',
-    ASSIGNEE_NOT_BOARD_MEMBER: 'task.assignee.not.board.member'
-};
-export const TASK_LABEL_MESSAGES = {
-    NOT_FOUND: 'task.label.not.found',
-    CREATE_SUCCESS: 'task.label.create.success',
-    CREATE_MANY_SUCCESS: 'task.label.create.many.success',
-    GET_SUCCESS: 'task.label.get.success',
-    GET_ALL_SUCCESS: 'task.label.get.all.success',
-    UPDATE_SUCCESS: 'task.label.update.success',
-    UPDATE_MANY_SUCCESS: 'task.label.update.many.success',
-    DELETE_SUCCESS: 'task.label.delete.success',
-    RESTORE_SUCCESS: 'task.label.restore.success'
-};
-export const TASK_COMMENT_MESSAGES = {
-    NOT_FOUND: 'task.comment.not.found',
-    CREATE_SUCCESS: 'task.comment.create.success',
-    CREATE_MANY_SUCCESS: 'task.comment.create.many.success',
-    GET_SUCCESS: 'task.comment.get.success',
-    GET_ALL_SUCCESS: 'task.comment.get.all.success',
-    UPDATE_SUCCESS: 'task.comment.update.success',
-    UPDATE_MANY_SUCCESS: 'task.comment.update.many.success',
-    DELETE_SUCCESS: 'task.comment.delete.success',
-    RESTORE_SUCCESS: 'task.comment.restore.success',
-    FORBIDDEN: 'task.comment.forbidden'
-};

package/fesm/config/task-manager.constants.js

@@ -1 +0,0 @@
-export const TASK_MANAGER_MODULE_OPTIONS = 'TASK_MANAGER_MODULE_OPTIONS';

package/fesm/controllers/task-board.controller.js

@@ -1,209 +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 { TASK_BOARD_PERMISSIONS } from '@flusys/nestjs-shared';
-import { createApiController } from '@flusys/nestjs-shared/classes';
-import { ApiResponseDto, CurrentUser, RequirePermission } from '@flusys/nestjs-shared/decorators';
-import { MessageResponseDto } from '@flusys/nestjs-shared/dtos';
-import { JwtAuthGuard, PermissionGuard } from '@flusys/nestjs-shared/guards';
-import { ILoggedUserInfo } from '@flusys/nestjs-shared/interfaces';
-import { Body, Controller, HttpCode, HttpStatus, Inject, Post, UseGuards } from '@nestjs/common';
-import { ApiBearerAuth, ApiBody, ApiOperation, ApiResponse, ApiTags } from '@nestjs/swagger';
-import { plainToInstance } from 'class-transformer';
-import { TASK_BOARD_MESSAGES } from '../config';
-import { AddBoardMemberDto, CreateTaskBoardDto, GetBoardMembersDto, RemoveBoardMemberDto, TaskBoardMemberResponseDto, TaskBoardResponseDto, UpdateTaskBoardDto } from '../dtos';
-import { TaskBoardService } from '../services/task-board.service';
-export class TaskBoardController extends createApiController(CreateTaskBoardDto, UpdateTaskBoardDto, TaskBoardResponseDto, {
-    entityName: 'task.board',
-    enabledEndpoints: [
-        'insert',
-        'insertMany',
-        'getById',
-        'getAll',
-        'update',
-        'updateMany',
-        'delete'
-    ],
-    security: {
-        insert: {
-            level: 'permission',
-            permissions: [
-                TASK_BOARD_PERMISSIONS.CREATE
-            ]
-        },
-        insertMany: {
-            level: 'permission',
-            permissions: [
-                TASK_BOARD_PERMISSIONS.CREATE
-            ]
-        },
-        getById: {
-            level: 'permission',
-            permissions: [
-                TASK_BOARD_PERMISSIONS.READ
-            ]
-        },
-        getAll: {
-            level: 'permission',
-            permissions: [
-                TASK_BOARD_PERMISSIONS.READ
-            ]
-        },
-        update: {
-            level: 'permission',
-            permissions: [
-                TASK_BOARD_PERMISSIONS.UPDATE
-            ]
-        },
-        updateMany: {
-            level: 'permission',
-            permissions: [
-                TASK_BOARD_PERMISSIONS.UPDATE
-            ]
-        },
-        delete: {
-            level: 'permission',
-            permissions: [
-                TASK_BOARD_PERMISSIONS.DELETE
-            ]
-        }
-    }
-}) {
-    async addMember(dto, user) {
-        const member = await this.boardService.addMember(dto, user);
-        return {
-            success: true,
-            message: 'Member added to board',
-            messageKey: TASK_BOARD_MESSAGES.MEMBER_ADDED,
-            data: plainToInstance(TaskBoardMemberResponseDto, member, {
-                excludeExtraneousValues: true
-            })
-        };
-    }
-    async removeMember(dto) {
-        await this.boardService.removeMember(dto);
-        return {
-            success: true,
-            message: 'Member removed',
-            messageKey: TASK_BOARD_MESSAGES.MEMBER_REMOVED
-        };
-    }
-    async getMembers(dto) {
-        const members = await this.boardService.getMembers(dto.boardId);
-        const data = plainToInstance(TaskBoardMemberResponseDto, members, {
-            excludeExtraneousValues: true
-        });
-        return {
-            success: true,
-            message: 'Board members retrieved',
-            messageKey: TASK_BOARD_MESSAGES.MEMBER_GET_ALL_SUCCESS,
-            data,
-            meta: {
-                total: data.length,
-                page: 0,
-                pageSize: data.length,
-                count: data.length
-            }
-        };
-    }
-    constructor(boardService){
-        super(boardService), _define_property(this, "boardService", void 0), this.boardService = boardService;
-    }
-}
-_ts_decorate([
-    Post('add-member'),
-    UseGuards(JwtAuthGuard, PermissionGuard),
-    ApiBearerAuth(),
-    HttpCode(HttpStatus.OK),
-    RequirePermission(TASK_BOARD_PERMISSIONS.MANAGE_MEMBERS),
-    ApiOperation({
-        summary: 'Add user to board'
-    }),
-    ApiBody({
-        type: AddBoardMemberDto
-    }),
-    ApiResponseDto(TaskBoardMemberResponseDto),
-    _ts_param(0, Body()),
-    _ts_param(1, CurrentUser()),
-    _ts_metadata("design:type", Function),
-    _ts_metadata("design:paramtypes", [
-        typeof AddBoardMemberDto === "undefined" ? Object : AddBoardMemberDto,
-        typeof ILoggedUserInfo === "undefined" ? Object : ILoggedUserInfo
-    ]),
-    _ts_metadata("design:returntype", Promise)
-], TaskBoardController.prototype, "addMember", null);
-_ts_decorate([
-    Post('remove-member'),
-    UseGuards(JwtAuthGuard, PermissionGuard),
-    ApiBearerAuth(),
-    HttpCode(HttpStatus.OK),
-    RequirePermission(TASK_BOARD_PERMISSIONS.MANAGE_MEMBERS),
-    ApiOperation({
-        summary: 'Remove user from board'
-    }),
-    ApiBody({
-        type: RemoveBoardMemberDto
-    }),
-    ApiResponse({
-        status: 200,
-        type: MessageResponseDto
-    }),
-    _ts_param(0, Body()),
-    _ts_metadata("design:type", Function),
-    _ts_metadata("design:paramtypes", [
-        typeof RemoveBoardMemberDto === "undefined" ? Object : RemoveBoardMemberDto
-    ]),
-    _ts_metadata("design:returntype", Promise)
-], TaskBoardController.prototype, "removeMember", null);
-_ts_decorate([
-    Post('get-members'),
-    UseGuards(JwtAuthGuard),
-    ApiBearerAuth(),
-    HttpCode(HttpStatus.OK),
-    ApiOperation({
-        summary: 'Get all board members'
-    }),
-    ApiBody({
-        type: GetBoardMembersDto
-    }),
-    ApiResponseDto(TaskBoardMemberResponseDto, true),
-    _ts_param(0, Body()),
-    _ts_metadata("design:type", Function),
-    _ts_metadata("design:paramtypes", [
-        typeof GetBoardMembersDto === "undefined" ? Object : GetBoardMembersDto
-    ]),
-    _ts_metadata("design:returntype", Promise)
-], TaskBoardController.prototype, "getMembers", null);
-TaskBoardController = _ts_decorate([
-    ApiTags('Task Manager - Boards'),
-    Controller('task-manager/board'),
-    _ts_param(0, Inject(TaskBoardService)),
-    _ts_metadata("design:type", Function),
-    _ts_metadata("design:paramtypes", [
-        typeof TaskBoardService === "undefined" ? Object : TaskBoardService
-    ])
-], TaskBoardController);

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

@@ -1,128 +0,0 @@
-import { buildMockUser } from '@test-utils/mocks/logged-user.mock';
-import { TaskBoardController } from './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(mockBoardService);
-    });
-    describe('insert', ()=>{
-        it('creates a board and returns the mapped response', async ()=>{
-            const user = 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({}, buildMockUser(), '');
-            expect(mockBoardService.getAll).toHaveBeenCalledWith('', {}, buildMockUser());
-            expect(result.data).toHaveLength(1);
-        });
-    });
-    describe('addMember', ()=>{
-        it('adds a member to the board and maps the response', async ()=>{
-            const user = 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/fesm/controllers/task-comment.controller.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 { createApiController } from '@flusys/nestjs-shared/classes';
-import { Controller, Inject } from '@nestjs/common';
-import { ApiTags } from '@nestjs/swagger';
-import { TASK_COMMENT_PERMISSIONS } from '@flusys/nestjs-shared';
-import { CreateTaskCommentDto, TaskCommentResponseDto, UpdateTaskCommentDto } from '../dtos';
-import { TaskCommentService } from '../services/task-comment.service';
-export class TaskCommentController extends createApiController(CreateTaskCommentDto, UpdateTaskCommentDto, TaskCommentResponseDto, {
-    entityName: 'task.comment',
-    enabledEndpoints: [
-        'insert',
-        'insertMany',
-        'getById',
-        'getAll',
-        'update',
-        'updateMany',
-        'delete'
-    ],
-    security: {
-        insert: {
-            level: 'permission',
-            permissions: [
-                TASK_COMMENT_PERMISSIONS.CREATE
-            ]
-        },
-        insertMany: {
-            level: 'permission',
-            permissions: [
-                TASK_COMMENT_PERMISSIONS.CREATE
-            ]
-        },
-        getById: {
-            level: 'jwt'
-        },
-        getAll: {
-            level: 'permission',
-            permissions: [
-                TASK_COMMENT_PERMISSIONS.READ
-            ]
-        },
-        update: {
-            level: 'jwt'
-        },
-        updateMany: {
-            level: 'jwt'
-        },
-        delete: {
-            level: 'permission',
-            permissions: [
-                TASK_COMMENT_PERMISSIONS.DELETE
-            ]
-        }
-    }
-}) {
-    constructor(commentService){
-        super(commentService), _define_property(this, "commentService", void 0), this.commentService = commentService;
-    }
-}
-TaskCommentController = _ts_decorate([
-    ApiTags('Task Manager - Comments'),
-    Controller('task-manager/comment'),
-    _ts_param(0, Inject(TaskCommentService)),
-    _ts_metadata("design:type", Function),
-    _ts_metadata("design:paramtypes", [
-        typeof TaskCommentService === "undefined" ? Object : TaskCommentService
-    ])
-], TaskCommentController);

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

@@ -1,82 +0,0 @@
-import { buildMockUser } from '@test-utils/mocks/logged-user.mock';
-import { TaskCommentController } from './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(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 = 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({}, buildMockUser(), '');
-            expect(mockCommentService.getAll).toHaveBeenCalledWith('', {}, 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'
-            }, buildMockUser());
-            expect(mockCommentService.delete).toHaveBeenCalledWith({
-                id: [
-                    'comment-1'
-                ],
-                type: 'delete'
-            }, buildMockUser());
-            expect(result.success).toBe(true);
-        });
-    });
-});