@flusys/nestjs-notification 6.0.1 → 6.1.0

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

@@ -0,0 +1,486 @@
+import { Test } from '@nestjs/testing';
+import { UtilsService } from '@flusys/nestjs-shared/modules';
+import { createMockDataSourceProvider, createMockRepository } from '@test-utils/mocks/repository.mock';
+import { buildMockUser } from '@test-utils/mocks/logged-user.mock';
+import { NotificationService } from './notification.service';
+import { NotificationConfigService } from './notification-config.service';
+import { NotificationDataSourceProvider } from './notification-datasource.provider';
+import { NotificationGateway } from '../gateways';
+import { Notification, NotificationWithCompany } from '../entities';
+function buildNotification(overrides = {}) {
+    return {
+        id: 'notif-uuid-1',
+        userId: 'user-uuid-1',
+        type: 'info',
+        title: 'Title',
+        message: 'Message',
+        data: null,
+        isRead: false,
+        readAt: null,
+        createdAt: new Date(),
+        updatedAt: new Date(),
+        deletedAt: null,
+        createdById: null,
+        updatedById: null,
+        deletedById: null,
+        ...overrides
+    };
+}
+function createMockQuery() {
+    return {
+        andWhere: jest.fn().mockReturnThis(),
+        addSelect: jest.fn().mockReturnThis(),
+        orderBy: jest.fn().mockReturnThis()
+    };
+}
+describe('NotificationService', ()=>{
+    let service;
+    let mockRepo;
+    let mockConfig;
+    let mockGateway;
+    async function buildService(withGateway = true) {
+        mockRepo = createMockRepository();
+        const mockDataSourceProvider = createMockDataSourceProvider(mockRepo);
+        mockConfig = {
+            isCompanyFeatureEnabled: jest.fn().mockReturnValue(false)
+        };
+        mockGateway = {
+            emitToUser: jest.fn(),
+            emitToUserInCompany: jest.fn()
+        };
+        const providers = [
+            NotificationService,
+            {
+                provide: 'CACHE_INSTANCE',
+                useValue: {}
+            },
+            {
+                provide: UtilsService,
+                useValue: {
+                    clearCache: jest.fn().mockResolvedValue(undefined)
+                }
+            },
+            {
+                provide: NotificationConfigService,
+                useValue: mockConfig
+            },
+            {
+                provide: NotificationDataSourceProvider,
+                useValue: mockDataSourceProvider
+            }
+        ];
+        if (withGateway) {
+            providers.push({
+                provide: NotificationGateway,
+                useValue: mockGateway
+            });
+        }
+        const module = await Test.createTestingModule({
+            providers
+        }).compile();
+        const resolved = await module.resolve(NotificationService);
+        resolved.repository = mockRepo;
+        return resolved;
+    }
+    beforeEach(async ()=>{
+        service = await buildService();
+    });
+    describe('resolveEntity', ()=>{
+        it('returns Notification when the company feature is disabled', ()=>{
+            expect(service.resolveEntity()).toBe(Notification);
+        });
+        it('returns NotificationWithCompany when the company feature is enabled', ()=>{
+            mockConfig.isCompanyFeatureEnabled.mockReturnValue(true);
+            expect(service.resolveEntity()).toBe(NotificationWithCompany);
+        });
+    });
+    describe('convertSingleDtoToEntity', ()=>{
+        it('builds a new entity for create (no id present)', async ()=>{
+            const user = buildMockUser();
+            const dto = {
+                userId: user.id,
+                title: 'Hello',
+                type: 'success'
+            };
+            const entity = await service.convertSingleDtoToEntity(dto, user);
+            expect(entity).toMatchObject({
+                userId: user.id,
+                title: 'Hello',
+                type: 'success',
+                isRead: false
+            });
+        });
+        it('defaults type to "info" when not provided', async ()=>{
+            const user = buildMockUser();
+            const entity = await service.convertSingleDtoToEntity({
+                userId: user.id,
+                title: 'Hi'
+            }, user);
+            expect(entity.type).toBe('info');
+        });
+        it('merges into the existing entity when updating by id', async ()=>{
+            const existing = buildNotification({
+                id: 'notif-1',
+                title: 'Old title'
+            });
+            mockRepo.findOne.mockResolvedValue(existing);
+            const user = buildMockUser();
+            const entity = await service.convertSingleDtoToEntity({
+                id: 'notif-1',
+                title: 'New title'
+            }, user);
+            expect(mockRepo.findOne).toHaveBeenCalledWith({
+                where: {
+                    id: 'notif-1'
+                }
+            });
+            expect(entity.title).toBe('New title');
+            expect(entity.isRead).toBe(false);
+        });
+        it('throws NotFoundException when updating an id that does not exist', async ()=>{
+            mockRepo.findOne.mockResolvedValue(null);
+            await expect(service.convertSingleDtoToEntity({
+                id: 'missing-id',
+                title: 'X'
+            }, buildMockUser())).rejects.toThrow();
+        });
+        it('includes companyId from the dto when the company feature is enabled', async ()=>{
+            mockConfig.isCompanyFeatureEnabled.mockReturnValue(true);
+            const user = buildMockUser({
+                companyId: 'company-user'
+            });
+            const entity = await service.convertSingleDtoToEntity({
+                userId: user.id,
+                title: 'Hi',
+                companyId: 'company-dto'
+            }, user);
+            expect(entity.companyId).toBe('company-dto');
+        });
+        it('falls back to the user companyId when the dto has none and the company feature is enabled', async ()=>{
+            mockConfig.isCompanyFeatureEnabled.mockReturnValue(true);
+            const user = buildMockUser({
+                companyId: 'company-user'
+            });
+            const entity = await service.convertSingleDtoToEntity({
+                userId: user.id,
+                title: 'Hi'
+            }, user);
+            expect(entity.companyId).toBe('company-user');
+        });
+        it('does not set companyId when the company feature is disabled', async ()=>{
+            const user = buildMockUser({
+                companyId: 'company-user'
+            });
+            const entity = await service.convertSingleDtoToEntity({
+                userId: user.id,
+                title: 'Hi',
+                companyId: 'company-dto'
+            }, user);
+            expect(entity.companyId).toBeUndefined();
+        });
+    });
+    describe('getFilterQuery', ()=>{
+        it('adds an isRead filter when provided as boolean', async ()=>{
+            const query = createMockQuery();
+            await service.getFilterQuery(query, {
+                isRead: true
+            }, buildMockUser());
+            expect(query.andWhere).toHaveBeenCalledWith('notification.isRead = :isRead', {
+                isRead: true
+            });
+        });
+        it('adds a type filter when provided', async ()=>{
+            const query = createMockQuery();
+            await service.getFilterQuery(query, {
+                type: 'success'
+            }, buildMockUser());
+            expect(query.andWhere).toHaveBeenCalledWith('notification.type = :type', {
+                type: 'success'
+            });
+        });
+        it('adds a userId filter when provided', async ()=>{
+            const query = createMockQuery();
+            await service.getFilterQuery(query, {
+                userId: 'user-9'
+            }, buildMockUser());
+            expect(query.andWhere).toHaveBeenCalledWith('notification.userId = :userId', {
+                userId: 'user-9'
+            });
+        });
+        it('ignores unrecognized filter keys', async ()=>{
+            const query = createMockQuery();
+            await service.getFilterQuery(query, {
+                unknownField: 'x'
+            }, buildMockUser());
+            expect(query.andWhere).not.toHaveBeenCalled();
+        });
+        it('ignores a non-boolean isRead value', async ()=>{
+            const query = createMockQuery();
+            await service.getFilterQuery(query, {
+                isRead: 'true'
+            }, buildMockUser());
+            expect(query.andWhere).not.toHaveBeenCalled();
+        });
+    });
+    describe('getSelectQuery', ()=>{
+        it('always selects createdAt and updatedAt in addition to requested fields', async ()=>{
+            const query = createMockQuery();
+            await service.getSelectQuery(query, buildMockUser(), [
+                'title',
+                'message'
+            ]);
+            expect(query.addSelect).toHaveBeenCalledWith([
+                'notification.title',
+                'notification.message',
+                'notification.createdAt',
+                'notification.updatedAt'
+            ]);
+        });
+        it('selects only createdAt/updatedAt when no fields are requested', async ()=>{
+            const query = createMockQuery();
+            await service.getSelectQuery(query, buildMockUser(), undefined);
+            expect(query.addSelect).toHaveBeenCalledWith([
+                'notification.createdAt',
+                'notification.updatedAt'
+            ]);
+        });
+        it('deduplicates fields already included in the always-selected set', async ()=>{
+            const query = createMockQuery();
+            await service.getSelectQuery(query, buildMockUser(), [
+                'createdAt'
+            ]);
+            expect(query.addSelect).toHaveBeenCalledWith([
+                'notification.createdAt',
+                'notification.updatedAt'
+            ]);
+        });
+    });
+    describe('getExtraManipulateQuery', ()=>{
+        it('scopes the query to the current user', async ()=>{
+            const query = createMockQuery();
+            const user = buildMockUser();
+            await service.getExtraManipulateQuery(query, {}, user);
+            expect(query.andWhere).toHaveBeenCalledWith('notification.userId = :currentUserId', {
+                currentUserId: user.id
+            });
+        });
+        it('applies the company filter when the company feature is enabled', async ()=>{
+            mockConfig.isCompanyFeatureEnabled.mockReturnValue(true);
+            const query = createMockQuery();
+            const user = buildMockUser({
+                companyId: 'company-1'
+            });
+            await service.getExtraManipulateQuery(query, {}, user);
+            expect(query.andWhere).toHaveBeenCalledWith('notification.companyId = :companyId', {
+                companyId: 'company-1'
+            });
+        });
+        it('defaults to ordering by createdAt DESC when no sort is provided', async ()=>{
+            const query = createMockQuery();
+            await service.getExtraManipulateQuery(query, {}, buildMockUser());
+            expect(query.orderBy).toHaveBeenCalledWith('notification.createdAt', 'DESC');
+        });
+        it('does not apply a default sort when the caller already specified one', async ()=>{
+            const query = createMockQuery();
+            await service.getExtraManipulateQuery(query, {
+                sort: {
+                    title: 'ASC'
+                }
+            }, buildMockUser());
+            expect(query.orderBy).not.toHaveBeenCalled();
+        });
+        it('does not scope by user when no user is provided', async ()=>{
+            const query = createMockQuery();
+            await service.getExtraManipulateQuery(query, {}, null);
+            expect(query.andWhere).not.toHaveBeenCalledWith(expect.stringContaining('currentUserId'), expect.anything());
+        });
+    });
+    describe('afterInsertOperation', ()=>{
+        it('emits a notification:new event for each inserted entity', async ()=>{
+            const entities = [
+                buildNotification({
+                    id: 'n1'
+                }),
+                buildNotification({
+                    id: 'n2'
+                })
+            ];
+            await service.afterInsertOperation(entities, {}, buildMockUser(), {});
+            expect(mockGateway.emitToUser).toHaveBeenCalledTimes(2);
+            expect(mockGateway.emitToUser).toHaveBeenCalledWith('user-uuid-1', 'notification:new', expect.objectContaining({
+                id: 'n1'
+            }));
+        });
+        it('uses emitToUserInCompany when the entity has a companyId and the company feature is enabled', async ()=>{
+            mockConfig.isCompanyFeatureEnabled.mockReturnValue(true);
+            const entities = [
+                buildNotification({
+                    id: 'n1',
+                    companyId: 'company-1'
+                })
+            ];
+            await service.afterInsertOperation(entities, {}, buildMockUser(), {});
+            expect(mockGateway.emitToUserInCompany).toHaveBeenCalledWith('user-uuid-1', 'company-1', 'notification:new', expect.any(Object));
+        });
+    });
+    describe('markAsRead', ()=>{
+        it('marks a matching notification as read and returns it', async ()=>{
+            const user = buildMockUser();
+            const notification = buildNotification({
+                id: 'notif-1',
+                userId: user.id,
+                isRead: false
+            });
+            mockRepo.findOne.mockResolvedValue(notification);
+            mockRepo.save.mockResolvedValue({
+                ...notification,
+                isRead: true
+            });
+            const result = await service.markAsRead('notif-1', user);
+            expect(mockRepo.findOne).toHaveBeenCalledWith({
+                where: {
+                    id: 'notif-1',
+                    userId: user.id
+                }
+            });
+            expect(mockRepo.save).toHaveBeenCalledWith(expect.objectContaining({
+                isRead: true,
+                readAt: expect.any(Date)
+            }));
+            expect(result.isRead).toBe(true);
+            expect(mockGateway.emitToUser).toHaveBeenCalledWith(user.id, 'notification:read', {
+                id: 'notif-1'
+            });
+        });
+        it('throws NotFoundException when the notification does not belong to the user or does not exist', async ()=>{
+            mockRepo.findOne.mockResolvedValue(null);
+            await expect(service.markAsRead('missing-id', buildMockUser())).rejects.toThrow();
+            expect(mockRepo.save).not.toHaveBeenCalled();
+        });
+        it('emits to the company-scoped room when the notification has a companyId', async ()=>{
+            mockConfig.isCompanyFeatureEnabled.mockReturnValue(true);
+            const user = buildMockUser({
+                companyId: 'company-1'
+            });
+            const notification = buildNotification({
+                id: 'notif-1',
+                userId: user.id,
+                companyId: 'company-1'
+            });
+            mockRepo.findOne.mockResolvedValue(notification);
+            mockRepo.save.mockResolvedValue({
+                ...notification,
+                isRead: true
+            });
+            await service.markAsRead('notif-1', user);
+            expect(mockGateway.emitToUserInCompany).toHaveBeenCalledWith(user.id, 'company-1', 'notification:read', {
+                id: 'notif-1'
+            });
+        });
+    });
+    describe('markAllAsRead', ()=>{
+        it('marks all unread notifications as read for the user and returns the affected count', async ()=>{
+            const user = buildMockUser();
+            mockRepo.update.mockResolvedValue({
+                affected: 4,
+                raw: {},
+                generatedMaps: []
+            });
+            const count = await service.markAllAsRead(user);
+            expect(mockRepo.update).toHaveBeenCalledWith({
+                userId: user.id,
+                isRead: false
+            }, {
+                isRead: true,
+                readAt: expect.any(Date)
+            });
+            expect(count).toBe(4);
+            expect(mockGateway.emitToUser).toHaveBeenCalledWith(user.id, 'notification:read-all', {});
+        });
+        it('returns 0 when there is nothing to update (zero unread notifications)', async ()=>{
+            mockRepo.update.mockResolvedValue({
+                affected: 0,
+                raw: {},
+                generatedMaps: []
+            });
+            const count = await service.markAllAsRead(buildMockUser());
+            expect(count).toBe(0);
+        });
+        it('returns 0 when affected is undefined/null', async ()=>{
+            mockRepo.update.mockResolvedValue({
+                affected: undefined,
+                raw: {},
+                generatedMaps: []
+            });
+            const count = await service.markAllAsRead(buildMockUser());
+            expect(count).toBe(0);
+        });
+        it('scopes the update by companyId when the company feature is enabled', async ()=>{
+            mockConfig.isCompanyFeatureEnabled.mockReturnValue(true);
+            const user = buildMockUser({
+                companyId: 'company-1'
+            });
+            mockRepo.update.mockResolvedValue({
+                affected: 1,
+                raw: {},
+                generatedMaps: []
+            });
+            await service.markAllAsRead(user);
+            expect(mockRepo.update).toHaveBeenCalledWith({
+                userId: user.id,
+                isRead: false,
+                companyId: 'company-1'
+            }, expect.any(Object));
+        });
+    });
+    describe('getUnreadCount', ()=>{
+        it('returns the unread count for the user', async ()=>{
+            const user = buildMockUser();
+            mockRepo.count.mockResolvedValue(7);
+            const count = await service.getUnreadCount(user);
+            expect(mockRepo.count).toHaveBeenCalledWith({
+                where: {
+                    userId: user.id,
+                    isRead: false
+                }
+            });
+            expect(count).toBe(7);
+        });
+        it('returns 0 for a user with no unread notifications', async ()=>{
+            mockRepo.count.mockResolvedValue(0);
+            const count = await service.getUnreadCount(buildMockUser());
+            expect(count).toBe(0);
+        });
+        it('scopes the count by companyId when the company feature is enabled', async ()=>{
+            mockConfig.isCompanyFeatureEnabled.mockReturnValue(true);
+            const user = buildMockUser({
+                companyId: 'company-1'
+            });
+            mockRepo.count.mockResolvedValue(2);
+            await service.getUnreadCount(user);
+            expect(mockRepo.count).toHaveBeenCalledWith({
+                where: {
+                    userId: user.id,
+                    isRead: false,
+                    companyId: 'company-1'
+                }
+            });
+        });
+    });
+    describe('without a bound gateway', ()=>{
+        it('does not throw when marking as read and no gateway is registered', async ()=>{
+            const noGatewayService = await buildService(false);
+            const user = buildMockUser();
+            const notification = buildNotification({
+                id: 'notif-1',
+                userId: user.id
+            });
+            mockRepo.findOne.mockResolvedValue(notification);
+            mockRepo.save.mockResolvedValue({
+                ...notification,
+                isRead: true
+            });
+            await expect(noGatewayService.markAsRead('notif-1', user)).resolves.toBeDefined();
+        });
+    });
+});

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@flusys/nestjs-notification",
-  "version": "6.0.1",
+  "version": "6.1.0",
   "description": "Notification module with real-time Socket.IO support",
   "main": "cjs/index.js",
   "module": "fesm/index.js",
@@ -93,7 +93,7 @@
     "express": "^5.0.0"
   },
   "dependencies": {
-    "@flusys/nestjs-core": "6.0.1",
-    "@flusys/nestjs-shared": "6.0.1"
+    "@flusys/nestjs-core": "6.1.0",
+    "@flusys/nestjs-shared": "6.1.0"
   }
 }