@flusys/nestjs-notification 3.0.1

package/cjs/gateways/notification.gateway.js

@@ -0,0 +1,226 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "NotificationGateway", {
+    enumerable: true,
+    get: function() {
+        return NotificationGateway;
+    }
+});
+const _common = require("@nestjs/common");
+const _websockets = require("@nestjs/websockets");
+const _socketio = require("socket.io");
+const _jsonwebtoken = /*#__PURE__*/ _interop_require_wildcard(require("jsonwebtoken"));
+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 _getRequireWildcardCache(nodeInterop) {
+    if (typeof WeakMap !== "function") return null;
+    var cacheBabelInterop = new WeakMap();
+    var cacheNodeInterop = new WeakMap();
+    return (_getRequireWildcardCache = function(nodeInterop) {
+        return nodeInterop ? cacheNodeInterop : cacheBabelInterop;
+    })(nodeInterop);
+}
+function _interop_require_wildcard(obj, nodeInterop) {
+    if (!nodeInterop && obj && obj.__esModule) {
+        return obj;
+    }
+    if (obj === null || typeof obj !== "object" && typeof obj !== "function") {
+        return {
+            default: obj
+        };
+    }
+    var cache = _getRequireWildcardCache(nodeInterop);
+    if (cache && cache.has(obj)) {
+        return cache.get(obj);
+    }
+    var newObj = {
+        __proto__: null
+    };
+    var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor;
+    for(var key in obj){
+        if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) {
+            var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null;
+            if (desc && (desc.get || desc.set)) {
+                Object.defineProperty(newObj, key, desc);
+            } else {
+                newObj[key] = obj[key];
+            }
+        }
+    }
+    newObj.default = obj;
+    if (cache) {
+        cache.set(obj, newObj);
+    }
+    return newObj;
+}
+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() {
+        this.logger.log('Notification WebSocket Gateway initialized');
+    }
+    async handleConnection(client) {
+        try {
+            const token = this.extractToken(client);
+            if (!token) {
+                this.logger.warn(`Client ${client.id} connection rejected: No token provided`);
+                client.disconnect();
+                return;
+            }
+            const payload = this.verifyToken(token);
+            if (!payload) {
+                this.logger.warn(`Client ${client.id} connection rejected: Invalid token`);
+                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}`);
+            }
+            this.logger.log(`Client ${client.id} connected for user ${userId}`);
+        } catch (error) {
+            this.logger.error(`Client ${client.id} connection error: ${error}`);
+            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);
+            }
+            this.logger.log(`Client ${client.id} disconnected for user ${userId}`);
+        }
+    }
+    emitToUser(userId, event, data) {
+        this.server.to(`user:${userId}`).emit(event, data);
+    }
+    /**
+   * Emit to a specific user only on sockets connected with a specific company.
+   * This is crucial for multi-company scenarios where a user may be logged in
+   * with different companies on different devices.
+   *
+   * @param userId - The user ID
+   * @param companyId - The company ID (if null/undefined, emits to all user's sockets)
+   * @param event - The event name
+   * @param data - The payload
+   */ emitToUserInCompany(userId, companyId, event, data) {
+        if (!companyId) {
+            // No company context - emit to all user's sockets
+            this.emitToUser(userId, event, data);
+            return;
+        }
+        // Get all sockets in the user's room
+        const userRoom = `user:${userId}`;
+        const sockets = this.server.sockets.adapter.rooms.get(userRoom);
+        if (!sockets) {
+            this.logger.debug(`No sockets found for user ${userId}`);
+            return;
+        }
+        // Emit only to sockets that match the company context
+        for (const socketId of sockets){
+            const socket = this.server.sockets.sockets.get(socketId);
+            if (socket && socket.data.companyId === companyId) {
+                socket.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) {
+                this.logger.error('No JWT secret configured for WebSocket authentication');
+                return null;
+            }
+            return _jsonwebtoken.verify(token, secret);
+        } catch (error) {
+            this.logger.warn(`Token verification failed: ${error}`);
+            return null;
+        }
+    }
+    constructor(configService){
+        _define_property(this, "configService", void 0);
+        _define_property(this, "logger", void 0);
+        _define_property(this, "connectedUsers", void 0);
+        _define_property(this, "server", void 0);
+        this.configService = configService;
+        this.logger = new _common.Logger(NotificationGateway.name);
+        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_metadata("design:type", Function),
+    _ts_metadata("design:paramtypes", [
+        typeof _notificationconfigservice.NotificationConfigService === "undefined" ? Object : _notificationconfigservice.NotificationConfigService
+    ])
+], NotificationGateway);

package/cjs/index.js

@@ -0,0 +1,28 @@
+// 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

@@ -0,0 +1,19 @@
+"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

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

package/cjs/interfaces/notification.interface.js

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

package/cjs/modules/index.js

@@ -0,0 +1,18 @@
+"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;
+}

package/cjs/modules/notification.module.js

@@ -0,0 +1,139 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "NotificationModule", {
+    enumerable: true,
+    get: function() {
+        return NotificationModule;
+    }
+});
+const _modules = require("@flusys/nestjs-shared/modules");
+const _interfaces = require("@flusys/nestjs-shared/interfaces");
+const _common = require("@nestjs/common");
+const _notificationconstants = require("../config/notification.constants");
+const _controllers = require("../controllers");
+const _adapters = require("../adapters");
+const _services = require("../services");
+const _gateways = require("../gateways");
+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;
+}
+const CONTROLLERS = [
+    _controllers.NotificationController
+];
+const EXPORTED_SERVICES = [
+    _services.NotificationConfigService,
+    _services.NotificationDataSourceProvider,
+    _services.NotificationService,
+    _services.NotificationHelperService
+];
+const ADAPTER_PROVIDER = {
+    provide: _interfaces.NOTIFICATION_ADAPTER,
+    useClass: _adapters.NotificationAdapter
+};
+let NotificationModule = class NotificationModule {
+    static forRoot(options) {
+        const enableRealtime = options.config?.enableRealtime !== false;
+        const gatewayProviders = enableRealtime ? [
+            _gateways.NotificationGateway
+        ] : [];
+        return {
+            module: NotificationModule,
+            global: options.global ?? false,
+            imports: [
+                _modules.CacheModule,
+                _modules.UtilsModule
+            ],
+            controllers: options.includeController !== false ? CONTROLLERS : [],
+            providers: [
+                ...this.buildProviders(options),
+                ...gatewayProviders,
+                _adapters.NotificationAdapter,
+                ADAPTER_PROVIDER
+            ],
+            exports: [
+                ...EXPORTED_SERVICES,
+                ...gatewayProviders,
+                _interfaces.NOTIFICATION_ADAPTER
+            ]
+        };
+    }
+    static forRootAsync(options) {
+        return {
+            module: NotificationModule,
+            global: options.global ?? false,
+            imports: [
+                ...options.imports || [],
+                _modules.CacheModule,
+                _modules.UtilsModule
+            ],
+            controllers: options.includeController !== false ? CONTROLLERS : [],
+            providers: [
+                ...this.createAsyncProviders(options),
+                ...this.buildProviders(),
+                _gateways.NotificationGateway,
+                _adapters.NotificationAdapter,
+                ADAPTER_PROVIDER
+            ],
+            exports: [
+                ...EXPORTED_SERVICES,
+                _gateways.NotificationGateway,
+                _interfaces.NOTIFICATION_ADAPTER
+            ]
+        };
+    }
+    static buildProviders(options) {
+        const providers = [
+            ...EXPORTED_SERVICES
+        ];
+        if (options) {
+            providers.unshift({
+                provide: _notificationconstants.NOTIFICATION_MODULE_OPTIONS,
+                useValue: options
+            });
+        }
+        return providers;
+    }
+    static createAsyncProviders(options) {
+        if (options.useFactory) {
+            return [
+                {
+                    provide: _notificationconstants.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: _notificationconstants.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([
+    (0, _common.Module)({})
+], NotificationModule);

package/cjs/services/index.js

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+_export_star(require("./notification-config.service"), exports);
+_export_star(require("./notification-datasource.provider"), exports);
+_export_star(require("./notification.service"), exports);
+_export_star(require("./notification-helper.service"), 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/services/notification-config.service.js

@@ -0,0 +1,72 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "NotificationConfigService", {
+    enumerable: true,
+    get: function() {
+        return NotificationConfigService;
+    }
+});
+const _common = require("@nestjs/common");
+const _interfaces = require("../interfaces");
+const _notificationconstants = require("../config/notification.constants");
+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 NotificationConfigService = class NotificationConfigService {
+    isCompanyFeatureEnabled() {
+        return this.options.bootstrapAppConfig?.enableCompanyFeature ?? false;
+    }
+    getDatabaseMode() {
+        return this.options.bootstrapAppConfig?.databaseMode ?? 'single';
+    }
+    isMultiTenant() {
+        return this.getDatabaseMode() === 'multi-tenant';
+    }
+    isRealtimeEnabled() {
+        return this.options.config?.enableRealtime !== false;
+    }
+    getJwtSecret() {
+        return this.options.config?.jwtSecret;
+    }
+    getOptions() {
+        return this.options;
+    }
+    constructor(options){
+        _define_property(this, "options", void 0);
+        this.options = options;
+    }
+};
+NotificationConfigService = _ts_decorate([
+    (0, _common.Injectable)(),
+    _ts_param(0, (0, _common.Inject)(_notificationconstants.NOTIFICATION_MODULE_OPTIONS)),
+    _ts_metadata("design:type", Function),
+    _ts_metadata("design:paramtypes", [
+        typeof _interfaces.NotificationModuleOptions === "undefined" ? Object : _interfaces.NotificationModuleOptions
+    ])
+], NotificationConfigService);