@techextensor/tab-core-utility 2.2.199 → 2.2.200

package/esm2022/lib/tab-core-utility/core/service/signalr/signalr.service.mjs

@@ -55,13 +55,29 @@ export class SignalRService {
         });
     }
     /**
-     * Establish a connection to the SignalR hub
+     * Establish a connection to the SignalR hub.
+     *
+     * Awaitable — the returned promise resolves when the first connection attempt
+     * settles (success or failure). Idempotent: repeated calls are de-duplicated;
+     * if already CONNECTED, resolves immediately.
      *
-     * This method is idempotent - if the connection is already established, it will not be re-established.
      * Hub URL is read from Common.signalRHubUrl (set during app initialization via Common.init())
      */
-    connect() {
-        this.infrastructure.connect();
+    async connect() {
+        await this.infrastructure.connect();
+    }
+    /**
+     * Tear down the connection (call from auth signOut or cross-tab logout).
+     *
+     * - Stops the hub and clears tracked groups
+     * - Drops all component registrations (stale once the socket dies)
+     * - Errors any in-flight waitForOperation() observers so the UI doesn't
+     *   strand until the 120s timeout
+     */
+    async disconnect() {
+        await this.infrastructure.disconnect();
+        this.componentRegistry.clear();
+        this.operationTracker.cancelAll('disconnected');
     }
     /**
      * Register component for real-time notifications
@@ -204,4 +220,4 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.2.21", ngImpo
                     providedIn: 'root',
                 }]
         }], ctorParameters: () => [] });
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"signalr.service.js","sourceRoot":"","sources":["../../../../../../../../../libs/data-access/src/lib/tab-core-utility/core/service/signalr/signalr.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { Injectable, inject, computed } from '@angular/core';\r\nimport { Observable } from 'rxjs';\r\nimport { SignalRInfrastructure } from './signalr-infrastructure.service';\r\nimport { OperationTrackerService } from './operation-tracker.service';\r\nimport {\r\n  CrudNotification,\r\n  NotificationCallback,\r\n  PendingOperation,\r\n  CONNECTION_STATE,\r\n} from '../../../app/interfaces/signalr.interface';\r\n\r\n/**\r\n * SignalR Service\r\n * Public API for:\r\n * 1. Components to register for real-time CRUD notifications\r\n * 2. Services (TabFormioService) to track async operations\r\n *\r\n * Usage in components:\r\n * ```typescript\r\n * ngOnInit() {\r\n *   this.signalRService.register(\r\n *     this.componentId,\r\n *     this.appObjectId,\r\n *     (notification) => this.handleNotification(notification)\r\n *   );\r\n * }\r\n *\r\n * ngOnDestroy() {\r\n *   this.signalRService.unregister(this.componentId, this.appObjectId);\r\n * }\r\n * ```\r\n *\r\n * Usage in services (TabFormioService):\r\n * ```typescript\r\n * const correlationId = response.correlationId;\r\n * this.signalRService.waitForOperation(correlationId).subscribe(notification => {\r\n *   // Handle completed operation\r\n * });\r\n * ```\r\n */\r\n@Injectable({\r\n  providedIn: 'root',\r\n})\r\nexport class SignalRService {\r\n  private infrastructure = inject(SignalRInfrastructure);\r\n  private operationTracker = inject(OperationTrackerService);\r\n\r\n  // Registry: Map<appObjectId, Map<componentId, callback>>\r\n  private componentRegistry = new Map<string, Map<string, NotificationCallback>>();\r\n\r\n  /**\r\n   * Get connection state (for UI indicators)\r\n   */\r\n  readonly connectionState = this.infrastructure.connectionState;\r\n\r\n  /**\r\n   * Check if currently connected\r\n   */\r\n  readonly isConnected = computed(() => this.connectionState() === CONNECTION_STATE.CONNECTED);\r\n\r\n  constructor() {\r\n    // Listen to notifications from infrastructure and route them\r\n    this.infrastructure.notifications$.subscribe((notification) => {\r\n      // 1. Check if this is a tracked async operation (processRequest)\r\n      this.operationTracker.handleNotification(notification);\r\n\r\n      // 2. Also notify components subscribed to this appObjectId (Grid, etc.)\r\n      this.notifyComponents(notification);\r\n    });\r\n  }\r\n\r\n  /**\r\n   * Establish a connection to the SignalR hub\r\n   *\r\n   * This method is idempotent - if the connection is already established, it will not be re-established.\r\n   * Hub URL is read from Common.signalRHubUrl (set during app initialization via Common.init())\r\n   */\r\n  connect(): void {\r\n    this.infrastructure.connect();\r\n  }\r\n\r\n  /**\r\n   * Register component for real-time notifications\r\n   *\r\n   * @param componentId - Unique component identifier (generated by component)\r\n   * @param appObjectId - AppObject ID to subscribe to\r\n   * @param callback - Function to call when notification received\r\n   */\r\n  register(componentId: string, appObjectId: string, callback: NotificationCallback): void {\r\n    // Initialize map for this AppObject if doesn't exist\r\n    if (!this.componentRegistry.has(appObjectId)) {\r\n      this.componentRegistry.set(appObjectId, new Map());\r\n    }\r\n\r\n    const components = this.componentRegistry.get(appObjectId)!;\r\n\r\n    // First component for this AppObject? Join SignalR group\r\n    if (components.size === 0) {\r\n      this.infrastructure.joinGroup(appObjectId);\r\n    }\r\n\r\n    // Add component to registry\r\n    components.set(componentId, callback);\r\n  }\r\n\r\n  /**\r\n   * Unregister component (cleanup on component destroy)\r\n   *\r\n   * @param componentId - Component identifier to remove\r\n   * @param appObjectId - AppObject ID to unsubscribe from\r\n   */\r\n  unregister(componentId: string, appObjectId: string): void {\r\n    const components = this.componentRegistry.get(appObjectId);\r\n    if (!components) {\r\n      return;\r\n    }\r\n\r\n    // Remove component from registry\r\n    components.delete(componentId);\r\n\r\n    // Last component for this AppObject? Leave SignalR group\r\n    if (components.size === 0) {\r\n      this.infrastructure.leaveGroup(appObjectId);\r\n      this.componentRegistry.delete(appObjectId);\r\n    }\r\n  }\r\n\r\n  /**\r\n   * Wait for specific async operation to complete\r\n   * Used by TabFormioService for async processRequest operations\r\n   *\r\n   * @param correlationId - Correlation ID from backend response\r\n   * @param timeout - Optional timeout in milliseconds\r\n   * @returns Observable that emits when operation completes\r\n   */\r\n  waitForOperation(correlationId: string, timeout?: number): Observable<CrudNotification> {\r\n    return this.operationTracker.waitForOperation(correlationId, timeout);\r\n  }\r\n\r\n  /**\r\n   * Register async operation for tracking\r\n   * Optional - waitForOperation handles registration automatically\r\n   *\r\n   * @param operation - Pending operation details\r\n   */\r\n  registerOperation(operation: PendingOperation): void {\r\n    this.operationTracker.registerOperation(operation);\r\n  }\r\n\r\n  /**\r\n   * Check if operation is pending\r\n   */\r\n  isOperationPending(correlationId: string): boolean {\r\n    return this.operationTracker.isPending(correlationId);\r\n  }\r\n\r\n  /**\r\n   * Notify all registered components for an AppObject\r\n   * Called when notification received from SignalR hub\r\n   */\r\n  private notifyComponents(notification: CrudNotification): void {\r\n    const components = this.componentRegistry.get(notification.appObjectId);\r\n\r\n    if (!components || components.size === 0) {\r\n      // No components registered for this AppObject - ignore notification\r\n      return;\r\n    }\r\n\r\n    // Call each component's callback\r\n    components.forEach((callback, componentId) => {\r\n      try {\r\n        callback(notification);\r\n      } catch (error) {\r\n        console.error(`[SignalR Service] Callback failed for component ${componentId}:`, error);\r\n      }\r\n    });\r\n  }\r\n\r\n  /**\r\n   * Get active AppObject groups (for debugging)\r\n   */\r\n  getActiveGroups(): string[] {\r\n    return Array.from(this.componentRegistry.keys());\r\n  }\r\n\r\n  /**\r\n   * Get component count for an AppObject (for debugging)\r\n   */\r\n  getComponentCount(appObjectId: string): number {\r\n    return this.componentRegistry.get(appObjectId)?.size || 0;\r\n  }\r\n\r\n  /**\r\n   * Get total registered components across all AppObjects (for debugging)\r\n   */\r\n  getTotalComponentCount(): number {\r\n    let total = 0;\r\n    this.componentRegistry.forEach((components) => {\r\n      total += components.size;\r\n    });\r\n    return total;\r\n  }\r\n\r\n  /**\r\n   * Get registry state (for debugging)\r\n   */\r\n  getRegistryState(): { appObjectId: string; componentCount: number }[] {\r\n    const state: { appObjectId: string; componentCount: number }[] = [];\r\n\r\n    this.componentRegistry.forEach((components, appObjectId) => {\r\n      state.push({\r\n        appObjectId,\r\n        componentCount: components.size,\r\n      });\r\n    });\r\n\r\n    return state;\r\n  }\r\n\r\n  /**\r\n   * Get pending operations count (for debugging)\r\n   */\r\n  getPendingOperationsCount(): number {\r\n    return this.operationTracker.getPendingCount();\r\n  }\r\n\r\n  /**\r\n   * Get all pending operations (for debugging)\r\n   */\r\n  getPendingOperations(): PendingOperation[] {\r\n    return this.operationTracker.getAllPending();\r\n  }\r\n}"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"signalr.service.js","sourceRoot":"","sources":["../../../../../../../../../libs/data-access/src/lib/tab-core-utility/core/service/signalr/signalr.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { Injectable, inject, computed } from '@angular/core';\r\nimport { Observable } from 'rxjs';\r\nimport { SignalRInfrastructure } from './signalr-infrastructure.service';\r\nimport { OperationTrackerService } from './operation-tracker.service';\r\nimport {\r\n  CrudNotification,\r\n  NotificationCallback,\r\n  PendingOperation,\r\n  CONNECTION_STATE,\r\n} from '../../../app/interfaces/signalr.interface';\r\n\r\n/**\r\n * SignalR Service\r\n * Public API for:\r\n * 1. Components to register for real-time CRUD notifications\r\n * 2. Services (TabFormioService) to track async operations\r\n *\r\n * Usage in components:\r\n * ```typescript\r\n * ngOnInit() {\r\n *   this.signalRService.register(\r\n *     this.componentId,\r\n *     this.appObjectId,\r\n *     (notification) => this.handleNotification(notification)\r\n *   );\r\n * }\r\n *\r\n * ngOnDestroy() {\r\n *   this.signalRService.unregister(this.componentId, this.appObjectId);\r\n * }\r\n * ```\r\n *\r\n * Usage in services (TabFormioService):\r\n * ```typescript\r\n * const correlationId = response.correlationId;\r\n * this.signalRService.waitForOperation(correlationId).subscribe(notification => {\r\n *   // Handle completed operation\r\n * });\r\n * ```\r\n */\r\n@Injectable({\r\n  providedIn: 'root',\r\n})\r\nexport class SignalRService {\r\n  private infrastructure = inject(SignalRInfrastructure);\r\n  private operationTracker = inject(OperationTrackerService);\r\n\r\n  // Registry: Map<appObjectId, Map<componentId, callback>>\r\n  private componentRegistry = new Map<string, Map<string, NotificationCallback>>();\r\n\r\n  /**\r\n   * Get connection state (for UI indicators)\r\n   */\r\n  readonly connectionState = this.infrastructure.connectionState;\r\n\r\n  /**\r\n   * Check if currently connected\r\n   */\r\n  readonly isConnected = computed(() => this.connectionState() === CONNECTION_STATE.CONNECTED);\r\n\r\n  constructor() {\r\n    // Listen to notifications from infrastructure and route them\r\n    this.infrastructure.notifications$.subscribe((notification) => {\r\n      // 1. Check if this is a tracked async operation (processRequest)\r\n      this.operationTracker.handleNotification(notification);\r\n\r\n      // 2. Also notify components subscribed to this appObjectId (Grid, etc.)\r\n      this.notifyComponents(notification);\r\n    });\r\n  }\r\n\r\n  /**\r\n   * Establish a connection to the SignalR hub.\r\n   *\r\n   * Awaitable — the returned promise resolves when the first connection attempt\r\n   * settles (success or failure). Idempotent: repeated calls are de-duplicated;\r\n   * if already CONNECTED, resolves immediately.\r\n   *\r\n   * Hub URL is read from Common.signalRHubUrl (set during app initialization via Common.init())\r\n   */\r\n  async connect(): Promise<void> {\r\n    await this.infrastructure.connect();\r\n  }\r\n\r\n  /**\r\n   * Tear down the connection (call from auth signOut or cross-tab logout).\r\n   *\r\n   * - Stops the hub and clears tracked groups\r\n   * - Drops all component registrations (stale once the socket dies)\r\n   * - Errors any in-flight waitForOperation() observers so the UI doesn't\r\n   *   strand until the 120s timeout\r\n   */\r\n  async disconnect(): Promise<void> {\r\n    await this.infrastructure.disconnect();\r\n    this.componentRegistry.clear();\r\n    this.operationTracker.cancelAll('disconnected');\r\n  }\r\n\r\n  /**\r\n   * Register component for real-time notifications\r\n   *\r\n   * @param componentId - Unique component identifier (generated by component)\r\n   * @param appObjectId - AppObject ID to subscribe to\r\n   * @param callback - Function to call when notification received\r\n   */\r\n  register(componentId: string, appObjectId: string, callback: NotificationCallback): void {\r\n    // Initialize map for this AppObject if doesn't exist\r\n    if (!this.componentRegistry.has(appObjectId)) {\r\n      this.componentRegistry.set(appObjectId, new Map());\r\n    }\r\n\r\n    const components = this.componentRegistry.get(appObjectId)!;\r\n\r\n    // First component for this AppObject? Join SignalR group\r\n    if (components.size === 0) {\r\n      this.infrastructure.joinGroup(appObjectId);\r\n    }\r\n\r\n    // Add component to registry\r\n    components.set(componentId, callback);\r\n  }\r\n\r\n  /**\r\n   * Unregister component (cleanup on component destroy)\r\n   *\r\n   * @param componentId - Component identifier to remove\r\n   * @param appObjectId - AppObject ID to unsubscribe from\r\n   */\r\n  unregister(componentId: string, appObjectId: string): void {\r\n    const components = this.componentRegistry.get(appObjectId);\r\n    if (!components) {\r\n      return;\r\n    }\r\n\r\n    // Remove component from registry\r\n    components.delete(componentId);\r\n\r\n    // Last component for this AppObject? Leave SignalR group\r\n    if (components.size === 0) {\r\n      this.infrastructure.leaveGroup(appObjectId);\r\n      this.componentRegistry.delete(appObjectId);\r\n    }\r\n  }\r\n\r\n  /**\r\n   * Wait for specific async operation to complete\r\n   * Used by TabFormioService for async processRequest operations\r\n   *\r\n   * @param correlationId - Correlation ID from backend response\r\n   * @param timeout - Optional timeout in milliseconds\r\n   * @returns Observable that emits when operation completes\r\n   */\r\n  waitForOperation(correlationId: string, timeout?: number): Observable<CrudNotification> {\r\n    return this.operationTracker.waitForOperation(correlationId, timeout);\r\n  }\r\n\r\n  /**\r\n   * Register async operation for tracking\r\n   * Optional - waitForOperation handles registration automatically\r\n   *\r\n   * @param operation - Pending operation details\r\n   */\r\n  registerOperation(operation: PendingOperation): void {\r\n    this.operationTracker.registerOperation(operation);\r\n  }\r\n\r\n  /**\r\n   * Check if operation is pending\r\n   */\r\n  isOperationPending(correlationId: string): boolean {\r\n    return this.operationTracker.isPending(correlationId);\r\n  }\r\n\r\n  /**\r\n   * Notify all registered components for an AppObject\r\n   * Called when notification received from SignalR hub\r\n   */\r\n  private notifyComponents(notification: CrudNotification): void {\r\n    const components = this.componentRegistry.get(notification.appObjectId);\r\n\r\n    if (!components || components.size === 0) {\r\n      // No components registered for this AppObject - ignore notification\r\n      return;\r\n    }\r\n\r\n    // Call each component's callback\r\n    components.forEach((callback, componentId) => {\r\n      try {\r\n        callback(notification);\r\n      } catch (error) {\r\n        console.error(`[SignalR Service] Callback failed for component ${componentId}:`, error);\r\n      }\r\n    });\r\n  }\r\n\r\n  /**\r\n   * Get active AppObject groups (for debugging)\r\n   */\r\n  getActiveGroups(): string[] {\r\n    return Array.from(this.componentRegistry.keys());\r\n  }\r\n\r\n  /**\r\n   * Get component count for an AppObject (for debugging)\r\n   */\r\n  getComponentCount(appObjectId: string): number {\r\n    return this.componentRegistry.get(appObjectId)?.size || 0;\r\n  }\r\n\r\n  /**\r\n   * Get total registered components across all AppObjects (for debugging)\r\n   */\r\n  getTotalComponentCount(): number {\r\n    let total = 0;\r\n    this.componentRegistry.forEach((components) => {\r\n      total += components.size;\r\n    });\r\n    return total;\r\n  }\r\n\r\n  /**\r\n   * Get registry state (for debugging)\r\n   */\r\n  getRegistryState(): { appObjectId: string; componentCount: number }[] {\r\n    const state: { appObjectId: string; componentCount: number }[] = [];\r\n\r\n    this.componentRegistry.forEach((components, appObjectId) => {\r\n      state.push({\r\n        appObjectId,\r\n        componentCount: components.size,\r\n      });\r\n    });\r\n\r\n    return state;\r\n  }\r\n\r\n  /**\r\n   * Get pending operations count (for debugging)\r\n   */\r\n  getPendingOperationsCount(): number {\r\n    return this.operationTracker.getPendingCount();\r\n  }\r\n\r\n  /**\r\n   * Get all pending operations (for debugging)\r\n   */\r\n  getPendingOperations(): PendingOperation[] {\r\n    return this.operationTracker.getAllPending();\r\n  }\r\n}"]}

package/index.d.ts

@@ -37,6 +37,7 @@ export * from './lib/tab-core-utility/app/interfaces/orgInfo.interface';
 export * from './lib/tab-core-utility/app/interfaces/schema.interface';
 export * from './lib/tab-core-utility/app/interfaces/grid.interface';
 export * from './lib/tab-core-utility/app/interfaces/signalr.interface';
+export * from './lib/tab-core-utility/app/interfaces/notification.interface';
 export * from './lib/tab-core-utility/app/interfaces/release.interface';
 export * from './lib/tab-core-utility/app/models/api-query.class';
 export * from './lib/tab-core-utility/app/models/app-field.model';
@@ -71,6 +72,8 @@ export * from './lib/tab-core-utility/core/service/encryption.service';
 export * from './lib/tab-core-utility/core/service/signalr/signalr.service';
 export * from './lib/tab-core-utility/core/service/signalr/signalr-infrastructure.service';
 export * from './lib/tab-core-utility/core/service/signalr/operation-tracker.service';
+export * from './lib/tab-core-utility/core/service/notification/notification-inbox.service';
+export * from './lib/tab-core-utility/core/service/notification/notification-websocket.service';
 export * from './lib/tab-core-utility/core/pipe/translate.pipe';
 export * from './lib/tab-core-utility/core/provider/translation.provider';
 export * from './lib/tab-core-utility/core/provider/notification.provider';

package/lib/tab-core-utility/app/constants/common.d.ts

@@ -11,6 +11,8 @@ export declare class Common {
     static apiServiceUrls: APIServiceUrls;
     /** SignalR hub URL for real-time notifications */
     static signalRHubUrl: string;
+    /** Notification WebSocket URL for in-app inbox */
+    static notificationWebSocketUrl: string;
     /**
      * Schema source of truth.
      * Reading is cheap (returns the backing field).

package/lib/tab-core-utility/app/interfaces/notification.interface.d.ts

@@ -0,0 +1,154 @@
+/**
+ * Notification types & WebSocket protocol constants.
+ * Driven by the TAF Notification Service API doc.
+ */
+/**
+ * Notification status lifecycle (per BE confirmation):
+ *
+ *   Pending    — record just created (not yet visible in inbox)
+ *   Delivered  — successfully sent over WebSocket (visible, shown as unread)
+ *   Read       — after mark_notification_read / mark_all_notification_read
+ *   Done       — after clear_notification / clear_all_notifications (soft delete, filtered out)
+ *   Failed     — WebSocket send failed (filtered out)
+ *
+ * Inbox `get_notifications_response` only returns `Delivered` + `Read`.
+ * `isRead` is derived as `status === 'Read'`.
+ */
+export type NotificationStatus = 'Pending' | 'Delivered' | 'Read' | 'Done' | 'Failed';
+export type NotificationPriority = 'Low' | 'Normal' | 'High' | 'Urgent';
+export type WsConnectionState = 'Disconnected' | 'Connecting' | 'Connected' | 'Reconnecting' | 'Failed' | 'Closed';
+export declare const WS_CONNECTION_STATE: {
+    readonly DISCONNECTED: "Disconnected";
+    readonly CONNECTING: "Connecting";
+    readonly CONNECTED: "Connected";
+    readonly RECONNECTING: "Reconnecting";
+    readonly FAILED: "Failed";
+    readonly CLOSED: "Closed";
+};
+export type NotificationActionType = 'Navigate' | 'Dismiss';
+/**
+ * WebSocket message types (per BE doc).
+ * Outbound: client → server.
+ * Inbound: server → client (responses + push events).
+ */
+export declare const WS_MESSAGE_TYPE: {
+    readonly PING: "ping";
+    readonly HEARTBEAT: "heartbeat";
+    readonly GET_NOTIFICATIONS: "get_notifications";
+    readonly GET_UNREAD_COUNT: "get_unread_count";
+    readonly MARK_NOTIFICATION_READ: "mark_notification_read";
+    readonly MARK_ALL_NOTIFICATION_READ: "mark_all_notification_read";
+    readonly CLEAR_NOTIFICATION: "clear_notification";
+    readonly CLEAR_ALL_NOTIFICATIONS: "clear_all_notifications";
+    readonly CONNECTION_ESTABLISHED: "connection_established";
+    readonly PONG: "pong";
+    readonly HEARTBEAT_ACK: "heartbeat_ack";
+    readonly GET_NOTIFICATIONS_RESPONSE: "get_notifications_response";
+    readonly GET_UNREAD_COUNT_RESPONSE: "get_unread_count_response";
+    readonly MARK_NOTIFICATION_READ_RESPONSE: "mark_notification_read_response";
+    readonly MARK_ALL_NOTIFICATION_READ_RESPONSE: "mark_all_notification_read_response";
+    readonly CLEAR_NOTIFICATION_RESPONSE: "clear_notification_response";
+    readonly CLEAR_ALL_NOTIFICATIONS_RESPONSE: "clear_all_notifications_response";
+    readonly NOTIFICATION_MARKED_READ: "notification_marked_read";
+    readonly NOTIFICATION_CLEARED: "notification_cleared";
+    readonly ALL_NOTIFICATIONS_CLEARED: "all_notifications_cleared";
+    readonly NOTIFICATION: "notification";
+    readonly ERROR: "error";
+};
+export type WsMessageType = typeof WS_MESSAGE_TYPE[keyof typeof WS_MESSAGE_TYPE];
+export declare const NOTIFICATION_WS_CONFIG: {
+    readonly DEFAULT_PAGE_SIZE: 20;
+    readonly RECONNECT_DELAYS_MS: readonly [2000, 5000, 10000];
+    readonly RECONNECT_MAX_DELAY_MS: 10000;
+};
+/**
+ * One item in `get_notifications_response.notifications[]` per BE doc.
+ */
+export interface NotificationItem {
+    id: string;
+    status: NotificationStatus;
+    data: string;
+    priority: NotificationPriority;
+    workspaceKey: string;
+    provider: string;
+    createdAt: string;
+    updatedAt: string;
+    expiresAt: string | null;
+    errorMessage: string | null;
+}
+/**
+ * Live-push payload — fields flat at top level (NOT inside `data`).
+ */
+export interface NotificationPushPayload {
+    id: string;
+    title: string;
+    body: string;
+    category: string;
+    priority: NotificationPriority;
+    workspaceKey: string;
+    createdAt: string;
+}
+/**
+ * Action object inside the `data` JSON of an inbox notification.
+ */
+export interface NotificationAction {
+    label: string;
+    url: string;
+    type: NotificationActionType;
+}
+/**
+ * Parsed contents of an inbox notification's `data` JSON string.
+ */
+export interface ParsedNotificationPayload {
+    title?: string;
+    body?: string;
+    category?: string;
+    priority?: NotificationPriority;
+    actions?: NotificationAction[];
+    [key: string]: unknown;
+}
+/**
+ * Canonical UI shape after normalization.
+ * Both inbox items and live pushes are normalized into this.
+ */
+export interface UiNotification {
+    id: string;
+    createdAt: string;
+    status: NotificationStatus;
+    priority: NotificationPriority;
+    parsedPayload: ParsedNotificationPayload;
+    isRead: boolean;
+}
+/**
+ * Auth identifiers required to open the WebSocket and address messages.
+ * The app supplies these at connect time — the core service does not read storage.
+ */
+export interface NotificationConnectParams {
+    /** End user — required for the URL. */
+    userId: string;
+    /** Application — used in URL + workspaceKey. */
+    appId: string;
+    /** Tenant — used in URL + workspaceKey. */
+    tenantId: string;
+    /** Environment — used in workspaceKey only. */
+    environmentId: string;
+}
+/**
+ * Composed once at the app boundary, passed down to the inbox service.
+ * Used as the URL query for the WebSocket and in every outbound message body.
+ */
+export interface NotificationInboxConnectParams {
+    userId: string;
+    appId: string;
+    tenantId: string;
+    /** `tenantId.appId.environmentId` — pre-composed by the SDK facade. */
+    workspaceKey: string;
+}
+/**
+ * URL-only params for the low-level transport.
+ */
+export interface NotificationWebSocketConnectParams {
+    userId: string;
+    appId: string;
+    tenantId: string;
+}

package/lib/tab-core-utility/core/service/notification/notification-inbox.service.d.ts

@@ -0,0 +1,80 @@
+import { Observable } from 'rxjs';
+import { NotificationInboxConnectParams, UiNotification } from '../../../app/interfaces/notification.interface';
+import * as i0 from "@angular/core";
+/**
+ * Public notification inbox service.
+ *
+ * Pure — no storage / auth coupling. The caller (SDK facade) supplies all auth
+ * identifiers via `connect(params)`, and they're held for the lifetime of the
+ * connection (cleared on disconnect).
+ *
+ * Subscribes to the WebSocket transport, routes incoming messages by type into
+ * dedicated streams, and exposes high-level actions for the UI.
+ *
+ * Components/extensions consume this via the SDK facade (`TabSdk.notification.*`),
+ * not directly.
+ *
+ * Named `NotificationInboxService` to avoid collision with the existing toastr
+ * `NotificationService` in `core/service/notification.service.ts`.
+ */
+export declare class NotificationInboxService {
+    private readonly ws;
+    private workspaceKey;
+    private readonly latestNotifications$;
+    private readonly unreadCount$;
+    private readonly markAsReadEvent$;
+    private readonly clearEvent$;
+    private readonly loading$;
+    private readonly totalPages$;
+    constructor();
+    /**
+     * Connect to the notification WebSocket. Awaitable, idempotent.
+     *
+     * If a connection is already active for a *different* workspace (tenant/app/env
+     * switch without signOut), we tear it down first so the new connection uses
+     * the correct URL and workspaceKey. The underlying `ws.connect` is idempotent
+     * by connection state, so it would otherwise keep the stale URL.
+     *
+     * Once connected, an unread-count fetch is fired automatically so the badge populates.
+     */
+    connect(params: NotificationInboxConnectParams): Promise<void>;
+    /**
+     * Tear down the connection. Resets all stream state so the UI clears.
+     */
+    disconnect(): Promise<void>;
+    /**
+     * Fetch a page of notifications. Server replies via GET_NOTIFICATIONS_RESPONSE.
+     */
+    loadMore(pageNumber: number, pageSize?: number): void;
+    /**
+     * Request unread count. Result arrives on `unreadCount$`.
+     */
+    requestUnreadCount(): void;
+    markAsRead(notificationId: string): void;
+    markAllAsRead(): void;
+    clearOne(notificationId: string): void;
+    clearAll(): void;
+    getLatestNotifications(): Observable<UiNotification | UiNotification[]>;
+    getUnreadCount(): Observable<number>;
+    getMarkAsReadEvents(): Observable<string | null>;
+    getClearEvents(): Observable<string[] | null>;
+    getLoadingState(): Observable<boolean>;
+    getTotalPages(): Observable<number>;
+    private handleMessage;
+    /**
+     * Parse an inbox notification's `data` JSON into a UI-shaped object.
+     *
+     * Read state is surfaced via `status === 'Read'` (confirmed by BE).
+     * Inbox response only contains `Delivered` (unread) + `Read` items;
+     * `Pending` / `Done` / `Failed` are filtered out server-side.
+     */
+    private parseInboxNotification;
+    /**
+     * Wrap a server-pushed live notification into the same UI shape as inbox items.
+     * The push event has fields flat at the top level (NOT inside `data`) — synthesize
+     * `parsedPayload` from those fields so the component sees a uniform shape.
+     */
+    private transformPushNotification;
+    static ɵfac: i0.ɵɵFactoryDeclaration<NotificationInboxService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<NotificationInboxService>;
+}

package/lib/tab-core-utility/core/service/notification/notification-websocket.service.d.ts

@@ -0,0 +1,56 @@
+import { Subject } from 'rxjs';
+import { NotificationWebSocketConnectParams, WsConnectionState } from '../../../app/interfaces/notification.interface';
+import * as i0 from "@angular/core";
+/**
+ * Low-level Notification WebSocket transport.
+ *
+ * Pure — no storage / auth coupling. The caller (SDK facade or app layer)
+ * supplies all auth identifiers via `connect(params)`.
+ *
+ * Mirrors the SignalR infrastructure pattern:
+ *  - connect() is idempotent, dedupes concurrent calls, tears down stale sockets
+ *  - disconnect() flips an explicit-disconnected flag so retries don't revive
+ *  - state exposed as Angular signal
+ *  - inbound messages forwarded on `messages$` for higher-level service to route
+ *
+ * Internal use — consumers should use `NotificationInboxService` instead.
+ */
+export declare class NotificationWebSocketService {
+    private socket;
+    private socketSub;
+    private connectingPromise;
+    private explicitlyDisconnected;
+    private lastParams;
+    private reconnectAttempt;
+    private reconnectTimer;
+    readonly connectionState: import("@angular/core").WritableSignal<WsConnectionState>;
+    readonly messages$: Subject<any>;
+    /**
+     * Establish the WebSocket connection.
+     *
+     * Idempotent — if already OPEN, resolves immediately.
+     * In-flight calls are de-duplicated.
+     * Any stale (non-OPEN) socket is torn down before rebuild.
+     */
+    connect(params: NotificationWebSocketConnectParams): Promise<void>;
+    private doConnect;
+    /**
+     * Send a message over the socket. Silently no-ops if not connected.
+     */
+    send(message: Record<string, any>): void;
+    /**
+     * Tear down the socket.
+     *
+     * Sets explicitlyDisconnected so any pending retry timers become no-ops,
+     * then closes the socket and clears state.
+     */
+    disconnect(): Promise<void>;
+    private handleIncoming;
+    private scheduleReconnect;
+    /**
+     * Snapshot of current connection state — for debugging.
+     */
+    isConnected(): boolean;
+    static ɵfac: i0.ɵɵFactoryDeclaration<NotificationWebSocketService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<NotificationWebSocketService>;
+}

package/lib/tab-core-utility/core/service/signalr/operation-tracker.service.d.ts

@@ -9,13 +9,15 @@ import * as i0 from "@angular/core";
 export declare class OperationTrackerService {
     private pendingOperations;
     private operationCompleted$;
+    private cancellation$;
     /**
      * Register an async operation for tracking
      */
     registerOperation(operation: PendingOperation): void;
     /**
      * Wait for operation to complete via SignalR notification
-     * Returns Observable that emits when notification with matching correlationId is received
+     * Returns Observable that emits when notification with matching correlationId is received,
+     * or errors if cancelAll() is invoked (e.g. on disconnect / signOut).
      */
     waitForOperation(correlationId: string, timeoutMs?: number): Observable<CrudNotification>;
     /**
@@ -23,6 +25,12 @@ export declare class OperationTrackerService {
      * Called by SignalRService when notification is received
      */
     handleNotification(notification: CrudNotification): void;
+    /**
+     * Cancel all pending operations — errors all open waitForOperation() observers.
+     * Called by SignalRService.disconnect() so in-flight CRUD UIs resolve fast
+     * instead of stranding until the 120s timeout.
+     */
+    cancelAll(reason: string): void;
     /**
      * Check if operation is pending
      */

package/lib/tab-core-utility/core/service/signalr/signalr-infrastructure.service.d.ts

@@ -10,6 +10,8 @@ import * as i0 from "@angular/core";
  */
 export declare class SignalRInfrastructure {
     private hubConnection;
+    private connectingPromise;
+    private explicitlyDisconnected;
     readonly sessionStorageService: SessionStorageService;
     readonly localStorageService: LocalStorageService;
     readonly connectionState: import("@angular/core").WritableSignal<ConnectionState>;
@@ -28,8 +30,14 @@ export declare class SignalRInfrastructure {
     get token(): string | null;
     /**
      * Connect to SignalR hub
+     *
+     * Idempotent and safe to call from multiple sites:
+     * - already CONNECTED → returns immediately
+     * - already CONNECTING → returns the in-flight promise
+     * - any non-Connected leftover hubConnection → torn down before rebuild
      */
     connect(): Promise<void>;
+    private doConnect;
     /**
      * Register SignalR event handlers for CRUD notifications
      */
@@ -62,6 +70,9 @@ export declare class SignalRInfrastructure {
     isConnected(): boolean;
     /**
      * Disconnect from SignalR hub (cleanup)
+     *
+     * Sets explicitlyDisconnected so any pending retry timers from connect()/onclose
+     * become no-ops, then stops the hub and clears tracked groups.
      */
     disconnect(): Promise<void>;
     /**

package/lib/tab-core-utility/core/service/signalr/signalr.service.d.ts

@@ -44,12 +44,24 @@ export declare class SignalRService {
     readonly isConnected: import("@angular/core").Signal<boolean>;
     constructor();
     /**
-     * Establish a connection to the SignalR hub
+     * Establish a connection to the SignalR hub.
+     *
+     * Awaitable — the returned promise resolves when the first connection attempt
+     * settles (success or failure). Idempotent: repeated calls are de-duplicated;
+     * if already CONNECTED, resolves immediately.
      *
-     * This method is idempotent - if the connection is already established, it will not be re-established.
      * Hub URL is read from Common.signalRHubUrl (set during app initialization via Common.init())
      */
-    connect(): void;
+    connect(): Promise<void>;
+    /**
+     * Tear down the connection (call from auth signOut or cross-tab logout).
+     *
+     * - Stops the hub and clears tracked groups
+     * - Drops all component registrations (stale once the socket dies)
+     * - Errors any in-flight waitForOperation() observers so the UI doesn't
+     *   strand until the 120s timeout
+     */
+    disconnect(): Promise<void>;
     /**
      * Register component for real-time notifications
      *

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@techextensor/tab-core-utility",
-  "version": "2.2.199",
+  "version": "2.2.200",
   "peerDependencies": {
     "@angular/common": "^19.2.15",
     "@angular/core": "^19.2.15",