@flusys/nestjs-task-manager 5.3.0

package/cjs/services/task-manager-config.service.js

@@ -0,0 +1,69 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "TaskManagerConfigService", {
+    enumerable: true,
+    get: function() {
+        return TaskManagerConfigService;
+    }
+});
+const _common = require("@nestjs/common");
+const _taskmanagerconstants = require("../config/task-manager.constants");
+const _interfaces = require("../interfaces");
+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);
+    };
+}
+let TaskManagerConfigService = class TaskManagerConfigService {
+    isCompanyFeatureEnabled() {
+        return this.options.bootstrapAppConfig?.enableCompanyFeature ?? false;
+    }
+    getDatabaseMode() {
+        return this.options.bootstrapAppConfig?.databaseMode ?? 'single';
+    }
+    isMultiTenant() {
+        return this.getDatabaseMode() === 'multi-tenant';
+    }
+    getJwtSecret() {
+        return this.options.config?.jwtSecret;
+    }
+    getOptions() {
+        return this.options;
+    }
+    constructor(options){
+        _define_property(this, "options", void 0);
+        this.options = options;
+    }
+};
+TaskManagerConfigService = _ts_decorate([
+    (0, _common.Injectable)(),
+    _ts_param(0, (0, _common.Inject)(_taskmanagerconstants.TASK_MANAGER_MODULE_OPTIONS)),
+    _ts_metadata("design:type", Function),
+    _ts_metadata("design:paramtypes", [
+        typeof _interfaces.TaskManagerModuleOptions === "undefined" ? Object : _interfaces.TaskManagerModuleOptions
+    ])
+], TaskManagerConfigService);

package/cjs/services/task-manager-datasource.provider.js

@@ -0,0 +1,84 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "TaskManagerDataSourceProvider", {
+    enumerable: true,
+    get: function() {
+        return TaskManagerDataSourceProvider;
+    }
+});
+const _modules = require("@flusys/nestjs-shared/modules");
+const _common = require("@nestjs/common");
+const _core = require("@nestjs/core");
+const _express = require("express");
+const _entities = require("../entities");
+const _taskmanagerconfigservice = require("./task-manager-config.service");
+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);
+    };
+}
+let TaskManagerDataSourceProvider = class TaskManagerDataSourceProvider extends _modules.MultiTenantDataSourceService {
+    static buildParentOptions(options) {
+        return {
+            bootstrapAppConfig: options.bootstrapAppConfig,
+            defaultDatabaseConfig: options.config?.defaultDatabaseConfig,
+            tenantDefaultDatabaseConfig: options.config?.tenantDefaultDatabaseConfig,
+            tenants: options.config?.tenants
+        };
+    }
+    getEnableCompanyFeatureForTenant(tenant) {
+        return tenant?.enableCompanyFeature ?? this.configService.isCompanyFeatureEnabled();
+    }
+    async createDataSourceFromConfig(config) {
+        const currentTenant = this.getCurrentTenant();
+        const enableCompanyFeature = this.getEnableCompanyFeatureForTenant(currentTenant ?? undefined);
+        const entities = (0, _entities.getTaskManagerEntitiesByConfig)(enableCompanyFeature);
+        return super.createDataSourceFromConfig(config, entities);
+    }
+    constructor(configService, request){
+        super(TaskManagerDataSourceProvider.buildParentOptions(configService.getOptions()), request), _define_property(this, "configService", void 0), this.configService = configService;
+    }
+};
+_define_property(TaskManagerDataSourceProvider, "tenantConnections", new Map());
+_define_property(TaskManagerDataSourceProvider, "singleDataSource", null);
+_define_property(TaskManagerDataSourceProvider, "tenantsRegistry", new Map());
+_define_property(TaskManagerDataSourceProvider, "initialized", false);
+_define_property(TaskManagerDataSourceProvider, "connectionLocks", new Map());
+_define_property(TaskManagerDataSourceProvider, "singleConnectionLock", null);
+TaskManagerDataSourceProvider = _ts_decorate([
+    (0, _common.Injectable)({
+        scope: _common.Scope.REQUEST
+    }),
+    _ts_param(0, (0, _common.Inject)(_taskmanagerconfigservice.TaskManagerConfigService)),
+    _ts_param(1, (0, _common.Optional)()),
+    _ts_param(1, (0, _common.Inject)(_core.REQUEST)),
+    _ts_metadata("design:type", Function),
+    _ts_metadata("design:paramtypes", [
+        typeof _taskmanagerconfigservice.TaskManagerConfigService === "undefined" ? Object : _taskmanagerconfigservice.TaskManagerConfigService,
+        typeof _express.Request === "undefined" ? Object : _express.Request
+    ])
+], TaskManagerDataSourceProvider);

package/cjs/services/task.service.js

@@ -0,0 +1,359 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "TaskService", {
+    enumerable: true,
+    get: function() {
+        return TaskService;
+    }
+});
+const _classes = require("@flusys/nestjs-shared/classes");
+const _modules = require("@flusys/nestjs-shared/modules");
+const _common = require("@nestjs/common");
+const _typeorm = require("typeorm");
+const _config = require("../config");
+const _entities = require("../entities");
+const _taskactivityservice = require("./task-activity.service");
+const _taskboardservice = require("./task-board.service");
+const _taskmanagerdatasourceprovider = require("./task-manager-datasource.provider");
+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);
+    };
+}
+let TaskService = class TaskService extends _classes.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 _common.NotFoundException({
+                message: 'Task not found',
+                messageKey: _config.TASK_MESSAGES.NOT_FOUND
+            });
+            entity = existing;
+        }
+        if (dto.assigneeIds?.length) {
+            const boardId = dto.boardId ?? entity.boardId;
+            const memberChecks = await Promise.all(dto.assigneeIds.map((id)=>this.boardService.isBoardMember(boardId, id)));
+            if (memberChecks.some((isMember)=>!isMember)) {
+                throw new _common.BadRequestException({
+                    message: 'Assignee is not a board member',
+                    messageKey: _config.TASK_MESSAGES.ASSIGNEE_NOT_BOARD_MEMBER
+                });
+            }
+        }
+        if ('labelIds' in dto && dto.labelIds !== undefined) {
+            this.pendingLabelIds.push(dto.labelIds ?? []);
+        }
+        if ('assigneeIds' in dto && dto.assigneeIds !== undefined) {
+            this.pendingAssigneeIds.push(dto.assigneeIds ?? []);
+        } else {
+            this.pendingAssigneeIds.push(undefined);
+        }
+        return {
+            ...entity,
+            boardId: dto.boardId ?? entity.boardId,
+            listId: dto.listId ?? entity.listId,
+            title: dto.title ?? entity.title,
+            description: dto.description !== undefined ? dto.description ?? null : entity.description ?? null,
+            priority: dto.priority ?? entity.priority ?? 'MEDIUM',
+            dueDate: dto.dueDate !== undefined ? dto.dueDate ?? null : entity.dueDate ?? null,
+            position: entity.position ?? 0,
+            reporterId: entity.reporterId ?? user?.id ?? null,
+            parentTaskId: dto.parentTaskId !== undefined ? dto.parentTaskId ?? null : entity.parentTaskId ?? null,
+            estimatedHours: dto.estimatedHours !== undefined ? dto.estimatedHours ?? null : entity.estimatedHours ?? null
+        };
+    }
+    async afterInsertOperation(entities, user, _qr) {
+        await Promise.all(entities.map(async (entity, i)=>{
+            const assigneeIds = this.pendingAssigneeIds[i] ?? [];
+            const syncOps = [
+                this.syncLabels(entity.id, this.pendingLabelIds[i] ?? [])
+            ];
+            if (assigneeIds.length > 0) {
+                syncOps.push(this.syncAssignees(entity.id, assigneeIds));
+            }
+            await Promise.all(syncOps);
+        }));
+        await Promise.all([
+            this.loadLabelsForTasks(entities),
+            this.loadAssigneesForTasks(entities)
+        ]);
+        await Promise.all(entities.map((entity)=>this.activityService.log(entity.id, entity.boardId, user?.id ?? null, 'task.created', null, {
+                title: entity.title
+            })));
+        this.pendingLabelIds = [];
+        this.pendingAssigneeIds = [];
+    }
+    async afterUpdateOperation(entities, _user, _qr) {
+        await Promise.all(entities.map(async (entity, i)=>{
+            const syncOps = [];
+            if (this.pendingLabelIds[i] !== undefined) {
+                syncOps.push(this.syncLabels(entity.id, this.pendingLabelIds[i]));
+            }
+            if (this.pendingAssigneeIds[i] !== undefined) {
+                syncOps.push(this.syncAssignees(entity.id, this.pendingAssigneeIds[i]));
+            }
+            if (syncOps.length > 0) await Promise.all(syncOps);
+        }));
+        await this.loadLabelsForTasks(entities);
+        const entitiesWithAssigneeUpdates = entities.filter((_, i)=>this.pendingAssigneeIds[i] !== undefined);
+        if (entitiesWithAssigneeUpdates.length > 0) {
+            await this.loadAssigneesForTasks(entitiesWithAssigneeUpdates);
+        }
+        this.pendingLabelIds = [];
+        this.pendingAssigneeIds = [];
+    }
+    async getFilterQuery(query, filter, _user) {
+        for (const [key, value] of Object.entries(filter)){
+            if (key === 'boardId') {
+                query.andWhere('task.boardId = :boardId', {
+                    boardId: value
+                });
+            } else if (key === 'listId') {
+                query.andWhere('task.listId = :listId', {
+                    listId: value
+                });
+            } else if (key === 'assigneeId') {
+                query.innerJoin('task_assignee', 'ta', 'ta.task_id = task.id').andWhere('ta.user_id = :assigneeUserId', {
+                    assigneeUserId: value
+                });
+            } else if (key === 'priority') {
+                query.andWhere('task.priority = :priority', {
+                    priority: value
+                });
+            }
+        }
+        return {
+            query,
+            isRaw: false
+        };
+    }
+    async getAll(search, filterAndPaginationDto, user) {
+        const result = await super.getAll(search, filterAndPaginationDto, user);
+        await this.loadLabelsForTasks(result.data);
+        await this.loadAssigneesForTasks(result.data);
+        return result;
+    }
+    async moveTask(dto, user) {
+        await this.ensureDataSourceRepository();
+        const task = await this.repository.findOne({
+            where: {
+                id: dto.taskId,
+                deletedAt: (0, _typeorm.IsNull)()
+            }
+        });
+        if (!task) throw new _common.NotFoundException({
+            message: 'Task not found',
+            messageKey: _config.TASK_MESSAGES.NOT_FOUND
+        });
+        const oldListId = task.listId;
+        task.listId = dto.targetListId;
+        task.position = dto.position ?? 0;
+        task.updatedById = user.id;
+        const saved = await this.repository.save(task);
+        await this.activityService.log(task.id, task.boardId, user.id, 'task.moved', {
+            listId: oldListId
+        }, {
+            listId: dto.targetListId
+        });
+        return saved;
+    }
+    async assignTask(dto, user) {
+        await this.ensureDataSourceRepository();
+        const task = await this.repository.findOne({
+            where: {
+                id: dto.taskId,
+                deletedAt: (0, _typeorm.IsNull)()
+            }
+        });
+        if (!task) throw new _common.NotFoundException({
+            message: 'Task not found',
+            messageKey: _config.TASK_MESSAGES.NOT_FOUND
+        });
+        const memberChecks = await Promise.all(dto.assigneeIds.map((id)=>this.boardService.isBoardMember(task.boardId, id)));
+        if (memberChecks.some((isMember)=>!isMember)) {
+            throw new _common.BadRequestException({
+                message: 'Assignee is not a board member',
+                messageKey: _config.TASK_MESSAGES.ASSIGNEE_NOT_BOARD_MEMBER
+            });
+        }
+        const assigneeRepo = await this.ensureAssigneeRepository();
+        const oldRows = await assigneeRepo.find({
+            where: {
+                taskId: dto.taskId
+            }
+        });
+        const oldIds = oldRows.map((r)=>r.userId);
+        await this.syncAssignees(dto.taskId, dto.assigneeIds);
+        task.updatedById = user.id;
+        const saved = await this.repository.save(task);
+        await this.activityService.log(task.id, task.boardId, user.id, 'task.assigned', {
+            assigneeIds: oldIds
+        }, {
+            assigneeIds: dto.assigneeIds
+        });
+        saved.assignees = await this.loadAssigneesForTask(saved.id);
+        return saved;
+    }
+    async syncAssignees(taskId, userIds) {
+        const repo = await this.ensureAssigneeRepository();
+        await repo.delete({
+            taskId
+        });
+        if (userIds.length > 0) {
+            await repo.save(userIds.map((userId)=>repo.create({
+                    taskId,
+                    userId
+                })));
+        }
+    }
+    async syncLabels(taskId, labelIds) {
+        const labelRepo = await this.ensureLabelRepository();
+        await labelRepo.delete({
+            taskId
+        });
+        if (labelIds.length > 0) {
+            const rows = labelIds.map((labelId)=>labelRepo.create({
+                    taskId,
+                    labelId
+                }));
+            await labelRepo.save(rows);
+        }
+    }
+    async loadLabelsForTasks(tasks) {
+        if (tasks.length === 0) return;
+        const junctionRepo = await this.ensureLabelRepository();
+        const fullRepo = await this.ensureFullLabelRepository();
+        const taskIds = tasks.map((t)=>t.id);
+        const junctionRows = await junctionRepo.find({
+            where: {
+                taskId: (0, _typeorm.In)(taskIds),
+                deletedAt: (0, _typeorm.IsNull)()
+            }
+        });
+        const uniqueLabelIds = [
+            ...new Set(junctionRows.map((r)=>r.labelId))
+        ];
+        const fullLabels = uniqueLabelIds.length > 0 ? await fullRepo.find({
+            where: {
+                id: (0, _typeorm.In)(uniqueLabelIds),
+                deletedAt: (0, _typeorm.IsNull)()
+            }
+        }) : [];
+        const labelById = new Map(fullLabels.map((l)=>[
+                l.id,
+                l
+            ]));
+        const byTask = new Map();
+        for (const row of junctionRows){
+            const label = labelById.get(row.labelId);
+            if (!label) continue;
+            const list = byTask.get(row.taskId) ?? [];
+            list.push(label);
+            byTask.set(row.taskId, list);
+        }
+        for (const task of tasks){
+            const taskLabels = byTask.get(task.id) ?? [];
+            task.labelIds = taskLabels.map((l)=>l.id);
+            task.labels = taskLabels;
+        }
+    }
+    async loadAssigneesForTasks(tasks) {
+        if (tasks.length === 0) return;
+        const repo = await this.ensureAssigneeRepository();
+        const taskIds = tasks.map((t)=>t.id);
+        const rows = await repo.createQueryBuilder('ta').select('ta.task_id', 'taskId').addSelect('ta.user_id', 'userId').addSelect('u.name', 'userName').leftJoin('app_user', 'u', 'u.id = ta.user_id').where('ta.task_id IN (:...taskIds)', {
+            taskIds
+        }).getRawMany();
+        const byTask = new Map();
+        for (const row of rows){
+            const list = byTask.get(row.taskId) ?? [];
+            list.push({
+                userId: row.userId,
+                userName: row.userName ?? null
+            });
+            byTask.set(row.taskId, list);
+        }
+        for (const task of tasks){
+            task.assignees = byTask.get(task.id) ?? [];
+        }
+    }
+    async loadAssigneesForTask(taskId) {
+        const repo = await this.ensureAssigneeRepository();
+        const rows = await repo.createQueryBuilder('ta').select('ta.user_id', 'userId').addSelect('u.name', 'userName').leftJoin('app_user', 'u', 'u.id = ta.user_id').where('ta.task_id = :taskId', {
+            taskId
+        }).getRawMany();
+        return rows.map((r)=>({
+                userId: r.userId,
+                userName: r.userName ?? null
+            }));
+    }
+    async ensureLabelRepository() {
+        if (!this.taskLabelRepository) {
+            this.taskLabelRepository = await this.dataSourceProvider.getRepository(_entities.TaskTaskLabel);
+        }
+        return this.taskLabelRepository;
+    }
+    async ensureFullLabelRepository() {
+        if (!this.fullLabelRepository) {
+            this.fullLabelRepository = await this.dataSourceProvider.getRepository(_entities.TaskLabel);
+        }
+        return this.fullLabelRepository;
+    }
+    async ensureAssigneeRepository() {
+        if (!this.taskAssigneeRepository) {
+            this.taskAssigneeRepository = await this.dataSourceProvider.getRepository(_entities.TaskAssignee);
+        }
+        return this.taskAssigneeRepository;
+    }
+    constructor(cacheManager, utilsService, dataSourceProvider, boardService, activityService){
+        super('task', cacheManager, utilsService, TaskService.name, true, 'task-manager', _entities.Task, dataSourceProvider), _define_property(this, "cacheManager", void 0), _define_property(this, "utilsService", void 0), _define_property(this, "dataSourceProvider", void 0), _define_property(this, "boardService", void 0), _define_property(this, "activityService", void 0), _define_property(this, "taskLabelRepository", void 0), _define_property(this, "fullLabelRepository", void 0), _define_property(this, "taskAssigneeRepository", void 0), _define_property(this, "pendingLabelIds", void 0), _define_property(this, "pendingAssigneeIds", void 0), this.cacheManager = cacheManager, this.utilsService = utilsService, this.dataSourceProvider = dataSourceProvider, this.boardService = boardService, this.activityService = activityService, this.taskLabelRepository = null, this.fullLabelRepository = null, this.taskAssigneeRepository = null, this.pendingLabelIds = [], this.pendingAssigneeIds = [];
+    }
+};
+TaskService = _ts_decorate([
+    (0, _common.Injectable)({
+        scope: _common.Scope.REQUEST
+    }),
+    _ts_param(0, (0, _common.Inject)('CACHE_INSTANCE')),
+    _ts_param(1, (0, _common.Inject)(_modules.UtilsService)),
+    _ts_param(2, (0, _common.Inject)(_taskmanagerdatasourceprovider.TaskManagerDataSourceProvider)),
+    _ts_param(3, (0, _common.Inject)(_taskboardservice.TaskBoardService)),
+    _ts_param(4, (0, _common.Inject)(_taskactivityservice.TaskActivityService)),
+    _ts_metadata("design:type", Function),
+    _ts_metadata("design:paramtypes", [
+        typeof _classes.HybridCache === "undefined" ? Object : _classes.HybridCache,
+        typeof _modules.UtilsService === "undefined" ? Object : _modules.UtilsService,
+        typeof _taskmanagerdatasourceprovider.TaskManagerDataSourceProvider === "undefined" ? Object : _taskmanagerdatasourceprovider.TaskManagerDataSourceProvider,
+        typeof _taskboardservice.TaskBoardService === "undefined" ? Object : _taskboardservice.TaskBoardService,
+        typeof _taskactivityservice.TaskActivityService === "undefined" ? Object : _taskactivityservice.TaskActivityService
+    ])
+], TaskService);

package/config/index.d.ts

@@ -0,0 +1,2 @@
+export * from './task-manager.constants';
+export * from './message-keys';

package/config/message-keys.d.ts

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

package/config/task-manager.constants.d.ts

@@ -0,0 +1 @@
+export declare const TASK_MANAGER_MODULE_OPTIONS = "TASK_MANAGER_MODULE_OPTIONS";

package/controllers/index.d.ts

@@ -0,0 +1,5 @@
+export * from './task-board.controller';
+export * from './task-list.controller';
+export * from './task.controller';
+export * from './task-label.controller';
+export * from './task-comment.controller';

package/controllers/task-board.controller.d.ts

@@ -0,0 +1,27 @@
+import { ListResponseDto, MessageResponseDto, SingleResponseDto } from '@flusys/nestjs-shared/dtos';
+import { ILoggedUserInfo } from '@flusys/nestjs-shared/interfaces';
+import { AddBoardMemberDto, CreateTaskBoardDto, GetBoardMembersDto, RemoveBoardMemberDto, TaskBoardMemberResponseDto, TaskBoardResponseDto, UpdateTaskBoardDto } from '../dtos';
+import { TaskBoardService } from '../services/task-board.service';
+declare const TaskBoardController_base: abstract new (service: TaskBoardService) => {
+    readonly enabledEndpoints: import("@flusys/nestjs-shared").ApiEndpoint[] | "all";
+    service: TaskBoardService;
+    isEnabled(endpoint: import("@flusys/nestjs-shared").ApiEndpoint): boolean;
+    insert(addDto: CreateTaskBoardDto, user: ILoggedUserInfo | null): Promise<SingleResponseDto<TaskBoardResponseDto>>;
+    insertMany(addDto: CreateTaskBoardDto[], user: ILoggedUserInfo | null): Promise<import("@flusys/nestjs-shared").BulkResponseDto<TaskBoardResponseDto>>;
+    getById(id: string, body: import("@flusys/nestjs-shared").GetByIdBodyDto, user: ILoggedUserInfo | null): Promise<SingleResponseDto<TaskBoardResponseDto>>;
+    getByIds(body: import("@flusys/nestjs-shared").GetByIdsDto, user: ILoggedUserInfo | null): Promise<ListResponseDto<TaskBoardResponseDto>>;
+    update(updateDto: UpdateTaskBoardDto, user: ILoggedUserInfo | null): Promise<SingleResponseDto<TaskBoardResponseDto>>;
+    updateMany(updateDtos: UpdateTaskBoardDto[], user: ILoggedUserInfo | null): Promise<import("@flusys/nestjs-shared").BulkResponseDto<TaskBoardResponseDto>>;
+    bulkUpsert(dtos: (CreateTaskBoardDto | UpdateTaskBoardDto)[], user: ILoggedUserInfo | null): Promise<import("@flusys/nestjs-shared").BulkResponseDto<TaskBoardResponseDto>>;
+    getByFilter(filter: Record<string, any>, user: ILoggedUserInfo | null): Promise<SingleResponseDto<TaskBoardResponseDto>>;
+    getAll(filterAndPaginationDto: import("@flusys/nestjs-shared").FilterAndPaginationDto, user: ILoggedUserInfo | null, search?: string): Promise<ListResponseDto<TaskBoardResponseDto>>;
+    delete(deleteDto: import("@flusys/nestjs-shared").DeleteDto, user: ILoggedUserInfo | null): Promise<MessageResponseDto>;
+};
+export declare class TaskBoardController extends TaskBoardController_base {
+    protected boardService: TaskBoardService;
+    constructor(boardService: TaskBoardService);
+    addMember(dto: AddBoardMemberDto, user: ILoggedUserInfo): Promise<SingleResponseDto<TaskBoardMemberResponseDto>>;
+    removeMember(dto: RemoveBoardMemberDto): Promise<MessageResponseDto>;
+    getMembers(dto: GetBoardMembersDto): Promise<ListResponseDto<TaskBoardMemberResponseDto>>;
+}
+export {};

package/controllers/task-comment.controller.d.ts

@@ -0,0 +1,22 @@
+import { CreateTaskCommentDto, TaskCommentResponseDto, UpdateTaskCommentDto } from '../dtos';
+import { TaskCommentService } from '../services/task-comment.service';
+declare const TaskCommentController_base: abstract new (service: TaskCommentService) => {
+    readonly enabledEndpoints: import("@flusys/nestjs-shared").ApiEndpoint[] | "all";
+    service: TaskCommentService;
+    isEnabled(endpoint: import("@flusys/nestjs-shared").ApiEndpoint): boolean;
+    insert(addDto: CreateTaskCommentDto, user: import("@flusys/nestjs-shared").ILoggedUserInfo | null): Promise<import("@flusys/nestjs-shared").SingleResponseDto<TaskCommentResponseDto>>;
+    insertMany(addDto: CreateTaskCommentDto[], user: import("@flusys/nestjs-shared").ILoggedUserInfo | null): Promise<import("@flusys/nestjs-shared").BulkResponseDto<TaskCommentResponseDto>>;
+    getById(id: string, body: import("@flusys/nestjs-shared").GetByIdBodyDto, user: import("@flusys/nestjs-shared").ILoggedUserInfo | null): Promise<import("@flusys/nestjs-shared").SingleResponseDto<TaskCommentResponseDto>>;
+    getByIds(body: import("@flusys/nestjs-shared").GetByIdsDto, user: import("@flusys/nestjs-shared").ILoggedUserInfo | null): Promise<import("@flusys/nestjs-shared").ListResponseDto<TaskCommentResponseDto>>;
+    update(updateDto: UpdateTaskCommentDto, user: import("@flusys/nestjs-shared").ILoggedUserInfo | null): Promise<import("@flusys/nestjs-shared").SingleResponseDto<TaskCommentResponseDto>>;
+    updateMany(updateDtos: UpdateTaskCommentDto[], user: import("@flusys/nestjs-shared").ILoggedUserInfo | null): Promise<import("@flusys/nestjs-shared").BulkResponseDto<TaskCommentResponseDto>>;
+    bulkUpsert(dtos: (CreateTaskCommentDto | UpdateTaskCommentDto)[], user: import("@flusys/nestjs-shared").ILoggedUserInfo | null): Promise<import("@flusys/nestjs-shared").BulkResponseDto<TaskCommentResponseDto>>;
+    getByFilter(filter: Record<string, any>, user: import("@flusys/nestjs-shared").ILoggedUserInfo | null): Promise<import("@flusys/nestjs-shared").SingleResponseDto<TaskCommentResponseDto>>;
+    getAll(filterAndPaginationDto: import("@flusys/nestjs-shared").FilterAndPaginationDto, user: import("@flusys/nestjs-shared").ILoggedUserInfo | null, search?: string): Promise<import("@flusys/nestjs-shared").ListResponseDto<TaskCommentResponseDto>>;
+    delete(deleteDto: import("@flusys/nestjs-shared").DeleteDto, user: import("@flusys/nestjs-shared").ILoggedUserInfo | null): Promise<import("@flusys/nestjs-shared").MessageResponseDto>;
+};
+export declare class TaskCommentController extends TaskCommentController_base {
+    protected commentService: TaskCommentService;
+    constructor(commentService: TaskCommentService);
+}
+export {};