@flusys/nestjs-task-manager 6.3.0 → 6.4.1

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

@@ -142,11 +142,13 @@ let TaskBoardService = class TaskBoardService extends _classes.ApiService {
             }, {
                 role: dto.role ?? _entities.BoardMemberRole.MEMBER
             });
-            return memberRepo.findOne({
+            const restored = await memberRepo.findOne({
                 where: {
                     id: softDeleted.id
                 }
             });
+            await this.invalidateBoardCache(dto.boardId);
+            return restored;
         }
         const member = memberRepo.create({
             boardId: dto.boardId,
@@ -154,7 +156,9 @@ let TaskBoardService = class TaskBoardService extends _classes.ApiService {
             role: dto.role ?? _entities.BoardMemberRole.MEMBER,
             createdById: user.id
         });
-        return memberRepo.save(member);
+        const saved = await memberRepo.save(member);
+        await this.invalidateBoardCache(dto.boardId);
+        return saved;
     }
     async removeMember(dto) {
         const memberRepo = await this.ensureMemberRepository();
@@ -174,6 +178,7 @@ let TaskBoardService = class TaskBoardService extends _classes.ApiService {
         }, {
             deletedAt: new Date()
         });
+        await this.invalidateBoardCache(dto.boardId);
     }
     async getMembers(boardId) {
         const memberRepo = await this.ensureMemberRepository();
@@ -207,6 +212,16 @@ let TaskBoardService = class TaskBoardService extends _classes.ApiService {
                 createdById: user.id
             })));
     }
+    async invalidateBoardCache(boardId) {
+        await Promise.all([
+            this.clearCacheForAll(),
+            this.clearCacheForId([
+                {
+                    id: boardId
+                }
+            ])
+        ]);
+    }
     async ensureMemberRepository() {
         if (!this.memberRepository) {
             this.memberRepository = await this.dataSourceProvider.getRepository(_entities.TaskBoardMember);

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

@@ -57,6 +57,15 @@ function mockQueryRunner(repo) {
     return qr;
 }
 describe('TaskBoardService', ()=>{
+    const mockUtilsService = {
+        clearCache: jest.fn(),
+        getCacheKey: jest.fn().mockReturnValue('cache-key'),
+        trackCacheKey: jest.fn()
+    };
+    // Call history is shared across tests in this file; reset it so each cache assertion is exact.
+    beforeEach(()=>{
+        mockUtilsService.clearCache.mockClear();
+    });
     let service;
     let mockRepo;
     let mockMemberRepo;
@@ -84,11 +93,7 @@ describe('TaskBoardService', ()=>{
                 },
                 {
                     provide: _modules.UtilsService,
-                    useValue: {
-                        clearCache: jest.fn(),
-                        getCacheKey: jest.fn(),
-                        trackCacheKey: jest.fn()
-                    }
+                    useValue: mockUtilsService
                 },
                 {
                     provide: _taskmanagerconfigservice.TaskManagerConfigService,
@@ -264,6 +269,23 @@ describe('TaskBoardService', ()=>{
             }));
             expect(result).toEqual(created);
         });
+        it('invalidates the board list cache and the board entry (membership drives visibility and total_members)', async ()=>{
+            mockRepo.findOne.mockResolvedValue(buildBoard({
+                id: 'board-1'
+            }));
+            mockMemberRepo.findOne.mockResolvedValueOnce(null);
+            mockMemberRepo.findOne.mockResolvedValueOnce(null);
+            mockMemberRepo.create.mockImplementation((data)=>data);
+            mockMemberRepo.save.mockResolvedValue(buildMember({
+                boardId: 'board-1'
+            }));
+            await service.addMember({
+                boardId: 'board-1',
+                userId: 'user-2'
+            }, (0, _loggedusermock.buildMockUser)());
+            expect(mockUtilsService.clearCache).toHaveBeenCalledWith('task_board', expect.anything());
+            expect(mockUtilsService.clearCache).toHaveBeenCalledWith('task_board', expect.anything(), 'board-1');
+        });
         it('defaults the role to MEMBER when none is given', async ()=>{
             mockRepo.findOne.mockResolvedValue(buildBoard({
                 id: 'board-1'
@@ -347,6 +369,17 @@ describe('TaskBoardService', ()=>{
                 deletedAt: expect.any(Date)
             });
         });
+        it('invalidates the board list cache and the board entry', async ()=>{
+            mockMemberRepo.findOne.mockResolvedValue(buildMember({
+                id: 'member-1'
+            }));
+            await service.removeMember({
+                boardId: 'board-1',
+                userId: 'user-uuid-1'
+            });
+            expect(mockUtilsService.clearCache).toHaveBeenCalledWith('task_board', expect.anything());
+            expect(mockUtilsService.clearCache).toHaveBeenCalledWith('task_board', expect.anything(), 'board-1');
+        });
         it('throws NotFoundException when the member is not found', async ()=>{
             mockMemberRepo.findOne.mockResolvedValue(null);
             await expect(service.removeMember({

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

@@ -42,6 +42,10 @@ function _ts_param(paramIndex, decorator) {
     };
 }
 let TaskListService = class TaskListService extends _classes.ApiService {
+    /** Boards cache denormalized `total_tasks` / `total_lists`, so board caches go stale on any write here. */ async clearCacheForAll() {
+        await super.clearCacheForAll();
+        await this.utilsService.clearCache('task_board', this.cacheManager);
+    }
     async convertSingleDtoToEntity(dto, _user) {
         await this.ensureDataSourceRepository();
         let entity = {};
@@ -93,7 +97,12 @@ let TaskListService = class TaskListService extends _classes.ApiService {
             }, {
                 position: i * 100
             })));
-        await this.clearCacheForAll();
+        await Promise.all([
+            this.clearCacheForAll(),
+            this.clearCacheForId(dto.orderedIds.map((id)=>({
+                    id
+                })))
+        ]);
     }
     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;

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

@@ -41,6 +41,15 @@ function mockQueryRunner(repo) {
     return qr;
 }
 describe('TaskListService', ()=>{
+    const mockUtilsService = {
+        clearCache: jest.fn(),
+        getCacheKey: jest.fn().mockReturnValue('cache-key'),
+        trackCacheKey: jest.fn()
+    };
+    // Call history is shared across tests in this file; reset it so each cache assertion is exact.
+    beforeEach(()=>{
+        mockUtilsService.clearCache.mockClear();
+    });
     let service;
     let mockRepo;
     beforeEach(async ()=>{
@@ -55,11 +64,7 @@ describe('TaskListService', ()=>{
                 },
                 {
                     provide: _modules.UtilsService,
-                    useValue: {
-                        clearCache: jest.fn(),
-                        getCacheKey: jest.fn(),
-                        trackCacheKey: jest.fn()
-                    }
+                    useValue: mockUtilsService
                 },
                 {
                     provide: _taskmanagerdatasourceprovider.TaskManagerDataSourceProvider,
@@ -188,6 +193,19 @@ describe('TaskListService', ()=>{
                 position: 200
             });
         });
+        it('invalidates the list cache, each reordered entry, and the parent board cache', async ()=>{
+            await service.reorderLists({
+                boardId: 'board-1',
+                orderedIds: [
+                    'list-a',
+                    'list-b'
+                ]
+            });
+            expect(mockUtilsService.clearCache).toHaveBeenCalledWith('task_list', expect.anything());
+            expect(mockUtilsService.clearCache).toHaveBeenCalledWith('task_list', expect.anything(), 'list-a');
+            expect(mockUtilsService.clearCache).toHaveBeenCalledWith('task_list', expect.anything(), 'list-b');
+            expect(mockUtilsService.clearCache).toHaveBeenCalledWith('task_board', expect.anything());
+        });
         it('handles reordering a single-item list (position 0)', async ()=>{
             await service.reorderLists({
                 boardId: 'board-1',

package/cjs/services/task.service.js

@@ -45,6 +45,10 @@ function _ts_param(paramIndex, decorator) {
     };
 }
 let TaskService = class TaskService extends _classes.ApiService {
+    /** Boards cache denormalized `total_tasks` / `total_lists`, so board caches go stale on any write here. */ async clearCacheForAll() {
+        await super.clearCacheForAll();
+        await this.utilsService.clearCache('task_board', this.cacheManager);
+    }
     async convertSingleDtoToEntity(dto, user) {
         await this.ensureDataSourceRepository();
         let entity = {};
@@ -185,6 +189,12 @@ let TaskService = class TaskService extends _classes.ApiService {
         }, {
             listId: dto.targetListId
         });
+        await Promise.all([
+            this.clearCacheForAll(),
+            this.clearCacheForId([
+                saved
+            ])
+        ]);
         return saved;
     }
     async assignTask(dto, user) {
@@ -221,6 +231,12 @@ let TaskService = class TaskService extends _classes.ApiService {
         }, {
             assigneeIds: dto.assigneeIds
         });
+        await Promise.all([
+            this.clearCacheForAll(),
+            this.clearCacheForId([
+                saved
+            ])
+        ]);
         saved.assignees = await this.loadAssigneesForTask(saved.id);
         return saved;
     }

package/cjs/services/task.service.spec.js

@@ -49,6 +49,15 @@ function mockQueryRunner(repo) {
     return qr;
 }
 describe('TaskService', ()=>{
+    const mockUtilsService = {
+        clearCache: jest.fn(),
+        getCacheKey: jest.fn().mockReturnValue('cache-key'),
+        trackCacheKey: jest.fn()
+    };
+    // Call history is shared across tests in this file; reset it so each cache assertion is exact.
+    beforeEach(()=>{
+        mockUtilsService.clearCache.mockClear();
+    });
     let service;
     let mockRepo;
     let mockLabelJunctionRepo;
@@ -96,11 +105,7 @@ describe('TaskService', ()=>{
                 },
                 {
                     provide: _modules.UtilsService,
-                    useValue: {
-                        clearCache: jest.fn(),
-                        getCacheKey: jest.fn(),
-                        trackCacheKey: jest.fn()
-                    }
+                    useValue: mockUtilsService
                 },
                 {
                     provide: _taskmanagerdatasourceprovider.TaskManagerDataSourceProvider,
@@ -368,6 +373,25 @@ describe('TaskService', ()=>{
                 listId: 'list-new'
             });
         });
+        it('invalidates the task list cache and the moved task entry', async ()=>{
+            const task = buildTask({
+                id: 'task-1',
+                listId: 'list-old',
+                boardId: 'board-1'
+            });
+            mockRepo.findOne.mockResolvedValue(task);
+            mockRepo.save.mockImplementation((t)=>Promise.resolve(t));
+            await service.moveTask({
+                taskId: 'task-1',
+                targetListId: 'list-new',
+                position: 1
+            }, (0, _loggedusermock.buildMockUser)({
+                id: 'mover-1'
+            }));
+            expect(mockUtilsService.clearCache).toHaveBeenCalledWith('task', expect.anything());
+            expect(mockUtilsService.clearCache).toHaveBeenCalledWith('task', expect.anything(), 'task-1');
+            expect(mockUtilsService.clearCache).toHaveBeenCalledWith('task_board', expect.anything());
+        });
         it('defaults position to 0 (first position) when no position is given', async ()=>{
             const task = buildTask({
                 id: 'task-1',

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

@@ -132,11 +132,13 @@ export class TaskBoardService extends ApiService {
             }, {
                 role: dto.role ?? BoardMemberRole.MEMBER
             });
-            return memberRepo.findOne({
+            const restored = await memberRepo.findOne({
                 where: {
                     id: softDeleted.id
                 }
             });
+            await this.invalidateBoardCache(dto.boardId);
+            return restored;
         }
         const member = memberRepo.create({
             boardId: dto.boardId,
@@ -144,7 +146,9 @@ export class TaskBoardService extends ApiService {
             role: dto.role ?? BoardMemberRole.MEMBER,
             createdById: user.id
         });
-        return memberRepo.save(member);
+        const saved = await memberRepo.save(member);
+        await this.invalidateBoardCache(dto.boardId);
+        return saved;
     }
     async removeMember(dto) {
         const memberRepo = await this.ensureMemberRepository();
@@ -164,6 +168,7 @@ export class TaskBoardService extends ApiService {
         }, {
             deletedAt: new Date()
         });
+        await this.invalidateBoardCache(dto.boardId);
     }
     async getMembers(boardId) {
         const memberRepo = await this.ensureMemberRepository();
@@ -197,6 +202,16 @@ export class TaskBoardService extends ApiService {
                 createdById: user.id
             })));
     }
+    async invalidateBoardCache(boardId) {
+        await Promise.all([
+            this.clearCacheForAll(),
+            this.clearCacheForId([
+                {
+                    id: boardId
+                }
+            ])
+        ]);
+    }
     async ensureMemberRepository() {
         if (!this.memberRepository) {
             this.memberRepository = await this.dataSourceProvider.getRepository(TaskBoardMember);

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

@@ -53,6 +53,15 @@ function mockQueryRunner(repo) {
     return qr;
 }
 describe('TaskBoardService', ()=>{
+    const mockUtilsService = {
+        clearCache: jest.fn(),
+        getCacheKey: jest.fn().mockReturnValue('cache-key'),
+        trackCacheKey: jest.fn()
+    };
+    // Call history is shared across tests in this file; reset it so each cache assertion is exact.
+    beforeEach(()=>{
+        mockUtilsService.clearCache.mockClear();
+    });
     let service;
     let mockRepo;
     let mockMemberRepo;
@@ -80,11 +89,7 @@ describe('TaskBoardService', ()=>{
                 },
                 {
                     provide: UtilsService,
-                    useValue: {
-                        clearCache: jest.fn(),
-                        getCacheKey: jest.fn(),
-                        trackCacheKey: jest.fn()
-                    }
+                    useValue: mockUtilsService
                 },
                 {
                     provide: TaskManagerConfigService,
@@ -260,6 +265,23 @@ describe('TaskBoardService', ()=>{
             }));
             expect(result).toEqual(created);
         });
+        it('invalidates the board list cache and the board entry (membership drives visibility and total_members)', async ()=>{
+            mockRepo.findOne.mockResolvedValue(buildBoard({
+                id: 'board-1'
+            }));
+            mockMemberRepo.findOne.mockResolvedValueOnce(null);
+            mockMemberRepo.findOne.mockResolvedValueOnce(null);
+            mockMemberRepo.create.mockImplementation((data)=>data);
+            mockMemberRepo.save.mockResolvedValue(buildMember({
+                boardId: 'board-1'
+            }));
+            await service.addMember({
+                boardId: 'board-1',
+                userId: 'user-2'
+            }, buildMockUser());
+            expect(mockUtilsService.clearCache).toHaveBeenCalledWith('task_board', expect.anything());
+            expect(mockUtilsService.clearCache).toHaveBeenCalledWith('task_board', expect.anything(), 'board-1');
+        });
         it('defaults the role to MEMBER when none is given', async ()=>{
             mockRepo.findOne.mockResolvedValue(buildBoard({
                 id: 'board-1'
@@ -343,6 +365,17 @@ describe('TaskBoardService', ()=>{
                 deletedAt: expect.any(Date)
             });
         });
+        it('invalidates the board list cache and the board entry', async ()=>{
+            mockMemberRepo.findOne.mockResolvedValue(buildMember({
+                id: 'member-1'
+            }));
+            await service.removeMember({
+                boardId: 'board-1',
+                userId: 'user-uuid-1'
+            });
+            expect(mockUtilsService.clearCache).toHaveBeenCalledWith('task_board', expect.anything());
+            expect(mockUtilsService.clearCache).toHaveBeenCalledWith('task_board', expect.anything(), 'board-1');
+        });
         it('throws NotFoundException when the member is not found', async ()=>{
             mockMemberRepo.findOne.mockResolvedValue(null);
             await expect(service.removeMember({

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

@@ -32,6 +32,10 @@ import { TASK_LIST_MESSAGES } from '../config';
 import { TaskList } from '../entities';
 import { TaskManagerDataSourceProvider } from './task-manager-datasource.provider';
 export class TaskListService extends ApiService {
+    /** Boards cache denormalized `total_tasks` / `total_lists`, so board caches go stale on any write here. */ async clearCacheForAll() {
+        await super.clearCacheForAll();
+        await this.utilsService.clearCache('task_board', this.cacheManager);
+    }
     async convertSingleDtoToEntity(dto, _user) {
         await this.ensureDataSourceRepository();
         let entity = {};
@@ -83,7 +87,12 @@ export class TaskListService extends ApiService {
             }, {
                 position: i * 100
             })));
-        await this.clearCacheForAll();
+        await Promise.all([
+            this.clearCacheForAll(),
+            this.clearCacheForId(dto.orderedIds.map((id)=>({
+                    id
+                })))
+        ]);
     }
     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;

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

@@ -37,6 +37,15 @@ function mockQueryRunner(repo) {
     return qr;
 }
 describe('TaskListService', ()=>{
+    const mockUtilsService = {
+        clearCache: jest.fn(),
+        getCacheKey: jest.fn().mockReturnValue('cache-key'),
+        trackCacheKey: jest.fn()
+    };
+    // Call history is shared across tests in this file; reset it so each cache assertion is exact.
+    beforeEach(()=>{
+        mockUtilsService.clearCache.mockClear();
+    });
     let service;
     let mockRepo;
     beforeEach(async ()=>{
@@ -51,11 +60,7 @@ describe('TaskListService', ()=>{
                 },
                 {
                     provide: UtilsService,
-                    useValue: {
-                        clearCache: jest.fn(),
-                        getCacheKey: jest.fn(),
-                        trackCacheKey: jest.fn()
-                    }
+                    useValue: mockUtilsService
                 },
                 {
                     provide: TaskManagerDataSourceProvider,
@@ -184,6 +189,19 @@ describe('TaskListService', ()=>{
                 position: 200
             });
         });
+        it('invalidates the list cache, each reordered entry, and the parent board cache', async ()=>{
+            await service.reorderLists({
+                boardId: 'board-1',
+                orderedIds: [
+                    'list-a',
+                    'list-b'
+                ]
+            });
+            expect(mockUtilsService.clearCache).toHaveBeenCalledWith('task_list', expect.anything());
+            expect(mockUtilsService.clearCache).toHaveBeenCalledWith('task_list', expect.anything(), 'list-a');
+            expect(mockUtilsService.clearCache).toHaveBeenCalledWith('task_list', expect.anything(), 'list-b');
+            expect(mockUtilsService.clearCache).toHaveBeenCalledWith('task_board', expect.anything());
+        });
         it('handles reordering a single-item list (position 0)', async ()=>{
             await service.reorderLists({
                 boardId: 'board-1',

package/fesm/services/task.service.js

@@ -35,6 +35,10 @@ import { TaskActivityService } from './task-activity.service';
 import { TaskBoardService } from './task-board.service';
 import { TaskManagerDataSourceProvider } from './task-manager-datasource.provider';
 export class TaskService extends ApiService {
+    /** Boards cache denormalized `total_tasks` / `total_lists`, so board caches go stale on any write here. */ async clearCacheForAll() {
+        await super.clearCacheForAll();
+        await this.utilsService.clearCache('task_board', this.cacheManager);
+    }
     async convertSingleDtoToEntity(dto, user) {
         await this.ensureDataSourceRepository();
         let entity = {};
@@ -175,6 +179,12 @@ export class TaskService extends ApiService {
         }, {
             listId: dto.targetListId
         });
+        await Promise.all([
+            this.clearCacheForAll(),
+            this.clearCacheForId([
+                saved
+            ])
+        ]);
         return saved;
     }
     async assignTask(dto, user) {
@@ -211,6 +221,12 @@ export class TaskService extends ApiService {
         }, {
             assigneeIds: dto.assigneeIds
         });
+        await Promise.all([
+            this.clearCacheForAll(),
+            this.clearCacheForId([
+                saved
+            ])
+        ]);
         saved.assignees = await this.loadAssigneesForTask(saved.id);
         return saved;
     }

package/fesm/services/task.service.spec.js

@@ -45,6 +45,15 @@ function mockQueryRunner(repo) {
     return qr;
 }
 describe('TaskService', ()=>{
+    const mockUtilsService = {
+        clearCache: jest.fn(),
+        getCacheKey: jest.fn().mockReturnValue('cache-key'),
+        trackCacheKey: jest.fn()
+    };
+    // Call history is shared across tests in this file; reset it so each cache assertion is exact.
+    beforeEach(()=>{
+        mockUtilsService.clearCache.mockClear();
+    });
     let service;
     let mockRepo;
     let mockLabelJunctionRepo;
@@ -92,11 +101,7 @@ describe('TaskService', ()=>{
                 },
                 {
                     provide: UtilsService,
-                    useValue: {
-                        clearCache: jest.fn(),
-                        getCacheKey: jest.fn(),
-                        trackCacheKey: jest.fn()
-                    }
+                    useValue: mockUtilsService
                 },
                 {
                     provide: TaskManagerDataSourceProvider,
@@ -364,6 +369,25 @@ describe('TaskService', ()=>{
                 listId: 'list-new'
             });
         });
+        it('invalidates the task list cache and the moved task entry', async ()=>{
+            const task = buildTask({
+                id: 'task-1',
+                listId: 'list-old',
+                boardId: 'board-1'
+            });
+            mockRepo.findOne.mockResolvedValue(task);
+            mockRepo.save.mockImplementation((t)=>Promise.resolve(t));
+            await service.moveTask({
+                taskId: 'task-1',
+                targetListId: 'list-new',
+                position: 1
+            }, buildMockUser({
+                id: 'mover-1'
+            }));
+            expect(mockUtilsService.clearCache).toHaveBeenCalledWith('task', expect.anything());
+            expect(mockUtilsService.clearCache).toHaveBeenCalledWith('task', expect.anything(), 'task-1');
+            expect(mockUtilsService.clearCache).toHaveBeenCalledWith('task_board', expect.anything());
+        });
         it('defaults position to 0 (first position) when no position is given', async ()=>{
             const task = buildTask({
                 id: 'task-1',

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@flusys/nestjs-task-manager",
-  "version": "6.3.0",
+  "version": "6.4.1",
   "description": "Task management module with dynamic boards and real-time collaboration",
   "main": "cjs/index.js",
   "module": "fesm/index.js",
@@ -85,7 +85,7 @@
     "socket.io": "^4.8.0"
   },
   "dependencies": {
-    "@flusys/nestjs-core": "6.3.0",
-    "@flusys/nestjs-shared": "6.3.0"
+    "@flusys/nestjs-core": "6.4.1",
+    "@flusys/nestjs-shared": "6.4.1"
   }
 }

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

@@ -28,5 +28,6 @@ export declare class TaskBoardService extends ApiService<CreateTaskBoardDto, Upd
     })[]>;
     isBoardMember(boardId: string, userId: string): Promise<boolean>;
     protected afterInsertOperation(entities: TaskBoardBase[], _dto: CreateTaskBoardDto | Array<CreateTaskBoardDto>, user: ILoggedUserInfo | null, _qr: any): Promise<void>;
+    private invalidateBoardCache;
     private ensureMemberRepository;
 }

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

@@ -10,6 +10,7 @@ export declare class TaskListService extends ApiService<CreateTaskListDto, Updat
     protected utilsService: UtilsService;
     private readonly dataSourceProvider;
     constructor(cacheManager: HybridCache, utilsService: UtilsService, dataSourceProvider: TaskManagerDataSourceProvider);
+    clearCacheForAll(): Promise<void>;
     convertSingleDtoToEntity(dto: CreateTaskListDto | UpdateTaskListDto, _user: ILoggedUserInfo | null): Promise<TaskList>;
     protected getFilterQuery(query: SelectQueryBuilder<TaskList>, filter: Record<string, unknown>, _user: ILoggedUserInfo | null): Promise<{
         query: SelectQueryBuilder<TaskList>;

package/services/task.service.d.ts

@@ -20,6 +20,7 @@ export declare class TaskService extends ApiService<CreateTaskDto, UpdateTaskDto
     private pendingLabelIds;
     private pendingAssigneeIds;
     constructor(cacheManager: HybridCache, utilsService: UtilsService, dataSourceProvider: TaskManagerDataSourceProvider, boardService: TaskBoardService, activityService: TaskActivityService);
+    clearCacheForAll(): Promise<void>;
     convertSingleDtoToEntity(dto: CreateTaskDto | UpdateTaskDto, user: ILoggedUserInfo | null): Promise<Task>;
     protected afterInsertOperation(entities: Task[], _dto: CreateTaskDto | Array<CreateTaskDto>, user: ILoggedUserInfo | null, _qr: QueryRunner): Promise<void>;
     protected afterUpdateOperation(entities: Task[], _dto: UpdateTaskDto | Array<UpdateTaskDto>, _user: ILoggedUserInfo | null, _qr: QueryRunner): Promise<void>;