@flusys/nestjs-notification 7.1.0 → 8.0.0

package/fesm/config/message-keys.js

@@ -1,9 +0,0 @@
-// ==================== NOTIFICATION MODULE MESSAGE KEYS ====================
-export const NOTIFICATION_MESSAGES = {
-    NOT_FOUND: 'notification.not.found',
-    MARK_READ_SUCCESS: 'notification.mark.read.success',
-    MARK_ALL_READ_SUCCESS: 'notification.mark.all.read.success',
-    UNREAD_COUNT_SUCCESS: 'notification.unread.count.success',
-    SEND_SUCCESS: 'notification.send.success',
-    BROADCAST_SUCCESS: 'notification.broadcast.success'
-};

package/fesm/config/notification.constants.js

@@ -1 +0,0 @@
-export const NOTIFICATION_MODULE_OPTIONS = 'NOTIFICATION_MODULE_OPTIONS';

package/fesm/controllers/notification.controller.js

@@ -1,289 +0,0 @@
-function _define_property(obj, key, value) {
-    if (key in obj) {
-        Object.defineProperty(obj, key, {
-            value: value,
-            enumerable: true,
-            configurable: true,
-            writable: true
-        });
-    } else {
-        obj[key] = value;
-    }
-    return obj;
-}
-function _ts_decorate(decorators, target, key, desc) {
-    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
-    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.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;
-}
-function _ts_metadata(k, v) {
-    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
-}
-function _ts_param(paramIndex, decorator) {
-    return function(target, key) {
-        decorator(target, key, paramIndex);
-    };
-}
-import { createApiController, NOTIFICATION_PERMISSIONS } from '@flusys/nestjs-shared/classes';
-import { CurrentUser, RequirePermission } from '@flusys/nestjs-shared/decorators';
-import { BulkResponseDto, MessageResponseDto, SingleResponseDto } from '@flusys/nestjs-shared/dtos';
-import { JwtAuthGuard, PermissionGuard } from '@flusys/nestjs-shared/guards';
-import { ILoggedUserInfo } from '@flusys/nestjs-shared/interfaces';
-import { Body, Controller, HttpCode, HttpStatus, Inject, Post, UseGuards } from '@nestjs/common';
-import { ApiBearerAuth, ApiBody, ApiOperation, ApiResponse, ApiTags } from '@nestjs/swagger';
-import { plainToInstance } from 'class-transformer';
-import { NOTIFICATION_MESSAGES } from '../config';
-import { CreateNotificationDto, MarkReadDto, NotificationResponseDto, SendBulkNotificationDto, SendNotificationDto, UpdateNotificationDto } from '../dtos';
-import { NotificationHelperService } from '../services/notification-helper.service';
-import { NotificationService } from '../services/notification.service';
-export class NotificationController extends createApiController(CreateNotificationDto, UpdateNotificationDto, NotificationResponseDto, {
-    entityName: 'notification',
-    security: {
-        insert: {
-            level: 'permission',
-            permissions: [
-                NOTIFICATION_PERMISSIONS.CREATE
-            ]
-        },
-        insertMany: {
-            level: 'permission',
-            permissions: [
-                NOTIFICATION_PERMISSIONS.CREATE
-            ]
-        },
-        getById: {
-            level: 'permission',
-            permissions: [
-                NOTIFICATION_PERMISSIONS.READ
-            ]
-        },
-        getAll: {
-            level: 'jwt'
-        },
-        update: {
-            level: 'permission',
-            permissions: [
-                NOTIFICATION_PERMISSIONS.UPDATE
-            ]
-        },
-        updateMany: {
-            level: 'permission',
-            permissions: [
-                NOTIFICATION_PERMISSIONS.UPDATE
-            ]
-        },
-        delete: {
-            level: 'permission',
-            permissions: [
-                NOTIFICATION_PERMISSIONS.DELETE
-            ]
-        }
-    }
-}) {
-    async markAsRead(dto, user) {
-        const notification = await this.service.markAsRead(dto.id, user);
-        const plainOptions = {
-            excludeExtraneousValues: true
-        };
-        return {
-            success: true,
-            message: 'Notification marked as read',
-            messageKey: NOTIFICATION_MESSAGES.MARK_READ_SUCCESS,
-            data: plainToInstance(NotificationResponseDto, notification, plainOptions)
-        };
-    }
-    async markAllAsRead(user) {
-        const count = await this.service.markAllAsRead(user);
-        return {
-            success: true,
-            message: `${count} notifications marked as read`,
-            messageKey: NOTIFICATION_MESSAGES.MARK_ALL_READ_SUCCESS,
-            messageVariables: {
-                count
-            }
-        };
-    }
-    async getUnreadCount(user) {
-        const count = await this.service.getUnreadCount(user);
-        return {
-            success: true,
-            message: 'Unread count retrieved',
-            messageKey: NOTIFICATION_MESSAGES.UNREAD_COUNT_SUCCESS,
-            data: {
-                count
-            }
-        };
-    }
-    async sendNotification(dto) {
-        const notification = await this.notificationHelper.send({
-            userId: dto.userId,
-            title: dto.title,
-            message: dto.message,
-            type: dto.type,
-            data: dto.data,
-            companyId: dto.companyId
-        });
-        const plainOptions = {
-            excludeExtraneousValues: true
-        };
-        return {
-            success: true,
-            message: 'Notification sent successfully',
-            messageKey: NOTIFICATION_MESSAGES.SEND_SUCCESS,
-            data: plainToInstance(NotificationResponseDto, notification, plainOptions)
-        };
-    }
-    async sendBulkNotification(dto) {
-        const notifications = await this.notificationHelper.sendToMany({
-            userIds: dto.userIds,
-            title: dto.title,
-            message: dto.message,
-            type: dto.type,
-            data: dto.data,
-            companyId: dto.companyId
-        });
-        const plainOptions = {
-            excludeExtraneousValues: true
-        };
-        return {
-            success: true,
-            message: `${notifications.length} notifications sent successfully`,
-            messageKey: NOTIFICATION_MESSAGES.BROADCAST_SUCCESS,
-            messageVariables: {
-                count: notifications.length
-            },
-            data: notifications.map((n)=>plainToInstance(NotificationResponseDto, n, plainOptions)),
-            meta: {
-                count: notifications.length,
-                total: dto.userIds.length
-            }
-        };
-    }
-    constructor(service, notificationHelper){
-        super(service), _define_property(this, "service", void 0), _define_property(this, "notificationHelper", void 0), this.service = service, this.notificationHelper = notificationHelper;
-    }
-}
-_ts_decorate([
-    Post('mark-read'),
-    HttpCode(HttpStatus.OK),
-    UseGuards(JwtAuthGuard),
-    ApiBearerAuth(),
-    ApiOperation({
-        summary: 'Mark a notification as read'
-    }),
-    ApiBody({
-        type: MarkReadDto
-    }),
-    ApiResponse({
-        status: 200,
-        description: 'Notification marked as read',
-        type: SingleResponseDto
-    }),
-    _ts_param(0, Body()),
-    _ts_param(1, CurrentUser()),
-    _ts_metadata("design:type", Function),
-    _ts_metadata("design:paramtypes", [
-        typeof MarkReadDto === "undefined" ? Object : MarkReadDto,
-        typeof ILoggedUserInfo === "undefined" ? Object : ILoggedUserInfo
-    ]),
-    _ts_metadata("design:returntype", Promise)
-], NotificationController.prototype, "markAsRead", null);
-_ts_decorate([
-    Post('mark-all-read'),
-    HttpCode(HttpStatus.OK),
-    UseGuards(JwtAuthGuard),
-    ApiBearerAuth(),
-    ApiOperation({
-        summary: 'Mark all notifications as read'
-    }),
-    ApiResponse({
-        status: 200,
-        description: 'All notifications marked as read',
-        type: MessageResponseDto
-    }),
-    _ts_param(0, CurrentUser()),
-    _ts_metadata("design:type", Function),
-    _ts_metadata("design:paramtypes", [
-        typeof ILoggedUserInfo === "undefined" ? Object : ILoggedUserInfo
-    ]),
-    _ts_metadata("design:returntype", Promise)
-], NotificationController.prototype, "markAllAsRead", null);
-_ts_decorate([
-    Post('unread-count'),
-    HttpCode(HttpStatus.OK),
-    UseGuards(JwtAuthGuard),
-    ApiBearerAuth(),
-    ApiOperation({
-        summary: 'Get unread notification count'
-    }),
-    ApiResponse({
-        status: 200,
-        description: 'Unread count retrieved',
-        type: SingleResponseDto
-    }),
-    _ts_param(0, CurrentUser()),
-    _ts_metadata("design:type", Function),
-    _ts_metadata("design:paramtypes", [
-        typeof ILoggedUserInfo === "undefined" ? Object : ILoggedUserInfo
-    ]),
-    _ts_metadata("design:returntype", Promise)
-], NotificationController.prototype, "getUnreadCount", null);
-_ts_decorate([
-    Post('send'),
-    HttpCode(HttpStatus.OK),
-    UseGuards(JwtAuthGuard, PermissionGuard),
-    RequirePermission(NOTIFICATION_PERMISSIONS.CREATE),
-    ApiOperation({
-        summary: 'Send a notification to a user'
-    }),
-    ApiBody({
-        type: SendNotificationDto
-    }),
-    ApiResponse({
-        status: 200,
-        description: 'Notification sent successfully',
-        type: SingleResponseDto
-    }),
-    _ts_param(0, Body()),
-    _ts_metadata("design:type", Function),
-    _ts_metadata("design:paramtypes", [
-        typeof SendNotificationDto === "undefined" ? Object : SendNotificationDto
-    ]),
-    _ts_metadata("design:returntype", Promise)
-], NotificationController.prototype, "sendNotification", null);
-_ts_decorate([
-    Post('send-bulk'),
-    HttpCode(HttpStatus.OK),
-    UseGuards(JwtAuthGuard, PermissionGuard),
-    RequirePermission(NOTIFICATION_PERMISSIONS.CREATE),
-    ApiOperation({
-        summary: 'Send a notification to multiple users'
-    }),
-    ApiBody({
-        type: SendBulkNotificationDto
-    }),
-    ApiResponse({
-        status: 200,
-        description: 'Notifications sent successfully',
-        type: BulkResponseDto
-    }),
-    _ts_param(0, Body()),
-    _ts_metadata("design:type", Function),
-    _ts_metadata("design:paramtypes", [
-        typeof SendBulkNotificationDto === "undefined" ? Object : SendBulkNotificationDto
-    ]),
-    _ts_metadata("design:returntype", Promise)
-], NotificationController.prototype, "sendBulkNotification", null);
-NotificationController = _ts_decorate([
-    ApiTags('Notifications'),
-    ApiBearerAuth(),
-    Controller('notification'),
-    _ts_param(0, Inject(NotificationService)),
-    _ts_param(1, Inject(NotificationHelperService)),
-    _ts_metadata("design:type", Function),
-    _ts_metadata("design:paramtypes", [
-        typeof NotificationService === "undefined" ? Object : NotificationService,
-        typeof NotificationHelperService === "undefined" ? Object : NotificationHelperService
-    ])
-], NotificationController);

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

@@ -1,210 +0,0 @@
-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.js

@@ -1,87 +0,0 @@
-/** Schema properties to exclude when company feature is disabled */ const COMPANY_SCHEMA_EXCLUSIONS = [
-    {
-        schemaName: 'NotificationResponseDto',
-        properties: [
-            'companyId'
-        ]
-    },
-    {
-        schemaName: 'CreateNotificationDto',
-        properties: [
-            'companyId'
-        ]
-    },
-    {
-        schemaName: 'SendNotificationDto',
-        properties: [
-            'companyId'
-        ]
-    },
-    {
-        schemaName: 'SendBulkNotificationDto',
-        properties: [
-            'companyId'
-        ]
-    },
-    {
-        schemaName: 'UpdateNotificationDto',
-        properties: [
-            'companyId'
-        ]
-    }
-];
-export function notificationSwaggerConfig(bootstrapConfig) {
-    const enableCompanyFeature = bootstrapConfig?.enableCompanyFeature ?? true;
-    const isMultiTenant = bootstrapConfig?.databaseMode === 'multi-tenant';
-    const multiTenantNote = isMultiTenant ? `\n> **Multi-Tenant Mode**: Include \`x-tenant-id\` header to target a specific tenant database.\n` : '';
-    return {
-        title: 'Notification API',
-        description: `
-## Notification API
-${multiTenantNote}
-Real-time notification system with WebSocket support.
-
-### Features
-- Push notifications to users
-- Mark notifications as read
-- Unread count tracking
-- Real-time delivery via WebSocket
-- Bulk notification sending
-
-### Endpoints
-
-#### User Notifications
-- \`POST /notification/get-all\` - Get user's notifications (paginated, sorted by newest)
-- \`POST /notification/get/:id\` - Get single notification
-- \`POST /notification/mark-read\` - Mark notification as read
-- \`POST /notification/mark-all-read\` - Mark all notifications as read
-- \`POST /notification/unread-count\` - Get unread notification count
-
-#### Admin/System
-- \`POST /notification/send\` - Send notification to a user
-- \`POST /notification/send-bulk\` - Send notification to multiple users
-
-### WebSocket Events
-
-Connect to WebSocket with JWT authentication:
-\`\`\`
-ws://localhost:2002/notification?token=<jwt>
-\`\`\`
-
-**Events:**
-- \`notification:new\` - New notification received
-- \`notification:read\` - Notification marked as read
-- \`notification:read-all\` - All notifications marked as read
-
-### Notification Types
-- \`info\` - General information
-- \`success\` - Success message
-- \`warning\` - Warning message
-- \`error\` - Error message
-    `,
-        version: '1.0',
-        path: 'api/docs/notification',
-        bearerAuth: true,
-        excludeSchemaProperties: enableCompanyFeature ? undefined : COMPANY_SCHEMA_EXCLUSIONS
-    };
-}

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

@@ -1,64 +0,0 @@
-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');
-    });
-});