@flusys/nestjs-notification 6.0.1 → 6.1.0

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

@@ -0,0 +1,490 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+const _testing = require("@nestjs/testing");
+const _modules = require("@flusys/nestjs-shared/modules");
+const _repositorymock = require("@test-utils/mocks/repository.mock");
+const _loggedusermock = require("@test-utils/mocks/logged-user.mock");
+const _notificationservice = require("./notification.service");
+const _notificationconfigservice = require("./notification-config.service");
+const _notificationdatasourceprovider = require("./notification-datasource.provider");
+const _gateways = require("../gateways");
+const _entities = require("../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 = (0, _repositorymock.createMockRepository)();
+        const mockDataSourceProvider = (0, _repositorymock.createMockDataSourceProvider)(mockRepo);
+        mockConfig = {
+            isCompanyFeatureEnabled: jest.fn().mockReturnValue(false)
+        };
+        mockGateway = {
+            emitToUser: jest.fn(),
+            emitToUserInCompany: jest.fn()
+        };
+        const providers = [
+            _notificationservice.NotificationService,
+            {
+                provide: 'CACHE_INSTANCE',
+                useValue: {}
+            },
+            {
+                provide: _modules.UtilsService,
+                useValue: {
+                    clearCache: jest.fn().mockResolvedValue(undefined)
+                }
+            },
+            {
+                provide: _notificationconfigservice.NotificationConfigService,
+                useValue: mockConfig
+            },
+            {
+                provide: _notificationdatasourceprovider.NotificationDataSourceProvider,
+                useValue: mockDataSourceProvider
+            }
+        ];
+        if (withGateway) {
+            providers.push({
+                provide: _gateways.NotificationGateway,
+                useValue: mockGateway
+            });
+        }
+        const module = await _testing.Test.createTestingModule({
+            providers
+        }).compile();
+        const resolved = await module.resolve(_notificationservice.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(_entities.Notification);
+        });
+        it('returns NotificationWithCompany when the company feature is enabled', ()=>{
+            mockConfig.isCompanyFeatureEnabled.mockReturnValue(true);
+            expect(service.resolveEntity()).toBe(_entities.NotificationWithCompany);
+        });
+    });
+    describe('convertSingleDtoToEntity', ()=>{
+        it('builds a new entity for create (no id present)', async ()=>{
+            const user = (0, _loggedusermock.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 = (0, _loggedusermock.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 = (0, _loggedusermock.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'
+            }, (0, _loggedusermock.buildMockUser)())).rejects.toThrow();
+        });
+        it('includes companyId from the dto when the company feature is enabled', async ()=>{
+            mockConfig.isCompanyFeatureEnabled.mockReturnValue(true);
+            const user = (0, _loggedusermock.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 = (0, _loggedusermock.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 = (0, _loggedusermock.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
+            }, (0, _loggedusermock.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'
+            }, (0, _loggedusermock.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'
+            }, (0, _loggedusermock.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'
+            }, (0, _loggedusermock.buildMockUser)());
+            expect(query.andWhere).not.toHaveBeenCalled();
+        });
+        it('ignores a non-boolean isRead value', async ()=>{
+            const query = createMockQuery();
+            await service.getFilterQuery(query, {
+                isRead: 'true'
+            }, (0, _loggedusermock.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, (0, _loggedusermock.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, (0, _loggedusermock.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, (0, _loggedusermock.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 = (0, _loggedusermock.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 = (0, _loggedusermock.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, {}, (0, _loggedusermock.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'
+                }
+            }, (0, _loggedusermock.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, {}, (0, _loggedusermock.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, {}, (0, _loggedusermock.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 = (0, _loggedusermock.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', (0, _loggedusermock.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 = (0, _loggedusermock.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 = (0, _loggedusermock.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((0, _loggedusermock.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((0, _loggedusermock.buildMockUser)());
+            expect(count).toBe(0);
+        });
+        it('scopes the update by companyId when the company feature is enabled', async ()=>{
+            mockConfig.isCompanyFeatureEnabled.mockReturnValue(true);
+            const user = (0, _loggedusermock.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 = (0, _loggedusermock.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((0, _loggedusermock.buildMockUser)());
+            expect(count).toBe(0);
+        });
+        it('scopes the count by companyId when the company feature is enabled', async ()=>{
+            mockConfig.isCompanyFeatureEnabled.mockReturnValue(true);
+            const user = (0, _loggedusermock.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 = (0, _loggedusermock.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/fesm/adapters/notification.adapter.spec.js

@@ -0,0 +1,69 @@
+import { NotificationAdapter } from './notification.adapter';
+describe('NotificationAdapter', ()=>{
+    let adapter;
+    let mockHelper;
+    beforeEach(()=>{
+        mockHelper = {
+            send: jest.fn(),
+            sendToMany: jest.fn(),
+            isUserOnline: jest.fn()
+        };
+        adapter = new NotificationAdapter(mockHelper);
+    });
+    describe('send', ()=>{
+        it('delegates to NotificationHelperService.send with the same options', async ()=>{
+            const options = {
+                userId: 'user-uuid-1',
+                title: 'Hello',
+                message: 'World'
+            };
+            mockHelper.send.mockResolvedValue(undefined);
+            await adapter.send(options);
+            expect(mockHelper.send).toHaveBeenCalledWith(options);
+            expect(mockHelper.send).toHaveBeenCalledTimes(1);
+        });
+        it('propagates errors thrown by the helper service', async ()=>{
+            const options = {
+                userId: 'user-uuid-1',
+                title: 'Hello'
+            };
+            mockHelper.send.mockRejectedValue(new Error('boom'));
+            await expect(adapter.send(options)).rejects.toThrow('boom');
+        });
+    });
+    describe('sendToMany', ()=>{
+        it('delegates to NotificationHelperService.sendToMany with the same options', async ()=>{
+            const options = {
+                userIds: [
+                    'user-uuid-1',
+                    'user-uuid-2'
+                ],
+                title: 'Broadcast'
+            };
+            mockHelper.sendToMany.mockResolvedValue(undefined);
+            await adapter.sendToMany(options);
+            expect(mockHelper.sendToMany).toHaveBeenCalledWith(options);
+            expect(mockHelper.sendToMany).toHaveBeenCalledTimes(1);
+        });
+        it('handles an empty userIds array without throwing', async ()=>{
+            const options = {
+                userIds: [],
+                title: 'Nobody'
+            };
+            mockHelper.sendToMany.mockResolvedValue(undefined);
+            await expect(adapter.sendToMany(options)).resolves.toBeUndefined();
+            expect(mockHelper.sendToMany).toHaveBeenCalledWith(options);
+        });
+    });
+    describe('isUserOnline', ()=>{
+        it('returns true when the helper reports the user online', ()=>{
+            mockHelper.isUserOnline.mockReturnValue(true);
+            expect(adapter.isUserOnline('user-uuid-1')).toBe(true);
+            expect(mockHelper.isUserOnline).toHaveBeenCalledWith('user-uuid-1');
+        });
+        it('returns false when the helper reports the user offline', ()=>{
+            mockHelper.isUserOnline.mockReturnValue(false);
+            expect(adapter.isUserOnline('user-uuid-2')).toBe(false);
+        });
+    });
+});