@flusys/nestjs-task-manager 5.3.0

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

@@ -0,0 +1,225 @@
+function _define_property(obj, key, value) {
+    if (key in obj) {
+        Object.defineProperty(obj, key, {
+            value: value,
+            enumerable: true,
+            configurable: true,
+            writable: true
+        });
+    } else {
+        obj[key] = value;
+    }
+    return obj;
+}
+function _ts_decorate(decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for(var i = decorators.length - 1; i >= 0; i--)if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+}
+function _ts_metadata(k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+}
+function _ts_param(paramIndex, decorator) {
+    return function(target, key) {
+        decorator(target, key, paramIndex);
+    };
+}
+import { HybridCache, ApiService } from '@flusys/nestjs-shared/classes';
+import { UtilsService } from '@flusys/nestjs-shared/modules';
+import { applyCompanyFilter } from '@flusys/nestjs-shared/utils';
+import { BadRequestException, Inject, Injectable, NotFoundException, Scope } from '@nestjs/common';
+import { IsNull } from 'typeorm';
+import { TASK_BOARD_MESSAGES } from '../config';
+import { BoardMemberRole, TaskBoardMember, TaskBoard, TaskBoardWithCompany } from '../entities';
+import { TaskManagerConfigService } from './task-manager-config.service';
+import { TaskManagerDataSourceProvider } from './task-manager-datasource.provider';
+export class TaskBoardService extends ApiService {
+    resolveEntity() {
+        return this.config.isCompanyFeatureEnabled() ? TaskBoardWithCompany : TaskBoard;
+    }
+    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: 'Board not found',
+                messageKey: TASK_BOARD_MESSAGES.NOT_FOUND
+            });
+            entity = existing;
+        }
+        const merged = {
+            ...entity,
+            name: dto.name ?? entity.name,
+            description: dto.description !== undefined ? dto.description ?? null : entity.description ?? null,
+            color: dto.color ?? entity.color ?? '#3B82F6',
+            isActive: ('isActive' in dto ? dto.isActive : undefined) ?? entity.isActive ?? true
+        };
+        if (this.config.isCompanyFeatureEnabled()) {
+            merged.companyId = user?.companyId ?? null;
+        }
+        return merged;
+    }
+    async getExtraManipulateQuery(query, filterDto, user) {
+        await super.getExtraManipulateQuery(query, filterDto, user);
+        applyCompanyFilter(query, {
+            isCompanyFeatureEnabled: this.config.isCompanyFeatureEnabled(),
+            entityAlias: 'task_board'
+        }, user);
+        if (user?.id) {
+            query.innerJoin('task_board_member', 'tbm_filter', 'tbm_filter.board_id = task_board.id AND tbm_filter.user_id = :currentUserId AND tbm_filter.deleted_at IS NULL', {
+                currentUserId: user.id
+            });
+        }
+        query.addSelect('task_board.createdAt').addSelect('task_board.updatedAt').addSelect(`(SELECT CAST(COUNT(*) AS INTEGER) FROM task_board_member tbm WHERE tbm.board_id = task_board.id AND tbm.deleted_at IS NULL)`, 'total_members').addSelect(`(SELECT CAST(COUNT(*) AS INTEGER) FROM task_list tl WHERE tl.board_id = task_board.id AND tl.is_active = true AND tl.deleted_at IS NULL)`, 'total_lists').addSelect(`(SELECT CAST(COUNT(*) AS INTEGER) FROM task t WHERE t.board_id = task_board.id AND t.deleted_at IS NULL)`, 'total_tasks');
+        return {
+            query,
+            isRaw: true
+        };
+    }
+    convertEntityToResponseDto(entity, isRaw) {
+        if (!isRaw) return super.convertEntityToResponseDto(entity, isRaw);
+        const prefix = `${this.entityName}_`;
+        const mapped = {};
+        for (const [key, value] of Object.entries(entity)){
+            const rawKey = key.startsWith(prefix) ? key.slice(prefix.length) : key;
+            const camelKey = rawKey.replace(/_([a-z])/g, (_, c)=>c.toUpperCase());
+            mapped[camelKey] = typeof value === 'string' && value !== '' && !isNaN(Number(value)) ? Number(value) : value;
+        }
+        return mapped;
+    }
+    async addMember(dto, user) {
+        await this.ensureDataSourceRepository();
+        const memberRepo = await this.ensureMemberRepository();
+        const board = await this.repository.findOne({
+            where: {
+                id: dto.boardId
+            }
+        });
+        if (!board) throw new NotFoundException({
+            message: 'Board not found',
+            messageKey: TASK_BOARD_MESSAGES.NOT_FOUND
+        });
+        const existing = await memberRepo.findOne({
+            where: {
+                boardId: dto.boardId,
+                userId: dto.userId,
+                deletedAt: IsNull()
+            }
+        });
+        if (existing) throw new BadRequestException({
+            message: 'User is already a board member',
+            messageKey: TASK_BOARD_MESSAGES.MEMBER_ALREADY_EXISTS
+        });
+        const softDeleted = await memberRepo.findOne({
+            where: {
+                boardId: dto.boardId,
+                userId: dto.userId
+            },
+            withDeleted: true
+        });
+        if (softDeleted) {
+            await memberRepo.restore({
+                id: softDeleted.id
+            });
+            await memberRepo.update({
+                id: softDeleted.id
+            }, {
+                role: dto.role ?? BoardMemberRole.MEMBER
+            });
+            return memberRepo.findOne({
+                where: {
+                    id: softDeleted.id
+                }
+            });
+        }
+        const member = memberRepo.create({
+            boardId: dto.boardId,
+            userId: dto.userId,
+            role: dto.role ?? BoardMemberRole.MEMBER,
+            createdById: user.id
+        });
+        return memberRepo.save(member);
+    }
+    async removeMember(dto) {
+        const memberRepo = await this.ensureMemberRepository();
+        const member = await memberRepo.findOne({
+            where: {
+                boardId: dto.boardId,
+                userId: dto.userId,
+                deletedAt: IsNull()
+            }
+        });
+        if (!member) throw new NotFoundException({
+            message: 'Member not found',
+            messageKey: TASK_BOARD_MESSAGES.MEMBER_NOT_FOUND
+        });
+        await memberRepo.update({
+            id: member.id
+        }, {
+            deletedAt: new Date()
+        });
+    }
+    async getMembers(boardId) {
+        const memberRepo = await this.ensureMemberRepository();
+        const { entities, raw } = await memberRepo.createQueryBuilder('tbm').leftJoin('app_user', 'u', 'u.id = tbm.user_id').addSelect('u.name', 'userName').addSelect('u.email', 'userEmail').where('tbm.board_id = :boardId', {
+            boardId
+        }).andWhere('tbm.deleted_at IS NULL').orderBy('tbm.created_at', 'ASC').getRawAndEntities();
+        return entities.map((entity, i)=>({
+                ...entity,
+                userName: raw[i]?.userName ?? null,
+                userEmail: raw[i]?.userEmail ?? null
+            }));
+    }
+    async isBoardMember(boardId, userId) {
+        const memberRepo = await this.ensureMemberRepository();
+        const count = await memberRepo.count({
+            where: {
+                boardId,
+                userId,
+                deletedAt: IsNull()
+            }
+        });
+        return count > 0;
+    }
+    async afterInsertOperation(entities, user, _qr) {
+        if (!user?.id) return;
+        const memberRepo = await this.ensureMemberRepository();
+        await memberRepo.save(entities.map((board)=>memberRepo.create({
+                boardId: board.id,
+                userId: user.id,
+                role: BoardMemberRole.OWNER,
+                createdById: user.id
+            })));
+    }
+    async ensureMemberRepository() {
+        if (!this.memberRepository) {
+            this.memberRepository = await this.dataSourceProvider.getRepository(TaskBoardMember);
+        }
+        return this.memberRepository;
+    }
+    constructor(cacheManager, utilsService, config, dataSourceProvider){
+        super('task_board', cacheManager, utilsService, TaskBoardService.name, true, 'task-manager', undefined, dataSourceProvider), _define_property(this, "cacheManager", void 0), _define_property(this, "utilsService", void 0), _define_property(this, "config", void 0), _define_property(this, "dataSourceProvider", void 0), _define_property(this, "memberRepository", void 0), this.cacheManager = cacheManager, this.utilsService = utilsService, this.config = config, this.dataSourceProvider = dataSourceProvider, this.memberRepository = null;
+    }
+}
+TaskBoardService = _ts_decorate([
+    Injectable({
+        scope: Scope.REQUEST
+    }),
+    _ts_param(0, Inject('CACHE_INSTANCE')),
+    _ts_param(1, Inject(UtilsService)),
+    _ts_param(2, Inject(TaskManagerConfigService)),
+    _ts_param(3, Inject(TaskManagerDataSourceProvider)),
+    _ts_metadata("design:type", Function),
+    _ts_metadata("design:paramtypes", [
+        typeof HybridCache === "undefined" ? Object : HybridCache,
+        typeof UtilsService === "undefined" ? Object : UtilsService,
+        typeof TaskManagerConfigService === "undefined" ? Object : TaskManagerConfigService,
+        typeof TaskManagerDataSourceProvider === "undefined" ? Object : TaskManagerDataSourceProvider
+    ])
+], TaskBoardService);

package/fesm/services/task-comment.service.js

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

package/fesm/services/task-label.service.js

@@ -0,0 +1,87 @@
+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 { Inject, Injectable, NotFoundException, Scope } from '@nestjs/common';
+import { TASK_LABEL_MESSAGES } from '../config';
+import { TaskLabel } from '../entities';
+import { TaskManagerDataSourceProvider } from './task-manager-datasource.provider';
+export class TaskLabelService 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: 'Label not found',
+                messageKey: TASK_LABEL_MESSAGES.NOT_FOUND
+            });
+            entity = existing;
+        }
+        return {
+            ...entity,
+            boardId: dto.boardId ?? entity.boardId,
+            name: dto.name ?? entity.name,
+            color: dto.color ?? entity.color ?? '#10B981'
+        };
+    }
+    async getFilterQuery(query, filter, _user) {
+        for (const [key, value] of Object.entries(filter)){
+            if (key === 'boardId') {
+                query.andWhere('task_label.boardId = :boardId', {
+                    boardId: value
+                });
+            }
+        }
+        return {
+            query,
+            isRaw: false
+        };
+    }
+    constructor(cacheManager, utilsService, dataSourceProvider){
+        super('task_label', cacheManager, utilsService, TaskLabelService.name, true, 'task-manager', TaskLabel, dataSourceProvider), _define_property(this, "cacheManager", void 0), _define_property(this, "utilsService", void 0), _define_property(this, "dataSourceProvider", void 0), this.cacheManager = cacheManager, this.utilsService = utilsService, this.dataSourceProvider = dataSourceProvider;
+    }
+}
+TaskLabelService = _ts_decorate([
+    Injectable({
+        scope: Scope.REQUEST
+    }),
+    _ts_param(0, Inject('CACHE_INSTANCE')),
+    _ts_param(1, Inject(UtilsService)),
+    _ts_param(2, Inject(TaskManagerDataSourceProvider)),
+    _ts_metadata("design:type", Function),
+    _ts_metadata("design:paramtypes", [
+        typeof HybridCache === "undefined" ? Object : HybridCache,
+        typeof UtilsService === "undefined" ? Object : UtilsService,
+        typeof TaskManagerDataSourceProvider === "undefined" ? Object : TaskManagerDataSourceProvider
+    ])
+], TaskLabelService);

package/fesm/services/task-list.service.js

@@ -0,0 +1,105 @@
+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 { Inject, Injectable, NotFoundException, Scope } from '@nestjs/common';
+import { TASK_LIST_MESSAGES } from '../config';
+import { TaskList } from '../entities';
+import { TaskManagerDataSourceProvider } from './task-manager-datasource.provider';
+export class TaskListService 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: 'List not found',
+                messageKey: TASK_LIST_MESSAGES.NOT_FOUND
+            });
+            entity = existing;
+        }
+        return {
+            ...entity,
+            boardId: dto.boardId ?? entity.boardId,
+            name: dto.name ?? entity.name,
+            color: dto.color ?? entity.color ?? '#6B7280',
+            position: dto.position ?? entity.position ?? 0,
+            isDoneList: ('isDoneList' in dto ? dto.isDoneList : undefined) ?? entity.isDoneList ?? false,
+            isActive: ('isActive' in dto ? dto.isActive : undefined) ?? entity.isActive ?? true
+        };
+    }
+    async getFilterQuery(query, filter, _user) {
+        for (const [key, value] of Object.entries(filter)){
+            if (key === 'boardId') {
+                query.andWhere('task_list.boardId = :boardId', {
+                    boardId: value
+                });
+            } else if (key === 'isActive' && typeof value === 'boolean') {
+                query.andWhere('task_list.isActive = :isActive', {
+                    isActive: value
+                });
+            }
+        }
+        query.orderBy('task_list.position', 'ASC');
+        return {
+            query,
+            isRaw: false
+        };
+    }
+    async reorderLists(dto) {
+        await this.ensureDataSourceRepository();
+        await Promise.all(dto.orderedIds.map((id, i)=>this.repository.update({
+                id,
+                boardId: dto.boardId
+            }, {
+                position: i * 100
+            })));
+        await this.clearCacheForAll();
+    }
+    constructor(cacheManager, utilsService, dataSourceProvider){
+        super('task_list', cacheManager, utilsService, TaskListService.name, true, 'task-manager', TaskList, dataSourceProvider), _define_property(this, "cacheManager", void 0), _define_property(this, "utilsService", void 0), _define_property(this, "dataSourceProvider", void 0), this.cacheManager = cacheManager, this.utilsService = utilsService, this.dataSourceProvider = dataSourceProvider;
+    }
+}
+TaskListService = _ts_decorate([
+    Injectable({
+        scope: Scope.REQUEST
+    }),
+    _ts_param(0, Inject('CACHE_INSTANCE')),
+    _ts_param(1, Inject(UtilsService)),
+    _ts_param(2, Inject(TaskManagerDataSourceProvider)),
+    _ts_metadata("design:type", Function),
+    _ts_metadata("design:paramtypes", [
+        typeof HybridCache === "undefined" ? Object : HybridCache,
+        typeof UtilsService === "undefined" ? Object : UtilsService,
+        typeof TaskManagerDataSourceProvider === "undefined" ? Object : TaskManagerDataSourceProvider
+    ])
+], TaskListService);

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

@@ -0,0 +1,59 @@
+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 } from '@nestjs/common';
+import { TASK_MANAGER_MODULE_OPTIONS } from '../config/task-manager.constants';
+import { TaskManagerModuleOptions } from '../interfaces';
+export 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([
+    Injectable(),
+    _ts_param(0, Inject(TASK_MANAGER_MODULE_OPTIONS)),
+    _ts_metadata("design:type", Function),
+    _ts_metadata("design:paramtypes", [
+        typeof TaskManagerModuleOptions === "undefined" ? Object : TaskManagerModuleOptions
+    ])
+], TaskManagerConfigService);

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

@@ -0,0 +1,74 @@
+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 { MultiTenantDataSourceService } from '@flusys/nestjs-shared/modules';
+import { Inject, Injectable, Optional, Scope } from '@nestjs/common';
+import { REQUEST } from '@nestjs/core';
+import { Request } from 'express';
+import { getTaskManagerEntitiesByConfig } from '../entities';
+import { TaskManagerConfigService } from './task-manager-config.service';
+export class TaskManagerDataSourceProvider extends 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 = 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([
+    Injectable({
+        scope: Scope.REQUEST
+    }),
+    _ts_param(0, Inject(TaskManagerConfigService)),
+    _ts_param(1, Optional()),
+    _ts_param(1, Inject(REQUEST)),
+    _ts_metadata("design:type", Function),
+    _ts_metadata("design:paramtypes", [
+        typeof TaskManagerConfigService === "undefined" ? Object : TaskManagerConfigService,
+        typeof Request === "undefined" ? Object : Request
+    ])
+], TaskManagerDataSourceProvider);