@flusys/nestjs-task-manager 5.3.0

package/cjs/services/task-activity.service.js

@@ -0,0 +1,76 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "TaskActivityService", {
+    enumerable: true,
+    get: function() {
+        return TaskActivityService;
+    }
+});
+const _common = require("@nestjs/common");
+const _entities = require("../entities");
+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 TaskActivityService = 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(_entities.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([
+    (0, _common.Injectable)({
+        scope: _common.Scope.REQUEST
+    }),
+    _ts_param(0, (0, _common.Inject)(_taskmanagerdatasourceprovider.TaskManagerDataSourceProvider)),
+    _ts_metadata("design:type", Function),
+    _ts_metadata("design:paramtypes", [
+        typeof _taskmanagerdatasourceprovider.TaskManagerDataSourceProvider === "undefined" ? Object : _taskmanagerdatasourceprovider.TaskManagerDataSourceProvider
+    ])
+], TaskActivityService);

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

@@ -0,0 +1,235 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "TaskBoardService", {
+    enumerable: true,
+    get: function() {
+        return TaskBoardService;
+    }
+});
+const _classes = require("@flusys/nestjs-shared/classes");
+const _modules = require("@flusys/nestjs-shared/modules");
+const _utils = require("@flusys/nestjs-shared/utils");
+const _common = require("@nestjs/common");
+const _typeorm = require("typeorm");
+const _config = require("../config");
+const _entities = require("../entities");
+const _taskmanagerconfigservice = require("./task-manager-config.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 TaskBoardService = class TaskBoardService extends _classes.ApiService {
+    resolveEntity() {
+        return this.config.isCompanyFeatureEnabled() ? _entities.TaskBoardWithCompany : _entities.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 _common.NotFoundException({
+                message: 'Board not found',
+                messageKey: _config.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);
+        (0, _utils.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 _common.NotFoundException({
+            message: 'Board not found',
+            messageKey: _config.TASK_BOARD_MESSAGES.NOT_FOUND
+        });
+        const existing = await memberRepo.findOne({
+            where: {
+                boardId: dto.boardId,
+                userId: dto.userId,
+                deletedAt: (0, _typeorm.IsNull)()
+            }
+        });
+        if (existing) throw new _common.BadRequestException({
+            message: 'User is already a board member',
+            messageKey: _config.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 ?? _entities.BoardMemberRole.MEMBER
+            });
+            return memberRepo.findOne({
+                where: {
+                    id: softDeleted.id
+                }
+            });
+        }
+        const member = memberRepo.create({
+            boardId: dto.boardId,
+            userId: dto.userId,
+            role: dto.role ?? _entities.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: (0, _typeorm.IsNull)()
+            }
+        });
+        if (!member) throw new _common.NotFoundException({
+            message: 'Member not found',
+            messageKey: _config.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: (0, _typeorm.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: _entities.BoardMemberRole.OWNER,
+                createdById: user.id
+            })));
+    }
+    async ensureMemberRepository() {
+        if (!this.memberRepository) {
+            this.memberRepository = await this.dataSourceProvider.getRepository(_entities.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([
+    (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)(_taskmanagerconfigservice.TaskManagerConfigService)),
+    _ts_param(3, (0, _common.Inject)(_taskmanagerdatasourceprovider.TaskManagerDataSourceProvider)),
+    _ts_metadata("design:type", Function),
+    _ts_metadata("design:paramtypes", [
+        typeof _classes.HybridCache === "undefined" ? Object : _classes.HybridCache,
+        typeof _modules.UtilsService === "undefined" ? Object : _modules.UtilsService,
+        typeof _taskmanagerconfigservice.TaskManagerConfigService === "undefined" ? Object : _taskmanagerconfigservice.TaskManagerConfigService,
+        typeof _taskmanagerdatasourceprovider.TaskManagerDataSourceProvider === "undefined" ? Object : _taskmanagerdatasourceprovider.TaskManagerDataSourceProvider
+    ])
+], TaskBoardService);

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

@@ -0,0 +1,103 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "TaskCommentService", {
+    enumerable: true,
+    get: function() {
+        return TaskCommentService;
+    }
+});
+const _classes = require("@flusys/nestjs-shared/classes");
+const _modules = require("@flusys/nestjs-shared/modules");
+const _common = require("@nestjs/common");
+const _config = require("../config");
+const _entities = require("../entities");
+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 TaskCommentService = class TaskCommentService 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: 'Comment not found',
+                messageKey: _config.TASK_COMMENT_MESSAGES.NOT_FOUND
+            });
+            if (existing.userId !== user?.id) throw new _common.ForbiddenException({
+                message: 'Cannot edit another user comment',
+                messageKey: _config.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', _entities.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([
+    (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_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
+    ])
+], TaskCommentService);

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

@@ -0,0 +1,97 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "TaskLabelService", {
+    enumerable: true,
+    get: function() {
+        return TaskLabelService;
+    }
+});
+const _classes = require("@flusys/nestjs-shared/classes");
+const _modules = require("@flusys/nestjs-shared/modules");
+const _common = require("@nestjs/common");
+const _config = require("../config");
+const _entities = require("../entities");
+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 TaskLabelService = class TaskLabelService 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: 'Label not found',
+                messageKey: _config.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', _entities.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([
+    (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_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
+    ])
+], TaskLabelService);

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

@@ -0,0 +1,115 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "TaskListService", {
+    enumerable: true,
+    get: function() {
+        return TaskListService;
+    }
+});
+const _classes = require("@flusys/nestjs-shared/classes");
+const _modules = require("@flusys/nestjs-shared/modules");
+const _common = require("@nestjs/common");
+const _config = require("../config");
+const _entities = require("../entities");
+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 TaskListService = class TaskListService 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: 'List not found',
+                messageKey: _config.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', _entities.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([
+    (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_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
+    ])
+], TaskListService);