@flusys/nestjs-notification 4.1.1 → 5.0.1

package/README.md

@@ -1,74 +1,9 @@
 # @flusys/nestjs-notification
 
-> Real-time notification system for NestJS — WebSocket via Socket.IO, persistent PostgreSQL storage, read/unread tracking, company broadcasting, and a cross-module adapter for dependency-free integration.
+Real-time notification system for NestJS — Socket.IO WebSocket delivery, persistent PostgreSQL storage, read/unread tracking, and a cross-module adapter so any package can send notifications without importing this one directly.
 
 [![npm version](https://img.shields.io/npm/v/@flusys/nestjs-notification.svg)](https://www.npmjs.com/package/@flusys/nestjs-notification)
 [![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
-[![NestJS](https://img.shields.io/badge/NestJS-11.x-red.svg)](https://nestjs.com/)
-[![TypeScript](https://img.shields.io/badge/TypeScript-5.x-blue.svg)](https://www.typescriptlang.org/)
-[![Node.js](https://img.shields.io/badge/Node.js-%3E%3D18.x-green.svg)](https://nodejs.org/)
-
----
-
-## Table of Contents
-
-- [Overview](#overview)
-- [Features](#features)
-- [Compatibility](#compatibility)
-- [Installation](#installation)
-- [Quick Start](#quick-start)
-- [Module Registration](#module-registration)
-  - [forRoot (Sync)](#forroot-sync)
-  - [forRootAsync (Factory)](#forrootasync-factory)
-- [Configuration Reference](#configuration-reference)
-- [Feature Toggles](#feature-toggles)
-- [WebSocket Gateway](#websocket-gateway)
-  - [Client Connection](#client-connection)
-  - [WebSocket Events](#websocket-events)
-- [API Endpoints](#api-endpoints)
-- [Entities](#entities)
-- [Cross-Module Adapter (NOTIFICATION_ADAPTER)](#cross-module-adapter-notification_adapter)
-- [Exported Services](#exported-services)
-- [Sending Notifications Programmatically](#sending-notifications-programmatically)
-- [Frontend Integration](#frontend-integration)
-- [Troubleshooting](#troubleshooting)
-- [License](#license)
-
----
-
-## Overview
-
-`@flusys/nestjs-notification` delivers notifications both in real-time (Socket.IO WebSocket) and persistently (PostgreSQL). Unread notifications survive disconnections and are delivered on the next connection. The `NOTIFICATION_ADAPTER` allows auth, email, and other modules to send notifications without importing this package directly.
-
----
-
-## Features
-
-- **Persistent storage** — Notifications stored in PostgreSQL with read/unread tracking
-- **Real-time WebSocket** — Socket.IO gateway at `/notifications` namespace
-- **JWT authentication on WebSocket** — Token verified on connection handshake
-- **Read tracking** — `isRead` + `readAt` timestamp per notification
-- **Mark as read** — Single notification or bulk "mark all as read"
-- **Unread count** — Fast count query for notification badge
-- **Company scoping** — Filter by company in multi-company setups
-- **Broadcast to company** — Emit to all users in a company Socket.IO room
-- **Online presence** — Check if a user is currently connected
-- **Cross-module adapter** — `NOTIFICATION_ADAPTER` for sending from any module
-- **Configurable realtime** — Disable Socket.IO gateway when not needed
-
----
-
-## Compatibility
-
-| Package | Version |
-|---------|---------|
-| `@flusys/nestjs-core` | `^4.0.0` |
-| `@flusys/nestjs-shared` | `^4.0.0` |
-| `@nestjs/websockets` | `^11.0.0` |
-| `@nestjs/platform-socket.io` | `^11.0.0` |
-| `socket.io` | `^4.0.0` |
-| `jsonwebtoken` | `^9.0.0` |
-| Node.js | `>= 18.x` |
 
 ---
 
@@ -79,14 +14,13 @@ npm install @flusys/nestjs-notification @flusys/nestjs-shared @flusys/nestjs-cor
 npm install @nestjs/platform-socket.io socket.io
 ```
 
----
+## 1. Module Registration
 
-## Quick Start
+### forRoot (sync)
 
-### With Realtime Enabled
+#### Mode 1: Single Database
 
 ```typescript
-import { Module } from '@nestjs/common';
 import { NotificationModule } from '@flusys/nestjs-notification';
 
 @Module({
@@ -99,12 +33,12 @@ import { NotificationModule } from '@flusys/nestjs-notification';
         enableCompanyFeature: false,
       },
       config: {
-        enableRealtime: true,
-        jwtSecret: process.env.JWT_SECRET,
+        enableRealtime: true, // false = no Socket.IO gateway registered
+        jwtSecret: process.env.JWT_SECRET, // required for WebSocket auth
         defaultDatabaseConfig: {
-          type: 'postgres',
+          type: 'mysql',
           host: process.env.DB_HOST,
-          port: Number(process.env.DB_PORT ?? 5432),
+          port: Number(process.env.DB_PORT ?? 3306),
           username: process.env.DB_USER,
           password: process.env.DB_PASSWORD,
           database: process.env.DB_NAME,
@@ -116,64 +50,42 @@ import { NotificationModule } from '@flusys/nestjs-notification';
 export class AppModule {}
 ```
 
-### Using NOTIFICATION_ADAPTER in Another Module
-
-```typescript
-// In auth.service.ts — sends a notification after login
-import { NOTIFICATION_ADAPTER } from '@flusys/nestjs-shared/interfaces';
-import { INotificationAdapter } from '@flusys/nestjs-shared/interfaces';
-
-@Injectable()
-export class AuthenticationService {
-  constructor(
-    @Optional() @Inject(NOTIFICATION_ADAPTER)
-    private readonly notificationAdapter?: INotificationAdapter,
-  ) {}
-
-  async afterLogin(userId: string): Promise<void> {
-    await this.notificationAdapter?.send({
-      userId,
-      title: 'New Login',
-      message: 'Your account was accessed from a new device.',
-      type: 'warning',
-    });
-  }
-}
-```
-
----
-
-## Module Registration
-
-### forRoot (Sync)
+#### Mode 2: Multi-Tenant
 
 ```typescript
 NotificationModule.forRoot({
-  global?: boolean;
-  includeController?: boolean;       // Default: true
-  bootstrapAppConfig?: {
-    databaseMode: 'single' | 'multi-tenant';
-    enableCompanyFeature: boolean;
-  };
-  config?: {
-    enableRealtime?: boolean;        // Default: true — registers Socket.IO gateway
-    jwtSecret?: string;              // Required for WebSocket JWT authentication
-    defaultDatabaseConfig?: IDatabaseConfig;
-    tenants?: ITenantDatabaseConfig[];
-  };
-})
+  global: true,
+  includeController: true,
+  bootstrapAppConfig: {
+    databaseMode: 'multi-tenant',
+    enableCompanyFeature: true,
+  },
+  config: {
+    enableRealtime: true,
+    jwtSecret: process.env.JWT_SECRET,
+    tenantDefaultDatabaseConfig: {
+      type: 'mysql',
+      host: process.env.TENANT_DB_HOST,
+      port: Number(process.env.TENANT_DB_PORT ?? 3306),
+      username: process.env.TENANT_DB_USER,
+      password: process.env.TENANT_DB_PASSWORD,
+      database: process.env.TENANT_DB_NAME,
+    },
+    tenants: [
+      { id: 'tenant-a', database: 'tenant_a_db' },
+      { id: 'tenant-b', database: 'tenant_b_db' },
+    ],
+  },
+});
 ```
 
-**Behavior:**
-- `enableRealtime: false` → `NotificationGateway` is NOT registered (no WebSocket)
-- `includeController: false` → No HTTP endpoints registered
-- `global: true` → Exports available application-wide
-
-### forRootAsync (Factory)
+### forRootAsync (factory)
 
 ```typescript
-import { ConfigService } from '@nestjs/config';
+import { ConfigModule, ConfigService } from '@nestjs/config';
+import { NotificationModule, ITenantDatabaseConfig } from '@flusys/nestjs-notification';
 
+// Single database
 NotificationModule.forRootAsync({
   global: true,
   includeController: true,
@@ -182,389 +94,111 @@ NotificationModule.forRootAsync({
     enableCompanyFeature: true,
   },
   imports: [ConfigModule],
-  useFactory: (configService: ConfigService) => ({
+  useFactory: (config: ConfigService) => ({
     enableRealtime: true,
-    jwtSecret: configService.get('JWT_SECRET'),
+    jwtSecret: config.get('JWT_SECRET'),
     defaultDatabaseConfig: {
-      type: 'postgres',
-      host: configService.get('DB_HOST'),
-      port: configService.get<number>('DB_PORT'),
-      username: configService.get('DB_USER'),
-      password: configService.get('DB_PASSWORD'),
-      database: configService.get('DB_NAME'),
+      type: 'mysql',
+      host: config.get('DB_HOST'),
+      port: config.get<number>('DB_PORT'),
+      username: config.get('DB_USER'),
+      password: config.get('DB_PASSWORD'),
+      database: config.get('DB_NAME'),
     },
   }),
   inject: [ConfigService],
-})
-```
-
-**Exported services:**
-- `NotificationConfigService`
-- `NotificationDataSourceProvider`
-- `NotificationService`
-- `NotificationHelperService`
-- `NotificationGateway` *(when `enableRealtime: true`)*
-- `NOTIFICATION_ADAPTER`
-
----
-
-## Configuration Reference
-
-```typescript
-interface INotificationModuleConfig extends IDataSourceServiceOptions {
-  /** Enable Socket.IO WebSocket gateway (default: true) */
-  enableRealtime?: boolean;
-
-  /** JWT secret for WebSocket connection authentication */
-  jwtSecret?: string;
-}
-```
-
----
-
-## Feature Toggles
-
-| Feature | Config | Default | Effect |
-|---------|--------|---------|--------|
-| WebSocket gateway | `enableRealtime: true` | `true` | Registers `NotificationGateway` on `/notifications` namespace |
-| Company scoping | `enableCompanyFeature: true` | `false` | Uses `NotificationWithCompany` entity; adds company room broadcasting |
-| Multi-tenant | `databaseMode: 'multi-tenant'` | `'single'` | Per-tenant DataSource connections |
-
----
-
-## WebSocket Gateway
-
-The gateway runs on the `/notifications` Socket.IO namespace. JWT authentication is required on connection.
-
-### Client Connection
-
-**Browser (JavaScript):**
-
-```javascript
-import { io } from 'socket.io-client';
-
-const socket = io('http://localhost:2002/notifications', {
-  auth: { token: 'Bearer eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9...' },
-  transports: ['websocket'],
-});
-
-socket.on('connect', () => {
-  console.log('Connected to notification gateway');
 });
 
-socket.on('notification', (data) => {
-  console.log('New notification:', data);
-  // { id, title, message, type, data, createdAt }
-});
-
-socket.on('disconnect', () => {
-  console.log('Disconnected');
+// Multi-tenant
+NotificationModule.forRootAsync({
+  global: true,
+  includeController: true,
+  bootstrapAppConfig: {
+    databaseMode: 'multi-tenant',
+    enableCompanyFeature: true,
+  },
+  imports: [ConfigModule],
+  useFactory: (config: ConfigService) => ({
+    enableRealtime: true,
+    jwtSecret: config.get('JWT_SECRET'),
+    tenantDefaultDatabaseConfig: {
+      type: 'mysql',
+      host: config.get('TENANT_DB_HOST'),
+      port: config.get<number>('TENANT_DB_PORT'),
+      username: config.get('TENANT_DB_USER'),
+      password: config.get('TENANT_DB_PASSWORD'),
+      database: config.get('TENANT_DB_NAME'),
+    },
+    tenants: config.get<ITenantDatabaseConfig[]>('TENANTS'),
+  }),
+  inject: [ConfigService],
 });
 ```
 
-**Angular service:**
+## 2. Register Entities
 
 ```typescript
-import { io, Socket } from 'socket.io-client';
-
-@Injectable({ providedIn: 'root' })
-export class NotificationSocketService {
-  private socket: Socket;
-
-  connect(token: string): void {
-    this.socket = io(`${environment.apiUrl}/notifications`, {
-      auth: { token: `Bearer ${token}` },
-    });
-
-    this.socket.on('notification', (data) => {
-      this.handleNewNotification(data);
-    });
-  }
-
-  disconnect(): void {
-    this.socket?.disconnect();
-  }
-}
-```
-
-### WebSocket Events
-
-**Server → Client (emitted by the gateway):**
-
-| Event | Payload | Description |
-|-------|---------|-------------|
-| `notification` | `INotificationPayload` | New notification delivered in real-time |
-| `notification:count` | `{ count: number }` | Updated unread count |
-
-**Client → Server (handled by the gateway):**
-
-| Event | Payload | Description |
-|-------|---------|-------------|
-| `join:company` | `{ companyId: string }` | Join a company room for broadcast notifications |
-| `leave:company` | `{ companyId: string }` | Leave a company room |
-| `ping` | — | Keepalive |
-
----
-
-## API Endpoints
-
-All endpoints use **POST** and require JWT authentication.
-
-### Notifications — `POST /notification/*`
-
-| Endpoint | Auth | Description |
-|----------|------|-------------|
-| `POST /notification/get-all` | JWT | Get current user's notifications |
-| `POST /notification/get-unread-count` | JWT | Get unread notification count |
-| `POST /notification/mark-read` | JWT | Mark a single notification as read |
-| `POST /notification/mark-all-read` | JWT | Mark all notifications as read |
-| `POST /notification/delete` | JWT | Delete a notification |
-| `POST /notification/get/:id` | JWT | Get a notification by ID |
-
-### Admin — `POST /notification/admin/*`
-
-| Endpoint | Permission | Description |
-|----------|-----------|-------------|
-| `POST /notification/admin/send` | `notification.create` | Send notification to specific user(s) |
-| `POST /notification/admin/broadcast` | `notification.create` | Broadcast to all users in a company |
-| `POST /notification/admin/get-all` | `notification.read` | List all notifications (all users) |
-
-**Send notification request:**
-
-```json
-POST /notification/admin/send
-{
-  "userId": "uuid",
-  "title": "Order Shipped",
-  "message": "Your order #12345 has been shipped.",
-  "type": "success",
-  "data": { "orderId": "12345", "trackingUrl": "https://..." }
-}
-```
-
-**Broadcast to company:**
-
-```json
-POST /notification/admin/broadcast
-{
-  "companyId": "uuid",
-  "title": "System Maintenance",
-  "message": "The system will be down for maintenance at 2:00 AM.",
-  "type": "warning"
-}
-```
-
----
-
-## Entities
-
-### Core Entities
-
-| Entity | Table | Description |
-|--------|-------|-------------|
-| `Notification` | `notification` | User notification with type, title, message, JSON data, isRead, readAt |
-
-**Indexes:** `(userId, isRead)`, `(userId, createdAt)` for fast unread queries.
-
-### Company Feature Entities (`enableCompanyFeature: true`)
-
-| Entity | Table | Description |
-|--------|-------|-------------|
-| `NotificationWithCompany` | `notification` | Same + `companyId` column |
-
-**Additional index:** `(companyId, userId, isRead)`
-
-```typescript
-import { NotificationModule } from '@flusys/nestjs-notification';
+import { getNotificationEntitiesByConfig } from '@flusys/nestjs-notification/entities';
 
 TypeOrmModule.forRoot({
   entities: [
-    ...NotificationModule.getEntities({ enableCompanyFeature: true }),
+    ...getNotificationEntitiesByConfig(false), // match enableCompanyFeature in bootstrapAppConfig
   ],
-})
+});
 ```
 
----
-
-## Cross-Module Adapter (NOTIFICATION_ADAPTER)
-
-The `NOTIFICATION_ADAPTER` token is defined in `@flusys/nestjs-shared` so any module can send notifications without importing `@flusys/nestjs-notification`.
+| `enableCompanyFeature` | Entity registered                                   |
+| ---------------------- | --------------------------------------------------- |
+| `false`                | `Notification`                                      |
+| `true`                 | `NotificationWithCompany` (adds `companyId` column) |
 
-When `NotificationModule` is registered in the app, it provides the implementation. When it is not registered, `@Optional()` prevents injection errors.
 
-**INotificationAdapter interface (from `@flusys/nestjs-shared`):**
+## 4. Send Notifications Programmatically
 
-```typescript
-interface INotificationAdapter {
-  send(data: INotificationSendData): Promise<void>;
-  sendBulk(data: INotificationSendData[]): Promise<void>;
-  broadcast(companyId: string, data: Omit<INotificationSendData, 'userId'>): Promise<void>;
-  isUserOnline(userId: string): boolean;
-}
-
-interface INotificationSendData {
-  userId: string;
-  title: string;
-  message: string;
-  type?: 'info' | 'success' | 'warning' | 'error';
-  data?: Record<string, any>;
-  companyId?: string;
-}
-```
-
-**Usage pattern:**
+Use `NotificationHelperService` (singleton) from within the same application:
 
 ```typescript
-import { NOTIFICATION_ADAPTER, INotificationAdapter } from '@flusys/nestjs-shared/interfaces';
+import { NotificationHelperService } from '@flusys/nestjs-notification';
 
 @Injectable()
 export class OrderService {
   constructor(
-    @Optional() @Inject(NOTIFICATION_ADAPTER)
-    private readonly notifications?: INotificationAdapter,
+    @Inject(NotificationHelperService)
+    private readonly notifications: NotificationHelperService,
   ) {}
 
-  async shipOrder(orderId: string, userId: string): Promise<void> {
-    // ... ship order logic
-
-    // Send notification if adapter is available
-    await this.notifications?.send({
+  async afterShipment(orderId: string, userId: string): Promise<void> {
+    await this.notifications.send({
       userId,
       title: 'Order Shipped',
-      message: `Your order has been shipped.`,
-      type: 'success',
-      data: { orderId },
+      message: `Order ${orderId} is on its way.`,
+      type: 'success', // 'info' | 'success' | 'warning' | 'error'
+      data: { orderId }, // optional JSON payload for the client
     });
   }
-}
-```
-
----
 
-## Exported Services
-
-| Service | Description |
-|---------|-------------|
-| `NotificationService` | Notification CRUD (REQUEST-scoped) |
-| `NotificationHelperService` | Singleton service for programmatic sending |
-| `NotificationGateway` | Socket.IO gateway *(when `enableRealtime: true`)* |
-| `NotificationConfigService` | Runtime config and feature flags |
-| `NotificationDataSourceProvider` | Dynamic DataSource per request |
-| `NOTIFICATION_ADAPTER` | Cross-module adapter implementation |
-
----
-
-## Sending Notifications Programmatically
-
-Use `NotificationHelperService` (singleton) within the same application:
-
-```typescript
-import { NotificationHelperService } from '@flusys/nestjs-notification';
-
-@Injectable()
-export class PaymentService {
-  constructor(
-    @Inject(NotificationHelperService)
-    private readonly notificationHelper: NotificationHelperService,
-  ) {}
-
-  async afterPayment(userId: string, amount: number): Promise<void> {
-    await this.notificationHelper.send({
-      userId,
-      title: 'Payment Received',
-      message: `We received your payment of $${amount}.`,
-      type: 'success',
-      data: { amount },
-    });
+  // Broadcast to all users in a company (requires enableCompanyFeature: true)
+  async broadcastMaintenance(companyId: string): Promise<void> {
+    await this.notifications.sendToCompany(
+      companyId,
+      'Scheduled Maintenance',
+      'The system will be offline at 2:00 AM.',
+      'warning',
+    );
   }
 
-  async notifyCompany(companyId: string): Promise<void> {
-    await this.notificationHelper.broadcast(companyId, {
-      title: 'Company Announcement',
-      message: 'Check your email for important updates.',
+  // Send to multiple users at once
+  async notifyTeam(userIds: string[], message: string): Promise<void> {
+    await this.notifications.sendToMany({
+      userIds,
+      title: 'Team Update',
+      message,
       type: 'info',
     });
   }
 }
 ```
 
----
-
-## Frontend Integration
-
-### Unread Badge Count
-
-```typescript
-// Poll for unread count (or update via WebSocket event 'notification:count')
-async getUnreadCount(): Promise<number> {
-  const response = await this.http.post('/notification/get-unread-count', {}).toPromise();
-  return response.data.count;
-}
-```
-
-### Notification List
-
-```typescript
-async getNotifications(page = 1, pageSize = 20) {
-  return this.http.post('/notification/get-all', { page, pageSize }).toPromise();
-}
-```
-
-### Mark as Read
-
-```typescript
-// Single
-await this.http.post('/notification/mark-read', { id: notificationId }).toPromise();
-
-// All
-await this.http.post('/notification/mark-all-read', {}).toPromise();
-```
-
----
-
-## Troubleshooting
-
-**WebSocket connection rejected (401)**
-
-The JWT token in the `auth.token` field is invalid or expired. Ensure you pass `Bearer <token>` format:
-
-```javascript
-auth: { token: `Bearer ${accessToken}` }
-```
-
----
-
-**Notifications delivered via REST but not real-time**
-
-Check that `enableRealtime: true` is set in the config and `@nestjs/platform-socket.io` is installed. Also verify that the client is connecting to the correct namespace (`/notifications`).
-
----
-
-**Company broadcast not reaching all users**
-
-Users must join the company room via the `join:company` WebSocket event after connecting. If `enableCompanyFeature: false`, company rooms are not created.
-
----
-
-**`NOTIFICATION_ADAPTER` is `undefined`**
-
-`NotificationModule` is not registered. Use `@Optional() @Inject(NOTIFICATION_ADAPTER)` so the injection doesn't throw when the module is absent.
-
----
-
-**`No metadata for entity`**
-
-Register entities in `TypeOrmModule`:
-```typescript
-entities: [...NotificationModule.getEntities({ enableCompanyFeature: true })]
-```
-
----
-
 ## License
 
 MIT © FLUSYS
-
----
-
-> Part of the **FLUSYS** framework — a full-stack monorepo powering Angular 21 + NestJS 11 applications.

package/cjs/config/message-keys.js

@@ -3,37 +3,17 @@
 Object.defineProperty(exports, "__esModule", {
     value: true
 });
-function _export(target, all) {
-    for(var name in all)Object.defineProperty(target, name, {
-        enumerable: true,
-        get: Object.getOwnPropertyDescriptor(all, name).get
-    });
-}
-_export(exports, {
-    get NOTIFICATION_MESSAGES () {
+Object.defineProperty(exports, "NOTIFICATION_MESSAGES", {
+    enumerable: true,
+    get: function() {
         return NOTIFICATION_MESSAGES;
-    },
-    get NOTIFICATION_MODULE_MESSAGES () {
-        return NOTIFICATION_MODULE_MESSAGES;
     }
 });
 const NOTIFICATION_MESSAGES = {
-    CREATE_SUCCESS: 'notification.create.success',
-    CREATE_MANY_SUCCESS: 'notification.create.many.success',
-    GET_SUCCESS: 'notification.get.success',
-    GET_ALL_SUCCESS: 'notification.get.all.success',
-    UPDATE_SUCCESS: 'notification.update.success',
-    UPDATE_MANY_SUCCESS: 'notification.update.many.success',
-    DELETE_SUCCESS: 'notification.delete.success',
-    RESTORE_SUCCESS: 'notification.restore.success',
     NOT_FOUND: 'notification.not.found',
     MARK_READ_SUCCESS: 'notification.mark.read.success',
     MARK_ALL_READ_SUCCESS: 'notification.mark.all.read.success',
     UNREAD_COUNT_SUCCESS: 'notification.unread.count.success',
-    MY_NOTIFICATIONS_SUCCESS: 'notification.my.notifications.success',
     SEND_SUCCESS: 'notification.send.success',
     BROADCAST_SUCCESS: 'notification.broadcast.success'
 };
-const NOTIFICATION_MODULE_MESSAGES = {
-    NOTIFICATION: NOTIFICATION_MESSAGES
-};

package/cjs/docs/notification-swagger.config.js

@@ -8,12 +8,47 @@ Object.defineProperty(exports, "notificationSwaggerConfig", {
         return notificationSwaggerConfig;
     }
 });
-function notificationSwaggerConfig() {
+/** Schema properties to exclude when company feature is disabled */ const COMPANY_SCHEMA_EXCLUSIONS = [
+    {
+        schemaName: 'NotificationResponseDto',
+        properties: [
+            'companyId'
+        ]
+    },
+    {
+        schemaName: 'CreateNotificationDto',
+        properties: [
+            'companyId'
+        ]
+    },
+    {
+        schemaName: 'SendNotificationDto',
+        properties: [
+            'companyId'
+        ]
+    },
+    {
+        schemaName: 'SendBulkNotificationDto',
+        properties: [
+            'companyId'
+        ]
+    },
+    {
+        schemaName: 'UpdateNotificationDto',
+        properties: [
+            'companyId'
+        ]
+    }
+];
+function notificationSwaggerConfig(bootstrapConfig) {
+    const enableCompanyFeature = bootstrapConfig?.enableCompanyFeature ?? true;
+    const isMultiTenant = bootstrapConfig?.databaseMode === 'multi-tenant';
+    const multiTenantNote = isMultiTenant ? `\n> **Multi-Tenant Mode**: Include \`x-tenant-id\` header to target a specific tenant database.\n` : '';
     return {
         title: 'Notification API',
         description: `
 ## Notification API
-
+${multiTenantNote}
 Real-time notification system with WebSocket support.
 
 ### Features
@@ -56,6 +91,7 @@ ws://localhost:2002/notification?token=<jwt>
     `,
         version: '1.0',
         path: 'api/docs/notification',
-        bearerAuth: true
+        bearerAuth: true,
+        excludeSchemaProperties: enableCompanyFeature ? undefined : COMPANY_SCHEMA_EXCLUSIONS
     };
 }

package/cjs/entities/notification.entity.js

@@ -8,9 +8,10 @@ Object.defineProperty(exports, "Notification", {
         return Notification;
     }
 });
+const _nestjsshared = require("@flusys/nestjs-shared");
 const _entities = require("@flusys/nestjs-shared/entities");
-const _typeorm = require("typeorm");
 const _enums = require("@flusys/nestjs-shared/enums");
+const _typeorm = require("typeorm");
 function _define_property(obj, key, value) {
     if (key in obj) {
         Object.defineProperty(obj, key, {
@@ -73,7 +74,7 @@ _ts_decorate([
 ], Notification.prototype, "message", void 0);
 _ts_decorate([
     (0, _typeorm.Column)({
-        type: 'simple-json',
+        type: (0, _nestjsshared.getJsonColumnType)(),
         nullable: true
     }),
     _ts_metadata("design:type", Object)

package/cjs/gateways/notification.gateway.js

@@ -10,8 +10,8 @@ Object.defineProperty(exports, "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 _socketio = require("socket.io");
 const _notificationconfigservice = require("../services/notification-config.service");
 function _define_property(obj, key, value) {
     if (key in obj) {
@@ -107,6 +107,7 @@ let NotificationGateway = class NotificationGateway {
             client.join(`user:${userId}`);
             if (payload.companyId) {
                 client.join(`company:${payload.companyId}`);
+                client.join(`user:${userId}:company:${payload.companyId}`);
             }
         } catch  {
             client.disconnect();
@@ -126,33 +127,20 @@ let NotificationGateway = class NotificationGateway {
         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
+   * 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?.sockets?.adapter) {
+        if (!this.server) {
             return;
         }
         if (!companyId) {
             this.emitToUser(userId, event, data);
             return;
         }
-        const userRoom = `user:${userId}`;
-        const sockets = this.server.sockets.adapter.rooms.get(userRoom);
-        if (!sockets) {
-            return;
-        }
-        for (const socketId of sockets){
-            const socket = this.server.sockets.sockets.get(socketId);
-            if (socket && socket.data.companyId === companyId) {
-                socket.emit(event, data);
-            }
-        }
+        this.server.to(`user:${userId}:company:${companyId}`).emit(event, data);
     }
     emitToCompany(companyId, event, data) {
         this.server?.to(`company:${companyId}`).emit(event, data);

package/cjs/services/notification.service.js

@@ -8,13 +8,13 @@ Object.defineProperty(exports, "NotificationService", {
         return NotificationService;
     }
 });
-const _classes = require("@flusys/nestjs-shared/classes");
 const _nestjsshared = require("@flusys/nestjs-shared");
-const _config = require("../config");
+const _classes = require("@flusys/nestjs-shared/classes");
 const _interfaces = require("@flusys/nestjs-shared/interfaces");
 const _modules = require("@flusys/nestjs-shared/modules");
 const _utils = require("@flusys/nestjs-shared/utils");
 const _common = require("@nestjs/common");
+const _config = require("../config");
 const _entities = require("../entities");
 const _gateways = require("../gateways");
 const _notificationconfigservice = require("./notification-config.service");
@@ -160,10 +160,14 @@ let NotificationService = class NotificationService extends _classes.RequestScop
     }
     async markAllAsRead(user) {
         await this.ensureRepositoryInitialized();
-        const result = await this.repository.update({
+        const where = {
             userId: user.id,
             isRead: false
-        }, {
+        };
+        if (this.notificationConfig.isCompanyFeatureEnabled() && user.companyId) {
+            where.companyId = user.companyId;
+        }
+        const result = await this.repository.update(where, {
             isRead: true,
             readAt: new Date()
         });
@@ -174,11 +178,15 @@ let NotificationService = class NotificationService extends _classes.RequestScop
     }
     async getUnreadCount(user) {
         await this.ensureRepositoryInitialized();
+        const where = {
+            userId: user.id,
+            isRead: false
+        };
+        if (this.notificationConfig.isCompanyFeatureEnabled() && user.companyId) {
+            where.companyId = user.companyId;
+        }
         return this.repository.count({
-            where: {
-                userId: user.id,
-                isRead: false
-            }
+            where
         });
     }
     toPayload(entity) {

package/config/message-keys.d.ts

@@ -1,36 +1,8 @@
 export declare const NOTIFICATION_MESSAGES: {
-    readonly CREATE_SUCCESS: "notification.create.success";
-    readonly CREATE_MANY_SUCCESS: "notification.create.many.success";
-    readonly GET_SUCCESS: "notification.get.success";
-    readonly GET_ALL_SUCCESS: "notification.get.all.success";
-    readonly UPDATE_SUCCESS: "notification.update.success";
-    readonly UPDATE_MANY_SUCCESS: "notification.update.many.success";
-    readonly DELETE_SUCCESS: "notification.delete.success";
-    readonly RESTORE_SUCCESS: "notification.restore.success";
     readonly NOT_FOUND: "notification.not.found";
     readonly MARK_READ_SUCCESS: "notification.mark.read.success";
     readonly MARK_ALL_READ_SUCCESS: "notification.mark.all.read.success";
     readonly UNREAD_COUNT_SUCCESS: "notification.unread.count.success";
-    readonly MY_NOTIFICATIONS_SUCCESS: "notification.my.notifications.success";
     readonly SEND_SUCCESS: "notification.send.success";
     readonly BROADCAST_SUCCESS: "notification.broadcast.success";
 };
-export declare const NOTIFICATION_MODULE_MESSAGES: {
-    readonly NOTIFICATION: {
-        readonly CREATE_SUCCESS: "notification.create.success";
-        readonly CREATE_MANY_SUCCESS: "notification.create.many.success";
-        readonly GET_SUCCESS: "notification.get.success";
-        readonly GET_ALL_SUCCESS: "notification.get.all.success";
-        readonly UPDATE_SUCCESS: "notification.update.success";
-        readonly UPDATE_MANY_SUCCESS: "notification.update.many.success";
-        readonly DELETE_SUCCESS: "notification.delete.success";
-        readonly RESTORE_SUCCESS: "notification.restore.success";
-        readonly NOT_FOUND: "notification.not.found";
-        readonly MARK_READ_SUCCESS: "notification.mark.read.success";
-        readonly MARK_ALL_READ_SUCCESS: "notification.mark.all.read.success";
-        readonly UNREAD_COUNT_SUCCESS: "notification.unread.count.success";
-        readonly MY_NOTIFICATIONS_SUCCESS: "notification.my.notifications.success";
-        readonly SEND_SUCCESS: "notification.send.success";
-        readonly BROADCAST_SUCCESS: "notification.broadcast.success";
-    };
-};

package/docs/notification-swagger.config.d.ts

@@ -1,2 +1,3 @@
+import { IBootstrapAppConfig } from '@flusys/nestjs-core';
 import { IModuleSwaggerOptions } from '@flusys/nestjs-core/docs';
-export declare function notificationSwaggerConfig(): IModuleSwaggerOptions;
+export declare function notificationSwaggerConfig(bootstrapConfig?: IBootstrapAppConfig): IModuleSwaggerOptions;

package/fesm/config/message-keys.js

@@ -1,22 +1,9 @@
 // ==================== NOTIFICATION MODULE MESSAGE KEYS ====================
 export const NOTIFICATION_MESSAGES = {
-    CREATE_SUCCESS: 'notification.create.success',
-    CREATE_MANY_SUCCESS: 'notification.create.many.success',
-    GET_SUCCESS: 'notification.get.success',
-    GET_ALL_SUCCESS: 'notification.get.all.success',
-    UPDATE_SUCCESS: 'notification.update.success',
-    UPDATE_MANY_SUCCESS: 'notification.update.many.success',
-    DELETE_SUCCESS: 'notification.delete.success',
-    RESTORE_SUCCESS: 'notification.restore.success',
     NOT_FOUND: 'notification.not.found',
     MARK_READ_SUCCESS: 'notification.mark.read.success',
     MARK_ALL_READ_SUCCESS: 'notification.mark.all.read.success',
     UNREAD_COUNT_SUCCESS: 'notification.unread.count.success',
-    MY_NOTIFICATIONS_SUCCESS: 'notification.my.notifications.success',
     SEND_SUCCESS: 'notification.send.success',
     BROADCAST_SUCCESS: 'notification.broadcast.success'
 };
-// Aggregated export for backward compatibility
-export const NOTIFICATION_MODULE_MESSAGES = {
-    NOTIFICATION: NOTIFICATION_MESSAGES
-};

package/fesm/docs/notification-swagger.config.js

@@ -1,9 +1,44 @@
-export function notificationSwaggerConfig() {
+/** Schema properties to exclude when company feature is disabled */ const COMPANY_SCHEMA_EXCLUSIONS = [
+    {
+        schemaName: 'NotificationResponseDto',
+        properties: [
+            'companyId'
+        ]
+    },
+    {
+        schemaName: 'CreateNotificationDto',
+        properties: [
+            'companyId'
+        ]
+    },
+    {
+        schemaName: 'SendNotificationDto',
+        properties: [
+            'companyId'
+        ]
+    },
+    {
+        schemaName: 'SendBulkNotificationDto',
+        properties: [
+            'companyId'
+        ]
+    },
+    {
+        schemaName: 'UpdateNotificationDto',
+        properties: [
+            'companyId'
+        ]
+    }
+];
+export function notificationSwaggerConfig(bootstrapConfig) {
+    const enableCompanyFeature = bootstrapConfig?.enableCompanyFeature ?? true;
+    const isMultiTenant = bootstrapConfig?.databaseMode === 'multi-tenant';
+    const multiTenantNote = isMultiTenant ? `\n> **Multi-Tenant Mode**: Include \`x-tenant-id\` header to target a specific tenant database.\n` : '';
     return {
         title: 'Notification API',
         description: `
 ## Notification API
-
+${multiTenantNote}
 Real-time notification system with WebSocket support.
 
 ### Features
@@ -46,6 +81,7 @@ ws://localhost:2002/notification?token=<jwt>
     `,
         version: '1.0',
         path: 'api/docs/notification',
-        bearerAuth: true
+        bearerAuth: true,
+        excludeSchemaProperties: enableCompanyFeature ? undefined : COMPANY_SCHEMA_EXCLUSIONS
     };
 }

package/fesm/entities/notification.entity.js

@@ -20,9 +20,10 @@ function _ts_decorate(decorators, target, key, desc) {
 function _ts_metadata(k, v) {
     if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
 }
+import { getJsonColumnType } from '@flusys/nestjs-shared';
 import { Identity } from '@flusys/nestjs-shared/entities';
-import { Column, Entity, Index } from 'typeorm';
 import { NotificationType } from '@flusys/nestjs-shared/enums';
+import { Column, Entity, Index } from 'typeorm';
 export class Notification extends Identity {
     constructor(...args){
         super(...args), _define_property(this, "userId", void 0), _define_property(this, "type", void 0), _define_property(this, "title", void 0), _define_property(this, "message", void 0), _define_property(this, "data", void 0), _define_property(this, "isRead", void 0), _define_property(this, "readAt", void 0);
@@ -63,7 +64,7 @@ _ts_decorate([
 ], Notification.prototype, "message", void 0);
 _ts_decorate([
     Column({
-        type: 'simple-json',
+        type: getJsonColumnType(),
         nullable: true
     }),
     _ts_metadata("design:type", Object)

package/fesm/gateways/notification.gateway.js

@@ -27,8 +27,8 @@ function _ts_param(paramIndex, decorator) {
 }
 import { Inject } from '@nestjs/common';
 import { WebSocketGateway, WebSocketServer } from '@nestjs/websockets';
-import { Server } from 'socket.io';
 import * as jwt from 'jsonwebtoken';
+import { Server } from 'socket.io';
 import { NotificationConfigService } from '../services/notification-config.service';
 export class NotificationGateway {
     afterInit() {
@@ -56,6 +56,7 @@ export class NotificationGateway {
             client.join(`user:${userId}`);
             if (payload.companyId) {
                 client.join(`company:${payload.companyId}`);
+                client.join(`user:${userId}:company:${payload.companyId}`);
             }
         } catch  {
             client.disconnect();
@@ -75,33 +76,20 @@ export class NotificationGateway {
         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
+   * 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?.sockets?.adapter) {
+        if (!this.server) {
             return;
         }
         if (!companyId) {
             this.emitToUser(userId, event, data);
             return;
         }
-        const userRoom = `user:${userId}`;
-        const sockets = this.server.sockets.adapter.rooms.get(userRoom);
-        if (!sockets) {
-            return;
-        }
-        for (const socketId of sockets){
-            const socket = this.server.sockets.sockets.get(socketId);
-            if (socket && socket.data.companyId === companyId) {
-                socket.emit(event, data);
-            }
-        }
+        this.server.to(`user:${userId}:company:${companyId}`).emit(event, data);
     }
     emitToCompany(companyId, event, data) {
         this.server?.to(`company:${companyId}`).emit(event, data);

package/fesm/services/notification.service.js

@@ -25,13 +25,13 @@ function _ts_param(paramIndex, decorator) {
         decorator(target, key, paramIndex);
     };
 }
-import { HybridCache, RequestScopedApiService } from '@flusys/nestjs-shared/classes';
 import { LogAction } from '@flusys/nestjs-shared';
-import { NOTIFICATION_MESSAGES } from '../config';
+import { HybridCache, RequestScopedApiService } from '@flusys/nestjs-shared/classes';
 import { ILoggedUserInfo } from '@flusys/nestjs-shared/interfaces';
 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_MESSAGES } from '../config';
 import { Notification, NotificationWithCompany } from '../entities';
 import { NotificationGateway } from '../gateways';
 import { NotificationConfigService } from './notification-config.service';
@@ -150,10 +150,14 @@ export class NotificationService extends RequestScopedApiService {
     }
     async markAllAsRead(user) {
         await this.ensureRepositoryInitialized();
-        const result = await this.repository.update({
+        const where = {
             userId: user.id,
             isRead: false
-        }, {
+        };
+        if (this.notificationConfig.isCompanyFeatureEnabled() && user.companyId) {
+            where.companyId = user.companyId;
+        }
+        const result = await this.repository.update(where, {
             isRead: true,
             readAt: new Date()
         });
@@ -164,11 +168,15 @@ export class NotificationService extends RequestScopedApiService {
     }
     async getUnreadCount(user) {
         await this.ensureRepositoryInitialized();
+        const where = {
+            userId: user.id,
+            isRead: false
+        };
+        if (this.notificationConfig.isCompanyFeatureEnabled() && user.companyId) {
+            where.companyId = user.companyId;
+        }
         return this.repository.count({
-            where: {
-                userId: user.id,
-                isRead: false
-            }
+            where
         });
     }
     toPayload(entity) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@flusys/nestjs-notification",
-  "version": "4.1.1",
+  "version": "5.0.1",
   "description": "Notification module with real-time Socket.IO support",
   "main": "cjs/index.js",
   "module": "fesm/index.js",
@@ -92,8 +92,8 @@
     "express": "^4.18.0"
   },
   "dependencies": {
-    "@flusys/nestjs-core": "4.1.1",
-    "@flusys/nestjs-shared": "4.1.1",
+    "@flusys/nestjs-core": "5.0.1",
+    "@flusys/nestjs-shared": "5.0.1",
     "jsonwebtoken": "^9.0.0"
   }
 }