@flusys/nestjs-notification 3.0.1

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

@@ -0,0 +1,176 @@
+function _define_property(obj, key, value) {
+    if (key in obj) {
+        Object.defineProperty(obj, key, {
+            value: value,
+            enumerable: true,
+            configurable: true,
+            writable: true
+        });
+    } else {
+        obj[key] = value;
+    }
+    return obj;
+}
+function _ts_decorate(decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for(var i = decorators.length - 1; i >= 0; i--)if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+}
+function _ts_metadata(k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+}
+function _ts_param(paramIndex, decorator) {
+    return function(target, key) {
+        decorator(target, key, paramIndex);
+    };
+}
+import { Inject, Injectable, Logger, Optional } from '@nestjs/common';
+import { HybridCache } from '@flusys/nestjs-shared/classes';
+import { UtilsService } from '@flusys/nestjs-shared/modules';
+import { NotificationConfigService } from './notification-config.service';
+import { NotificationDataSourceProvider } from './notification-datasource.provider';
+import { NotificationGateway } from '../gateways';
+import { Notification, NotificationWithCompany } from '../entities';
+import { NotificationType } from '@flusys/nestjs-shared/enums';
+export class NotificationHelperService {
+    async getDataSource() {
+        if (!this.dataSource) {
+            this.dataSource = await this.dataSourceProvider.getDataSource();
+        }
+        return this.dataSource;
+    }
+    async getRepository() {
+        const ds = await this.getDataSource();
+        const EntityClass = this.configService.isCompanyFeatureEnabled() ? NotificationWithCompany : Notification;
+        return ds.getRepository(EntityClass);
+    }
+    async send(options) {
+        const { userId, title, message = null, type = NotificationType.INFO, data = null, companyId } = options;
+        const repo = await this.getRepository();
+        const entity = {
+            userId,
+            type,
+            title,
+            message,
+            data,
+            isRead: false
+        };
+        if (this.configService.isCompanyFeatureEnabled() && companyId) {
+            entity.companyId = companyId;
+        }
+        const saved = await repo.save(entity);
+        await this.clearCache();
+        this.emitRealtime(saved);
+        this.logger.debug(`Notification sent to user ${userId}: ${title}`);
+        return saved;
+    }
+    async sendToMany(options) {
+        const { userIds, title, message = null, type = NotificationType.INFO, data = null, companyId } = options;
+        const repo = await this.getRepository();
+        const entities = userIds.map((userId)=>({
+                userId,
+                type,
+                title,
+                message,
+                data,
+                isRead: false,
+                ...this.configService.isCompanyFeatureEnabled() && companyId ? {
+                    companyId
+                } : {}
+            }));
+        const saved = await repo.save(entities);
+        await this.clearCache();
+        for (const notification of saved){
+            this.emitRealtime(notification);
+        }
+        this.logger.debug(`Notification sent to ${userIds.length} users: ${title}`);
+        return saved;
+    }
+    async sendToCompany(companyId, title, message, type = NotificationType.INFO, data) {
+        if (!this.configService.isCompanyFeatureEnabled()) {
+            this.logger.warn('sendToCompany called but company feature is disabled');
+            return;
+        }
+        if (this.configService.isRealtimeEnabled() && this.gateway) {
+            const payload = {
+                id: `broadcast-${Date.now()}`,
+                type,
+                title,
+                message: message ?? null,
+                data: data ?? null,
+                createdAt: new Date()
+            };
+            this.gateway.emitToCompany(companyId, 'notification:new', payload);
+            this.logger.debug(`Broadcast notification sent to company ${companyId}: ${title}`);
+        }
+    }
+    isUserOnline(userId) {
+        return this.gateway?.isUserOnline(userId) ?? false;
+    }
+    getOnlineUserCount() {
+        return this.gateway?.getOnlineUserCount() ?? 0;
+    }
+    emitRealtime(notification) {
+        if (!this.configService.isRealtimeEnabled() || !this.gateway) {
+            return;
+        }
+        const ext = notification;
+        const payload = this.toPayload(notification);
+        if (this.configService.isCompanyFeatureEnabled() && ext.companyId) {
+            // Company feature enabled - emit only to sockets in matching company context
+            this.gateway.emitToUserInCompany(notification.userId, ext.companyId, 'notification:new', payload);
+        } else {
+            // No company feature or no companyId - emit to all user's sockets
+            this.gateway.emitToUser(notification.userId, 'notification:new', payload);
+        }
+    }
+    toPayload(notification) {
+        return {
+            id: notification.id,
+            type: notification.type,
+            title: notification.title,
+            message: notification.message,
+            data: notification.data,
+            createdAt: notification.createdAt
+        };
+    }
+    async clearCache() {
+        await this.utilsService.clearCache(this.entityName, this.cacheManager);
+    }
+    constructor(cacheManager, utilsService, configService, dataSourceProvider, gateway){
+        _define_property(this, "cacheManager", void 0);
+        _define_property(this, "utilsService", void 0);
+        _define_property(this, "configService", void 0);
+        _define_property(this, "dataSourceProvider", void 0);
+        _define_property(this, "gateway", void 0);
+        _define_property(this, "logger", void 0);
+        _define_property(this, "entityName", void 0);
+        _define_property(this, "dataSource", void 0);
+        this.cacheManager = cacheManager;
+        this.utilsService = utilsService;
+        this.configService = configService;
+        this.dataSourceProvider = dataSourceProvider;
+        this.gateway = gateway;
+        this.logger = new Logger(NotificationHelperService.name);
+        this.entityName = 'notification';
+        this.dataSource = null;
+    }
+}
+NotificationHelperService = _ts_decorate([
+    Injectable(),
+    _ts_param(0, Inject('CACHE_INSTANCE')),
+    _ts_param(1, Inject(UtilsService)),
+    _ts_param(2, Inject(NotificationConfigService)),
+    _ts_param(3, Inject(NotificationDataSourceProvider)),
+    _ts_param(4, Optional()),
+    _ts_param(4, Inject(NotificationGateway)),
+    _ts_metadata("design:type", Function),
+    _ts_metadata("design:paramtypes", [
+        typeof HybridCache === "undefined" ? Object : HybridCache,
+        typeof UtilsService === "undefined" ? Object : UtilsService,
+        typeof NotificationConfigService === "undefined" ? Object : NotificationConfigService,
+        typeof NotificationDataSourceProvider === "undefined" ? Object : NotificationDataSourceProvider,
+        typeof NotificationGateway === "undefined" ? Object : NotificationGateway
+    ])
+], NotificationHelperService);

package/fesm/services/notification.service.js

@@ -0,0 +1,210 @@
+function _define_property(obj, key, value) {
+    if (key in obj) {
+        Object.defineProperty(obj, key, {
+            value: value,
+            enumerable: true,
+            configurable: true,
+            writable: true
+        });
+    } else {
+        obj[key] = value;
+    }
+    return obj;
+}
+function _ts_decorate(decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for(var i = decorators.length - 1; i >= 0; i--)if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+}
+function _ts_metadata(k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+}
+function _ts_param(paramIndex, decorator) {
+    return function(target, key) {
+        decorator(target, key, paramIndex);
+    };
+}
+import { HybridCache, RequestScopedApiService } from '@flusys/nestjs-shared/classes';
+import { UtilsService } from '@flusys/nestjs-shared/modules';
+import { applyCompanyFilter } from '@flusys/nestjs-shared/utils';
+import { Inject, Injectable, NotFoundException, Optional, Scope } from '@nestjs/common';
+import { Notification, NotificationWithCompany } from '../entities';
+import { NotificationGateway } from '../gateways';
+import { NotificationConfigService } from './notification-config.service';
+import { NotificationDataSourceProvider } from './notification-datasource.provider';
+export class NotificationService extends RequestScopedApiService {
+    resolveEntity() {
+        return this.notificationConfig.isCompanyFeatureEnabled() ? NotificationWithCompany : Notification;
+    }
+    getDataSourceProvider() {
+        return this.dataSourceProvider;
+    }
+    async convertSingleDtoToEntity(dto, user) {
+        let entity = {};
+        if ('id' in dto && dto.id) {
+            const existing = await this.repository.findOne({
+                where: {
+                    id: dto.id
+                }
+            });
+            if (!existing) throw new NotFoundException('Notification not found');
+            entity = existing;
+        }
+        const merged = {
+            ...entity,
+            userId: user?.id ?? entity.userId,
+            type: dto.type ?? entity.type ?? 'info',
+            title: dto.title ?? entity.title,
+            message: dto.message ?? entity.message,
+            data: dto.data ?? entity.data,
+            isRead: entity.isRead ?? false,
+            readAt: entity.readAt
+        };
+        if (this.notificationConfig.isCompanyFeatureEnabled()) {
+            merged.companyId = dto.companyId ?? user?.companyId ?? entity.companyId ?? null;
+        }
+        return merged;
+    }
+    async getFilterQuery(query, filter, _user) {
+        for (const [key, value] of Object.entries(filter)){
+            if (key === 'isRead' && typeof value === 'boolean') {
+                query.andWhere(`${this.entityName}.isRead = :isRead`, {
+                    isRead: value
+                });
+            } else if (key === 'type' && value) {
+                query.andWhere(`${this.entityName}.type = :type`, {
+                    type: value
+                });
+            } else if (key === 'userId' && value) {
+                query.andWhere(`${this.entityName}.userId = :userId`, {
+                    userId: value
+                });
+            }
+        }
+        return {
+            query,
+            isRaw: false
+        };
+    }
+    async getExtraManipulateQuery(query, filterDto, user) {
+        const result = await super.getExtraManipulateQuery(query, filterDto, user);
+        if (user?.id) {
+            query.andWhere(`${this.entityName}.userId = :currentUserId`, {
+                currentUserId: user.id
+            });
+        }
+        applyCompanyFilter(query, {
+            isCompanyFeatureEnabled: this.notificationConfig.isCompanyFeatureEnabled(),
+            entityAlias: this.entityName
+        }, user);
+        if (!filterDto?.sort || Object.keys(filterDto.sort).length === 0) {
+            query.orderBy(`${this.entityName}.createdAt`, 'DESC');
+        }
+        return result;
+    }
+    async afterInsertOperation(entities, _user, _qr) {
+        for (const entity of entities){
+            const ext = entity;
+            this.emitToUserInCompanyIfRealtime(entity.userId, ext.companyId, 'notification:new', this.toPayload(entity));
+        }
+    }
+    async markAsRead(id, user) {
+        await this.ensureRepositoryInitialized();
+        const notification = await this.repository.findOne({
+            where: {
+                id,
+                userId: user.id
+            }
+        });
+        if (!notification) {
+            throw new NotFoundException('Notification not found');
+        }
+        notification.isRead = true;
+        notification.readAt = new Date();
+        await this.repository.save(notification);
+        await Promise.all([
+            this.clearCacheForAll(),
+            this.clearCacheForId([
+                notification
+            ])
+        ]);
+        // Emit to user's sockets in the same company context
+        const ext = notification;
+        this.emitToUserInCompanyIfRealtime(user.id, ext.companyId ?? user.companyId, 'notification:read', {
+            id
+        });
+        return notification;
+    }
+    async markAllAsRead(user) {
+        await this.ensureRepositoryInitialized();
+        const result = await this.repository.update({
+            userId: user.id,
+            isRead: false
+        }, {
+            isRead: true,
+            readAt: new Date()
+        });
+        await this.clearCacheForAll();
+        // Emit to user's sockets in the current company context
+        this.emitToUserInCompanyIfRealtime(user.id, user.companyId, 'notification:read-all', {});
+        return result.affected ?? 0;
+    }
+    async getUnreadCount(user) {
+        await this.ensureRepositoryInitialized();
+        return this.repository.count({
+            where: {
+                userId: user.id,
+                isRead: false
+            }
+        });
+    }
+    toPayload(entity) {
+        return {
+            id: entity.id,
+            type: entity.type,
+            title: entity.title,
+            message: entity.message,
+            data: entity.data,
+            createdAt: entity.createdAt
+        };
+    }
+    /**
+   * Emit to user's sockets within a specific company context.
+   * If company feature is enabled and companyId is provided, only sockets
+   * connected with that company will receive the event.
+   */ emitToUserInCompanyIfRealtime(userId, companyId, event, payload) {
+        if (!this.notificationConfig.isRealtimeEnabled() || !this.gateway) {
+            return;
+        }
+        if (this.notificationConfig.isCompanyFeatureEnabled() && companyId) {
+            // Company feature enabled - emit only to sockets in matching company context
+            this.gateway.emitToUserInCompany(userId, companyId, event, payload);
+        } else {
+            // No company feature or no companyId - emit to all user's sockets
+            this.gateway.emitToUser(userId, event, payload);
+        }
+    }
+    constructor(cacheManager, utilsService, notificationConfig, dataSourceProvider, gateway){
+        super('notification', null, cacheManager, utilsService, NotificationService.name, false), _define_property(this, "cacheManager", void 0), _define_property(this, "utilsService", void 0), _define_property(this, "notificationConfig", void 0), _define_property(this, "dataSourceProvider", void 0), _define_property(this, "gateway", void 0), this.cacheManager = cacheManager, this.utilsService = utilsService, this.notificationConfig = notificationConfig, this.dataSourceProvider = dataSourceProvider, this.gateway = gateway;
+    }
+}
+NotificationService = _ts_decorate([
+    Injectable({
+        scope: Scope.REQUEST
+    }),
+    _ts_param(0, Inject('CACHE_INSTANCE')),
+    _ts_param(1, Inject(UtilsService)),
+    _ts_param(2, Inject(NotificationConfigService)),
+    _ts_param(3, Inject(NotificationDataSourceProvider)),
+    _ts_param(4, Optional()),
+    _ts_param(4, Inject(NotificationGateway)),
+    _ts_metadata("design:type", Function),
+    _ts_metadata("design:paramtypes", [
+        typeof HybridCache === "undefined" ? Object : HybridCache,
+        typeof UtilsService === "undefined" ? Object : UtilsService,
+        typeof NotificationConfigService === "undefined" ? Object : NotificationConfigService,
+        typeof NotificationDataSourceProvider === "undefined" ? Object : NotificationDataSourceProvider,
+        typeof NotificationGateway === "undefined" ? Object : NotificationGateway
+    ])
+], NotificationService);

package/gateways/index.d.ts

@@ -0,0 +1 @@
+export * from './notification.gateway';

package/gateways/notification.gateway.d.ts

@@ -0,0 +1,21 @@
+import { OnGatewayConnection, OnGatewayDisconnect, OnGatewayInit } from '@nestjs/websockets';
+import { Server, Socket } from 'socket.io';
+import { NotificationConfigService } from '../services/notification-config.service';
+export declare class NotificationGateway implements OnGatewayInit, OnGatewayConnection, OnGatewayDisconnect {
+    private readonly configService;
+    private readonly logger;
+    private readonly connectedUsers;
+    server: Server;
+    constructor(configService: NotificationConfigService);
+    afterInit(): void;
+    handleConnection(client: Socket): Promise<void>;
+    handleDisconnect(client: Socket): void;
+    emitToUser(userId: string, event: string, data: unknown): void;
+    emitToUserInCompany(userId: string, companyId: string | null | undefined, event: string, data: unknown): void;
+    emitToCompany(companyId: string, event: string, data: unknown): void;
+    broadcast(event: string, data: unknown): void;
+    isUserOnline(userId: string): boolean;
+    getOnlineUserCount(): number;
+    private extractToken;
+    private verifyToken;
+}

package/index.d.ts

@@ -0,0 +1,10 @@
+export * from './adapters';
+export * from './config';
+export * from './controllers';
+export * from './docs';
+export * from './dtos';
+export * from './entities';
+export * from './gateways';
+export * from './interfaces';
+export * from './modules';
+export * from './services';

package/interfaces/index.d.ts

@@ -0,0 +1,2 @@
+export * from './notification.interface';
+export * from './notification-module.interface';

package/interfaces/notification-module.interface.d.ts

@@ -0,0 +1,20 @@
+import { IBootstrapAppConfig, IDataSourceServiceOptions, IDynamicModuleConfig, IModuleOptionsFactory } from '@flusys/nestjs-core';
+import { ModuleMetadata, Type } from '@nestjs/common';
+export interface INotificationModuleConfig extends IDataSourceServiceOptions {
+    enableRealtime?: boolean;
+    jwtSecret?: string;
+}
+export interface NotificationModuleOptions extends IDynamicModuleConfig {
+    bootstrapAppConfig?: IBootstrapAppConfig;
+    config?: INotificationModuleConfig;
+}
+export interface NotificationOptionsFactory extends IModuleOptionsFactory<INotificationModuleConfig> {
+    createNotificationOptions(): Promise<INotificationModuleConfig> | INotificationModuleConfig;
+}
+export interface NotificationModuleAsyncOptions extends Pick<ModuleMetadata, 'imports'>, IDynamicModuleConfig {
+    bootstrapAppConfig: IBootstrapAppConfig;
+    useFactory?: (...args: any[]) => Promise<INotificationModuleConfig> | INotificationModuleConfig;
+    inject?: any[];
+    useClass?: Type<NotificationOptionsFactory>;
+    useExisting?: Type<NotificationOptionsFactory>;
+}

package/interfaces/notification.interface.d.ts

@@ -0,0 +1,19 @@
+import { IIdentity } from '@flusys/nestjs-shared/interfaces';
+export interface INotification extends IIdentity {
+    userId: string;
+    type: string;
+    title: string;
+    message: string | null;
+    data: Record<string, unknown> | null;
+    isRead: boolean;
+    readAt: Date | null;
+    companyId?: string | null;
+}
+export interface INotificationPayload {
+    id: string;
+    type: string;
+    title: string;
+    message: string | null;
+    data: Record<string, unknown> | null;
+    createdAt: Date;
+}

package/modules/index.d.ts

@@ -0,0 +1 @@
+export * from './notification.module';

package/modules/notification.module.d.ts

@@ -0,0 +1,8 @@
+import { DynamicModule } from '@nestjs/common';
+import { NotificationModuleAsyncOptions, NotificationModuleOptions } from '../interfaces';
+export declare class NotificationModule {
+    static forRoot(options: NotificationModuleOptions): DynamicModule;
+    static forRootAsync(options: NotificationModuleAsyncOptions): DynamicModule;
+    private static buildProviders;
+    private static createAsyncProviders;
+}

package/package.json

@@ -0,0 +1,98 @@
+{
+  "name": "@flusys/nestjs-notification",
+  "version": "3.0.1",
+  "description": "Notification module with real-time Socket.IO support",
+  "main": "cjs/index.js",
+  "module": "fesm/index.js",
+  "types": "index.d.ts",
+  "sideEffects": false,
+  "keywords": [
+    "nestjs",
+    "notification",
+    "socket.io",
+    "real-time",
+    "@flusys"
+  ],
+  "license": "UNLICENSED",
+  "exports": {
+    ".": {
+      "types": "./index.d.ts",
+      "import": "./fesm/index.js",
+      "require": "./cjs/index.js"
+    },
+    "./config": {
+      "types": "./config/index.d.ts",
+      "import": "./fesm/config/index.js",
+      "require": "./cjs/config/index.js"
+    },
+    "./controllers": {
+      "types": "./controllers/index.d.ts",
+      "import": "./fesm/controllers/index.js",
+      "require": "./cjs/controllers/index.js"
+    },
+    "./docs": {
+      "types": "./docs/index.d.ts",
+      "import": "./fesm/docs/index.js",
+      "require": "./cjs/docs/index.js"
+    },
+    "./dtos": {
+      "types": "./dtos/index.d.ts",
+      "import": "./fesm/dtos/index.js",
+      "require": "./cjs/dtos/index.js"
+    },
+    "./entities": {
+      "types": "./entities/index.d.ts",
+      "import": "./fesm/entities/index.js",
+      "require": "./cjs/entities/index.js"
+    },
+    "./enums": {
+      "types": "./enums/index.d.ts",
+      "import": "./fesm/enums/index.js",
+      "require": "./cjs/enums/index.js"
+    },
+    "./gateways": {
+      "types": "./gateways/index.d.ts",
+      "import": "./fesm/gateways/index.js",
+      "require": "./cjs/gateways/index.js"
+    },
+    "./interfaces": {
+      "types": "./interfaces/index.d.ts",
+      "import": "./fesm/interfaces/index.js",
+      "require": "./cjs/interfaces/index.js"
+    },
+    "./modules": {
+      "types": "./modules/index.d.ts",
+      "import": "./fesm/modules/index.js",
+      "require": "./cjs/modules/index.js"
+    },
+    "./services": {
+      "types": "./services/index.d.ts",
+      "import": "./fesm/services/index.js",
+      "require": "./cjs/services/index.js"
+    },
+    "./*": {
+      "types": "./*.d.ts",
+      "import": "./*.js",
+      "require": "./*.js"
+    }
+  },
+  "peerDependencies": {
+    "@nestjs/common": "^10.0.0 || ^11.0.0",
+    "@nestjs/config": "^3.0.0 || ^4.0.0",
+    "@nestjs/core": "^10.0.0 || ^11.0.0",
+    "@nestjs/platform-express": "^10.0.0 || ^11.0.0",
+    "@nestjs/swagger": "^7.0.0 || ^11.0.0",
+    "@nestjs/typeorm": "^10.0.0 || ^11.0.0",
+    "@nestjs/websockets": "^10.0.0 || ^11.0.0",
+    "@nestjs/platform-socket.io": "^10.0.0 || ^11.0.0",
+    "class-transformer": "^0.5.0",
+    "class-validator": "^0.14.0",
+    "socket.io": "^4.0.0",
+    "typeorm": "^0.3.0"
+  },
+  "dependencies": {
+    "@flusys/nestjs-core": "3.0.1",
+    "@flusys/nestjs-shared": "3.0.1",
+    "jsonwebtoken": "^9.0.0"
+  }
+}

package/services/index.d.ts

@@ -0,0 +1,4 @@
+export * from './notification-config.service';
+export * from './notification-datasource.provider';
+export * from './notification.service';
+export * from './notification-helper.service';

package/services/notification-config.service.d.ts

@@ -0,0 +1,13 @@
+import { DatabaseMode } from '@flusys/nestjs-core';
+import { IModuleConfigService } from '@flusys/nestjs-shared/interfaces';
+import { NotificationModuleOptions } from '../interfaces';
+export declare class NotificationConfigService implements IModuleConfigService {
+    private readonly options;
+    constructor(options: NotificationModuleOptions);
+    isCompanyFeatureEnabled(): boolean;
+    getDatabaseMode(): DatabaseMode;
+    isMultiTenant(): boolean;
+    isRealtimeEnabled(): boolean;
+    getJwtSecret(): string | undefined;
+    getOptions(): NotificationModuleOptions;
+}

package/services/notification-datasource.provider.d.ts

@@ -0,0 +1,23 @@
+import { MultiTenantDataSourceService } from '@flusys/nestjs-shared/modules';
+import { IDatabaseConfig, ITenantDatabaseConfig } from '@flusys/nestjs-core';
+import { Logger } from '@nestjs/common';
+import { Request } from 'express';
+import { DataSource } from 'typeorm';
+import { NotificationConfigService } from './notification-config.service';
+export declare class NotificationDataSourceProvider extends MultiTenantDataSourceService {
+    private readonly configService;
+    protected readonly logger: Logger;
+    protected static readonly tenantConnections: Map<string, DataSource>;
+    protected static singleDataSource: DataSource | null;
+    protected static readonly tenantsRegistry: Map<string, ITenantDatabaseConfig>;
+    protected static initialized: boolean;
+    protected static readonly connectionLocks: Map<string, Promise<DataSource>>;
+    protected static singleConnectionLock: Promise<DataSource> | null;
+    constructor(configService: NotificationConfigService, request?: Request);
+    private static buildParentOptions;
+    getEnableCompanyFeatureForTenant(tenant?: ITenantDatabaseConfig): boolean;
+    getNotificationEntities(enableCompanyFeature?: boolean): Promise<any[]>;
+    protected createDataSourceFromConfig(config: IDatabaseConfig): Promise<DataSource>;
+    protected getSingleDataSource(): Promise<DataSource>;
+    protected getOrCreateTenantConnection(tenant: ITenantDatabaseConfig): Promise<DataSource>;
+}

package/services/notification-helper.service.d.ts

@@ -0,0 +1,44 @@
+import { HybridCache } from '@flusys/nestjs-shared/classes';
+import { UtilsService } from '@flusys/nestjs-shared/modules';
+import { NotificationConfigService } from './notification-config.service';
+import { NotificationDataSourceProvider } from './notification-datasource.provider';
+import { NotificationGateway } from '../gateways';
+import { NotificationBase } from '../entities';
+import { NotificationType } from '@flusys/nestjs-shared/enums';
+export interface SendNotificationOptions {
+    userId: string;
+    title: string;
+    message?: string | null;
+    type?: NotificationType | string;
+    data?: Record<string, unknown> | null;
+    companyId?: string | null;
+}
+export interface SendBulkNotificationOptions {
+    userIds: string[];
+    title: string;
+    message?: string | null;
+    type?: NotificationType | string;
+    data?: Record<string, unknown> | null;
+    companyId?: string | null;
+}
+export declare class NotificationHelperService {
+    private readonly cacheManager;
+    private readonly utilsService;
+    private readonly configService;
+    private readonly dataSourceProvider;
+    private readonly gateway?;
+    private readonly logger;
+    private readonly entityName;
+    private dataSource;
+    constructor(cacheManager: HybridCache, utilsService: UtilsService, configService: NotificationConfigService, dataSourceProvider: NotificationDataSourceProvider, gateway?: NotificationGateway);
+    private getDataSource;
+    private getRepository;
+    send(options: SendNotificationOptions): Promise<NotificationBase>;
+    sendToMany(options: SendBulkNotificationOptions): Promise<NotificationBase[]>;
+    sendToCompany(companyId: string, title: string, message?: string | null, type?: NotificationType | string, data?: Record<string, unknown> | null): Promise<void>;
+    isUserOnline(userId: string): boolean;
+    getOnlineUserCount(): number;
+    private emitRealtime;
+    private toPayload;
+    private clearCache;
+}