@flusys/nestjs-task-manager 5.3.0

package/fesm/entities/task.entity.js

@@ -0,0 +1,133 @@
+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);
+}
+import { Identity } from '@flusys/nestjs-shared/entities';
+import { Column, Entity, Index } from 'typeorm';
+export var TaskPriority = /*#__PURE__*/ function(TaskPriority) {
+    TaskPriority["LOW"] = "LOW";
+    TaskPriority["MEDIUM"] = "MEDIUM";
+    TaskPriority["HIGH"] = "HIGH";
+    TaskPriority["URGENT"] = "URGENT";
+    return TaskPriority;
+}({});
+export class Task extends Identity {
+    constructor(...args){
+        super(...args), _define_property(this, "boardId", void 0), _define_property(this, "listId", void 0), _define_property(this, "title", void 0), _define_property(this, "description", void 0), _define_property(this, "priority", void 0), _define_property(this, "dueDate", void 0), _define_property(this, "position", void 0), _define_property(this, "reporterId", void 0), _define_property(this, "parentTaskId", void 0), _define_property(this, "estimatedHours", void 0), _define_property(this, "assignees", []);
+    }
+}
+_ts_decorate([
+    Index(),
+    Column({
+        name: 'board_id',
+        type: 'uuid',
+        nullable: false
+    }),
+    _ts_metadata("design:type", String)
+], Task.prototype, "boardId", void 0);
+_ts_decorate([
+    Index(),
+    Column({
+        name: 'list_id',
+        type: 'uuid',
+        nullable: false
+    }),
+    _ts_metadata("design:type", String)
+], Task.prototype, "listId", void 0);
+_ts_decorate([
+    Column({
+        type: 'varchar',
+        length: 500,
+        nullable: false
+    }),
+    _ts_metadata("design:type", String)
+], Task.prototype, "title", void 0);
+_ts_decorate([
+    Column({
+        type: 'text',
+        nullable: true
+    }),
+    _ts_metadata("design:type", Object)
+], Task.prototype, "description", void 0);
+_ts_decorate([
+    Column({
+        type: 'varchar',
+        length: 20,
+        nullable: false,
+        default: "MEDIUM"
+    }),
+    _ts_metadata("design:type", String)
+], Task.prototype, "priority", void 0);
+_ts_decorate([
+    Column({
+        name: 'due_date',
+        type: 'date',
+        nullable: true
+    }),
+    _ts_metadata("design:type", Object)
+], Task.prototype, "dueDate", void 0);
+_ts_decorate([
+    Column({
+        type: 'int',
+        nullable: false,
+        default: 0
+    }),
+    _ts_metadata("design:type", Number)
+], Task.prototype, "position", void 0);
+_ts_decorate([
+    Column({
+        name: 'reporter_id',
+        type: 'uuid',
+        nullable: true
+    }),
+    _ts_metadata("design:type", Object)
+], Task.prototype, "reporterId", void 0);
+_ts_decorate([
+    Column({
+        name: 'parent_task_id',
+        type: 'uuid',
+        nullable: true
+    }),
+    _ts_metadata("design:type", Object)
+], Task.prototype, "parentTaskId", void 0);
+_ts_decorate([
+    Column({
+        name: 'estimated_hours',
+        type: 'decimal',
+        precision: 5,
+        scale: 1,
+        nullable: true
+    }),
+    _ts_metadata("design:type", Object)
+], Task.prototype, "estimatedHours", void 0);
+Task = _ts_decorate([
+    Entity({
+        name: 'task'
+    }),
+    Index([
+        'boardId',
+        'listId',
+        'position'
+    ]),
+    Index([
+        'dueDate'
+    ])
+], Task);

package/fesm/gateways/index.js

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

package/fesm/gateways/task-board.gateway.js

@@ -0,0 +1,148 @@
+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 { Inject } from '@nestjs/common';
+import { ConnectedSocket, MessageBody, SubscribeMessage, WebSocketGateway, WebSocketServer } from '@nestjs/websockets';
+import * as jwt from 'jsonwebtoken';
+import { Server, Socket } from 'socket.io';
+import { TaskManagerConfigService } from '../services/task-manager-config.service';
+export class TaskBoardGateway {
+    async handleConnection(client) {
+        try {
+            const token = this.extractToken(client);
+            if (!token) {
+                client.disconnect();
+                return;
+            }
+            const payload = this.verifyToken(token);
+            if (!payload) {
+                client.disconnect();
+                return;
+            }
+            client.data.userId = payload.id;
+            client.data.companyId = payload.companyId;
+            if (!this.connectedUsers.has(payload.id)) {
+                this.connectedUsers.set(payload.id, new Set());
+            }
+            this.connectedUsers.get(payload.id).add(client.id);
+            client.join(`user:${payload.id}`);
+        } catch  {
+            client.disconnect();
+        }
+    }
+    handleDisconnect(client) {
+        const userId = client.data.userId;
+        if (userId) {
+            const sockets = this.connectedUsers.get(userId);
+            sockets?.delete(client.id);
+            if (sockets?.size === 0) {
+                this.connectedUsers.delete(userId);
+            }
+        }
+    }
+    handleJoinBoard(client, data) {
+        if (data?.boardId) {
+            client.join(`board:${data.boardId}`);
+        }
+    }
+    handleLeaveBoard(client, data) {
+        if (data?.boardId) {
+            client.leave(`board:${data.boardId}`);
+        }
+    }
+    emitToBoardRoom(boardId, event) {
+        this.server?.to(`board:${boardId}`).emit('board:event', event);
+    }
+    isUserOnline(userId) {
+        return this.connectedUsers.has(userId);
+    }
+    extractToken(client) {
+        const authToken = client.handshake.auth?.token;
+        if (authToken) return authToken;
+        const queryToken = client.handshake.query?.token;
+        if (typeof queryToken === 'string') return queryToken;
+        const authHeader = client.handshake.headers?.authorization;
+        if (authHeader?.startsWith('Bearer ')) return authHeader.substring(7);
+        return null;
+    }
+    verifyToken(token) {
+        try {
+            const secret = this.configService.getJwtSecret();
+            if (!secret) return null;
+            return jwt.verify(token, secret);
+        } catch  {
+            return null;
+        }
+    }
+    constructor(configService){
+        _define_property(this, "configService", void 0);
+        _define_property(this, "connectedUsers", void 0);
+        _define_property(this, "server", void 0);
+        this.configService = configService;
+        this.connectedUsers = new Map();
+    }
+}
+_ts_decorate([
+    WebSocketServer(),
+    _ts_metadata("design:type", typeof Server === "undefined" ? Object : Server)
+], TaskBoardGateway.prototype, "server", void 0);
+_ts_decorate([
+    SubscribeMessage('board:join'),
+    _ts_param(0, ConnectedSocket()),
+    _ts_param(1, MessageBody()),
+    _ts_metadata("design:type", Function),
+    _ts_metadata("design:paramtypes", [
+        typeof Socket === "undefined" ? Object : Socket,
+        Object
+    ]),
+    _ts_metadata("design:returntype", void 0)
+], TaskBoardGateway.prototype, "handleJoinBoard", null);
+_ts_decorate([
+    SubscribeMessage('board:leave'),
+    _ts_param(0, ConnectedSocket()),
+    _ts_param(1, MessageBody()),
+    _ts_metadata("design:type", Function),
+    _ts_metadata("design:paramtypes", [
+        typeof Socket === "undefined" ? Object : Socket,
+        Object
+    ]),
+    _ts_metadata("design:returntype", void 0)
+], TaskBoardGateway.prototype, "handleLeaveBoard", null);
+TaskBoardGateway = _ts_decorate([
+    WebSocketGateway({
+        namespace: '/task-boards',
+        cors: {
+            origin: '*',
+            credentials: true
+        }
+    }),
+    _ts_param(0, Inject(TaskManagerConfigService)),
+    _ts_metadata("design:type", Function),
+    _ts_metadata("design:paramtypes", [
+        typeof TaskManagerConfigService === "undefined" ? Object : TaskManagerConfigService
+    ])
+], TaskBoardGateway);

package/fesm/index.js

@@ -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/fesm/interfaces/index.js

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

package/fesm/interfaces/task-manager-module.interface.js

@@ -0,0 +1 @@
+export { };

package/fesm/interfaces/task.interface.js

@@ -0,0 +1 @@
+export { };

package/fesm/modules/index.js

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

package/fesm/modules/task-manager.module.js

@@ -0,0 +1,121 @@
+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;
+}
+import { CacheModule, UtilsModule } from '@flusys/nestjs-shared/modules';
+import { Module } from '@nestjs/common';
+import { TASK_MANAGER_MODULE_OPTIONS } from '../config/task-manager.constants';
+import { TaskBoardController, TaskCommentController, TaskLabelController, TaskListController, TaskController } from '../controllers';
+import { TaskBoardGateway } from '../gateways/task-board.gateway';
+import { TaskActivityService, TaskBoardService, TaskCommentService, TaskLabelService, TaskListService, TaskManagerConfigService, TaskManagerDataSourceProvider, TaskService } from '../services';
+const CONTROLLERS = [
+    TaskBoardController,
+    TaskListController,
+    TaskController,
+    TaskLabelController,
+    TaskCommentController
+];
+const EXPORTED_SERVICES = [
+    TaskManagerConfigService,
+    TaskManagerDataSourceProvider,
+    TaskBoardService,
+    TaskListService,
+    TaskService,
+    TaskLabelService,
+    TaskCommentService,
+    TaskActivityService
+];
+export class TaskManagerModule {
+    static forRoot(options) {
+        return {
+            module: TaskManagerModule,
+            global: options.global ?? false,
+            imports: [
+                CacheModule,
+                UtilsModule
+            ],
+            controllers: options.includeController !== false ? CONTROLLERS : [],
+            providers: [
+                ...this.buildProviders(options),
+                TaskBoardGateway
+            ],
+            exports: [
+                ...EXPORTED_SERVICES,
+                TaskBoardGateway
+            ]
+        };
+    }
+    static forRootAsync(options) {
+        return {
+            module: TaskManagerModule,
+            global: options.global ?? false,
+            imports: [
+                ...options.imports || [],
+                CacheModule,
+                UtilsModule
+            ],
+            controllers: options.includeController !== false ? CONTROLLERS : [],
+            providers: [
+                ...this.createAsyncProviders(options),
+                ...this.buildProviders(),
+                TaskBoardGateway
+            ],
+            exports: [
+                ...EXPORTED_SERVICES,
+                TaskBoardGateway
+            ]
+        };
+    }
+    static buildProviders(options) {
+        const providers = [
+            ...EXPORTED_SERVICES
+        ];
+        if (options) {
+            providers.unshift({
+                provide: TASK_MANAGER_MODULE_OPTIONS,
+                useValue: options
+            });
+        }
+        return providers;
+    }
+    static createAsyncProviders(options) {
+        if (options.useFactory) {
+            return [
+                {
+                    provide: TASK_MANAGER_MODULE_OPTIONS,
+                    useFactory: async (...args)=>({
+                            ...options,
+                            config: await options.useFactory(...args)
+                        }),
+                    inject: options.inject || []
+                }
+            ];
+        }
+        const factoryClass = options.useClass || options.useExisting;
+        if (!factoryClass) return [];
+        const providers = [
+            {
+                provide: TASK_MANAGER_MODULE_OPTIONS,
+                useFactory: async (factory)=>({
+                        ...options,
+                        config: await factory.createTaskManagerOptions()
+                    }),
+                inject: [
+                    factoryClass
+                ]
+            }
+        ];
+        if (options.useClass) {
+            providers.push({
+                provide: options.useClass,
+                useClass: options.useClass
+            });
+        }
+        return providers;
+    }
+}
+TaskManagerModule = _ts_decorate([
+    Module({})
+], TaskManagerModule);

package/fesm/services/index.js

@@ -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/fesm/services/task-activity.service.js

@@ -0,0 +1,66 @@
+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 { Inject, Injectable, Scope } from '@nestjs/common';
+import { TaskActivity } from '../entities';
+import { TaskManagerDataSourceProvider } from './task-manager-datasource.provider';
+export class TaskActivityService {
+    async log(taskId, boardId, userId, action, oldValue, newValue) {
+        const repo = await this.ensureRepository();
+        const activity = repo.create({
+            taskId,
+            boardId,
+            userId,
+            action,
+            oldValue,
+            newValue
+        });
+        await repo.save(activity);
+    }
+    async ensureRepository() {
+        if (!this.repository) {
+            this.repository = await this.dataSourceProvider.getRepository(TaskActivity);
+        }
+        return this.repository;
+    }
+    constructor(dataSourceProvider){
+        _define_property(this, "dataSourceProvider", void 0);
+        _define_property(this, "repository", void 0);
+        this.dataSourceProvider = dataSourceProvider;
+        this.repository = null;
+    }
+}
+TaskActivityService = _ts_decorate([
+    Injectable({
+        scope: Scope.REQUEST
+    }),
+    _ts_param(0, Inject(TaskManagerDataSourceProvider)),
+    _ts_metadata("design:type", Function),
+    _ts_metadata("design:paramtypes", [
+        typeof TaskManagerDataSourceProvider === "undefined" ? Object : TaskManagerDataSourceProvider
+    ])
+], TaskActivityService);