@flusys/nestjs-notification 6.0.2 → 6.1.1

package/cjs/adapters/notification.adapter.spec.js

@@ -0,0 +1,73 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+const _notificationadapter = require("./notification.adapter");
+describe('NotificationAdapter', ()=>{
+    let adapter;
+    let mockHelper;
+    beforeEach(()=>{
+        mockHelper = {
+            send: jest.fn(),
+            sendToMany: jest.fn(),
+            isUserOnline: jest.fn()
+        };
+        adapter = new _notificationadapter.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);
+        });
+    });
+});

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

@@ -0,0 +1,214 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+const _enums = require("@flusys/nestjs-shared/enums");
+const _loggedusermock = require("@test-utils/mocks/logged-user.mock");
+const _notificationcontroller = require("./notification.controller");
+const _config = require("../config");
+function buildNotification(overrides = {}) {
+    return {
+        id: 'notif-1',
+        userId: 'user-uuid-1',
+        type: _enums.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.NotificationController(mockService, mockHelper);
+    });
+    describe('markAsRead', ()=>{
+        it('marks the notification as read and returns the mapped response', async ()=>{
+            const user = (0, _loggedusermock.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(_config.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(_config.NOTIFICATION_MESSAGES.NOT_FOUND));
+            await expect(controller.markAsRead({
+                id: 'missing'
+            }, (0, _loggedusermock.buildMockUser)())).rejects.toThrow();
+        });
+    });
+    describe('markAllAsRead', ()=>{
+        it('returns the count of notifications marked as read', async ()=>{
+            mockService.markAllAsRead.mockResolvedValue(3);
+            const result = await controller.markAllAsRead((0, _loggedusermock.buildMockUser)());
+            expect(result.success).toBe(true);
+            expect(result.messageKey).toBe(_config.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((0, _loggedusermock.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((0, _loggedusermock.buildMockUser)());
+            expect(result.success).toBe(true);
+            expect(result.messageKey).toBe(_config.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((0, _loggedusermock.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(_config.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(_config.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/cjs/docs/notification-swagger.config.spec.js

@@ -0,0 +1,68 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+const _notificationswaggerconfig = require("./notification-swagger.config");
+describe('notificationSwaggerConfig', ()=>{
+    it('should default to company feature enabled and single-database mode when no config is given', ()=>{
+        const config = (0, _notificationswaggerconfig.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 = (0, _notificationswaggerconfig.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 = (0, _notificationswaggerconfig.notificationSwaggerConfig)({
+            enableCompanyFeature: true
+        });
+        expect(config.excludeSchemaProperties).toBeUndefined();
+    });
+    it('should mention multi-tenant mode in the description only for multi-tenant database mode', ()=>{
+        const multiTenant = (0, _notificationswaggerconfig.notificationSwaggerConfig)({
+            databaseMode: 'multi-tenant'
+        });
+        const single = (0, _notificationswaggerconfig.notificationSwaggerConfig)({
+            databaseMode: 'single'
+        });
+        expect(multiTenant.description).toContain('Multi-Tenant Mode');
+        expect(single.description).not.toContain('Multi-Tenant Mode');
+    });
+});

package/cjs/entities/index.spec.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+const _index = require("./index");
+describe('getNotificationEntitiesByConfig', ()=>{
+    it('returns the core entities when the company feature is disabled', ()=>{
+        expect((0, _index.getNotificationEntitiesByConfig)(false)).toBe(_index.NotificationCoreEntities);
+    });
+    it('returns the company-scoped entities when the company feature is enabled', ()=>{
+        expect((0, _index.getNotificationEntitiesByConfig)(true)).toBe(_index.NotificationCompanyEntities);
+    });
+});