@techextensor/tab-core-utility 2.2.199 → 2.2.200

package/esm2022/lib/tab-core-utility/core/service/notification/notification-websocket.service.mjs

@@ -0,0 +1,209 @@
+import { Injectable, signal } from '@angular/core';
+import { Subject } from 'rxjs';
+import { webSocket } from 'rxjs/webSocket';
+import { Common } from '../../../app/constants/common';
+import { NOTIFICATION_WS_CONFIG, WS_CONNECTION_STATE, WS_MESSAGE_TYPE, } 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 class NotificationWebSocketService {
+    constructor() {
+        this.socket = null;
+        this.socketSub = null;
+        // In-flight connect promise — used to dedupe concurrent connect() calls
+        this.connectingPromise = null;
+        // Set true on explicit disconnect() so scheduled retries don't resurrect the connection
+        this.explicitlyDisconnected = false;
+        // Last connect params — kept so reconnect can rebuild the URL without the caller
+        // re-supplying them. Cleared on disconnect().
+        this.lastParams = null;
+        // Reconnect attempt counter (resets on successful connect)
+        this.reconnectAttempt = 0;
+        this.reconnectTimer = null;
+        // Connection state as Angular signal — for UI indicators / route resolvers
+        this.connectionState = signal(WS_CONNECTION_STATE.DISCONNECTED);
+        // Inbound message stream — NotificationInboxService subscribes and routes per type
+        this.messages$ = new Subject();
+    }
+    // ----------- public API -----------
+    /**
+     * 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.
+     */
+    async connect(params) {
+        this.explicitlyDisconnected = false;
+        this.lastParams = params;
+        if (this.connectionState() === WS_CONNECTION_STATE.CONNECTED) {
+            return;
+        }
+        if (this.connectingPromise) {
+            return this.connectingPromise;
+        }
+        if (this.socket) {
+            try {
+                this.socket.complete();
+            }
+            catch { /* ignore */ }
+            this.socket = null;
+            this.socketSub?.unsubscribe();
+            this.socketSub = null;
+        }
+        this.connectingPromise = this.doConnect(params);
+        try {
+            await this.connectingPromise;
+        }
+        finally {
+            this.connectingPromise = null;
+        }
+    }
+    async doConnect(params) {
+        const baseUrl = Common.notificationWebSocketUrl;
+        if (!baseUrl) {
+            this.connectionState.set(WS_CONNECTION_STATE.DISCONNECTED);
+            return;
+        }
+        if (!params.userId) {
+            console.warn('[NotificationWS] No userId provided — skipping connect');
+            this.connectionState.set(WS_CONNECTION_STATE.FAILED);
+            return;
+        }
+        // BE doc: ws://host/ws?userId=...&appId=...&tenantId=...
+        const url = `${baseUrl}?userId=${encodeURIComponent(params.userId)}` +
+            (params.appId ? `&appId=${encodeURIComponent(params.appId)}` : '') +
+            (params.tenantId ? `&tenantId=${encodeURIComponent(params.tenantId)}` : '');
+        this.connectionState.set(WS_CONNECTION_STATE.CONNECTING);
+        return new Promise((resolve) => {
+            this.socket = webSocket({
+                url,
+                openObserver: {
+                    next: () => {
+                        this.connectionState.set(WS_CONNECTION_STATE.CONNECTED);
+                        this.reconnectAttempt = 0;
+                        resolve();
+                    },
+                },
+                closeObserver: {
+                    next: () => {
+                        if (this.connectionState() !== WS_CONNECTION_STATE.CLOSED) {
+                            this.connectionState.set(WS_CONNECTION_STATE.DISCONNECTED);
+                        }
+                        this.scheduleReconnect();
+                        resolve();
+                    },
+                },
+            });
+            this.socketSub = this.socket.subscribe({
+                next: (msg) => this.handleIncoming(msg),
+                error: (err) => {
+                    console.error('[NotificationWS] Socket error:', err);
+                    this.connectionState.set(WS_CONNECTION_STATE.FAILED);
+                    this.scheduleReconnect();
+                    resolve();
+                },
+            });
+        });
+    }
+    /**
+     * Send a message over the socket. Silently no-ops if not connected.
+     */
+    send(message) {
+        if (!this.socket || this.connectionState() !== WS_CONNECTION_STATE.CONNECTED) {
+            return;
+        }
+        try {
+            this.socket.next(message);
+        }
+        catch (error) {
+            console.error('[NotificationWS] Failed to send message:', error);
+        }
+    }
+    /**
+     * Tear down the socket.
+     *
+     * Sets explicitlyDisconnected so any pending retry timers become no-ops,
+     * then closes the socket and clears state.
+     */
+    async disconnect() {
+        this.explicitlyDisconnected = true;
+        this.connectingPromise = null;
+        this.lastParams = null;
+        if (this.reconnectTimer) {
+            clearTimeout(this.reconnectTimer);
+            this.reconnectTimer = null;
+        }
+        if (this.socket) {
+            try {
+                this.socket.complete();
+            }
+            catch { /* ignore */ }
+            this.socket = null;
+        }
+        this.socketSub?.unsubscribe();
+        this.socketSub = null;
+        this.reconnectAttempt = 0;
+        this.connectionState.set(WS_CONNECTION_STATE.CLOSED);
+    }
+    // ----------- internal -----------
+    handleIncoming(message) {
+        if (!message || typeof message !== 'object')
+            return;
+        // Heartbeat: server pings every ~30s; we MUST reply or BE will close the socket.
+        if (message.type === WS_MESSAGE_TYPE.HEARTBEAT) {
+            this.send({ type: WS_MESSAGE_TYPE.HEARTBEAT });
+            return;
+        }
+        if (message.type === WS_MESSAGE_TYPE.CONNECTION_ESTABLISHED) {
+            this.connectionState.set(WS_CONNECTION_STATE.CONNECTED);
+        }
+        if (message.type === WS_MESSAGE_TYPE.ERROR) {
+            console.warn('[NotificationWS] Server error:', message.error);
+        }
+        this.messages$.next(message);
+    }
+    scheduleReconnect() {
+        if (this.explicitlyDisconnected)
+            return;
+        if (this.reconnectTimer)
+            return;
+        if (!this.lastParams)
+            return; // can't reconnect without params
+        const delays = NOTIFICATION_WS_CONFIG.RECONNECT_DELAYS_MS;
+        const delay = delays[Math.min(this.reconnectAttempt, delays.length - 1)];
+        this.reconnectAttempt++;
+        this.connectionState.set(WS_CONNECTION_STATE.RECONNECTING);
+        this.reconnectTimer = setTimeout(() => {
+            this.reconnectTimer = null;
+            if (!this.explicitlyDisconnected && this.lastParams) {
+                this.connect(this.lastParams);
+            }
+        }, delay);
+    }
+    /**
+     * Snapshot of current connection state — for debugging.
+     */
+    isConnected() {
+        return this.connectionState() === WS_CONNECTION_STATE.CONNECTED;
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "19.2.21", ngImport: i0, type: NotificationWebSocketService, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "19.2.21", ngImport: i0, type: NotificationWebSocketService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.2.21", ngImport: i0, type: NotificationWebSocketService, decorators: [{
+            type: Injectable,
+            args: [{ providedIn: 'root' }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"notification-websocket.service.js","sourceRoot":"","sources":["../../../../../../../../../libs/data-access/src/lib/tab-core-utility/core/service/notification/notification-websocket.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { Injectable, signal } from '@angular/core';\r\nimport { Subject, Subscription } from 'rxjs';\r\nimport { webSocket, WebSocketSubject } from 'rxjs/webSocket';\r\nimport { Common } from '../../../app/constants/common';\r\nimport {\r\n  NOTIFICATION_WS_CONFIG,\r\n  NotificationWebSocketConnectParams,\r\n  WS_CONNECTION_STATE,\r\n  WS_MESSAGE_TYPE,\r\n  WsConnectionState,\r\n} from '../../../app/interfaces/notification.interface';\r\n\r\n/**\r\n * Low-level Notification WebSocket transport.\r\n *\r\n * Pure — no storage / auth coupling. The caller (SDK facade or app layer)\r\n * supplies all auth identifiers via `connect(params)`.\r\n *\r\n * Mirrors the SignalR infrastructure pattern:\r\n *  - connect() is idempotent, dedupes concurrent calls, tears down stale sockets\r\n *  - disconnect() flips an explicit-disconnected flag so retries don't revive\r\n *  - state exposed as Angular signal\r\n *  - inbound messages forwarded on `messages$` for higher-level service to route\r\n *\r\n * Internal use — consumers should use `NotificationInboxService` instead.\r\n */\r\n@Injectable({ providedIn: 'root' })\r\nexport class NotificationWebSocketService {\r\n  private socket: WebSocketSubject<any> | null = null;\r\n  private socketSub: Subscription | null = null;\r\n\r\n  // In-flight connect promise — used to dedupe concurrent connect() calls\r\n  private connectingPromise: Promise<void> | null = null;\r\n\r\n  // Set true on explicit disconnect() so scheduled retries don't resurrect the connection\r\n  private explicitlyDisconnected = false;\r\n\r\n  // Last connect params — kept so reconnect can rebuild the URL without the caller\r\n  // re-supplying them. Cleared on disconnect().\r\n  private lastParams: NotificationWebSocketConnectParams | null = null;\r\n\r\n  // Reconnect attempt counter (resets on successful connect)\r\n  private reconnectAttempt = 0;\r\n  private reconnectTimer: ReturnType<typeof setTimeout> | null = null;\r\n\r\n  // Connection state as Angular signal — for UI indicators / route resolvers\r\n  readonly connectionState = signal<WsConnectionState>(WS_CONNECTION_STATE.DISCONNECTED);\r\n\r\n  // Inbound message stream — NotificationInboxService subscribes and routes per type\r\n  readonly messages$ = new Subject<any>();\r\n\r\n  // ----------- public API -----------\r\n\r\n  /**\r\n   * Establish the WebSocket connection.\r\n   *\r\n   * Idempotent — if already OPEN, resolves immediately.\r\n   * In-flight calls are de-duplicated.\r\n   * Any stale (non-OPEN) socket is torn down before rebuild.\r\n   */\r\n  async connect(params: NotificationWebSocketConnectParams): Promise<void> {\r\n    this.explicitlyDisconnected = false;\r\n    this.lastParams = params;\r\n\r\n    if (this.connectionState() === WS_CONNECTION_STATE.CONNECTED) {\r\n      return;\r\n    }\r\n\r\n    if (this.connectingPromise) {\r\n      return this.connectingPromise;\r\n    }\r\n\r\n    if (this.socket) {\r\n      try { this.socket.complete(); } catch { /* ignore */ }\r\n      this.socket = null;\r\n      this.socketSub?.unsubscribe();\r\n      this.socketSub = null;\r\n    }\r\n\r\n    this.connectingPromise = this.doConnect(params);\r\n    try {\r\n      await this.connectingPromise;\r\n    } finally {\r\n      this.connectingPromise = null;\r\n    }\r\n  }\r\n\r\n  private async doConnect(params: NotificationWebSocketConnectParams): Promise<void> {\r\n    const baseUrl = Common.notificationWebSocketUrl;\r\n    if (!baseUrl) {\r\n      this.connectionState.set(WS_CONNECTION_STATE.DISCONNECTED);\r\n      return;\r\n    }\r\n\r\n    if (!params.userId) {\r\n      console.warn('[NotificationWS] No userId provided — skipping connect');\r\n      this.connectionState.set(WS_CONNECTION_STATE.FAILED);\r\n      return;\r\n    }\r\n\r\n    // BE doc: ws://host/ws?userId=...&appId=...&tenantId=...\r\n    const url = `${baseUrl}?userId=${encodeURIComponent(params.userId)}` +\r\n      (params.appId ? `&appId=${encodeURIComponent(params.appId)}` : '') +\r\n      (params.tenantId ? `&tenantId=${encodeURIComponent(params.tenantId)}` : '');\r\n\r\n    this.connectionState.set(WS_CONNECTION_STATE.CONNECTING);\r\n\r\n    return new Promise<void>((resolve) => {\r\n      this.socket = webSocket<any>({\r\n        url,\r\n        openObserver: {\r\n          next: () => {\r\n            this.connectionState.set(WS_CONNECTION_STATE.CONNECTED);\r\n            this.reconnectAttempt = 0;\r\n            resolve();\r\n          },\r\n        },\r\n        closeObserver: {\r\n          next: () => {\r\n            if (this.connectionState() !== WS_CONNECTION_STATE.CLOSED) {\r\n              this.connectionState.set(WS_CONNECTION_STATE.DISCONNECTED);\r\n            }\r\n            this.scheduleReconnect();\r\n            resolve();\r\n          },\r\n        },\r\n      });\r\n\r\n      this.socketSub = this.socket.subscribe({\r\n        next: (msg) => this.handleIncoming(msg),\r\n        error: (err) => {\r\n          console.error('[NotificationWS] Socket error:', err);\r\n          this.connectionState.set(WS_CONNECTION_STATE.FAILED);\r\n          this.scheduleReconnect();\r\n          resolve();\r\n        },\r\n      });\r\n    });\r\n  }\r\n\r\n  /**\r\n   * Send a message over the socket. Silently no-ops if not connected.\r\n   */\r\n  send(message: Record<string, any>): void {\r\n    if (!this.socket || this.connectionState() !== WS_CONNECTION_STATE.CONNECTED) {\r\n      return;\r\n    }\r\n    try {\r\n      this.socket.next(message);\r\n    } catch (error) {\r\n      console.error('[NotificationWS] Failed to send message:', error);\r\n    }\r\n  }\r\n\r\n  /**\r\n   * Tear down the socket.\r\n   *\r\n   * Sets explicitlyDisconnected so any pending retry timers become no-ops,\r\n   * then closes the socket and clears state.\r\n   */\r\n  async disconnect(): Promise<void> {\r\n    this.explicitlyDisconnected = true;\r\n    this.connectingPromise = null;\r\n    this.lastParams = null;\r\n\r\n    if (this.reconnectTimer) {\r\n      clearTimeout(this.reconnectTimer);\r\n      this.reconnectTimer = null;\r\n    }\r\n\r\n    if (this.socket) {\r\n      try { this.socket.complete(); } catch { /* ignore */ }\r\n      this.socket = null;\r\n    }\r\n\r\n    this.socketSub?.unsubscribe();\r\n    this.socketSub = null;\r\n\r\n    this.reconnectAttempt = 0;\r\n    this.connectionState.set(WS_CONNECTION_STATE.CLOSED);\r\n  }\r\n\r\n  // ----------- internal -----------\r\n\r\n  private handleIncoming(message: any): void {\r\n    if (!message || typeof message !== 'object') return;\r\n\r\n    // Heartbeat: server pings every ~30s; we MUST reply or BE will close the socket.\r\n    if (message.type === WS_MESSAGE_TYPE.HEARTBEAT) {\r\n      this.send({ type: WS_MESSAGE_TYPE.HEARTBEAT });\r\n      return;\r\n    }\r\n\r\n    if (message.type === WS_MESSAGE_TYPE.CONNECTION_ESTABLISHED) {\r\n      this.connectionState.set(WS_CONNECTION_STATE.CONNECTED);\r\n    }\r\n\r\n    if (message.type === WS_MESSAGE_TYPE.ERROR) {\r\n      console.warn('[NotificationWS] Server error:', message.error);\r\n    }\r\n\r\n    this.messages$.next(message);\r\n  }\r\n\r\n  private scheduleReconnect(): void {\r\n    if (this.explicitlyDisconnected) return;\r\n    if (this.reconnectTimer) return;\r\n    if (!this.lastParams) return; // can't reconnect without params\r\n\r\n    const delays = NOTIFICATION_WS_CONFIG.RECONNECT_DELAYS_MS;\r\n    const delay = delays[Math.min(this.reconnectAttempt, delays.length - 1)];\r\n    this.reconnectAttempt++;\r\n\r\n    this.connectionState.set(WS_CONNECTION_STATE.RECONNECTING);\r\n\r\n    this.reconnectTimer = setTimeout(() => {\r\n      this.reconnectTimer = null;\r\n      if (!this.explicitlyDisconnected && this.lastParams) {\r\n        this.connect(this.lastParams);\r\n      }\r\n    }, delay);\r\n  }\r\n\r\n  /**\r\n   * Snapshot of current connection state — for debugging.\r\n   */\r\n  isConnected(): boolean {\r\n    return this.connectionState() === WS_CONNECTION_STATE.CONNECTED;\r\n  }\r\n}\r\n"]}

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

@@ -1,6 +1,6 @@
 import { Injectable } from '@angular/core';
-import { Subject, throwError, TimeoutError } from 'rxjs';
-import { filter, take, timeout, catchError } from 'rxjs/operators';
+import { merge, Subject, throwError, TimeoutError } from 'rxjs';
+import { filter, take, timeout, catchError, switchMap } from 'rxjs/operators';
 import { SIGNALR_CONFIG, } from '../../../app/interfaces/signalr.interface';
 import * as i0 from "@angular/core";
 /**
@@ -14,6 +14,8 @@ export class OperationTrackerService {
         this.pendingOperations = new Map();
         // Observable for completed operations
         this.operationCompleted$ = new Subject();
+        // Cancellation channel — emitted by cancelAll() to error any open waitForOperation observers
+        this.cancellation$ = new Subject();
     }
     /**
      * Register an async operation for tracking
@@ -29,7 +31,8 @@ export class OperationTrackerService {
     }
     /**
      * 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, timeoutMs = SIGNALR_CONFIG.DEFAULT_TIMEOUT) {
         // Auto-register so handleNotification can match it
@@ -40,8 +43,10 @@ export class OperationTrackerService {
                 timeout: timeoutMs
             });
         }
-        return this.operationCompleted$.pipe(filter((notification) => notification.correlationId === correlationId), take(1), timeout(timeoutMs), catchError((error) => {
-            // Cleanup on timeout
+        const completed$ = this.operationCompleted$.pipe(filter((notification) => notification.correlationId === correlationId), take(1));
+        const cancelled$ = this.cancellation$.pipe(take(1), switchMap((reason) => throwError(() => new Error(`SignalR operation cancelled: ${reason}`))));
+        return merge(completed$, cancelled$).pipe(take(1), timeout(timeoutMs), catchError((error) => {
+            // Cleanup on timeout / cancellation
             this.pendingOperations.delete(correlationId);
             if (error instanceof TimeoutError) {
                 return throwError(() => new Error('Operation timed out'));
@@ -62,6 +67,18 @@ export class OperationTrackerService {
             this.pendingOperations.delete(notification.correlationId);
         }
     }
+    /**
+     * 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) {
+        if (this.pendingOperations.size === 0) {
+            return;
+        }
+        this.pendingOperations.clear();
+        this.cancellation$.next(reason);
+    }
     /**
      * Check if operation is pending
      */
@@ -87,4 +104,4 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.2.21", ngImpo
             type: Injectable,
             args: [{ providedIn: 'root' }]
         }] });
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"operation-tracker.service.js","sourceRoot":"","sources":["../../../../../../../../../libs/data-access/src/lib/tab-core-utility/core/service/signalr/operation-tracker.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { Injectable } from '@angular/core';\r\nimport { merge, Observable, Subject, throwError, TimeoutError } from 'rxjs';\r\nimport { filter, take, timeout, catchError, switchMap } from 'rxjs/operators';\r\nimport {\r\n  CrudNotification,\r\n  PendingOperation,\r\n  SIGNALR_CONFIG,\r\n} from '../../../app/interfaces/signalr.interface';\r\n\r\n/**\r\n * Operation Tracker Service\r\n * Tracks async operations by correlationId and matches them with SignalR notifications\r\n * Used by TabFormioService for handling async processRequest operations\r\n */\r\n@Injectable({ providedIn: 'root' })\r\nexport class OperationTrackerService {\r\n  // Map<correlationId, PendingOperation>\r\n  private pendingOperations = new Map<string, PendingOperation>();\r\n\r\n  // Observable for completed operations\r\n  private operationCompleted$ = new Subject<CrudNotification>();\r\n\r\n  // Cancellation channel — emitted by cancelAll() to error any open waitForOperation observers\r\n  private cancellation$ = new Subject<string>();\r\n\r\n  /**\r\n   * Register an async operation for tracking\r\n   */\r\n  registerOperation(operation: PendingOperation): void {\r\n    this.pendingOperations.set(operation.correlationId, operation);\r\n\r\n    // Auto-cleanup after timeout\r\n    setTimeout(() => {\r\n      if (this.pendingOperations.has(operation.correlationId)) {\r\n        this.pendingOperations.delete(operation.correlationId);\r\n      }\r\n    }, operation.timeout || SIGNALR_CONFIG.DEFAULT_TIMEOUT);\r\n  }\r\n\r\n  /**\r\n   * Wait for operation to complete via SignalR notification\r\n   * Returns Observable that emits when notification with matching correlationId is received,\r\n   * or errors if cancelAll() is invoked (e.g. on disconnect / signOut).\r\n   */\r\n  waitForOperation(correlationId: string, timeoutMs: number = SIGNALR_CONFIG.DEFAULT_TIMEOUT): Observable<CrudNotification> {\r\n    // Auto-register so handleNotification can match it\r\n    if (!this.pendingOperations.has(correlationId)) {\r\n      this.registerOperation({\r\n        correlationId,\r\n        timestamp: new Date(),\r\n        timeout: timeoutMs\r\n      });\r\n    }\r\n\r\n    const completed$ = this.operationCompleted$.pipe(\r\n      filter((notification) => notification.correlationId === correlationId),\r\n      take(1)\r\n    );\r\n\r\n    const cancelled$ = this.cancellation$.pipe(\r\n      take(1),\r\n      switchMap((reason) => throwError(() => new Error(`SignalR operation cancelled: ${reason}`)))\r\n    );\r\n\r\n    return merge(completed$, cancelled$).pipe(\r\n      take(1),\r\n      timeout(timeoutMs),\r\n      catchError((error) => {\r\n        // Cleanup on timeout / cancellation\r\n        this.pendingOperations.delete(correlationId);\r\n\r\n        if (error instanceof TimeoutError) {\r\n          return throwError(() => new Error('Operation timed out'));\r\n        }\r\n        return throwError(() => error);\r\n      })\r\n    );\r\n  }\r\n\r\n  /**\r\n   * Handle incoming SignalR notification\r\n   * Called by SignalRService when notification is received\r\n   */\r\n  handleNotification(notification: CrudNotification): void {\r\n    const operation = this.pendingOperations.get(notification.correlationId);\r\n    if (operation) {\r\n      // Emit to observers waiting for this operation\r\n      this.operationCompleted$.next(notification);\r\n\r\n      // Cleanup\r\n      this.pendingOperations.delete(notification.correlationId);\r\n    }\r\n  }\r\n\r\n  /**\r\n   * Cancel all pending operations — errors all open waitForOperation() observers.\r\n   * Called by SignalRService.disconnect() so in-flight CRUD UIs resolve fast\r\n   * instead of stranding until the 120s timeout.\r\n   */\r\n  cancelAll(reason: string): void {\r\n    if (this.pendingOperations.size === 0) {\r\n      return;\r\n    }\r\n    this.pendingOperations.clear();\r\n    this.cancellation$.next(reason);\r\n  }\r\n\r\n  /**\r\n   * Check if operation is pending\r\n   */\r\n  isPending(correlationId: string): boolean {\r\n    return this.pendingOperations.has(correlationId);\r\n  }\r\n\r\n  /**\r\n   * Get pending operations count (for debugging)\r\n   */\r\n  getPendingCount(): number {\r\n    return this.pendingOperations.size;\r\n  }\r\n\r\n  /**\r\n   * Get all pending operations (for debugging)\r\n   */\r\n  getAllPending(): PendingOperation[] {\r\n    return Array.from(this.pendingOperations.values());\r\n  }\r\n}"]}

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

@@ -15,6 +15,10 @@ import * as i0 from "@angular/core";
 export class SignalRInfrastructure {
     constructor() {
         this.hubConnection = null;
+        // In-flight connect() promise — used to dedupe concurrent calls
+        this.connectingPromise = null;
+        // Set true on explicit disconnect() so scheduled retries don't resurrect the connection
+        this.explicitlyDisconnected = false;
         // Session storage
         this.sessionStorageService = inject(SessionStorageService);
         // local storage
@@ -73,11 +77,39 @@ export class SignalRInfrastructure {
     }
     /**
      * 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
      */
     async connect() {
+        this.explicitlyDisconnected = false;
         if (this.hubConnection?.state === signalR.HubConnectionState.Connected) {
             return;
         }
+        if (this.connectingPromise) {
+            return this.connectingPromise;
+        }
+        // Tear down any stale (non-Connected) hubConnection before rebuilding
+        if (this.hubConnection) {
+            try {
+                await this.hubConnection.stop();
+            }
+            catch {
+                // ignore — we're discarding it anyway
+            }
+            this.hubConnection = null;
+        }
+        this.connectingPromise = this.doConnect();
+        try {
+            await this.connectingPromise;
+        }
+        finally {
+            this.connectingPromise = null;
+        }
+    }
+    async doConnect() {
         // Get hub URL from Common (set during app initialization via Common.init())
         const hubUrl = Common.signalRHubUrl;
         if (!hubUrl) {
@@ -110,8 +142,12 @@ export class SignalRInfrastructure {
         }
         catch (error) {
             this.connectionState.set(CONNECTION_STATE.FAILED);
-            // Retry after 1 minute
-            setTimeout(() => this.connect(), 60 * 1000);
+            // Retry after 1 minute, but only if the caller hasn't explicitly disconnected
+            setTimeout(() => {
+                if (!this.explicitlyDisconnected) {
+                    this.connect();
+                }
+            }, 60 * 1000);
         }
     }
     /**
@@ -168,8 +204,12 @@ export class SignalRInfrastructure {
         });
         this.hubConnection.onclose(() => {
             this.connectionState.set(CONNECTION_STATE.DISCONNECTED);
-            // Try to reconnect
-            setTimeout(() => this.connect(), 60 * 1000);
+            // Try to reconnect — but only if the caller hasn't explicitly disconnected
+            setTimeout(() => {
+                if (!this.explicitlyDisconnected) {
+                    this.connect();
+                }
+            }, 60 * 1000);
         });
     }
     /**
@@ -237,18 +277,24 @@ export class SignalRInfrastructure {
     }
     /**
      * 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.
      */
     async disconnect() {
+        this.explicitlyDisconnected = true;
+        this.connectingPromise = null;
         if (this.hubConnection) {
             try {
                 await this.hubConnection.stop();
-                this.hubConnection = null;
-                this.connectionState.set(CONNECTION_STATE.DISCONNECTED);
             }
             catch (error) {
                 console.error('[SignalR] Error during disconnect:', error);
             }
+            this.hubConnection = null;
         }
+        this.activeGroups.clear();
+        this.connectionState.set(CONNECTION_STATE.DISCONNECTED);
     }
     /**
      * Get active groups (for debugging)
@@ -265,4 +311,4 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.2.21", ngImpo
                     providedIn: 'root',
                 }]
         }] });
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"signalr-infrastructure.service.js","sourceRoot":"","sources":["../../../../../../../../../libs/data-access/src/lib/tab-core-utility/core/service/signalr/signalr-infrastructure.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { inject, Injectable, signal } from '@angular/core';\r\nimport * as signalR from '@microsoft/signalr';\r\nimport { Subject } from 'rxjs';\r\nimport { Common } from '../../../app/constants/common';\r\nimport {\r\n  ConnectionState,\r\n  CrudNotification,\r\n  SignalRMessage,\r\n  SIGNALR_HUB_METHODS,\r\n  SIGNALR_EVENTS,\r\n  CRUD_OPERATION,\r\n  CONNECTION_STATE,\r\n} from '../../../app/interfaces/signalr.interface';\r\nimport { StorageConstants } from '../../../app/constants/storage-constants';\r\nimport { SessionStorageService } from '../../../auth/session-storage.service';\r\nimport { LocalStorageService } from '../../../auth/local-storage.service';\r\n\r\n/**\r\n * SignalR Infrastructure Service\r\n * Handles low-level WebSocket connection, group management, and reconnection\r\n * Internal use only - components should use SignalRService instead\r\n */\r\n@Injectable({\r\n  providedIn: 'root',\r\n})\r\nexport class SignalRInfrastructure {\r\n  private hubConnection: signalR.HubConnection | null = null;\r\n\r\n  // Session storage\r\n  readonly sessionStorageService = inject(SessionStorageService);\r\n\r\n  // local storage\r\n  readonly localStorageService = inject(LocalStorageService);\r\n\r\n  // Connection state as signal\r\n  readonly connectionState = signal<ConnectionState>(CONNECTION_STATE.DISCONNECTED);\r\n\r\n  // Notification stream (internal - emits to SignalRService)\r\n  readonly notifications$ = new Subject<CrudNotification>();\r\n\r\n  // Track active groups to rejoin after reconnection\r\n  private activeGroups = new Set<string>();\r\n\r\n  /**\r\n   * Helper method to get value from storage\r\n   * @param type The type of storage, 'Session' or 'Local'\r\n   * @param key The key to retrieve the value for\r\n   * @returns The value from storage, or null if not available\r\n   */\r\n  private getFromStorage(type: string, key: string) {\r\n    try {\r\n      let info: any = null;\r\n\r\n      if (type === 'Session') {\r\n        // Get value from session storage\r\n        info = this.sessionStorageService.getSessionStorage(key);\r\n      }\r\n\r\n      if (type === 'Local') {\r\n        // Get value from local storage\r\n        info = this.localStorageService.getLocalStorage(key);\r\n      }\r\n\r\n      if (info && typeof info === 'string') {\r\n        // Parse the value if it's a string\r\n        info = JSON.parse(info);\r\n      }\r\n\r\n      return info;\r\n    } catch (error) {\r\n      // Log error if failed to get value from storage\r\n      console.warn('Failed to get current app ID from session:', error);\r\n      return null;\r\n    }\r\n  }\r\n\r\n  get appId(): string | null {\r\n    const appInfo = this.getFromStorage('Session', StorageConstants.appInfo);\r\n    return appInfo?.Id || null;\r\n  }\r\n\r\n  get environmentId(): string | null {\r\n    const envInfo = this.getFromStorage('Session', StorageConstants.environmentInfo);\r\n    return envInfo?.Id || null;\r\n  }\r\n\r\n  get tenantId(): string | null {\r\n    const tenantInfo = this.getFromStorage('Local', StorageConstants.orgInfo);\r\n    return tenantInfo?.Id || null;\r\n  }\r\n\r\n  get token(): string | null {\r\n    const authInfo = this.getFromStorage('Local', StorageConstants.tokenInfo);\r\n    return authInfo?.token || null;\r\n  }\r\n\r\n  /**\r\n   * Connect to SignalR hub\r\n   */\r\n  async connect(): Promise<void> {\r\n    if (this.hubConnection?.state === signalR.HubConnectionState.Connected) {\r\n      return;\r\n    }\r\n\r\n    // Get hub URL from Common (set during app initialization via Common.init())\r\n    const hubUrl = Common.signalRHubUrl;\r\n\r\n    if (!hubUrl) {\r\n      console.error('[SignalR] Hub URL not configured. Make sure Common.init() is called with environment.');\r\n      return;\r\n    }\r\n\r\n    try {\r\n      this.connectionState.set(CONNECTION_STATE.CONNECTING);\r\n\r\n      this.hubConnection = new signalR.HubConnectionBuilder()\r\n        .withUrl(hubUrl, {\r\n          accessTokenFactory: () => this.token || '',\r\n          skipNegotiation: false,\r\n          transport: signalR.HttpTransportType.WebSockets | signalR.HttpTransportType.ServerSentEvents,\r\n        })\r\n        .withAutomaticReconnect({\r\n          nextRetryDelayInMilliseconds: (retryContext: any) => {\r\n            // Exponential backoff: 0s, 2s, 10s, 30s, max 60s\r\n            if (retryContext.elapsedMilliseconds < 60000) {\r\n              return Math.min(1000 * Math.pow(2, retryContext.previousRetryCount), 60000);\r\n            }\r\n            return null; // Stop retrying after 1 minute\r\n          },\r\n        })\r\n        .configureLogging(signalR.LogLevel.Information)\r\n        .build();\r\n\r\n      this.registerEventHandlers();\r\n      this.registerConnectionLifecycle();\r\n\r\n      await this.hubConnection.start();\r\n\r\n      this.connectionState.set(CONNECTION_STATE.CONNECTED);\r\n    } catch (error) {\r\n      this.connectionState.set(CONNECTION_STATE.FAILED);\r\n\r\n      // Retry after 1 minute\r\n      setTimeout(() => this.connect(), 60 * 1000);\r\n    }\r\n  }\r\n\r\n  /**\r\n   * Register SignalR event handlers for CRUD notifications\r\n   */\r\n  private registerEventHandlers(): void {\r\n    if (!this.hubConnection) return;\r\n\r\n    // INSERT notifications\r\n    this.hubConnection.on(SIGNALR_EVENTS.INSERT_COMPLETED, (...args: any[]) => {\r\n      const notification = this.extractNotification(args);\r\n      const enriched = { ...notification, operation: CRUD_OPERATION.INSERT, receivedAt: new Date() };\r\n      this.notifications$.next(enriched);\r\n    });\r\n\r\n    // UPDATE notifications\r\n    this.hubConnection.on(SIGNALR_EVENTS.UPDATE_COMPLETED, (...args: any[]) => {\r\n      const notification = this.extractNotification(args);\r\n      const enriched = { ...notification, operation: CRUD_OPERATION.UPDATE, receivedAt: new Date() };\r\n      this.notifications$.next(enriched);\r\n    });\r\n\r\n    // DELETE notifications\r\n    this.hubConnection.on(SIGNALR_EVENTS.DELETE_COMPLETED, (...args: any[]) => {\r\n      const notification = this.extractNotification(args);\r\n      const enriched = { ...notification, operation: CRUD_OPERATION.DELETE, receivedAt: new Date() };\r\n      this.notifications$.next(enriched);\r\n    });\r\n  }\r\n\r\n  /**\r\n   * Extract notification from SignalR callback args\r\n   * Handles both unwrapped (direct object) and wrapped ({ type, target, arguments }) formats\r\n   */\r\n  private extractNotification(args: any[]): CrudNotification {\r\n    const data = args[0];\r\n\r\n    // If SignalR didn't unwrap: data is raw SignalRMessage with { type, target, arguments: [...] }\r\n    if (data?.arguments && Array.isArray(data.arguments)) {\r\n      return (data as SignalRMessage).arguments[0];\r\n    }\r\n\r\n    // If SignalR unwrapped: data is the notification directly\r\n    return data as CrudNotification;\r\n  }\r\n\r\n  /**\r\n   * Register connection lifecycle handlers\r\n   */\r\n  private registerConnectionLifecycle(): void {\r\n    if (!this.hubConnection) return;\r\n\r\n    this.hubConnection.onreconnecting(() => {\r\n      this.connectionState.set(CONNECTION_STATE.RECONNECTING);\r\n    });\r\n\r\n    this.hubConnection.onreconnected(() => {\r\n      this.connectionState.set(CONNECTION_STATE.CONNECTED);\r\n\r\n      // Rejoin all groups after reconnection\r\n      this.rejoinGroups();\r\n    });\r\n\r\n    this.hubConnection.onclose(() => {\r\n      this.connectionState.set(CONNECTION_STATE.DISCONNECTED);\r\n\r\n      // Try to reconnect\r\n      setTimeout(() => this.connect(), 60 * 1000);\r\n    });\r\n  }\r\n\r\n  /**\r\n   * Join SignalR group for an AppObject\r\n   */\r\n  async joinGroup(appObjectId: string): Promise<void> {\r\n    if (!this.hubConnection || this.hubConnection.state !== signalR.HubConnectionState.Connected) {\r\n      return;\r\n    }\r\n\r\n    try {\r\n      if (!this.tenantId || !this.appId || !this.environmentId || !appObjectId) {\r\n        return;\r\n      }\r\n\r\n      await this.hubConnection.invoke(\r\n        SIGNALR_HUB_METHODS.JOIN_GROUP,\r\n        this.tenantId,\r\n        this.appId,\r\n        this.environmentId,\r\n        appObjectId\r\n      );\r\n\r\n      // Track this group for reconnection\r\n      this.activeGroups.add(appObjectId);\r\n    } catch (error) {\r\n      console.error(`[SignalR] Failed to join group: ${appObjectId}`, error);\r\n    }\r\n  }\r\n\r\n  /**\r\n   * Leave SignalR group\r\n   */\r\n  async leaveGroup(appObjectId: string): Promise<void> {\r\n    if (!this.hubConnection || this.hubConnection.state !== signalR.HubConnectionState.Connected) {\r\n      // Remove from tracking even if not connected\r\n      this.activeGroups.delete(appObjectId);\r\n      return;\r\n    }\r\n\r\n    if (!this.tenantId || !this.appId || !this.environmentId || !appObjectId) {\r\n      return;\r\n    }\r\n\r\n    try {\r\n      await this.hubConnection.invoke(\r\n        SIGNALR_HUB_METHODS.LEAVE_GROUP,\r\n        this.tenantId,\r\n        this.appId,\r\n        this.environmentId,\r\n        appObjectId\r\n      );\r\n\r\n      // Remove from tracking\r\n      this.activeGroups.delete(appObjectId);\r\n    } catch (error) {\r\n      console.error(`[SignalR] Failed to leave group: ${appObjectId}`, error);\r\n    }\r\n  }\r\n\r\n  /**\r\n   * Rejoin all active groups after reconnection\r\n   * This ensures components continue receiving notifications after network interruption\r\n   */\r\n  private async rejoinGroups(): Promise<void> {\r\n    if (this.activeGroups.size === 0) {\r\n      return;\r\n    }\r\n\r\n    // Get list of groups to rejoin\r\n    const groups = Array.from(this.activeGroups);\r\n\r\n    // Clear the set (will be re-added during joinGroup)\r\n    this.activeGroups.clear();\r\n\r\n    // Rejoin each group\r\n    for (const appObjectId of groups) {\r\n      await this.joinGroup(appObjectId);\r\n    }\r\n  }\r\n\r\n  /**\r\n   * Check if connected\r\n   */\r\n  isConnected(): boolean {\r\n    return this.hubConnection?.state === signalR.HubConnectionState.Connected;\r\n  }\r\n\r\n  /**\r\n   * Disconnect from SignalR hub (cleanup)\r\n   */\r\n  async disconnect(): Promise<void> {\r\n    if (this.hubConnection) {\r\n      try {\r\n        await this.hubConnection.stop();\r\n        this.hubConnection = null;\r\n        this.connectionState.set(CONNECTION_STATE.DISCONNECTED);\r\n      } catch (error) {\r\n        console.error('[SignalR] Error during disconnect:', error);\r\n      }\r\n    }\r\n  }\r\n\r\n  /**\r\n   * Get active groups (for debugging)\r\n   */\r\n  getActiveGroups(): string[] {\r\n    return Array.from(this.activeGroups);\r\n  }\r\n}"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"signalr-infrastructure.service.js","sourceRoot":"","sources":["../../../../../../../../../libs/data-access/src/lib/tab-core-utility/core/service/signalr/signalr-infrastructure.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { inject, Injectable, signal } from '@angular/core';\r\nimport * as signalR from '@microsoft/signalr';\r\nimport { Subject } from 'rxjs';\r\nimport { Common } from '../../../app/constants/common';\r\nimport {\r\n  ConnectionState,\r\n  CrudNotification,\r\n  SignalRMessage,\r\n  SIGNALR_HUB_METHODS,\r\n  SIGNALR_EVENTS,\r\n  CRUD_OPERATION,\r\n  CONNECTION_STATE,\r\n} from '../../../app/interfaces/signalr.interface';\r\nimport { StorageConstants } from '../../../app/constants/storage-constants';\r\nimport { SessionStorageService } from '../../../auth/session-storage.service';\r\nimport { LocalStorageService } from '../../../auth/local-storage.service';\r\n\r\n/**\r\n * SignalR Infrastructure Service\r\n * Handles low-level WebSocket connection, group management, and reconnection\r\n * Internal use only - components should use SignalRService instead\r\n */\r\n@Injectable({\r\n  providedIn: 'root',\r\n})\r\nexport class SignalRInfrastructure {\r\n  private hubConnection: signalR.HubConnection | null = null;\r\n\r\n  // In-flight connect() promise — used to dedupe concurrent calls\r\n  private connectingPromise: Promise<void> | null = null;\r\n\r\n  // Set true on explicit disconnect() so scheduled retries don't resurrect the connection\r\n  private explicitlyDisconnected = false;\r\n\r\n  // Session storage\r\n  readonly sessionStorageService = inject(SessionStorageService);\r\n\r\n  // local storage\r\n  readonly localStorageService = inject(LocalStorageService);\r\n\r\n  // Connection state as signal\r\n  readonly connectionState = signal<ConnectionState>(CONNECTION_STATE.DISCONNECTED);\r\n\r\n  // Notification stream (internal - emits to SignalRService)\r\n  readonly notifications$ = new Subject<CrudNotification>();\r\n\r\n  // Track active groups to rejoin after reconnection\r\n  private activeGroups = new Set<string>();\r\n\r\n  /**\r\n   * Helper method to get value from storage\r\n   * @param type The type of storage, 'Session' or 'Local'\r\n   * @param key The key to retrieve the value for\r\n   * @returns The value from storage, or null if not available\r\n   */\r\n  private getFromStorage(type: string, key: string) {\r\n    try {\r\n      let info: any = null;\r\n\r\n      if (type === 'Session') {\r\n        // Get value from session storage\r\n        info = this.sessionStorageService.getSessionStorage(key);\r\n      }\r\n\r\n      if (type === 'Local') {\r\n        // Get value from local storage\r\n        info = this.localStorageService.getLocalStorage(key);\r\n      }\r\n\r\n      if (info && typeof info === 'string') {\r\n        // Parse the value if it's a string\r\n        info = JSON.parse(info);\r\n      }\r\n\r\n      return info;\r\n    } catch (error) {\r\n      // Log error if failed to get value from storage\r\n      console.warn('Failed to get current app ID from session:', error);\r\n      return null;\r\n    }\r\n  }\r\n\r\n  get appId(): string | null {\r\n    const appInfo = this.getFromStorage('Session', StorageConstants.appInfo);\r\n    return appInfo?.Id || null;\r\n  }\r\n\r\n  get environmentId(): string | null {\r\n    const envInfo = this.getFromStorage('Session', StorageConstants.environmentInfo);\r\n    return envInfo?.Id || null;\r\n  }\r\n\r\n  get tenantId(): string | null {\r\n    const tenantInfo = this.getFromStorage('Local', StorageConstants.orgInfo);\r\n    return tenantInfo?.Id || null;\r\n  }\r\n\r\n  get token(): string | null {\r\n    const authInfo = this.getFromStorage('Local', StorageConstants.tokenInfo);\r\n    return authInfo?.token || null;\r\n  }\r\n\r\n  /**\r\n   * Connect to SignalR hub\r\n   *\r\n   * Idempotent and safe to call from multiple sites:\r\n   * - already CONNECTED → returns immediately\r\n   * - already CONNECTING → returns the in-flight promise\r\n   * - any non-Connected leftover hubConnection → torn down before rebuild\r\n   */\r\n  async connect(): Promise<void> {\r\n    this.explicitlyDisconnected = false;\r\n\r\n    if (this.hubConnection?.state === signalR.HubConnectionState.Connected) {\r\n      return;\r\n    }\r\n\r\n    if (this.connectingPromise) {\r\n      return this.connectingPromise;\r\n    }\r\n\r\n    // Tear down any stale (non-Connected) hubConnection before rebuilding\r\n    if (this.hubConnection) {\r\n      try {\r\n        await this.hubConnection.stop();\r\n      } catch {\r\n        // ignore — we're discarding it anyway\r\n      }\r\n      this.hubConnection = null;\r\n    }\r\n\r\n    this.connectingPromise = this.doConnect();\r\n    try {\r\n      await this.connectingPromise;\r\n    } finally {\r\n      this.connectingPromise = null;\r\n    }\r\n  }\r\n\r\n  private async doConnect(): Promise<void> {\r\n    // Get hub URL from Common (set during app initialization via Common.init())\r\n    const hubUrl = Common.signalRHubUrl;\r\n\r\n    if (!hubUrl) {\r\n      console.error('[SignalR] Hub URL not configured. Make sure Common.init() is called with environment.');\r\n      return;\r\n    }\r\n\r\n    try {\r\n      this.connectionState.set(CONNECTION_STATE.CONNECTING);\r\n\r\n      this.hubConnection = new signalR.HubConnectionBuilder()\r\n        .withUrl(hubUrl, {\r\n          accessTokenFactory: () => this.token || '',\r\n          skipNegotiation: false,\r\n          transport: signalR.HttpTransportType.WebSockets | signalR.HttpTransportType.ServerSentEvents,\r\n        })\r\n        .withAutomaticReconnect({\r\n          nextRetryDelayInMilliseconds: (retryContext: any) => {\r\n            // Exponential backoff: 0s, 2s, 10s, 30s, max 60s\r\n            if (retryContext.elapsedMilliseconds < 60000) {\r\n              return Math.min(1000 * Math.pow(2, retryContext.previousRetryCount), 60000);\r\n            }\r\n            return null; // Stop retrying after 1 minute\r\n          },\r\n        })\r\n        .configureLogging(signalR.LogLevel.Information)\r\n        .build();\r\n\r\n      this.registerEventHandlers();\r\n      this.registerConnectionLifecycle();\r\n\r\n      await this.hubConnection.start();\r\n\r\n      this.connectionState.set(CONNECTION_STATE.CONNECTED);\r\n    } catch (error) {\r\n      this.connectionState.set(CONNECTION_STATE.FAILED);\r\n\r\n      // Retry after 1 minute, but only if the caller hasn't explicitly disconnected\r\n      setTimeout(() => {\r\n        if (!this.explicitlyDisconnected) {\r\n          this.connect();\r\n        }\r\n      }, 60 * 1000);\r\n    }\r\n  }\r\n\r\n  /**\r\n   * Register SignalR event handlers for CRUD notifications\r\n   */\r\n  private registerEventHandlers(): void {\r\n    if (!this.hubConnection) return;\r\n\r\n    // INSERT notifications\r\n    this.hubConnection.on(SIGNALR_EVENTS.INSERT_COMPLETED, (...args: any[]) => {\r\n      const notification = this.extractNotification(args);\r\n      const enriched = { ...notification, operation: CRUD_OPERATION.INSERT, receivedAt: new Date() };\r\n      this.notifications$.next(enriched);\r\n    });\r\n\r\n    // UPDATE notifications\r\n    this.hubConnection.on(SIGNALR_EVENTS.UPDATE_COMPLETED, (...args: any[]) => {\r\n      const notification = this.extractNotification(args);\r\n      const enriched = { ...notification, operation: CRUD_OPERATION.UPDATE, receivedAt: new Date() };\r\n      this.notifications$.next(enriched);\r\n    });\r\n\r\n    // DELETE notifications\r\n    this.hubConnection.on(SIGNALR_EVENTS.DELETE_COMPLETED, (...args: any[]) => {\r\n      const notification = this.extractNotification(args);\r\n      const enriched = { ...notification, operation: CRUD_OPERATION.DELETE, receivedAt: new Date() };\r\n      this.notifications$.next(enriched);\r\n    });\r\n  }\r\n\r\n  /**\r\n   * Extract notification from SignalR callback args\r\n   * Handles both unwrapped (direct object) and wrapped ({ type, target, arguments }) formats\r\n   */\r\n  private extractNotification(args: any[]): CrudNotification {\r\n    const data = args[0];\r\n\r\n    // If SignalR didn't unwrap: data is raw SignalRMessage with { type, target, arguments: [...] }\r\n    if (data?.arguments && Array.isArray(data.arguments)) {\r\n      return (data as SignalRMessage).arguments[0];\r\n    }\r\n\r\n    // If SignalR unwrapped: data is the notification directly\r\n    return data as CrudNotification;\r\n  }\r\n\r\n  /**\r\n   * Register connection lifecycle handlers\r\n   */\r\n  private registerConnectionLifecycle(): void {\r\n    if (!this.hubConnection) return;\r\n\r\n    this.hubConnection.onreconnecting(() => {\r\n      this.connectionState.set(CONNECTION_STATE.RECONNECTING);\r\n    });\r\n\r\n    this.hubConnection.onreconnected(() => {\r\n      this.connectionState.set(CONNECTION_STATE.CONNECTED);\r\n\r\n      // Rejoin all groups after reconnection\r\n      this.rejoinGroups();\r\n    });\r\n\r\n    this.hubConnection.onclose(() => {\r\n      this.connectionState.set(CONNECTION_STATE.DISCONNECTED);\r\n\r\n      // Try to reconnect — but only if the caller hasn't explicitly disconnected\r\n      setTimeout(() => {\r\n        if (!this.explicitlyDisconnected) {\r\n          this.connect();\r\n        }\r\n      }, 60 * 1000);\r\n    });\r\n  }\r\n\r\n  /**\r\n   * Join SignalR group for an AppObject\r\n   */\r\n  async joinGroup(appObjectId: string): Promise<void> {\r\n    if (!this.hubConnection || this.hubConnection.state !== signalR.HubConnectionState.Connected) {\r\n      return;\r\n    }\r\n\r\n    try {\r\n      if (!this.tenantId || !this.appId || !this.environmentId || !appObjectId) {\r\n        return;\r\n      }\r\n\r\n      await this.hubConnection.invoke(\r\n        SIGNALR_HUB_METHODS.JOIN_GROUP,\r\n        this.tenantId,\r\n        this.appId,\r\n        this.environmentId,\r\n        appObjectId\r\n      );\r\n\r\n      // Track this group for reconnection\r\n      this.activeGroups.add(appObjectId);\r\n    } catch (error) {\r\n      console.error(`[SignalR] Failed to join group: ${appObjectId}`, error);\r\n    }\r\n  }\r\n\r\n  /**\r\n   * Leave SignalR group\r\n   */\r\n  async leaveGroup(appObjectId: string): Promise<void> {\r\n    if (!this.hubConnection || this.hubConnection.state !== signalR.HubConnectionState.Connected) {\r\n      // Remove from tracking even if not connected\r\n      this.activeGroups.delete(appObjectId);\r\n      return;\r\n    }\r\n\r\n    if (!this.tenantId || !this.appId || !this.environmentId || !appObjectId) {\r\n      return;\r\n    }\r\n\r\n    try {\r\n      await this.hubConnection.invoke(\r\n        SIGNALR_HUB_METHODS.LEAVE_GROUP,\r\n        this.tenantId,\r\n        this.appId,\r\n        this.environmentId,\r\n        appObjectId\r\n      );\r\n\r\n      // Remove from tracking\r\n      this.activeGroups.delete(appObjectId);\r\n    } catch (error) {\r\n      console.error(`[SignalR] Failed to leave group: ${appObjectId}`, error);\r\n    }\r\n  }\r\n\r\n  /**\r\n   * Rejoin all active groups after reconnection\r\n   * This ensures components continue receiving notifications after network interruption\r\n   */\r\n  private async rejoinGroups(): Promise<void> {\r\n    if (this.activeGroups.size === 0) {\r\n      return;\r\n    }\r\n\r\n    // Get list of groups to rejoin\r\n    const groups = Array.from(this.activeGroups);\r\n\r\n    // Clear the set (will be re-added during joinGroup)\r\n    this.activeGroups.clear();\r\n\r\n    // Rejoin each group\r\n    for (const appObjectId of groups) {\r\n      await this.joinGroup(appObjectId);\r\n    }\r\n  }\r\n\r\n  /**\r\n   * Check if connected\r\n   */\r\n  isConnected(): boolean {\r\n    return this.hubConnection?.state === signalR.HubConnectionState.Connected;\r\n  }\r\n\r\n  /**\r\n   * Disconnect from SignalR hub (cleanup)\r\n   *\r\n   * Sets explicitlyDisconnected so any pending retry timers from connect()/onclose\r\n   * become no-ops, then stops the hub and clears tracked groups.\r\n   */\r\n  async disconnect(): Promise<void> {\r\n    this.explicitlyDisconnected = true;\r\n    this.connectingPromise = null;\r\n\r\n    if (this.hubConnection) {\r\n      try {\r\n        await this.hubConnection.stop();\r\n      } catch (error) {\r\n        console.error('[SignalR] Error during disconnect:', error);\r\n      }\r\n      this.hubConnection = null;\r\n    }\r\n\r\n    this.activeGroups.clear();\r\n    this.connectionState.set(CONNECTION_STATE.DISCONNECTED);\r\n  }\r\n\r\n  /**\r\n   * Get active groups (for debugging)\r\n   */\r\n  getActiveGroups(): string[] {\r\n    return Array.from(this.activeGroups);\r\n  }\r\n}"]}