@flusys/nestjs-notification 7.1.0 → 8.0.0

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

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

package/fesm/interfaces/notification-module.interface.js

@@ -1 +0,0 @@
-export { };

package/fesm/interfaces/notification.interface.js

@@ -1 +0,0 @@
-export { };

package/fesm/modules/notification.module.js

@@ -1,129 +0,0 @@
-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;
-}
-import { CacheModule, UtilsModule, createModuleEventsProvider } from '@flusys/nestjs-shared/modules';
-import { NOTIFICATION_ADAPTER } from '@flusys/nestjs-shared/interfaces';
-import { Module } from '@nestjs/common';
-import { JwtService } from '@nestjs/jwt';
-import { NOTIFICATION_MODULE_OPTIONS } from '../config/notification.constants';
-import { NotificationController } from '../controllers';
-import { NotificationAdapter } from '../adapters';
-import { NotificationConfigService, NotificationDataSourceProvider, NotificationService, NotificationHelperService } from '../services';
-import { NotificationGateway } from '../gateways';
-const CONTROLLERS = [
-    NotificationController
-];
-const EXPORTED_SERVICES = [
-    NotificationConfigService,
-    NotificationDataSourceProvider,
-    NotificationService,
-    NotificationHelperService
-];
-const ADAPTER_PROVIDER = {
-    provide: NOTIFICATION_ADAPTER,
-    useClass: NotificationAdapter
-};
-export class NotificationModule {
-    static forRoot(options) {
-        return {
-            module: NotificationModule,
-            global: options.global ?? false,
-            imports: [
-                CacheModule,
-                UtilsModule
-            ],
-            controllers: options.includeController !== false ? CONTROLLERS : [],
-            providers: [
-                ...this.buildProviders(options),
-                JwtService,
-                NotificationGateway,
-                NotificationAdapter,
-                ADAPTER_PROVIDER
-            ],
-            exports: [
-                ...EXPORTED_SERVICES,
-                NotificationGateway,
-                NOTIFICATION_ADAPTER
-            ]
-        };
-    }
-    static forRootAsync(options) {
-        return {
-            module: NotificationModule,
-            global: options.global ?? false,
-            imports: [
-                ...options.imports || [],
-                CacheModule,
-                UtilsModule
-            ],
-            controllers: options.includeController !== false ? CONTROLLERS : [],
-            providers: [
-                ...this.createAsyncProviders(options),
-                ...this.buildProviders(),
-                JwtService,
-                NotificationGateway,
-                NotificationAdapter,
-                ADAPTER_PROVIDER
-            ],
-            exports: [
-                ...EXPORTED_SERVICES,
-                NotificationGateway,
-                NOTIFICATION_ADAPTER
-            ]
-        };
-    }
-    static buildProviders(options) {
-        const providers = [
-            ...EXPORTED_SERVICES
-        ];
-        if (options) {
-            providers.unshift({
-                provide: NOTIFICATION_MODULE_OPTIONS,
-                useValue: options
-            });
-        }
-        providers.push(createModuleEventsProvider('notification', NOTIFICATION_MODULE_OPTIONS));
-        return providers;
-    }
-    static createAsyncProviders(options) {
-        if (options.useFactory) {
-            return [
-                {
-                    provide: NOTIFICATION_MODULE_OPTIONS,
-                    useFactory: async (...args)=>({
-                            ...options,
-                            config: await options.useFactory(...args)
-                        }),
-                    inject: options.inject || []
-                }
-            ];
-        }
-        const factoryClass = options.useClass || options.useExisting;
-        if (!factoryClass) return [];
-        const providers = [
-            {
-                provide: NOTIFICATION_MODULE_OPTIONS,
-                useFactory: async (factory)=>({
-                        ...options,
-                        config: await factory.createNotificationOptions()
-                    }),
-                inject: [
-                    factoryClass
-                ]
-            }
-        ];
-        if (options.useClass) {
-            providers.push({
-                provide: options.useClass,
-                useClass: options.useClass
-            });
-        }
-        return providers;
-    }
-}
-NotificationModule = _ts_decorate([
-    Module({})
-], NotificationModule);

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

@@ -1,148 +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;
-}
-import { NOTIFICATION_ADAPTER } from '@flusys/nestjs-shared/interfaces';
-import { NotificationModule } from './notification.module';
-import { NOTIFICATION_MODULE_OPTIONS } from '../config/notification.constants';
-import { NotificationController } from '../controllers';
-import { NotificationGateway } from '../gateways';
-import { NotificationAdapter } from '../adapters';
-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.forRoot({});
-            expect(dynamicModule.module).toBe(NotificationModule);
-            expect(dynamicModule.global).toBe(false);
-            expect(dynamicModule.controllers).toEqual([
-                NotificationController
-            ]);
-        });
-        it('should respect global: true', ()=>{
-            expect(NotificationModule.forRoot({
-                global: true
-            }).global).toBe(true);
-        });
-        it('should register no controllers when includeController is false', ()=>{
-            expect(NotificationModule.forRoot({
-                includeController: false
-            }).controllers).toEqual([]);
-        });
-        it('should register the NOTIFICATION_ADAPTER provider backed by NotificationAdapter', ()=>{
-            const dynamicModule = NotificationModule.forRoot({});
-            const adapterProvider = dynamicModule.providers.find((p)=>p.provide === NOTIFICATION_ADAPTER);
-            expect(adapterProvider.useClass).toBe(NotificationAdapter);
-            expect(providerTokens(dynamicModule.providers)).toContain(NotificationGateway);
-        });
-        it('should export NotificationGateway and NOTIFICATION_ADAPTER alongside the base services', ()=>{
-            const dynamicModule = NotificationModule.forRoot({});
-            expect(dynamicModule.exports).toEqual(expect.arrayContaining([
-                NotificationGateway,
-                NOTIFICATION_ADAPTER
-            ]));
-        });
-        it('should register a NOTIFICATION_MODULE_OPTIONS provider carrying the given options', ()=>{
-            const options = {
-                bootstrapAppConfig: {
-                    enableCompanyFeature: true
-                }
-            };
-            const dynamicModule = NotificationModule.forRoot(options);
-            const provider = dynamicModule.providers.find((p)=>p.provide === 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.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.forRootAsync({
-                useFactory: jest.fn()
-            });
-            const adapterProvider = dynamicModule.providers.find((p)=>p.provide === NOTIFICATION_ADAPTER);
-            expect(adapterProvider.useClass).toBe(NotificationAdapter);
-        });
-        it('useFactory: builds a NOTIFICATION_MODULE_OPTIONS provider merging resolved config', async ()=>{
-            const useFactory = jest.fn().mockResolvedValue({
-                foo: 'bar'
-            });
-            const dynamicModule = NotificationModule.forRootAsync({
-                useFactory,
-                inject: [
-                    'SOME_TOKEN'
-                ]
-            });
-            const provider = dynamicModule.providers.find((p)=>p.provide === 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.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 === 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.forRootAsync({
-                useExisting: MyOptionsFactory
-            });
-            expect(dynamicModule.providers.filter((p)=>p.provide === MyOptionsFactory)).toHaveLength(0);
-            const optionsProvider = dynamicModule.providers.find((p)=>p.provide === 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.forRootAsync({});
-            expect(providerTokens(dynamicModule.providers)).not.toContain(NOTIFICATION_MODULE_OPTIONS);
-        });
-    });
-});