@flusys/nestjs-notification 6.0.2 → 6.1.1

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

@@ -0,0 +1,359 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+const _notificationgateway = require("./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.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.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.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);
+        });
+    });
+});

package/cjs/modules/notification.module.spec.js

@@ -0,0 +1,152 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+const _interfaces = require("@flusys/nestjs-shared/interfaces");
+const _notificationmodule = require("./notification.module");
+const _notificationconstants = require("../config/notification.constants");
+const _controllers = require("../controllers");
+const _gateways = require("../gateways");
+const _adapters = require("../adapters");
+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 providerTokens(providers) {
+    return providers.map((p)=>typeof p === 'function' ? p : p.provide);
+}
+describe('NotificationModule', ()=>{
+    describe('forRoot', ()=>{
+        it('should default to a non-global module with the notification controller registered', ()=>{
+            const dynamicModule = _notificationmodule.NotificationModule.forRoot({});
+            expect(dynamicModule.module).toBe(_notificationmodule.NotificationModule);
+            expect(dynamicModule.global).toBe(false);
+            expect(dynamicModule.controllers).toEqual([
+                _controllers.NotificationController
+            ]);
+        });
+        it('should respect global: true', ()=>{
+            expect(_notificationmodule.NotificationModule.forRoot({
+                global: true
+            }).global).toBe(true);
+        });
+        it('should register no controllers when includeController is false', ()=>{
+            expect(_notificationmodule.NotificationModule.forRoot({
+                includeController: false
+            }).controllers).toEqual([]);
+        });
+        it('should register the NOTIFICATION_ADAPTER provider backed by NotificationAdapter', ()=>{
+            const dynamicModule = _notificationmodule.NotificationModule.forRoot({});
+            const adapterProvider = dynamicModule.providers.find((p)=>p.provide === _interfaces.NOTIFICATION_ADAPTER);
+            expect(adapterProvider.useClass).toBe(_adapters.NotificationAdapter);
+            expect(providerTokens(dynamicModule.providers)).toContain(_gateways.NotificationGateway);
+        });
+        it('should export NotificationGateway and NOTIFICATION_ADAPTER alongside the base services', ()=>{
+            const dynamicModule = _notificationmodule.NotificationModule.forRoot({});
+            expect(dynamicModule.exports).toEqual(expect.arrayContaining([
+                _gateways.NotificationGateway,
+                _interfaces.NOTIFICATION_ADAPTER
+            ]));
+        });
+        it('should register a NOTIFICATION_MODULE_OPTIONS provider carrying the given options', ()=>{
+            const options = {
+                bootstrapAppConfig: {
+                    enableCompanyFeature: true
+                }
+            };
+            const dynamicModule = _notificationmodule.NotificationModule.forRoot(options);
+            const provider = dynamicModule.providers.find((p)=>p.provide === _notificationconstants.NOTIFICATION_MODULE_OPTIONS);
+            expect(provider.useValue).toBe(options);
+        });
+    });
+    describe('forRootAsync', ()=>{
+        it('should forward external imports alongside CacheModule/UtilsModule', ()=>{
+            let FakeImportedModule = class FakeImportedModule {
+            };
+            const dynamicModule = _notificationmodule.NotificationModule.forRootAsync({
+                imports: [
+                    FakeImportedModule
+                ]
+            });
+            expect(dynamicModule.imports).toEqual(expect.arrayContaining([
+                FakeImportedModule
+            ]));
+        });
+        it('should still wire the adapter/gateway providers when using async registration', ()=>{
+            const dynamicModule = _notificationmodule.NotificationModule.forRootAsync({
+                useFactory: jest.fn()
+            });
+            const adapterProvider = dynamicModule.providers.find((p)=>p.provide === _interfaces.NOTIFICATION_ADAPTER);
+            expect(adapterProvider.useClass).toBe(_adapters.NotificationAdapter);
+        });
+        it('useFactory: builds a NOTIFICATION_MODULE_OPTIONS provider merging resolved config', async ()=>{
+            const useFactory = jest.fn().mockResolvedValue({
+                foo: 'bar'
+            });
+            const dynamicModule = _notificationmodule.NotificationModule.forRootAsync({
+                useFactory,
+                inject: [
+                    'SOME_TOKEN'
+                ]
+            });
+            const provider = dynamicModule.providers.find((p)=>p.provide === _notificationconstants.NOTIFICATION_MODULE_OPTIONS);
+            expect(provider.inject).toEqual([
+                'SOME_TOKEN'
+            ]);
+            const resolved = await provider.useFactory('injected');
+            expect(useFactory).toHaveBeenCalledWith('injected');
+            expect(resolved.config).toEqual({
+                foo: 'bar'
+            });
+        });
+        it('useClass: registers both the class provider and an options provider calling createNotificationOptions()', async ()=>{
+            let MyOptionsFactory = class MyOptionsFactory {
+                constructor(){
+                    _define_property(this, "createNotificationOptions", jest.fn().mockResolvedValue({
+                        foo: 'from-class'
+                    }));
+                }
+            };
+            const dynamicModule = _notificationmodule.NotificationModule.forRootAsync({
+                useClass: MyOptionsFactory
+            });
+            const classProvider = dynamicModule.providers.find((p)=>p.provide === MyOptionsFactory);
+            expect(classProvider.useClass).toBe(MyOptionsFactory);
+            const optionsProvider = dynamicModule.providers.find((p)=>p.provide === _notificationconstants.NOTIFICATION_MODULE_OPTIONS);
+            const instance = new MyOptionsFactory();
+            const resolved = await optionsProvider.useFactory(instance);
+            expect(instance.createNotificationOptions).toHaveBeenCalled();
+            expect(resolved.config).toEqual({
+                foo: 'from-class'
+            });
+        });
+        it('useExisting: registers a single options provider without a duplicate class registration', ()=>{
+            let MyOptionsFactory = class MyOptionsFactory {
+                constructor(){
+                    _define_property(this, "createNotificationOptions", jest.fn());
+                }
+            };
+            const dynamicModule = _notificationmodule.NotificationModule.forRootAsync({
+                useExisting: MyOptionsFactory
+            });
+            expect(dynamicModule.providers.filter((p)=>p.provide === MyOptionsFactory)).toHaveLength(0);
+            const optionsProvider = dynamicModule.providers.find((p)=>p.provide === _notificationconstants.NOTIFICATION_MODULE_OPTIONS);
+            expect(optionsProvider.inject).toEqual([
+                MyOptionsFactory
+            ]);
+        });
+        it('should register no NOTIFICATION_MODULE_OPTIONS provider when neither useFactory, useClass, nor useExisting is given', ()=>{
+            const dynamicModule = _notificationmodule.NotificationModule.forRootAsync({});
+            expect(providerTokens(dynamicModule.providers)).not.toContain(_notificationconstants.NOTIFICATION_MODULE_OPTIONS);
+        });
+    });
+});

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

@@ -0,0 +1,113 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+const _notificationconfigservice = require("./notification-config.service");
+function buildOptions(overrides = {}) {
+    return {
+        bootstrapAppConfig: {
+            databaseMode: 'single',
+            enableCompanyFeature: false
+        },
+        config: {},
+        ...overrides
+    };
+}
+describe('NotificationConfigService', ()=>{
+    describe('isCompanyFeatureEnabled', ()=>{
+        it('returns true when bootstrapAppConfig enables the company feature', ()=>{
+            const service = new _notificationconfigservice.NotificationConfigService(buildOptions({
+                bootstrapAppConfig: {
+                    databaseMode: 'single',
+                    enableCompanyFeature: true
+                }
+            }));
+            expect(service.isCompanyFeatureEnabled()).toBe(true);
+        });
+        it('returns false when bootstrapAppConfig disables the company feature', ()=>{
+            const service = new _notificationconfigservice.NotificationConfigService(buildOptions({
+                bootstrapAppConfig: {
+                    databaseMode: 'single',
+                    enableCompanyFeature: false
+                }
+            }));
+            expect(service.isCompanyFeatureEnabled()).toBe(false);
+        });
+        it('defaults to false when bootstrapAppConfig is missing', ()=>{
+            const service = new _notificationconfigservice.NotificationConfigService(buildOptions({
+                bootstrapAppConfig: undefined
+            }));
+            expect(service.isCompanyFeatureEnabled()).toBe(false);
+        });
+    });
+    describe('getDatabaseMode', ()=>{
+        it('returns the configured database mode', ()=>{
+            const service = new _notificationconfigservice.NotificationConfigService(buildOptions({
+                bootstrapAppConfig: {
+                    databaseMode: 'multi-tenant',
+                    enableCompanyFeature: true
+                }
+            }));
+            expect(service.getDatabaseMode()).toBe('multi-tenant');
+        });
+        it('defaults to "single" when bootstrapAppConfig is missing', ()=>{
+            const service = new _notificationconfigservice.NotificationConfigService(buildOptions({
+                bootstrapAppConfig: undefined
+            }));
+            expect(service.getDatabaseMode()).toBe('single');
+        });
+    });
+    describe('isMultiTenant', ()=>{
+        it('returns true when database mode is multi-tenant', ()=>{
+            const service = new _notificationconfigservice.NotificationConfigService(buildOptions({
+                bootstrapAppConfig: {
+                    databaseMode: 'multi-tenant',
+                    enableCompanyFeature: true
+                }
+            }));
+            expect(service.isMultiTenant()).toBe(true);
+        });
+        it('returns false when database mode is single', ()=>{
+            const service = new _notificationconfigservice.NotificationConfigService(buildOptions({
+                bootstrapAppConfig: {
+                    databaseMode: 'single',
+                    enableCompanyFeature: false
+                }
+            }));
+            expect(service.isMultiTenant()).toBe(false);
+        });
+    });
+    describe('getJwtSecret', ()=>{
+        it('returns the configured jwt secret', ()=>{
+            const service = new _notificationconfigservice.NotificationConfigService(buildOptions({
+                config: {
+                    jwtSecret: 'top-secret'
+                }
+            }));
+            expect(service.getJwtSecret()).toBe('top-secret');
+        });
+        it('returns undefined when no jwt secret is configured', ()=>{
+            const service = new _notificationconfigservice.NotificationConfigService(buildOptions({
+                config: {}
+            }));
+            expect(service.getJwtSecret()).toBeUndefined();
+        });
+        it('returns undefined when config is missing entirely', ()=>{
+            const service = new _notificationconfigservice.NotificationConfigService(buildOptions({
+                config: undefined
+            }));
+            expect(service.getJwtSecret()).toBeUndefined();
+        });
+    });
+    describe('getOptions', ()=>{
+        it('returns the raw options object passed to the constructor', ()=>{
+            const options = buildOptions({
+                config: {
+                    jwtSecret: 'abc'
+                }
+            });
+            const service = new _notificationconfigservice.NotificationConfigService(options);
+            expect(service.getOptions()).toBe(options);
+        });
+    });
+});