@flusys/nestjs-task-manager 6.4.0 → 7.0.0-beta.1

package/cjs/config/event-actions.js

@@ -0,0 +1,33 @@
+/**
+ * Domain event actions published by the task manager module, alongside the CRUD
+ * lifecycle actions every ApiService emits.
+ */ "use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+function _export(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: true,
+        get: Object.getOwnPropertyDescriptor(all, name).get
+    });
+}
+_export(exports, {
+    get TASK_MANAGER_EVENT_ACTIONS () {
+        return TASK_MANAGER_EVENT_ACTIONS;
+    },
+    get TASK_MANAGER_EVENT_ENTITIES () {
+        return TASK_MANAGER_EVENT_ENTITIES;
+    }
+});
+const TASK_MANAGER_EVENT_ACTIONS = {
+    MOVED: 'moved',
+    ASSIGNED: 'assigned',
+    REORDERED: 'reordered'
+};
+const TASK_MANAGER_EVENT_ENTITIES = {
+    TASK: 'task',
+    TASK_BOARD: 'task_board',
+    TASK_LIST: 'task_list',
+    TASK_LABEL: 'task_label',
+    TASK_COMMENT: 'task_comment'
+};

package/cjs/config/index.js

@@ -2,8 +2,9 @@
 Object.defineProperty(exports, "__esModule", {
     value: true
 });
-_export_star(require("./task-manager.constants"), exports);
+_export_star(require("./event-actions"), exports);
 _export_star(require("./message-keys"), exports);
+_export_star(require("./task-manager.constants"), exports);
 function _export_star(from, to) {
     Object.keys(from).forEach(function(k) {
         if (k !== "default" && !Object.prototype.hasOwnProperty.call(to, k)) {

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

@@ -91,6 +91,7 @@ let TaskManagerModule = class TaskManagerModule {
                 useValue: options
             });
         }
+        providers.push((0, _modules.createModuleEventsProvider)('task-manager', _taskmanagerconstants.TASK_MANAGER_MODULE_OPTIONS));
         return providers;
     }
     static createAsyncProviders(options) {

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,18 @@ 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
+                })))
+        ]);
+        await this.publishDomainAction(_config.TASK_MANAGER_EVENT_ACTIONS.REORDERED, {
+            ids: dto.orderedIds,
+            metadata: {
+                boardId: dto.boardId
+            }
+        });
     }
     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

@@ -3,6 +3,7 @@ Object.defineProperty(exports, "__esModule", {
     value: true
 });
 const _testing = require("@nestjs/testing");
+const _classes = require("@flusys/nestjs-shared/classes");
 const _modules = require("@flusys/nestjs-shared/modules");
 const _repositorymock = require("@test-utils/mocks/repository.mock");
 const _loggedusermock = require("@test-utils/mocks/logged-user.mock");
@@ -41,6 +42,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 +65,7 @@ describe('TaskListService', ()=>{
                 },
                 {
                     provide: _modules.UtilsService,
-                    useValue: {
-                        clearCache: jest.fn(),
-                        getCacheKey: jest.fn(),
-                        trackCacheKey: jest.fn()
-                    }
+                    useValue: mockUtilsService
                 },
                 {
                     provide: _taskmanagerdatasourceprovider.TaskManagerDataSourceProvider,
@@ -188,6 +194,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',
@@ -211,4 +230,55 @@ describe('TaskListService', ()=>{
             expect(mockRepo.update).not.toHaveBeenCalled();
         });
     });
+    describe('domain events', ()=>{
+        let publish;
+        beforeEach(()=>{
+            publish = jest.fn().mockResolvedValue(undefined);
+            _classes.EventBusRegistry.reset();
+            _classes.EventBusRegistry.setBus({
+                publish,
+                subscribe: jest.fn(),
+                close: jest.fn()
+            });
+            _classes.EventBusRegistry.configureModule('task-manager', {
+                enabled: true
+            });
+        });
+        afterEach(()=>{
+            _classes.EventBusRegistry.reset();
+        });
+        it('publishes task-manager.task_list.reordered with every list id', async ()=>{
+            await service.reorderLists({
+                boardId: 'board-1',
+                orderedIds: [
+                    'list-a',
+                    'list-b'
+                ]
+            });
+            expect(publish).toHaveBeenCalledWith(expect.objectContaining({
+                name: 'task-manager.task_list.reordered',
+                payload: expect.objectContaining({
+                    ids: [
+                        'list-a',
+                        'list-b'
+                    ],
+                    metadata: {
+                        boardId: 'board-1'
+                    }
+                })
+            }));
+        });
+        it('does not publish when the task manager module has events disabled', async ()=>{
+            _classes.EventBusRegistry.configureModule('task-manager', {
+                enabled: false
+            });
+            await service.reorderLists({
+                boardId: 'board-1',
+                orderedIds: [
+                    'list-a'
+                ]
+            });
+            expect(publish).not.toHaveBeenCalled();
+        });
+    });
 });

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,24 @@ let TaskService = class TaskService extends _classes.ApiService {
         }, {
             listId: dto.targetListId
         });
+        await Promise.all([
+            this.clearCacheForAll(),
+            this.clearCacheForId([
+                saved
+            ])
+        ]);
+        await this.publishDomainAction(_config.TASK_MANAGER_EVENT_ACTIONS.MOVED, {
+            ids: [
+                saved.id
+            ],
+            metadata: {
+                boardId: saved.boardId,
+                fromListId: oldListId,
+                toListId: dto.targetListId,
+                position: saved.position
+            },
+            user
+        });
         return saved;
     }
     async assignTask(dto, user) {
@@ -221,7 +243,24 @@ 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);
+        await this.publishDomainAction(_config.TASK_MANAGER_EVENT_ACTIONS.ASSIGNED, {
+            ids: [
+                saved.id
+            ],
+            metadata: {
+                boardId: saved.boardId,
+                previousAssigneeIds: oldIds,
+                assigneeIds: dto.assigneeIds
+            },
+            user
+        });
         return saved;
     }
     async syncAssignees(taskId, userIds) {

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

@@ -3,6 +3,7 @@ Object.defineProperty(exports, "__esModule", {
     value: true
 });
 const _testing = require("@nestjs/testing");
+const _classes = require("@flusys/nestjs-shared/classes");
 const _modules = require("@flusys/nestjs-shared/modules");
 const _repositorymock = require("@test-utils/mocks/repository.mock");
 const _loggedusermock = require("@test-utils/mocks/logged-user.mock");
@@ -49,6 +50,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 +106,7 @@ describe('TaskService', ()=>{
                 },
                 {
                     provide: _modules.UtilsService,
-                    useValue: {
-                        clearCache: jest.fn(),
-                        getCacheKey: jest.fn(),
-                        trackCacheKey: jest.fn()
-                    }
+                    useValue: mockUtilsService
                 },
                 {
                     provide: _taskmanagerdatasourceprovider.TaskManagerDataSourceProvider,
@@ -368,6 +374,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',
@@ -607,4 +632,69 @@ describe('TaskService', ()=>{
             superGetAllSpy.mockRestore();
         });
     });
+    describe('domain events', ()=>{
+        let publish;
+        beforeEach(()=>{
+            publish = jest.fn().mockResolvedValue(undefined);
+            _classes.EventBusRegistry.reset();
+            _classes.EventBusRegistry.setBus({
+                publish,
+                subscribe: jest.fn(),
+                close: jest.fn()
+            });
+            _classes.EventBusRegistry.configureModule('task-manager', {
+                enabled: true
+            });
+        });
+        afterEach(()=>{
+            _classes.EventBusRegistry.reset();
+        });
+        it('publishes task-manager.task.moved with the source and target lists', async ()=>{
+            const task = buildTask({
+                id: 'task-1',
+                listId: 'list-old',
+                boardId: 'board-1',
+                position: 0
+            });
+            mockRepo.findOne.mockResolvedValue(task);
+            mockRepo.save.mockImplementation((t)=>Promise.resolve(t));
+            await service.moveTask({
+                taskId: 'task-1',
+                targetListId: 'list-new',
+                position: 3
+            }, (0, _loggedusermock.buildMockUser)({
+                id: 'mover-1'
+            }));
+            expect(publish).toHaveBeenCalledWith(expect.objectContaining({
+                name: 'task-manager.task.moved',
+                payload: expect.objectContaining({
+                    ids: [
+                        'task-1'
+                    ],
+                    metadata: expect.objectContaining({
+                        boardId: 'board-1',
+                        fromListId: 'list-old',
+                        toListId: 'list-new'
+                    })
+                })
+            }));
+        });
+        it('does not publish when the task manager module has events disabled', async ()=>{
+            _classes.EventBusRegistry.configureModule('task-manager', {
+                enabled: false
+            });
+            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'
+            }, (0, _loggedusermock.buildMockUser)());
+            expect(publish).not.toHaveBeenCalled();
+        });
+    });
 });

package/config/event-actions.d.ts

@@ -0,0 +1,12 @@
+export declare const TASK_MANAGER_EVENT_ACTIONS: {
+    readonly MOVED: "moved";
+    readonly ASSIGNED: "assigned";
+    readonly REORDERED: "reordered";
+};
+export declare const TASK_MANAGER_EVENT_ENTITIES: {
+    readonly TASK: "task";
+    readonly TASK_BOARD: "task_board";
+    readonly TASK_LIST: "task_list";
+    readonly TASK_LABEL: "task_label";
+    readonly TASK_COMMENT: "task_comment";
+};

package/config/index.d.ts

@@ -1,2 +1,3 @@
-export * from './task-manager.constants';
+export * from './event-actions';
 export * from './message-keys';
+export * from './task-manager.constants';

package/fesm/config/event-actions.js

@@ -0,0 +1,15 @@
+/**
+ * Domain event actions published by the task manager module, alongside the CRUD
+ * lifecycle actions every ApiService emits.
+ */ export const TASK_MANAGER_EVENT_ACTIONS = {
+    MOVED: 'moved',
+    ASSIGNED: 'assigned',
+    REORDERED: 'reordered'
+};
+/** Every entity the task manager module publishes under */ export const TASK_MANAGER_EVENT_ENTITIES = {
+    TASK: 'task',
+    TASK_BOARD: 'task_board',
+    TASK_LIST: 'task_list',
+    TASK_LABEL: 'task_label',
+    TASK_COMMENT: 'task_comment'
+};

package/fesm/config/index.js

@@ -1,2 +1,3 @@
-export * from './task-manager.constants';
+export * from './event-actions';
 export * from './message-keys';
+export * from './task-manager.constants';

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

@@ -4,7 +4,7 @@ function _ts_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 { CacheModule, UtilsModule, createModuleEventsProvider } from '@flusys/nestjs-shared/modules';
 import { Module } from '@nestjs/common';
 import { JwtService } from '@nestjs/jwt';
 import { TASK_MANAGER_MODULE_OPTIONS } from '../config/task-manager.constants';
@@ -81,6 +81,7 @@ export class TaskManagerModule {
                 useValue: options
             });
         }
+        providers.push(createModuleEventsProvider('task-manager', TASK_MANAGER_MODULE_OPTIONS));
         return providers;
     }
     static createAsyncProviders(options) {

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

@@ -28,10 +28,14 @@ function _ts_param(paramIndex, decorator) {
 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 { TASK_LIST_MESSAGES, TASK_MANAGER_EVENT_ACTIONS } 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,18 @@ export class TaskListService extends ApiService {
             }, {
                 position: i * 100
             })));
-        await this.clearCacheForAll();
+        await Promise.all([
+            this.clearCacheForAll(),
+            this.clearCacheForId(dto.orderedIds.map((id)=>({
+                    id
+                })))
+        ]);
+        await this.publishDomainAction(TASK_MANAGER_EVENT_ACTIONS.REORDERED, {
+            ids: dto.orderedIds,
+            metadata: {
+                boardId: dto.boardId
+            }
+        });
     }
     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

@@ -1,4 +1,5 @@
 import { Test } from '@nestjs/testing';
+import { EventBusRegistry } from '@flusys/nestjs-shared/classes';
 import { UtilsService } from '@flusys/nestjs-shared/modules';
 import { createMockDataSourceProvider, createMockQueryBuilder, createMockRepository } from '@test-utils/mocks/repository.mock';
 import { buildMockUser } from '@test-utils/mocks/logged-user.mock';
@@ -37,6 +38,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 +61,7 @@ describe('TaskListService', ()=>{
                 },
                 {
                     provide: UtilsService,
-                    useValue: {
-                        clearCache: jest.fn(),
-                        getCacheKey: jest.fn(),
-                        trackCacheKey: jest.fn()
-                    }
+                    useValue: mockUtilsService
                 },
                 {
                     provide: TaskManagerDataSourceProvider,
@@ -184,6 +190,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',
@@ -207,4 +226,55 @@ describe('TaskListService', ()=>{
             expect(mockRepo.update).not.toHaveBeenCalled();
         });
     });
+    describe('domain events', ()=>{
+        let publish;
+        beforeEach(()=>{
+            publish = jest.fn().mockResolvedValue(undefined);
+            EventBusRegistry.reset();
+            EventBusRegistry.setBus({
+                publish,
+                subscribe: jest.fn(),
+                close: jest.fn()
+            });
+            EventBusRegistry.configureModule('task-manager', {
+                enabled: true
+            });
+        });
+        afterEach(()=>{
+            EventBusRegistry.reset();
+        });
+        it('publishes task-manager.task_list.reordered with every list id', async ()=>{
+            await service.reorderLists({
+                boardId: 'board-1',
+                orderedIds: [
+                    'list-a',
+                    'list-b'
+                ]
+            });
+            expect(publish).toHaveBeenCalledWith(expect.objectContaining({
+                name: 'task-manager.task_list.reordered',
+                payload: expect.objectContaining({
+                    ids: [
+                        'list-a',
+                        'list-b'
+                    ],
+                    metadata: {
+                        boardId: 'board-1'
+                    }
+                })
+            }));
+        });
+        it('does not publish when the task manager module has events disabled', async ()=>{
+            EventBusRegistry.configureModule('task-manager', {
+                enabled: false
+            });
+            await service.reorderLists({
+                boardId: 'board-1',
+                orderedIds: [
+                    'list-a'
+                ]
+            });
+            expect(publish).not.toHaveBeenCalled();
+        });
+    });
 });

package/fesm/services/task.service.js

@@ -29,12 +29,16 @@ import { ApiService, HybridCache } from '@flusys/nestjs-shared/classes';
 import { UtilsService } from '@flusys/nestjs-shared/modules';
 import { BadRequestException, Inject, Injectable, NotFoundException, Scope } from '@nestjs/common';
 import { In, IsNull } from 'typeorm';
-import { TASK_MESSAGES } from '../config';
+import { TASK_MANAGER_EVENT_ACTIONS, TASK_MESSAGES } from '../config';
 import { Task, TaskAssignee, TaskLabel, TaskTaskLabel } from '../entities';
 import { TaskActivityService } from './task-activity.service';
 import { TaskBoardService } from './task-board.service';
 import { TaskManagerDataSourceProvider } from './task-manager-datasource.provider';
 export class TaskService extends ApiService {
+    /** 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,24 @@ export class TaskService extends ApiService {
         }, {
             listId: dto.targetListId
         });
+        await Promise.all([
+            this.clearCacheForAll(),
+            this.clearCacheForId([
+                saved
+            ])
+        ]);
+        await this.publishDomainAction(TASK_MANAGER_EVENT_ACTIONS.MOVED, {
+            ids: [
+                saved.id
+            ],
+            metadata: {
+                boardId: saved.boardId,
+                fromListId: oldListId,
+                toListId: dto.targetListId,
+                position: saved.position
+            },
+            user
+        });
         return saved;
     }
     async assignTask(dto, user) {
@@ -211,7 +233,24 @@ export class TaskService extends ApiService {
         }, {
             assigneeIds: dto.assigneeIds
         });
+        await Promise.all([
+            this.clearCacheForAll(),
+            this.clearCacheForId([
+                saved
+            ])
+        ]);
         saved.assignees = await this.loadAssigneesForTask(saved.id);
+        await this.publishDomainAction(TASK_MANAGER_EVENT_ACTIONS.ASSIGNED, {
+            ids: [
+                saved.id
+            ],
+            metadata: {
+                boardId: saved.boardId,
+                previousAssigneeIds: oldIds,
+                assigneeIds: dto.assigneeIds
+            },
+            user
+        });
         return saved;
     }
     async syncAssignees(taskId, userIds) {

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

@@ -1,4 +1,5 @@
 import { Test } from '@nestjs/testing';
+import { EventBusRegistry } from '@flusys/nestjs-shared/classes';
 import { UtilsService } from '@flusys/nestjs-shared/modules';
 import { createMockQueryBuilder, createMockRepository } from '@test-utils/mocks/repository.mock';
 import { buildMockUser } from '@test-utils/mocks/logged-user.mock';
@@ -45,6 +46,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 +102,7 @@ describe('TaskService', ()=>{
                 },
                 {
                     provide: UtilsService,
-                    useValue: {
-                        clearCache: jest.fn(),
-                        getCacheKey: jest.fn(),
-                        trackCacheKey: jest.fn()
-                    }
+                    useValue: mockUtilsService
                 },
                 {
                     provide: TaskManagerDataSourceProvider,
@@ -364,6 +370,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',
@@ -603,4 +628,69 @@ describe('TaskService', ()=>{
             superGetAllSpy.mockRestore();
         });
     });
+    describe('domain events', ()=>{
+        let publish;
+        beforeEach(()=>{
+            publish = jest.fn().mockResolvedValue(undefined);
+            EventBusRegistry.reset();
+            EventBusRegistry.setBus({
+                publish,
+                subscribe: jest.fn(),
+                close: jest.fn()
+            });
+            EventBusRegistry.configureModule('task-manager', {
+                enabled: true
+            });
+        });
+        afterEach(()=>{
+            EventBusRegistry.reset();
+        });
+        it('publishes task-manager.task.moved with the source and target lists', async ()=>{
+            const task = buildTask({
+                id: 'task-1',
+                listId: 'list-old',
+                boardId: 'board-1',
+                position: 0
+            });
+            mockRepo.findOne.mockResolvedValue(task);
+            mockRepo.save.mockImplementation((t)=>Promise.resolve(t));
+            await service.moveTask({
+                taskId: 'task-1',
+                targetListId: 'list-new',
+                position: 3
+            }, buildMockUser({
+                id: 'mover-1'
+            }));
+            expect(publish).toHaveBeenCalledWith(expect.objectContaining({
+                name: 'task-manager.task.moved',
+                payload: expect.objectContaining({
+                    ids: [
+                        'task-1'
+                    ],
+                    metadata: expect.objectContaining({
+                        boardId: 'board-1',
+                        fromListId: 'list-old',
+                        toListId: 'list-new'
+                    })
+                })
+            }));
+        });
+        it('does not publish when the task manager module has events disabled', async ()=>{
+            EventBusRegistry.configureModule('task-manager', {
+                enabled: false
+            });
+            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'
+            }, buildMockUser());
+            expect(publish).not.toHaveBeenCalled();
+        });
+    });
 });

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

@@ -1,7 +1,9 @@
 import { IBootstrapAppConfig, IDataSourceServiceOptions, IDynamicModuleConfig, IModuleOptionsFactory } from '@flusys/nestjs-core';
+import { IModuleEventsConfig } from '@flusys/nestjs-shared/interfaces';
 import { ModuleMetadata, Type } from '@nestjs/common';
 export interface ITaskManagerModuleConfig extends IDataSourceServiceOptions {
     jwtSecret?: string;
+    events?: IModuleEventsConfig;
 }
 export interface TaskManagerModuleOptions extends IDynamicModuleConfig {
     bootstrapAppConfig?: IBootstrapAppConfig;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@flusys/nestjs-task-manager",
-  "version": "6.4.0",
+  "version": "7.0.0-beta.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.4.0",
-    "@flusys/nestjs-shared": "6.4.0"
+    "@flusys/nestjs-core": "7.0.0-beta.1",
+    "@flusys/nestjs-shared": "7.0.0-beta.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>;