@flusys/nestjs-notification 7.1.0 → 8.0.0

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

@@ -1,388 +0,0 @@
-import { Test } from '@nestjs/testing';
-import { EventBusRegistry } from '@flusys/nestjs-shared/classes';
-import { UtilsService } from '@flusys/nestjs-shared/modules';
-import { NotificationType } from '@flusys/nestjs-shared/enums';
-import { NotificationHelperService } from './notification-helper.service';
-import { NotificationConfigService } from './notification-config.service';
-import { NotificationDataSourceProvider } from './notification-datasource.provider';
-import { NotificationGateway } from '../gateways';
-import { Notification, NotificationWithCompany } from '../entities';
-function createMockRepo() {
-    return {
-        save: jest.fn()
-    };
-}
-function createMockDataSource(repo) {
-    return {
-        getRepository: jest.fn().mockReturnValue(repo)
-    };
-}
-describe('NotificationHelperService', ()=>{
-    let mockCacheManager;
-    let mockUtilsService;
-    let mockConfigService;
-    let mockDataSourceProvider;
-    let mockGateway;
-    let mockRepo;
-    let mockDataSource;
-    async function buildService(withGateway = true) {
-        const providers = [
-            NotificationHelperService,
-            {
-                provide: 'CACHE_INSTANCE',
-                useValue: mockCacheManager
-            },
-            {
-                provide: UtilsService,
-                useValue: mockUtilsService
-            },
-            {
-                provide: NotificationConfigService,
-                useValue: mockConfigService
-            },
-            {
-                provide: NotificationDataSourceProvider,
-                useValue: mockDataSourceProvider
-            }
-        ];
-        if (withGateway) {
-            providers.push({
-                provide: NotificationGateway,
-                useValue: mockGateway
-            });
-        }
-        const module = await Test.createTestingModule({
-            providers
-        }).compile();
-        return module.get(NotificationHelperService);
-    }
-    beforeEach(()=>{
-        mockRepo = createMockRepo();
-        mockDataSource = createMockDataSource(mockRepo);
-        mockCacheManager = {};
-        mockUtilsService = {
-            clearCache: jest.fn().mockResolvedValue(undefined)
-        };
-        mockConfigService = {
-            isCompanyFeatureEnabled: jest.fn().mockReturnValue(false)
-        };
-        mockDataSourceProvider = {
-            getDataSource: jest.fn().mockResolvedValue(mockDataSource)
-        };
-        mockGateway = {
-            emitToUser: jest.fn(),
-            emitToUserInCompany: jest.fn(),
-            isUserOnline: jest.fn(),
-            getOnlineUserCount: jest.fn()
-        };
-    });
-    describe('send', ()=>{
-        it('saves the notification, clears the cache, and emits to the user in real time', async ()=>{
-            const service = await buildService();
-            const options = {
-                userId: 'user-1',
-                title: 'Hi',
-                message: 'body',
-                type: NotificationType.SUCCESS,
-                data: {
-                    a: 1
-                }
-            };
-            const saved = {
-                id: 'notif-1',
-                ...options,
-                isRead: false
-            };
-            mockRepo.save.mockResolvedValue(saved);
-            const result = await service.send(options);
-            expect(mockDataSource.getRepository).toHaveBeenCalledWith(Notification);
-            expect(mockRepo.save).toHaveBeenCalledWith(expect.objectContaining({
-                userId: 'user-1',
-                title: 'Hi',
-                isRead: false
-            }));
-            expect(mockUtilsService.clearCache).toHaveBeenCalledWith('notification', mockCacheManager);
-            expect(mockGateway.emitToUser).toHaveBeenCalledWith('user-1', 'notification:new', expect.objectContaining({
-                id: 'notif-1',
-                title: 'Hi'
-            }));
-            expect(result).toBe(saved);
-        });
-        it('defaults type to INFO and message/data to null when omitted', async ()=>{
-            const service = await buildService();
-            mockRepo.save.mockImplementation(async (entity)=>({
-                    id: 'notif-2',
-                    ...entity
-                }));
-            await service.send({
-                userId: 'user-1',
-                title: 'Only title'
-            });
-            expect(mockRepo.save).toHaveBeenCalledWith(expect.objectContaining({
-                type: NotificationType.INFO,
-                message: null,
-                data: null
-            }));
-        });
-        it('does not emit in real time when realtime is explicitly false', async ()=>{
-            const service = await buildService();
-            mockRepo.save.mockResolvedValue({
-                id: 'notif-3',
-                userId: 'user-1',
-                title: 'Silent'
-            });
-            await service.send({
-                userId: 'user-1',
-                title: 'Silent',
-                realtime: false
-            });
-            expect(mockGateway.emitToUser).not.toHaveBeenCalled();
-            expect(mockGateway.emitToUserInCompany).not.toHaveBeenCalled();
-        });
-        it('does not throw when no gateway is bound (gateway not registered)', async ()=>{
-            const service = await buildService(false);
-            mockRepo.save.mockResolvedValue({
-                id: 'notif-4',
-                userId: 'user-1',
-                title: 'No gateway'
-            });
-            await expect(service.send({
-                userId: 'user-1',
-                title: 'No gateway'
-            })).resolves.toBeDefined();
-        });
-        it('uses NotificationWithCompany and includes companyId when the company feature is enabled', async ()=>{
-            mockConfigService.isCompanyFeatureEnabled.mockReturnValue(true);
-            const service = await buildService();
-            mockRepo.save.mockImplementation(async (entity)=>({
-                    id: 'notif-5',
-                    ...entity
-                }));
-            await service.send({
-                userId: 'user-1',
-                title: 'Scoped',
-                companyId: 'company-1'
-            });
-            expect(mockDataSource.getRepository).toHaveBeenCalledWith(NotificationWithCompany);
-            expect(mockRepo.save).toHaveBeenCalledWith(expect.objectContaining({
-                companyId: 'company-1'
-            }));
-            expect(mockGateway.emitToUserInCompany).toHaveBeenCalledWith('user-1', 'company-1', 'notification:new', expect.any(Object));
-        });
-        it('omits companyId when the company feature is enabled but none was provided', async ()=>{
-            mockConfigService.isCompanyFeatureEnabled.mockReturnValue(true);
-            const service = await buildService();
-            mockRepo.save.mockImplementation(async (entity)=>({
-                    id: 'notif-6',
-                    ...entity
-                }));
-            await service.send({
-                userId: 'user-1',
-                title: 'No company'
-            });
-            const savedArg = mockRepo.save.mock.calls[0][0];
-            expect(savedArg.companyId).toBeUndefined();
-        });
-        it('reuses the same cached data source across multiple calls', async ()=>{
-            const service = await buildService();
-            mockRepo.save.mockResolvedValue({
-                id: 'notif-7',
-                userId: 'user-1',
-                title: 'A'
-            });
-            await service.send({
-                userId: 'user-1',
-                title: 'A'
-            });
-            await service.send({
-                userId: 'user-1',
-                title: 'B'
-            });
-            expect(mockDataSourceProvider.getDataSource).toHaveBeenCalledTimes(1);
-        });
-    });
-    describe('sendToMany', ()=>{
-        it('saves a notification for every user id and clears the cache once', async ()=>{
-            const service = await buildService();
-            const options = {
-                userIds: [
-                    'user-1',
-                    'user-2',
-                    'user-3'
-                ],
-                title: 'Broadcast'
-            };
-            mockRepo.save.mockImplementation(async (entities)=>entities.map((e, i)=>({
-                        id: `notif-${i}`,
-                        ...e
-                    })));
-            const result = await service.sendToMany(options);
-            expect(mockRepo.save).toHaveBeenCalledWith([
-                expect.objectContaining({
-                    userId: 'user-1'
-                }),
-                expect.objectContaining({
-                    userId: 'user-2'
-                }),
-                expect.objectContaining({
-                    userId: 'user-3'
-                })
-            ]);
-            expect(mockUtilsService.clearCache).toHaveBeenCalledTimes(1);
-            expect(result).toHaveLength(3);
-        });
-        it('handles an empty userIds array without saving or emitting', async ()=>{
-            const service = await buildService();
-            mockRepo.save.mockResolvedValue([]);
-            const result = await service.sendToMany({
-                userIds: [],
-                title: 'Nobody'
-            });
-            expect(mockRepo.save).toHaveBeenCalledWith([]);
-            expect(result).toEqual([]);
-        });
-        it('emits to each user asynchronously (after the microtask queue flushes) when realtime', async ()=>{
-            const service = await buildService();
-            mockRepo.save.mockImplementation(async (entities)=>entities.map((e, i)=>({
-                        id: `notif-${i}`,
-                        ...e
-                    })));
-            await service.sendToMany({
-                userIds: [
-                    'user-1',
-                    'user-2'
-                ],
-                title: 'Broadcast'
-            });
-            expect(mockGateway.emitToUser).not.toHaveBeenCalled();
-            await new Promise((resolve)=>setImmediate(resolve));
-            expect(mockGateway.emitToUser).toHaveBeenCalledTimes(2);
-            expect(mockGateway.emitToUser).toHaveBeenCalledWith('user-1', 'notification:new', expect.any(Object));
-            expect(mockGateway.emitToUser).toHaveBeenCalledWith('user-2', 'notification:new', expect.any(Object));
-        });
-        it('does not schedule emits when realtime is false', async ()=>{
-            const service = await buildService();
-            mockRepo.save.mockImplementation(async (entities)=>entities.map((e, i)=>({
-                        id: `notif-${i}`,
-                        ...e
-                    })));
-            await service.sendToMany({
-                userIds: [
-                    'user-1'
-                ],
-                title: 'Silent',
-                realtime: false
-            });
-            await new Promise((resolve)=>setImmediate(resolve));
-            expect(mockGateway.emitToUser).not.toHaveBeenCalled();
-        });
-    });
-    describe('isUserOnline', ()=>{
-        it('delegates to the gateway when present', async ()=>{
-            const service = await buildService();
-            mockGateway.isUserOnline.mockReturnValue(true);
-            expect(service.isUserOnline('user-1')).toBe(true);
-            expect(mockGateway.isUserOnline).toHaveBeenCalledWith('user-1');
-        });
-        it('returns false when no gateway is bound', async ()=>{
-            const service = await buildService(false);
-            expect(service.isUserOnline('user-1')).toBe(false);
-        });
-    });
-    describe('getOnlineUserCount', ()=>{
-        it('delegates to the gateway when present', async ()=>{
-            const service = await buildService();
-            mockGateway.getOnlineUserCount.mockReturnValue(5);
-            expect(service.getOnlineUserCount()).toBe(5);
-        });
-        it('returns 0 when no gateway is bound', async ()=>{
-            const service = await buildService(false);
-            expect(service.getOnlineUserCount()).toBe(0);
-        });
-    });
-    describe('domain events', ()=>{
-        let publish;
-        beforeEach(()=>{
-            publish = jest.fn().mockResolvedValue(undefined);
-            EventBusRegistry.reset();
-            EventBusRegistry.setBus({
-                publish,
-                subscribe: jest.fn(),
-                close: jest.fn()
-            });
-            EventBusRegistry.configureModule('notification', {
-                enabled: true
-            });
-        });
-        afterEach(()=>{
-            EventBusRegistry.reset();
-        });
-        it('publishes notification.notification.sent for a single send', async ()=>{
-            const service = await buildService();
-            mockRepo.save.mockResolvedValue({
-                id: 'notif-1',
-                userId: 'user-1'
-            });
-            await service.send({
-                userId: 'user-1',
-                title: 'Hi'
-            });
-            expect(publish).toHaveBeenCalledWith(expect.objectContaining({
-                name: 'notification.notification.sent',
-                payload: expect.objectContaining({
-                    ids: [
-                        'notif-1'
-                    ],
-                    metadata: expect.objectContaining({
-                        recipientCount: 1
-                    })
-                })
-            }));
-        });
-        it('reports the recipient count for a bulk send', async ()=>{
-            const service = await buildService();
-            mockRepo.save.mockResolvedValue([
-                {
-                    id: 'notif-1',
-                    userId: 'user-1'
-                },
-                {
-                    id: 'notif-2',
-                    userId: 'user-2'
-                }
-            ]);
-            await service.sendToMany({
-                userIds: [
-                    'user-1',
-                    'user-2'
-                ],
-                title: 'Hi',
-                realtime: false
-            });
-            expect(publish.mock.calls[0][0].payload).toEqual(expect.objectContaining({
-                ids: [
-                    'notif-1',
-                    'notif-2'
-                ],
-                metadata: expect.objectContaining({
-                    recipientCount: 2
-                })
-            }));
-        });
-        it('does not publish when the notification module has events disabled', async ()=>{
-            EventBusRegistry.configureModule('notification', {
-                enabled: false
-            });
-            const service = await buildService();
-            mockRepo.save.mockResolvedValue({
-                id: 'notif-1',
-                userId: 'user-1'
-            });
-            await service.send({
-                userId: 'user-1',
-                title: 'Hi'
-            });
-            expect(publish).not.toHaveBeenCalled();
-        });
-    });
-});

package/fesm/services/notification.service.js

@@ -1,271 +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 { LogAction } from '@flusys/nestjs-shared';
-import { ApiService, HybridCache } from '@flusys/nestjs-shared/classes';
-import { ILoggedUserInfo } from '@flusys/nestjs-shared/interfaces';
-import { UtilsService } from '@flusys/nestjs-shared/modules';
-import { applyCompanyFilter } from '@flusys/nestjs-shared/utils';
-import { Inject, Injectable, NotFoundException, Optional, Scope } from '@nestjs/common';
-import { NOTIFICATION_EVENT_ACTIONS, NOTIFICATION_EVENT_ENTITIES, NOTIFICATION_EVENT_MODULE, NOTIFICATION_MESSAGES } from '../config';
-import { Notification, NotificationWithCompany } from '../entities';
-import { NotificationGateway } from '../gateways';
-import { NotificationConfigService } from './notification-config.service';
-import { NotificationDataSourceProvider } from './notification-datasource.provider';
-export class NotificationService extends ApiService {
-    async convertSingleDtoToEntity(dto, user) {
-        let entity = {};
-        if ('id' in dto && dto.id) {
-            const existing = await this.repository.findOne({
-                where: {
-                    id: dto.id
-                }
-            });
-            if (!existing) {
-                throw new NotFoundException({
-                    message: 'Notification not found',
-                    messageKey: NOTIFICATION_MESSAGES.NOT_FOUND
-                });
-            }
-            entity = existing;
-        }
-        const merged = {
-            ...entity,
-            userId: user?.id ?? entity.userId,
-            type: dto.type ?? entity.type ?? 'info',
-            title: dto.title ?? entity.title,
-            message: dto.message ?? entity.message,
-            data: dto.data ?? entity.data,
-            isRead: entity.isRead ?? false,
-            readAt: entity.readAt
-        };
-        if (this.notificationConfig.isCompanyFeatureEnabled()) {
-            merged.companyId = dto.companyId ?? user?.companyId ?? entity.companyId ?? null;
-        }
-        return merged;
-    }
-    async getSelectQuery(query, _user, select) {
-        const fields = select && select.length ? select : [];
-        const always = [
-            'createdAt',
-            'updatedAt'
-        ];
-        const merged = [
-            ...new Set([
-                ...fields,
-                ...always
-            ])
-        ];
-        query.addSelect(merged.map((f)=>`${this.entityName}.${f}`));
-        return {
-            query,
-            isRaw: false
-        };
-    }
-    async getFilterQuery(query, filter, _user) {
-        for (const [key, value] of Object.entries(filter)){
-            if (key === 'isRead' && typeof value === 'boolean') {
-                query.andWhere(`${this.entityName}.isRead = :isRead`, {
-                    isRead: value
-                });
-            } else if (key === 'type' && value) {
-                query.andWhere(`${this.entityName}.type = :type`, {
-                    type: value
-                });
-            } else if (key === 'userId' && value) {
-                query.andWhere(`${this.entityName}.userId = :userId`, {
-                    userId: value
-                });
-            }
-        }
-        return {
-            query,
-            isRaw: false
-        };
-    }
-    async getExtraManipulateQuery(query, filterDto, user) {
-        const result = await super.getExtraManipulateQuery(query, filterDto, user);
-        if (user?.id) {
-            query.andWhere(`${this.entityName}.userId = :currentUserId`, {
-                currentUserId: user.id
-            });
-        }
-        applyCompanyFilter(query, {
-            isCompanyFeatureEnabled: this.notificationConfig.isCompanyFeatureEnabled(),
-            entityAlias: this.entityName
-        }, user);
-        const filterSort = filterDto?.sort;
-        if (!filterSort || Object.keys(filterSort).length === 0) {
-            query.orderBy(`${this.entityName}.createdAt`, 'DESC');
-        }
-        return result;
-    }
-    async afterInsertOperation(entities, _dto, _user, _qr) {
-        for (const entity of entities){
-            const ext = entity;
-            this.emitToUser(entity.userId, ext.companyId, 'notification:new', this.toPayload(entity));
-        }
-    }
-    async markAsRead(id, user) {
-        await this.ensureDataSourceRepository();
-        const notification = await this.repository.findOne({
-            where: {
-                id,
-                userId: user.id
-            }
-        });
-        if (!notification) {
-            throw new NotFoundException({
-                message: 'Notification not found',
-                messageKey: NOTIFICATION_MESSAGES.NOT_FOUND
-            });
-        }
-        notification.isRead = true;
-        notification.readAt = new Date();
-        await this.repository.save(notification);
-        await Promise.all([
-            this.clearCacheForAll(),
-            this.clearCacheForId([
-                notification
-            ])
-        ]);
-        // Emit to user's sockets in the same company context
-        const ext = notification;
-        this.emitToUser(user.id, ext.companyId ?? user.companyId, 'notification:read', {
-            id
-        });
-        await this.publishDomainAction(NOTIFICATION_EVENT_ACTIONS.READ, {
-            ids: [
-                notification.id
-            ],
-            user
-        });
-        return notification;
-    }
-    async markAllAsRead(user) {
-        await this.ensureDataSourceRepository();
-        const where = {
-            userId: user.id,
-            isRead: false
-        };
-        if (this.notificationConfig.isCompanyFeatureEnabled() && user.companyId) {
-            where.companyId = user.companyId;
-        }
-        const result = await this.repository.update(where, {
-            isRead: true,
-            readAt: new Date()
-        });
-        await this.clearCacheForAll();
-        // Emit to user's sockets in the current company context
-        this.emitToUser(user.id, user.companyId, 'notification:read-all', {});
-        await this.publishDomainAction(NOTIFICATION_EVENT_ACTIONS.ALL_READ, {
-            metadata: {
-                count: result.affected ?? 0
-            },
-            user
-        });
-        return result.affected ?? 0;
-    }
-    async getUnreadCount(user) {
-        await this.ensureDataSourceRepository();
-        const where = {
-            userId: user.id,
-            isRead: false
-        };
-        if (this.notificationConfig.isCompanyFeatureEnabled() && user.companyId) {
-            where.companyId = user.companyId;
-        }
-        return this.repository.count({
-            where
-        });
-    }
-    toPayload(entity) {
-        return {
-            id: entity.id,
-            type: entity.type,
-            title: entity.title,
-            message: entity.message,
-            data: entity.data,
-            createdAt: entity.createdAt
-        };
-    }
-    emitToUser(userId, companyId, event, payload) {
-        if (!this.gateway) {
-            return;
-        }
-        if (this.notificationConfig.isCompanyFeatureEnabled() && companyId) {
-            this.gateway.emitToUserInCompany(userId, companyId, event, payload);
-        } else {
-            this.gateway.emitToUser(userId, event, payload);
-        }
-    }
-    constructor(cacheManager, utilsService, notificationConfig, dataSourceProvider, gateway){
-        super(NOTIFICATION_EVENT_ENTITIES.NOTIFICATION, cacheManager, utilsService, NotificationService.name, false, NOTIFICATION_EVENT_MODULE, dataSourceProvider, notificationConfig.isCompanyFeatureEnabled() ? NotificationWithCompany : Notification), _define_property(this, "cacheManager", void 0), _define_property(this, "utilsService", void 0), _define_property(this, "notificationConfig", void 0), _define_property(this, "gateway", void 0), this.cacheManager = cacheManager, this.utilsService = utilsService, this.notificationConfig = notificationConfig, this.gateway = gateway;
-    }
-}
-_ts_decorate([
-    LogAction({
-        action: 'notification.markAsRead',
-        module: 'notification'
-    }),
-    _ts_metadata("design:type", Function),
-    _ts_metadata("design:paramtypes", [
-        String,
-        typeof ILoggedUserInfo === "undefined" ? Object : ILoggedUserInfo
-    ]),
-    _ts_metadata("design:returntype", Promise)
-], NotificationService.prototype, "markAsRead", null);
-_ts_decorate([
-    LogAction({
-        action: 'notification.markAllAsRead',
-        module: 'notification'
-    }),
-    _ts_metadata("design:type", Function),
-    _ts_metadata("design:paramtypes", [
-        typeof ILoggedUserInfo === "undefined" ? Object : ILoggedUserInfo
-    ]),
-    _ts_metadata("design:returntype", Promise)
-], NotificationService.prototype, "markAllAsRead", null);
-NotificationService = _ts_decorate([
-    Injectable({
-        scope: Scope.REQUEST
-    }),
-    _ts_param(0, Inject('CACHE_INSTANCE')),
-    _ts_param(1, Inject(UtilsService)),
-    _ts_param(2, Inject(NotificationConfigService)),
-    _ts_param(3, Inject(NotificationDataSourceProvider)),
-    _ts_param(4, Optional()),
-    _ts_param(4, Inject(NotificationGateway)),
-    _ts_metadata("design:type", Function),
-    _ts_metadata("design:paramtypes", [
-        typeof HybridCache === "undefined" ? Object : HybridCache,
-        typeof UtilsService === "undefined" ? Object : UtilsService,
-        typeof NotificationConfigService === "undefined" ? Object : NotificationConfigService,
-        typeof NotificationDataSourceProvider === "undefined" ? Object : NotificationDataSourceProvider,
-        typeof NotificationGateway === "undefined" ? Object : NotificationGateway
-    ])
-], NotificationService);