@flusys/nestjs-notification 6.0.2 → 6.1.0

package/fesm/controllers/notification.controller.spec.js

@@ -0,0 +1,210 @@
+import { NotificationType } from '@flusys/nestjs-shared/enums';
+import { buildMockUser } from '@test-utils/mocks/logged-user.mock';
+import { NotificationController } from './notification.controller';
+import { NOTIFICATION_MESSAGES } from '../config';
+function buildNotification(overrides = {}) {
+    return {
+        id: 'notif-1',
+        userId: 'user-uuid-1',
+        type: NotificationType.INFO,
+        title: 'Title',
+        message: 'Message',
+        data: null,
+        isRead: false,
+        readAt: null,
+        createdAt: new Date(),
+        updatedAt: new Date(),
+        ...overrides
+    };
+}
+describe('NotificationController', ()=>{
+    let controller;
+    let mockService;
+    let mockHelper;
+    beforeEach(()=>{
+        mockService = {
+            markAsRead: jest.fn(),
+            markAllAsRead: jest.fn(),
+            getUnreadCount: jest.fn(),
+            insert: jest.fn(),
+            insertMany: jest.fn(),
+            findById: jest.fn(),
+            findByIds: jest.fn(),
+            update: jest.fn(),
+            updateMany: jest.fn(),
+            bulkUpsert: jest.fn(),
+            getAll: jest.fn(),
+            delete: jest.fn()
+        };
+        mockHelper = {
+            send: jest.fn(),
+            sendToMany: jest.fn(),
+            isUserOnline: jest.fn(),
+            getOnlineUserCount: jest.fn()
+        };
+        controller = new NotificationController(mockService, mockHelper);
+    });
+    describe('markAsRead', ()=>{
+        it('marks the notification as read and returns the mapped response', async ()=>{
+            const user = buildMockUser();
+            const notification = buildNotification({
+                isRead: true
+            });
+            mockService.markAsRead.mockResolvedValue(notification);
+            const result = await controller.markAsRead({
+                id: 'notif-1'
+            }, user);
+            expect(mockService.markAsRead).toHaveBeenCalledWith('notif-1', user);
+            expect(result.success).toBe(true);
+            expect(result.messageKey).toBe(NOTIFICATION_MESSAGES.MARK_READ_SUCCESS);
+            expect(result.data?.id).toBe('notif-1');
+            expect(result.data?.isRead).toBe(true);
+        });
+        it('propagates a not-found error from the service', async ()=>{
+            mockService.markAsRead.mockRejectedValue(new Error(NOTIFICATION_MESSAGES.NOT_FOUND));
+            await expect(controller.markAsRead({
+                id: 'missing'
+            }, buildMockUser())).rejects.toThrow();
+        });
+    });
+    describe('markAllAsRead', ()=>{
+        it('returns the count of notifications marked as read', async ()=>{
+            mockService.markAllAsRead.mockResolvedValue(3);
+            const result = await controller.markAllAsRead(buildMockUser());
+            expect(result.success).toBe(true);
+            expect(result.messageKey).toBe(NOTIFICATION_MESSAGES.MARK_ALL_READ_SUCCESS);
+            expect(result.messageVariables).toEqual({
+                count: 3
+            });
+            expect(result.message).toBe('3 notifications marked as read');
+        });
+        it('handles a user with zero unread notifications gracefully', async ()=>{
+            mockService.markAllAsRead.mockResolvedValue(0);
+            const result = await controller.markAllAsRead(buildMockUser());
+            expect(result.messageVariables).toEqual({
+                count: 0
+            });
+            expect(result.message).toBe('0 notifications marked as read');
+        });
+    });
+    describe('getUnreadCount', ()=>{
+        it('returns the unread count wrapped in a single response', async ()=>{
+            mockService.getUnreadCount.mockResolvedValue(5);
+            const result = await controller.getUnreadCount(buildMockUser());
+            expect(result.success).toBe(true);
+            expect(result.messageKey).toBe(NOTIFICATION_MESSAGES.UNREAD_COUNT_SUCCESS);
+            expect(result.data).toEqual({
+                count: 5
+            });
+        });
+        it('returns zero for a user with no unread notifications', async ()=>{
+            mockService.getUnreadCount.mockResolvedValue(0);
+            const result = await controller.getUnreadCount(buildMockUser());
+            expect(result.data).toEqual({
+                count: 0
+            });
+        });
+    });
+    describe('sendNotification', ()=>{
+        it('sends a notification via the helper service and returns the mapped response', async ()=>{
+            const notification = buildNotification({
+                id: 'notif-2'
+            });
+            mockHelper.send.mockResolvedValue(notification);
+            const result = await controller.sendNotification({
+                userId: 'user-uuid-1',
+                title: 'Hello',
+                message: 'World'
+            });
+            expect(mockHelper.send).toHaveBeenCalledWith({
+                userId: 'user-uuid-1',
+                title: 'Hello',
+                message: 'World',
+                type: undefined,
+                data: undefined,
+                companyId: undefined
+            });
+            expect(result.success).toBe(true);
+            expect(result.messageKey).toBe(NOTIFICATION_MESSAGES.SEND_SUCCESS);
+            expect(result.data?.id).toBe('notif-2');
+        });
+        it('propagates errors from the helper service', async ()=>{
+            mockHelper.send.mockRejectedValue(new Error('db down'));
+            await expect(controller.sendNotification({
+                userId: 'user-1',
+                title: 'X'
+            })).rejects.toThrow('db down');
+        });
+    });
+    describe('sendBulkNotification', ()=>{
+        it('sends notifications to multiple users and returns bulk meta', async ()=>{
+            const notifications = [
+                buildNotification({
+                    id: 'n1',
+                    userId: 'user-1'
+                }),
+                buildNotification({
+                    id: 'n2',
+                    userId: 'user-2'
+                })
+            ];
+            mockHelper.sendToMany.mockResolvedValue(notifications);
+            const result = await controller.sendBulkNotification({
+                userIds: [
+                    'user-1',
+                    'user-2'
+                ],
+                title: 'Broadcast'
+            });
+            expect(mockHelper.sendToMany).toHaveBeenCalledWith({
+                userIds: [
+                    'user-1',
+                    'user-2'
+                ],
+                title: 'Broadcast',
+                message: undefined,
+                type: undefined,
+                data: undefined,
+                companyId: undefined
+            });
+            expect(result.success).toBe(true);
+            expect(result.messageKey).toBe(NOTIFICATION_MESSAGES.BROADCAST_SUCCESS);
+            expect(result.data).toHaveLength(2);
+            expect(result.meta).toEqual({
+                count: 2,
+                total: 2
+            });
+        });
+        it('reports a mismatch between requested and sent counts in the meta', async ()=>{
+            mockHelper.sendToMany.mockResolvedValue([
+                buildNotification({
+                    id: 'n1'
+                })
+            ]);
+            const result = await controller.sendBulkNotification({
+                userIds: [
+                    'user-1',
+                    'user-2',
+                    'user-3'
+                ],
+                title: 'Partial broadcast'
+            });
+            expect(result.meta).toEqual({
+                count: 1,
+                total: 3
+            });
+        });
+        it('handles an empty userIds bulk send without throwing', async ()=>{
+            mockHelper.sendToMany.mockResolvedValue([]);
+            const result = await controller.sendBulkNotification({
+                userIds: [],
+                title: 'Nobody'
+            });
+            expect(result.data).toEqual([]);
+            expect(result.meta).toEqual({
+                count: 0,
+                total: 0
+            });
+        });
+    });
+});

package/fesm/docs/notification-swagger.config.spec.js

@@ -0,0 +1,64 @@
+import { notificationSwaggerConfig } from './notification-swagger.config';
+describe('notificationSwaggerConfig', ()=>{
+    it('should default to company feature enabled and single-database mode when no config is given', ()=>{
+        const config = notificationSwaggerConfig();
+        expect(config.title).toBe('Notification API');
+        expect(config.path).toBe('api/docs/notification');
+        expect(config.bearerAuth).toBe(true);
+        expect(config.excludeSchemaProperties).toBeUndefined();
+        expect(config.description).not.toContain('Multi-Tenant Mode');
+    });
+    it('should exclude companyId schema properties across all notification DTOs when the company feature is disabled', ()=>{
+        const config = notificationSwaggerConfig({
+            enableCompanyFeature: false
+        });
+        expect(config.excludeSchemaProperties).toEqual([
+            {
+                schemaName: 'NotificationResponseDto',
+                properties: [
+                    'companyId'
+                ]
+            },
+            {
+                schemaName: 'CreateNotificationDto',
+                properties: [
+                    'companyId'
+                ]
+            },
+            {
+                schemaName: 'SendNotificationDto',
+                properties: [
+                    'companyId'
+                ]
+            },
+            {
+                schemaName: 'SendBulkNotificationDto',
+                properties: [
+                    'companyId'
+                ]
+            },
+            {
+                schemaName: 'UpdateNotificationDto',
+                properties: [
+                    'companyId'
+                ]
+            }
+        ]);
+    });
+    it('should not exclude any schema properties when the company feature is enabled', ()=>{
+        const config = notificationSwaggerConfig({
+            enableCompanyFeature: true
+        });
+        expect(config.excludeSchemaProperties).toBeUndefined();
+    });
+    it('should mention multi-tenant mode in the description only for multi-tenant database mode', ()=>{
+        const multiTenant = notificationSwaggerConfig({
+            databaseMode: 'multi-tenant'
+        });
+        const single = notificationSwaggerConfig({
+            databaseMode: 'single'
+        });
+        expect(multiTenant.description).toContain('Multi-Tenant Mode');
+        expect(single.description).not.toContain('Multi-Tenant Mode');
+    });
+});

package/fesm/entities/index.spec.js

@@ -0,0 +1,9 @@
+import { getNotificationEntitiesByConfig, NotificationCoreEntities, NotificationCompanyEntities } from './index';
+describe('getNotificationEntitiesByConfig', ()=>{
+    it('returns the core entities when the company feature is disabled', ()=>{
+        expect(getNotificationEntitiesByConfig(false)).toBe(NotificationCoreEntities);
+    });
+    it('returns the company-scoped entities when the company feature is enabled', ()=>{
+        expect(getNotificationEntitiesByConfig(true)).toBe(NotificationCompanyEntities);
+    });
+});

package/fesm/gateways/notification.gateway.spec.js

@@ -0,0 +1,355 @@
+import { NotificationGateway } from './notification.gateway';
+function createMockServer() {
+    const room = {
+        emit: jest.fn()
+    };
+    return {
+        to: jest.fn().mockReturnValue(room),
+        emit: jest.fn()
+    };
+}
+function createMockSocket(overrides = {}) {
+    return {
+        id: 'socket-id-1',
+        handshake: {
+            auth: {},
+            query: {},
+            headers: {}
+        },
+        data: {},
+        join: jest.fn(),
+        disconnect: jest.fn(),
+        ...overrides
+    };
+}
+describe('NotificationGateway', ()=>{
+    let gateway;
+    let mockConfigService;
+    let mockJwtService;
+    let mockServer;
+    beforeEach(()=>{
+        mockConfigService = {
+            getJwtSecret: jest.fn().mockReturnValue('jwt-secret')
+        };
+        mockJwtService = {
+            verify: jest.fn()
+        };
+        gateway = new NotificationGateway(mockConfigService, mockJwtService);
+        mockServer = createMockServer();
+        gateway.server = mockServer;
+    });
+    describe('afterInit', ()=>{
+        it('does not throw', ()=>{
+            expect(()=>gateway.afterInit()).not.toThrow();
+        });
+    });
+    describe('handleConnection', ()=>{
+        it('disconnects the client when no token is present anywhere', async ()=>{
+            const client = createMockSocket();
+            await gateway.handleConnection(client);
+            expect(client.disconnect).toHaveBeenCalled();
+            expect(mockJwtService.verify).not.toHaveBeenCalled();
+        });
+        it('accepts a token from handshake.auth and joins the user + company rooms', async ()=>{
+            const client = createMockSocket({
+                handshake: {
+                    auth: {
+                        token: 'auth-token'
+                    },
+                    query: {},
+                    headers: {}
+                }
+            });
+            mockJwtService.verify.mockReturnValue({
+                id: 'user-1',
+                companyId: 'company-1'
+            });
+            await gateway.handleConnection(client);
+            expect(mockJwtService.verify).toHaveBeenCalledWith('auth-token', {
+                secret: 'jwt-secret',
+                algorithms: [
+                    'HS256'
+                ]
+            });
+            expect(client.data.userId).toBe('user-1');
+            expect(client.data.companyId).toBe('company-1');
+            expect(client.join).toHaveBeenCalledWith('user:user-1');
+            expect(client.join).toHaveBeenCalledWith('company:company-1');
+            expect(client.join).toHaveBeenCalledWith('user:user-1:company:company-1');
+            expect(client.disconnect).not.toHaveBeenCalled();
+            expect(gateway.isUserOnline('user-1')).toBe(true);
+        });
+        it('accepts a token from the query string', async ()=>{
+            const client = createMockSocket({
+                handshake: {
+                    auth: {},
+                    query: {
+                        token: 'query-token'
+                    },
+                    headers: {}
+                }
+            });
+            mockJwtService.verify.mockReturnValue({
+                id: 'user-2'
+            });
+            await gateway.handleConnection(client);
+            expect(mockJwtService.verify).toHaveBeenCalledWith('query-token', expect.any(Object));
+            expect(client.join).toHaveBeenCalledWith('user:user-2');
+        });
+        it('accepts a token from the Authorization header', async ()=>{
+            const client = createMockSocket({
+                handshake: {
+                    auth: {},
+                    query: {},
+                    headers: {
+                        authorization: 'Bearer header-token'
+                    }
+                }
+            });
+            mockJwtService.verify.mockReturnValue({
+                id: 'user-3'
+            });
+            await gateway.handleConnection(client);
+            expect(mockJwtService.verify).toHaveBeenCalledWith('header-token', expect.any(Object));
+            expect(client.join).toHaveBeenCalledWith('user:user-3');
+        });
+        it('ignores a malformed Authorization header without the Bearer prefix', async ()=>{
+            const client = createMockSocket({
+                handshake: {
+                    auth: {},
+                    query: {},
+                    headers: {
+                        authorization: 'Basic abc123'
+                    }
+                }
+            });
+            await gateway.handleConnection(client);
+            expect(client.disconnect).toHaveBeenCalled();
+            expect(mockJwtService.verify).not.toHaveBeenCalled();
+        });
+        it('joins only the personal room when the token payload has no companyId', async ()=>{
+            const client = createMockSocket({
+                handshake: {
+                    auth: {
+                        token: 't'
+                    },
+                    query: {},
+                    headers: {}
+                }
+            });
+            mockJwtService.verify.mockReturnValue({
+                id: 'user-4'
+            });
+            await gateway.handleConnection(client);
+            expect(client.join).toHaveBeenCalledWith('user:user-4');
+            expect(client.join).toHaveBeenCalledTimes(1);
+        });
+        it('disconnects the client when the JWT secret is not configured', async ()=>{
+            mockConfigService.getJwtSecret.mockReturnValue(undefined);
+            const client = createMockSocket({
+                handshake: {
+                    auth: {
+                        token: 't'
+                    },
+                    query: {},
+                    headers: {}
+                }
+            });
+            await gateway.handleConnection(client);
+            expect(client.disconnect).toHaveBeenCalled();
+            expect(mockJwtService.verify).not.toHaveBeenCalled();
+        });
+        it('disconnects the client when token verification throws (invalid/expired token)', async ()=>{
+            const client = createMockSocket({
+                handshake: {
+                    auth: {
+                        token: 'bad-token'
+                    },
+                    query: {},
+                    headers: {}
+                }
+            });
+            mockJwtService.verify.mockImplementation(()=>{
+                throw new Error('jwt expired');
+            });
+            await gateway.handleConnection(client);
+            expect(client.disconnect).toHaveBeenCalled();
+            expect(gateway.isUserOnline('user-1')).toBe(false);
+        });
+        it('tracks multiple sockets for the same user', async ()=>{
+            mockJwtService.verify.mockReturnValue({
+                id: 'user-5'
+            });
+            const clientA = createMockSocket({
+                id: 'socket-a',
+                handshake: {
+                    auth: {
+                        token: 't'
+                    },
+                    query: {},
+                    headers: {}
+                }
+            });
+            const clientB = createMockSocket({
+                id: 'socket-b',
+                handshake: {
+                    auth: {
+                        token: 't'
+                    },
+                    query: {},
+                    headers: {}
+                }
+            });
+            await gateway.handleConnection(clientA);
+            await gateway.handleConnection(clientB);
+            expect(gateway.isUserOnline('user-5')).toBe(true);
+            expect(gateway.getOnlineUserCount()).toBe(1);
+        });
+        it('disconnects the client when an unexpected error occurs during connection handling', async ()=>{
+            const client = createMockSocket({
+                handshake: {
+                    auth: {
+                        token: 't'
+                    },
+                    query: {},
+                    headers: {}
+                }
+            });
+            mockJwtService.verify.mockReturnValue({
+                id: 'user-6'
+            });
+            client.join = jest.fn().mockImplementation(()=>{
+                throw new Error('join failed');
+            });
+            await gateway.handleConnection(client);
+            expect(client.disconnect).toHaveBeenCalled();
+        });
+    });
+    describe('handleDisconnect', ()=>{
+        it('removes the socket and marks the user offline when it was their only connection', async ()=>{
+            mockJwtService.verify.mockReturnValue({
+                id: 'user-1'
+            });
+            const client = createMockSocket({
+                handshake: {
+                    auth: {
+                        token: 't'
+                    },
+                    query: {},
+                    headers: {}
+                }
+            });
+            await gateway.handleConnection(client);
+            expect(gateway.isUserOnline('user-1')).toBe(true);
+            gateway.handleDisconnect(client);
+            expect(gateway.isUserOnline('user-1')).toBe(false);
+            expect(gateway.getOnlineUserCount()).toBe(0);
+        });
+        it('keeps the user online when they still have another connected socket', async ()=>{
+            mockJwtService.verify.mockReturnValue({
+                id: 'user-1'
+            });
+            const clientA = createMockSocket({
+                id: 'socket-a',
+                handshake: {
+                    auth: {
+                        token: 't'
+                    },
+                    query: {},
+                    headers: {}
+                }
+            });
+            const clientB = createMockSocket({
+                id: 'socket-b',
+                handshake: {
+                    auth: {
+                        token: 't'
+                    },
+                    query: {},
+                    headers: {}
+                }
+            });
+            await gateway.handleConnection(clientA);
+            await gateway.handleConnection(clientB);
+            gateway.handleDisconnect(clientA);
+            expect(gateway.isUserOnline('user-1')).toBe(true);
+        });
+        it('does nothing when the client never authenticated (no userId on socket data)', ()=>{
+            const client = createMockSocket();
+            expect(()=>gateway.handleDisconnect(client)).not.toThrow();
+            expect(gateway.getOnlineUserCount()).toBe(0);
+        });
+        it('is a no-op when disconnecting an unknown user id', ()=>{
+            const client = createMockSocket({
+                data: {
+                    userId: 'ghost-user'
+                }
+            });
+            expect(()=>gateway.handleDisconnect(client)).not.toThrow();
+            expect(gateway.isUserOnline('ghost-user')).toBe(false);
+        });
+    });
+    describe('emitToUser', ()=>{
+        it('emits the event to the user-scoped room', ()=>{
+            gateway.emitToUser('user-1', 'notification:new', {
+                title: 'hi'
+            });
+            expect(mockServer.to).toHaveBeenCalledWith('user:user-1');
+            expect(mockServer.to('user:user-1').emit).toHaveBeenCalledWith('notification:new', {
+                title: 'hi'
+            });
+        });
+        it('does not throw when the server has not been initialized yet', ()=>{
+            const freshGateway = new NotificationGateway(mockConfigService, mockJwtService);
+            expect(()=>freshGateway.emitToUser('user-1', 'notification:new', {})).not.toThrow();
+        });
+    });
+    describe('emitToUserInCompany', ()=>{
+        it('emits to the combined user+company room when companyId is provided', ()=>{
+            gateway.emitToUserInCompany('user-1', 'company-1', 'notification:new', {
+                a: 1
+            });
+            expect(mockServer.to).toHaveBeenCalledWith('user:user-1:company:company-1');
+        });
+        it('falls back to emitToUser when companyId is null', ()=>{
+            gateway.emitToUserInCompany('user-1', null, 'notification:new', {
+                a: 1
+            });
+            expect(mockServer.to).toHaveBeenCalledWith('user:user-1');
+        });
+        it('falls back to emitToUser when companyId is undefined', ()=>{
+            gateway.emitToUserInCompany('user-1', undefined, 'notification:new', {
+                a: 1
+            });
+            expect(mockServer.to).toHaveBeenCalledWith('user:user-1');
+        });
+        it('does not throw when the server has not been initialized yet', ()=>{
+            const freshGateway = new NotificationGateway(mockConfigService, mockJwtService);
+            expect(()=>freshGateway.emitToUserInCompany('user-1', 'company-1', 'notification:new', {})).not.toThrow();
+        });
+    });
+    describe('emitToCompany', ()=>{
+        it('emits the event to the company-scoped room', ()=>{
+            gateway.emitToCompany('company-1', 'notification:new', {
+                b: 2
+            });
+            expect(mockServer.to).toHaveBeenCalledWith('company:company-1');
+        });
+    });
+    describe('broadcast', ()=>{
+        it('emits the event to all connected sockets', ()=>{
+            gateway.broadcast('server:announcement', {
+                text: 'hi all'
+            });
+            expect(mockServer.emit).toHaveBeenCalledWith('server:announcement', {
+                text: 'hi all'
+            });
+        });
+    });
+    describe('isUserOnline / getOnlineUserCount', ()=>{
+        it('reports zero online users when nobody has connected', ()=>{
+            expect(gateway.isUserOnline('nobody')).toBe(false);
+            expect(gateway.getOnlineUserCount()).toBe(0);
+        });
+    });
+});