@flusys/nestjs-task-manager 5.3.0

package/fesm/services/task.service.js

@@ -0,0 +1,349 @@
+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 { ApiService, HybridCache } from '@flusys/nestjs-shared/classes';
+import { UtilsService } from '@flusys/nestjs-shared/modules';
+import { BadRequestException, Inject, Injectable, NotFoundException, Scope } from '@nestjs/common';
+import { In, IsNull } from 'typeorm';
+import { TASK_MESSAGES } from '../config';
+import { Task, TaskAssignee, TaskLabel, TaskTaskLabel } from '../entities';
+import { TaskActivityService } from './task-activity.service';
+import { TaskBoardService } from './task-board.service';
+import { TaskManagerDataSourceProvider } from './task-manager-datasource.provider';
+export class TaskService 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: 'Task not found',
+                messageKey: 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 BadRequestException({
+                    message: 'Assignee is not a board member',
+                    messageKey: 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: IsNull()
+            }
+        });
+        if (!task) throw new NotFoundException({
+            message: 'Task not found',
+            messageKey: 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: IsNull()
+            }
+        });
+        if (!task) throw new NotFoundException({
+            message: 'Task not found',
+            messageKey: 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 BadRequestException({
+                message: 'Assignee is not a board member',
+                messageKey: 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: In(taskIds),
+                deletedAt: IsNull()
+            }
+        });
+        const uniqueLabelIds = [
+            ...new Set(junctionRows.map((r)=>r.labelId))
+        ];
+        const fullLabels = uniqueLabelIds.length > 0 ? await fullRepo.find({
+            where: {
+                id: In(uniqueLabelIds),
+                deletedAt: 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(TaskTaskLabel);
+        }
+        return this.taskLabelRepository;
+    }
+    async ensureFullLabelRepository() {
+        if (!this.fullLabelRepository) {
+            this.fullLabelRepository = await this.dataSourceProvider.getRepository(TaskLabel);
+        }
+        return this.fullLabelRepository;
+    }
+    async ensureAssigneeRepository() {
+        if (!this.taskAssigneeRepository) {
+            this.taskAssigneeRepository = await this.dataSourceProvider.getRepository(TaskAssignee);
+        }
+        return this.taskAssigneeRepository;
+    }
+    constructor(cacheManager, utilsService, dataSourceProvider, boardService, activityService){
+        super('task', cacheManager, utilsService, TaskService.name, true, 'task-manager', 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([
+    Injectable({
+        scope: Scope.REQUEST
+    }),
+    _ts_param(0, Inject('CACHE_INSTANCE')),
+    _ts_param(1, Inject(UtilsService)),
+    _ts_param(2, Inject(TaskManagerDataSourceProvider)),
+    _ts_param(3, Inject(TaskBoardService)),
+    _ts_param(4, Inject(TaskActivityService)),
+    _ts_metadata("design:type", Function),
+    _ts_metadata("design:paramtypes", [
+        typeof HybridCache === "undefined" ? Object : HybridCache,
+        typeof UtilsService === "undefined" ? Object : UtilsService,
+        typeof TaskManagerDataSourceProvider === "undefined" ? Object : TaskManagerDataSourceProvider,
+        typeof TaskBoardService === "undefined" ? Object : TaskBoardService,
+        typeof TaskActivityService === "undefined" ? Object : TaskActivityService
+    ])
+], TaskService);

package/gateways/index.d.ts

@@ -0,0 +1 @@
+export * from './task-board.gateway';

package/gateways/task-board.gateway.d.ts

@@ -0,0 +1,22 @@
+import { OnGatewayConnection, OnGatewayDisconnect } from '@nestjs/websockets';
+import { Server, Socket } from 'socket.io';
+import { ITaskBoardSocketEvent } from '../interfaces';
+import { TaskManagerConfigService } from '../services/task-manager-config.service';
+export declare class TaskBoardGateway implements OnGatewayConnection, OnGatewayDisconnect {
+    private readonly configService;
+    private readonly connectedUsers;
+    server: Server;
+    constructor(configService: TaskManagerConfigService);
+    handleConnection(client: Socket): Promise<void>;
+    handleDisconnect(client: Socket): void;
+    handleJoinBoard(client: Socket, data: {
+        boardId: string;
+    }): void;
+    handleLeaveBoard(client: Socket, data: {
+        boardId: string;
+    }): void;
+    emitToBoardRoom(boardId: string, event: ITaskBoardSocketEvent): void;
+    isUserOnline(userId: string): boolean;
+    private extractToken;
+    private verifyToken;
+}

package/index.d.ts

@@ -0,0 +1,9 @@
+export * from './config';
+export * from './controllers';
+export * from './docs';
+export * from './dtos';
+export * from './entities';
+export * from './gateways';
+export * from './interfaces';
+export * from './modules';
+export * from './services';

package/interfaces/index.d.ts

@@ -0,0 +1,2 @@
+export * from './task-manager-module.interface';
+export * from './task.interface';

package/interfaces/task-manager-module.interface.d.ts

@@ -0,0 +1,19 @@
+import { IBootstrapAppConfig, IDataSourceServiceOptions, IDynamicModuleConfig, IModuleOptionsFactory } from '@flusys/nestjs-core';
+import { ModuleMetadata, Type } from '@nestjs/common';
+export interface ITaskManagerModuleConfig extends IDataSourceServiceOptions {
+    jwtSecret?: string;
+}
+export interface TaskManagerModuleOptions extends IDynamicModuleConfig {
+    bootstrapAppConfig?: IBootstrapAppConfig;
+    config?: ITaskManagerModuleConfig;
+}
+export interface TaskManagerOptionsFactory extends IModuleOptionsFactory<ITaskManagerModuleConfig> {
+    createTaskManagerOptions(): Promise<ITaskManagerModuleConfig> | ITaskManagerModuleConfig;
+}
+export interface TaskManagerModuleAsyncOptions extends Pick<ModuleMetadata, 'imports'>, IDynamicModuleConfig {
+    bootstrapAppConfig: IBootstrapAppConfig;
+    useFactory?: (...args: any[]) => Promise<ITaskManagerModuleConfig> | ITaskManagerModuleConfig;
+    inject?: any[];
+    useClass?: Type<TaskManagerOptionsFactory>;
+    useExisting?: Type<TaskManagerOptionsFactory>;
+}

package/interfaces/task.interface.d.ts

@@ -0,0 +1,52 @@
+import { IIdentity } from '@flusys/nestjs-shared/interfaces';
+import { TaskPriority } from '../entities/task.entity';
+export interface ITaskBoard extends IIdentity {
+    name: string;
+    description: string | null;
+    color: string;
+    isActive: boolean;
+    settings: Record<string, unknown> | null;
+    companyId?: string | null;
+}
+export interface ITaskList extends IIdentity {
+    boardId: string;
+    name: string;
+    color: string;
+    position: number;
+    isActive: boolean;
+    isDoneList: boolean;
+}
+export interface ITaskAssignee {
+    userId: string;
+    userName: string | null;
+}
+export interface ITask extends IIdentity {
+    boardId: string;
+    listId: string;
+    title: string;
+    description: string | null;
+    priority: TaskPriority;
+    dueDate: string | null;
+    position: number;
+    assignees: ITaskAssignee[];
+    reporterId: string | null;
+    parentTaskId: string | null;
+    estimatedHours: number | null;
+    labels?: ITaskLabel[];
+}
+export interface ITaskLabel extends IIdentity {
+    boardId: string;
+    name: string;
+    color: string;
+}
+export interface ITaskComment extends IIdentity {
+    taskId: string;
+    userId: string;
+    content: string;
+    parentCommentId: string | null;
+}
+export interface ITaskBoardSocketEvent {
+    type: 'task:created' | 'task:updated' | 'task:deleted' | 'task:moved' | 'list:created' | 'list:updated' | 'list:deleted' | 'list:reordered';
+    boardId: string;
+    payload: unknown;
+}

package/modules/index.d.ts

@@ -0,0 +1 @@
+export * from './task-manager.module';

package/modules/task-manager.module.d.ts

@@ -0,0 +1,8 @@
+import { DynamicModule } from '@nestjs/common';
+import { TaskManagerModuleAsyncOptions, TaskManagerModuleOptions } from '../interfaces';
+export declare class TaskManagerModule {
+    static forRoot(options: TaskManagerModuleOptions): DynamicModule;
+    static forRootAsync(options: TaskManagerModuleAsyncOptions): DynamicModule;
+    private static buildProviders;
+    private static createAsyncProviders;
+}

package/package.json

@@ -0,0 +1,91 @@
+{
+  "name": "@flusys/nestjs-task-manager",
+  "version": "5.3.0",
+  "description": "Task management module with dynamic boards and real-time collaboration",
+  "main": "cjs/index.js",
+  "module": "fesm/index.js",
+  "types": "index.d.ts",
+  "sideEffects": false,
+  "keywords": [
+    "nestjs",
+    "task-manager",
+    "kanban",
+    "socket.io",
+    "real-time",
+    "@flusys"
+  ],
+  "license": "UNLICENSED",
+  "exports": {
+    ".": {
+      "types": "./index.d.ts",
+      "import": "./fesm/index.js",
+      "require": "./cjs/index.js"
+    },
+    "./config": {
+      "types": "./config/index.d.ts",
+      "import": "./fesm/config/index.js",
+      "require": "./cjs/config/index.js"
+    },
+    "./controllers": {
+      "types": "./controllers/index.d.ts",
+      "import": "./fesm/controllers/index.js",
+      "require": "./cjs/controllers/index.js"
+    },
+    "./docs": {
+      "types": "./docs/index.d.ts",
+      "import": "./fesm/docs/index.js",
+      "require": "./cjs/docs/index.js"
+    },
+    "./dtos": {
+      "types": "./dtos/index.d.ts",
+      "import": "./fesm/dtos/index.js",
+      "require": "./cjs/dtos/index.js"
+    },
+    "./entities": {
+      "types": "./entities/index.d.ts",
+      "import": "./fesm/entities/index.js",
+      "require": "./cjs/entities/index.js"
+    },
+    "./gateways": {
+      "types": "./gateways/index.d.ts",
+      "import": "./fesm/gateways/index.js",
+      "require": "./cjs/gateways/index.js"
+    },
+    "./interfaces": {
+      "types": "./interfaces/index.d.ts",
+      "import": "./fesm/interfaces/index.js",
+      "require": "./cjs/interfaces/index.js"
+    },
+    "./modules": {
+      "types": "./modules/index.d.ts",
+      "import": "./fesm/modules/index.js",
+      "require": "./cjs/modules/index.js"
+    },
+    "./services": {
+      "types": "./services/index.d.ts",
+      "import": "./fesm/services/index.js",
+      "require": "./cjs/services/index.js"
+    },
+    "./*": {
+      "types": "./*.d.ts",
+      "import": "./*.js",
+      "require": "./*.js"
+    }
+  },
+  "peerDependencies": {
+    "@nestjs/common": "^11.0.0",
+    "@nestjs/core": "^11.0.0",
+    "@nestjs/swagger": "^11.0.0",
+    "@nestjs/websockets": "^11.0.0",
+    "@nestjs/platform-socket.io": "^11.0.0",
+    "typeorm": "^0.3.0",
+    "class-transformer": "^0.5.1",
+    "class-validator": "^0.14.0 || ^0.15.0",
+    "socket.io": "^4.8.0"
+  },
+  "dependencies": {
+    "@flusys/nestjs-core": "5.3.0",
+    "@flusys/nestjs-shared": "5.3.0",
+    "jsonwebtoken": "^9.0.0"
+  }
+}

package/services/index.d.ts

@@ -0,0 +1,8 @@
+export * from './task-manager-config.service';
+export * from './task-manager-datasource.provider';
+export * from './task-board.service';
+export * from './task-list.service';
+export * from './task-activity.service';
+export * from './task-label.service';
+export * from './task-comment.service';
+export * from './task.service';

package/services/task-activity.service.d.ts

@@ -0,0 +1,8 @@
+import { TaskManagerDataSourceProvider } from './task-manager-datasource.provider';
+export declare class TaskActivityService {
+    private readonly dataSourceProvider;
+    private repository;
+    constructor(dataSourceProvider: TaskManagerDataSourceProvider);
+    log(taskId: string, boardId: string, userId: string | null, action: string, oldValue: Record<string, unknown> | null, newValue: Record<string, unknown> | null): Promise<void>;
+    private ensureRepository;
+}

package/services/task-board.service.d.ts

@@ -0,0 +1,32 @@
+import { HybridCache, ApiService } from '@flusys/nestjs-shared/classes';
+import { ILoggedUserInfo } from '@flusys/nestjs-shared/interfaces';
+import { UtilsService } from '@flusys/nestjs-shared/modules';
+import { EntityTarget, SelectQueryBuilder } from 'typeorm';
+import { AddBoardMemberDto, CreateTaskBoardDto, RemoveBoardMemberDto, UpdateTaskBoardDto } from '../dtos';
+import { TaskBoardMember, TaskBoardBase } from '../entities';
+import { TaskManagerConfigService } from './task-manager-config.service';
+import { TaskManagerDataSourceProvider } from './task-manager-datasource.provider';
+export declare class TaskBoardService extends ApiService<CreateTaskBoardDto, UpdateTaskBoardDto, TaskBoardBase, TaskBoardBase> {
+    protected cacheManager: HybridCache;
+    protected utilsService: UtilsService;
+    private readonly config;
+    private readonly dataSourceProvider;
+    private memberRepository;
+    constructor(cacheManager: HybridCache, utilsService: UtilsService, config: TaskManagerConfigService, dataSourceProvider: TaskManagerDataSourceProvider);
+    protected resolveEntity(): EntityTarget<TaskBoardBase>;
+    convertSingleDtoToEntity(dto: CreateTaskBoardDto | UpdateTaskBoardDto, user: ILoggedUserInfo | null): Promise<TaskBoardBase>;
+    protected getExtraManipulateQuery(query: SelectQueryBuilder<TaskBoardBase>, filterDto: Record<string, unknown>, user: ILoggedUserInfo | null): Promise<{
+        query: SelectQueryBuilder<TaskBoardBase>;
+        isRaw: boolean;
+    }>;
+    protected convertEntityToResponseDto(entity: any, isRaw: boolean): any;
+    addMember(dto: AddBoardMemberDto, user: ILoggedUserInfo): Promise<TaskBoardMember>;
+    removeMember(dto: RemoveBoardMemberDto): Promise<void>;
+    getMembers(boardId: string): Promise<(TaskBoardMember & {
+        userName: string | null;
+        userEmail: string | null;
+    })[]>;
+    isBoardMember(boardId: string, userId: string): Promise<boolean>;
+    protected afterInsertOperation(entities: TaskBoardBase[], user: ILoggedUserInfo | null, _qr: any): Promise<void>;
+    private ensureMemberRepository;
+}

package/services/task-comment.service.d.ts

@@ -0,0 +1,18 @@
+import { HybridCache, ApiService } from '@flusys/nestjs-shared/classes';
+import { ILoggedUserInfo } from '@flusys/nestjs-shared/interfaces';
+import { UtilsService } from '@flusys/nestjs-shared/modules';
+import { SelectQueryBuilder } from 'typeorm';
+import { CreateTaskCommentDto, UpdateTaskCommentDto } from '../dtos';
+import { TaskComment } from '../entities';
+import { TaskManagerDataSourceProvider } from './task-manager-datasource.provider';
+export declare class TaskCommentService extends ApiService<CreateTaskCommentDto, UpdateTaskCommentDto, TaskComment, TaskComment> {
+    protected cacheManager: HybridCache;
+    protected utilsService: UtilsService;
+    private readonly dataSourceProvider;
+    constructor(cacheManager: HybridCache, utilsService: UtilsService, dataSourceProvider: TaskManagerDataSourceProvider);
+    convertSingleDtoToEntity(dto: CreateTaskCommentDto | UpdateTaskCommentDto, user: ILoggedUserInfo | null): Promise<TaskComment>;
+    protected getFilterQuery(query: SelectQueryBuilder<TaskComment>, filter: Record<string, unknown>, _user: ILoggedUserInfo | null): Promise<{
+        query: SelectQueryBuilder<TaskComment>;
+        isRaw: boolean;
+    }>;
+}

package/services/task-label.service.d.ts

@@ -0,0 +1,18 @@
+import { ApiService, HybridCache } from '@flusys/nestjs-shared/classes';
+import { ILoggedUserInfo } from '@flusys/nestjs-shared/interfaces';
+import { UtilsService } from '@flusys/nestjs-shared/modules';
+import { SelectQueryBuilder } from 'typeorm';
+import { CreateTaskLabelDto, UpdateTaskLabelDto } from '../dtos';
+import { TaskLabel } from '../entities';
+import { TaskManagerDataSourceProvider } from './task-manager-datasource.provider';
+export declare class TaskLabelService extends ApiService<CreateTaskLabelDto, UpdateTaskLabelDto, TaskLabel, TaskLabel> {
+    protected cacheManager: HybridCache;
+    protected utilsService: UtilsService;
+    private readonly dataSourceProvider;
+    constructor(cacheManager: HybridCache, utilsService: UtilsService, dataSourceProvider: TaskManagerDataSourceProvider);
+    convertSingleDtoToEntity(dto: CreateTaskLabelDto | UpdateTaskLabelDto, _user: ILoggedUserInfo | null): Promise<TaskLabel>;
+    protected getFilterQuery(query: SelectQueryBuilder<TaskLabel>, filter: Record<string, unknown>, _user: ILoggedUserInfo | null): Promise<{
+        query: SelectQueryBuilder<TaskLabel>;
+        isRaw: boolean;
+    }>;
+}