@flusys/nestjs-notification 7.0.2 → 8.0.0-beta.1

package/cjs/gateways/notification.gateway.js

@@ -1,172 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", {
-    value: true
-});
-Object.defineProperty(exports, "NotificationGateway", {
-    enumerable: true,
-    get: function() {
-        return NotificationGateway;
-    }
-});
-const _common = require("@nestjs/common");
-const _jwt = require("@nestjs/jwt");
-const _websockets = require("@nestjs/websockets");
-const _socketio = require("socket.io");
-const _notificationconfigservice = require("../services/notification-config.service");
-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);
-    };
-}
-let NotificationGateway = class NotificationGateway {
-    afterInit() {
-    // Gateway initialized
-    }
-    async handleConnection(client) {
-        try {
-            const token = this.extractToken(client);
-            if (!token) {
-                client.disconnect();
-                return;
-            }
-            const payload = this.verifyToken(token);
-            if (!payload) {
-                client.disconnect();
-                return;
-            }
-            const userId = payload.id;
-            client.data.userId = userId;
-            client.data.companyId = payload.companyId;
-            if (!this.connectedUsers.has(userId)) {
-                this.connectedUsers.set(userId, new Set());
-            }
-            this.connectedUsers.get(userId).add(client.id);
-            client.join(`user:${userId}`);
-            if (payload.companyId) {
-                client.join(`company:${payload.companyId}`);
-                client.join(`user:${userId}:company:${payload.companyId}`);
-            }
-        } catch  {
-            client.disconnect();
-        }
-    }
-    handleDisconnect(client) {
-        const userId = client.data.userId;
-        if (userId) {
-            const sockets = this.connectedUsers.get(userId);
-            sockets?.delete(client.id);
-            if (sockets?.size === 0) {
-                this.connectedUsers.delete(userId);
-            }
-        }
-    }
-    emitToUser(userId, event, data) {
-        this.server?.to(`user:${userId}`).emit(event, data);
-    }
-    /**
-   * Emit to a user scoped to a specific company session.
-   * Uses the combined room `user:{id}:company:{cid}` so only sockets
-   * authenticated under that company receive the event — critical for
-   * users logged in across multiple companies on different devices.
-   * Falls back to all user sockets when companyId is absent.
-   */ emitToUserInCompany(userId, companyId, event, data) {
-        if (!this.server) {
-            return;
-        }
-        if (!companyId) {
-            this.emitToUser(userId, event, data);
-            return;
-        }
-        this.server.to(`user:${userId}:company:${companyId}`).emit(event, data);
-    }
-    emitToCompany(companyId, event, data) {
-        this.server?.to(`company:${companyId}`).emit(event, data);
-    }
-    broadcast(event, data) {
-        this.server?.emit(event, data);
-    }
-    isUserOnline(userId) {
-        return this.connectedUsers.has(userId);
-    }
-    getOnlineUserCount() {
-        return this.connectedUsers.size;
-    }
-    extractToken(client) {
-        const authToken = client.handshake.auth?.token;
-        if (authToken) return authToken;
-        const queryToken = client.handshake.query?.token;
-        if (typeof queryToken === 'string') return queryToken;
-        const authHeader = client.handshake.headers?.authorization;
-        if (authHeader?.startsWith('Bearer ')) {
-            return authHeader.substring(7);
-        }
-        return null;
-    }
-    verifyToken(token) {
-        try {
-            const secret = this.configService.getJwtSecret();
-            if (!secret) {
-                return null;
-            }
-            return this.jwtService.verify(token, {
-                secret,
-                algorithms: [
-                    'HS256'
-                ]
-            });
-        } catch  {
-            return null;
-        }
-    }
-    constructor(configService, jwtService){
-        _define_property(this, "configService", void 0);
-        _define_property(this, "jwtService", void 0);
-        _define_property(this, "connectedUsers", void 0);
-        _define_property(this, "server", void 0);
-        this.configService = configService;
-        this.jwtService = jwtService;
-        this.connectedUsers = new Map();
-    }
-};
-_ts_decorate([
-    (0, _websockets.WebSocketServer)(),
-    _ts_metadata("design:type", typeof _socketio.Server === "undefined" ? Object : _socketio.Server)
-], NotificationGateway.prototype, "server", void 0);
-NotificationGateway = _ts_decorate([
-    (0, _websockets.WebSocketGateway)({
-        namespace: '/notifications',
-        cors: {
-            origin: '*',
-            credentials: true
-        }
-    }),
-    _ts_param(0, (0, _common.Inject)(_notificationconfigservice.NotificationConfigService)),
-    _ts_param(1, (0, _common.Inject)(_jwt.JwtService)),
-    _ts_metadata("design:type", Function),
-    _ts_metadata("design:paramtypes", [
-        typeof _notificationconfigservice.NotificationConfigService === "undefined" ? Object : _notificationconfigservice.NotificationConfigService,
-        typeof _jwt.JwtService === "undefined" ? Object : _jwt.JwtService
-    ])
-], NotificationGateway);

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

@@ -1,359 +0,0 @@
-"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/index.js

@@ -1,28 +0,0 @@
-// Adapters
-"use strict";
-Object.defineProperty(exports, "__esModule", {
-    value: true
-});
-_export_star(require("./adapters"), exports);
-_export_star(require("./config"), exports);
-_export_star(require("./controllers"), exports);
-_export_star(require("./docs"), exports);
-_export_star(require("./dtos"), exports);
-_export_star(require("./entities"), exports);
-_export_star(require("./gateways"), exports);
-_export_star(require("./interfaces"), exports);
-_export_star(require("./modules"), exports);
-_export_star(require("./services"), exports);
-function _export_star(from, to) {
-    Object.keys(from).forEach(function(k) {
-        if (k !== "default" && !Object.prototype.hasOwnProperty.call(to, k)) {
-            Object.defineProperty(to, k, {
-                enumerable: true,
-                get: function() {
-                    return from[k];
-                }
-            });
-        }
-    });
-    return from;
-}

package/cjs/interfaces/index.js

@@ -1,19 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", {
-    value: true
-});
-_export_star(require("./notification.interface"), exports);
-_export_star(require("./notification-module.interface"), exports);
-function _export_star(from, to) {
-    Object.keys(from).forEach(function(k) {
-        if (k !== "default" && !Object.prototype.hasOwnProperty.call(to, k)) {
-            Object.defineProperty(to, k, {
-                enumerable: true,
-                get: function() {
-                    return from[k];
-                }
-            });
-        }
-    });
-    return from;
-}

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

@@ -1,4 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", {
-    value: true
-});

package/cjs/interfaces/notification.interface.js

@@ -1,4 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", {
-    value: true
-});

package/cjs/modules/index.js

@@ -1,18 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", {
-    value: true
-});
-_export_star(require("./notification.module"), exports);
-function _export_star(from, to) {
-    Object.keys(from).forEach(function(k) {
-        if (k !== "default" && !Object.prototype.hasOwnProperty.call(to, k)) {
-            Object.defineProperty(to, k, {
-                enumerable: true,
-                get: function() {
-                    return from[k];
-                }
-            });
-        }
-    });
-    return from;
-}