@techextensor/tab-core-utility 2.2.180 → 2.2.184

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

@@ -0,0 +1,252 @@
+import { inject, Injectable, signal } from '@angular/core';
+import * as signalR from '@microsoft/signalr';
+import { Subject } from 'rxjs';
+import { Common } from '../../../app/constants/common';
+import { SIGNALR_HUB_METHODS, SIGNALR_EVENTS, CRUD_OPERATION, CONNECTION_STATE, } from '../../../app/interfaces/signalr.interface';
+import { StorageConstants } from '../../../app/constants/storage-constants';
+import { SessionStorageService } from '../../../auth/session-storage.service';
+import { LocalStorageService } from '../../../auth/local-storage.service';
+import * as i0 from "@angular/core";
+/**
+ * SignalR Infrastructure Service
+ * Handles low-level WebSocket connection, group management, and reconnection
+ * Internal use only - components should use SignalRService instead
+ */
+export class SignalRInfrastructure {
+    constructor() {
+        this.hubConnection = null;
+        // Session storage
+        this.sessionStorageService = inject(SessionStorageService);
+        // local storage
+        this.localStorageService = inject(LocalStorageService);
+        // Connection state as signal
+        this.connectionState = signal(CONNECTION_STATE.DISCONNECTED);
+        // Notification stream (internal - emits to SignalRService)
+        this.notifications$ = new Subject();
+        // Track active groups to rejoin after reconnection
+        this.activeGroups = new Set();
+    }
+    /**
+     * Helper method to get value from storage
+     * @param type The type of storage, 'Session' or 'Local'
+     * @param key The key to retrieve the value for
+     * @returns The value from storage, or null if not available
+     */
+    getFromStorage(type, key) {
+        try {
+            let info = null;
+            if (type === 'Session') {
+                // Get value from session storage
+                info = this.sessionStorageService.getSessionStorage(key);
+            }
+            if (type === 'Local') {
+                // Get value from local storage
+                info = this.localStorageService.getLocalStorage(key);
+            }
+            if (info && typeof info === 'string') {
+                // Parse the value if it's a string
+                info = JSON.parse(info);
+            }
+            return info;
+        }
+        catch (error) {
+            // Log error if failed to get value from storage
+            console.warn('Failed to get current app ID from session:', error);
+            return null;
+        }
+    }
+    get appId() {
+        const appInfo = this.getFromStorage('Session', StorageConstants.appInfo);
+        return appInfo?.Id || null;
+    }
+    get environmentId() {
+        const envInfo = this.getFromStorage('Session', StorageConstants.environmentInfo);
+        return envInfo?.Id || null;
+    }
+    get tenantId() {
+        const tenantInfo = this.getFromStorage('Local', StorageConstants.orgInfo);
+        return tenantInfo?.Id || null;
+    }
+    get token() {
+        const authInfo = this.getFromStorage('Local', StorageConstants.tokenInfo);
+        return authInfo?.token || null;
+    }
+    /**
+     * Connect to SignalR hub
+     */
+    async connect() {
+        if (this.hubConnection?.state === signalR.HubConnectionState.Connected) {
+            return;
+        }
+        // Get hub URL from Common (set during app initialization via Common.init())
+        const hubUrl = Common.signalRHubUrl;
+        if (!hubUrl) {
+            console.error('[SignalR] Hub URL not configured. Make sure Common.init() is called with environment.');
+            return;
+        }
+        try {
+            this.connectionState.set(CONNECTION_STATE.CONNECTING);
+            this.hubConnection = new signalR.HubConnectionBuilder()
+                .withUrl(hubUrl, {
+                accessTokenFactory: () => this.token || '',
+                skipNegotiation: false,
+                transport: signalR.HttpTransportType.WebSockets | signalR.HttpTransportType.ServerSentEvents,
+            })
+                .withAutomaticReconnect({
+                nextRetryDelayInMilliseconds: (retryContext) => {
+                    // Exponential backoff: 0s, 2s, 10s, 30s, max 60s
+                    if (retryContext.elapsedMilliseconds < 60000) {
+                        return Math.min(1000 * Math.pow(2, retryContext.previousRetryCount), 60000);
+                    }
+                    return null; // Stop retrying after 1 minute
+                },
+            })
+                .configureLogging(signalR.LogLevel.Information)
+                .build();
+            this.registerEventHandlers();
+            this.registerConnectionLifecycle();
+            await this.hubConnection.start();
+            this.connectionState.set(CONNECTION_STATE.CONNECTED);
+        }
+        catch (error) {
+            this.connectionState.set(CONNECTION_STATE.FAILED);
+            // Retry after 1 minute
+            setTimeout(() => this.connect(), 60 * 1000);
+        }
+    }
+    /**
+     * Register SignalR event handlers for CRUD notifications
+     */
+    registerEventHandlers() {
+        if (!this.hubConnection)
+            return;
+        // INSERT notifications
+        this.hubConnection.on(SIGNALR_EVENTS.INSERT_COMPLETED, (notification) => {
+            const enriched = { ...notification, operation: CRUD_OPERATION.INSERT, receivedAt: new Date() };
+            this.notifications$.next(enriched);
+        });
+        // UPDATE notifications
+        this.hubConnection.on(SIGNALR_EVENTS.UPDATE_COMPLETED, (notification) => {
+            const enriched = { ...notification, operation: CRUD_OPERATION.UPDATE, receivedAt: new Date() };
+            this.notifications$.next(enriched);
+        });
+        // DELETE notifications
+        this.hubConnection.on(SIGNALR_EVENTS.DELETE_COMPLETED, (notification) => {
+            const enriched = { ...notification, operation: CRUD_OPERATION.DELETE, receivedAt: new Date() };
+            this.notifications$.next(enriched);
+        });
+    }
+    /**
+     * Register connection lifecycle handlers
+     */
+    registerConnectionLifecycle() {
+        if (!this.hubConnection)
+            return;
+        this.hubConnection.onreconnecting(() => {
+            this.connectionState.set(CONNECTION_STATE.RECONNECTING);
+        });
+        this.hubConnection.onreconnected(() => {
+            this.connectionState.set(CONNECTION_STATE.CONNECTED);
+            // Rejoin all groups after reconnection
+            this.rejoinGroups();
+        });
+        this.hubConnection.onclose(() => {
+            this.connectionState.set(CONNECTION_STATE.DISCONNECTED);
+            // Try to reconnect
+            setTimeout(() => this.connect(), 60 * 1000);
+        });
+    }
+    /**
+     * Join SignalR group for an AppObject
+     */
+    async joinGroup(appObjectId) {
+        if (!this.hubConnection || this.hubConnection.state !== signalR.HubConnectionState.Connected) {
+            return;
+        }
+        try {
+            if (!this.tenantId || !this.appId || !this.environmentId || !appObjectId) {
+                return;
+            }
+            await this.hubConnection.invoke(SIGNALR_HUB_METHODS.JOIN_GROUP, this.tenantId, this.appId, this.environmentId, appObjectId);
+            // Track this group for reconnection
+            this.activeGroups.add(appObjectId);
+        }
+        catch (error) {
+            console.error(`[SignalR] Failed to join group: ${appObjectId}`, error);
+        }
+    }
+    /**
+     * Leave SignalR group
+     */
+    async leaveGroup(appObjectId) {
+        if (!this.hubConnection || this.hubConnection.state !== signalR.HubConnectionState.Connected) {
+            // Remove from tracking even if not connected
+            this.activeGroups.delete(appObjectId);
+            return;
+        }
+        if (!this.tenantId || !this.appId || !this.environmentId || !appObjectId) {
+            return;
+        }
+        try {
+            await this.hubConnection.invoke(SIGNALR_HUB_METHODS.LEAVE_GROUP, this.tenantId, this.appId, this.environmentId, appObjectId);
+            // Remove from tracking
+            this.activeGroups.delete(appObjectId);
+        }
+        catch (error) {
+            console.error(`[SignalR] Failed to leave group: ${appObjectId}`, error);
+        }
+    }
+    /**
+     * Rejoin all active groups after reconnection
+     * This ensures components continue receiving notifications after network interruption
+     */
+    async rejoinGroups() {
+        if (this.activeGroups.size === 0) {
+            return;
+        }
+        // Get list of groups to rejoin
+        const groups = Array.from(this.activeGroups);
+        // Clear the set (will be re-added during joinGroup)
+        this.activeGroups.clear();
+        // Rejoin each group
+        for (const appObjectId of groups) {
+            await this.joinGroup(appObjectId);
+        }
+    }
+    /**
+     * Check if connected
+     */
+    isConnected() {
+        return this.hubConnection?.state === signalR.HubConnectionState.Connected;
+    }
+    /**
+     * Disconnect from SignalR hub (cleanup)
+     */
+    async disconnect() {
+        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);
+            }
+        }
+    }
+    /**
+     * Get active groups (for debugging)
+     */
+    getActiveGroups() {
+        return Array.from(this.activeGroups);
+    }
+    static { this.ɵfac = function SignalRInfrastructure_Factory(t) { return new (t || SignalRInfrastructure)(); }; }
+    static { this.ɵprov = /*@__PURE__*/ i0.ɵɵdefineInjectable({ token: SignalRInfrastructure, factory: SignalRInfrastructure.ɵfac, providedIn: 'root' }); }
+}
+(() => { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(SignalRInfrastructure, [{
+        type: Injectable,
+        args: [{
+                providedIn: 'root',
+            }]
+    }], null, null); })();
+//# 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  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, (notification: CrudNotification) => {\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, (notification: CrudNotification) => {\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, (notification: CrudNotification) => {\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   * 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}"]}

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

@@ -0,0 +1,207 @@
+import { Injectable, inject, computed } from '@angular/core';
+import { SignalRInfrastructure } from './signalr-infrastructure.service';
+import { OperationTrackerService } from './operation-tracker.service';
+import { CONNECTION_STATE, } from '../../../app/interfaces/signalr.interface';
+import * as i0 from "@angular/core";
+/**
+ * SignalR Service
+ * Public API for:
+ * 1. Components to register for real-time CRUD notifications
+ * 2. Services (TabFormioService) to track async operations
+ *
+ * Usage in components:
+ * ```typescript
+ * ngOnInit() {
+ *   this.signalRService.register(
+ *     this.componentId,
+ *     this.appObjectId,
+ *     (notification) => this.handleNotification(notification)
+ *   );
+ * }
+ *
+ * ngOnDestroy() {
+ *   this.signalRService.unregister(this.componentId, this.appObjectId);
+ * }
+ * ```
+ *
+ * Usage in services (TabFormioService):
+ * ```typescript
+ * const correlationId = response.correlationId;
+ * this.signalRService.waitForOperation(correlationId).subscribe(notification => {
+ *   // Handle completed operation
+ * });
+ * ```
+ */
+export class SignalRService {
+    constructor() {
+        this.infrastructure = inject(SignalRInfrastructure);
+        this.operationTracker = inject(OperationTrackerService);
+        // Registry: Map<appObjectId, Map<componentId, callback>>
+        this.componentRegistry = new Map();
+        /**
+         * Get connection state (for UI indicators)
+         */
+        this.connectionState = this.infrastructure.connectionState;
+        /**
+         * Check if currently connected
+         */
+        this.isConnected = computed(() => this.connectionState() === CONNECTION_STATE.CONNECTED);
+        // Listen to notifications from infrastructure and route them
+        this.infrastructure.notifications$.subscribe((notification) => {
+            // 1. Check if this is a tracked async operation (processRequest)
+            this.operationTracker.handleNotification(notification);
+            // 2. Also notify components subscribed to this appObjectId (Grid, etc.)
+            this.notifyComponents(notification);
+        });
+    }
+    /**
+     * Establish a connection to the SignalR hub
+     *
+     * 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();
+    }
+    /**
+     * Register component for real-time notifications
+     *
+     * @param componentId - Unique component identifier (generated by component)
+     * @param appObjectId - AppObject ID to subscribe to
+     * @param callback - Function to call when notification received
+     */
+    register(componentId, appObjectId, callback) {
+        // Initialize map for this AppObject if doesn't exist
+        if (!this.componentRegistry.has(appObjectId)) {
+            this.componentRegistry.set(appObjectId, new Map());
+        }
+        const components = this.componentRegistry.get(appObjectId);
+        // First component for this AppObject? Join SignalR group
+        if (components.size === 0) {
+            this.infrastructure.joinGroup(appObjectId);
+        }
+        // Add component to registry
+        components.set(componentId, callback);
+    }
+    /**
+     * Unregister component (cleanup on component destroy)
+     *
+     * @param componentId - Component identifier to remove
+     * @param appObjectId - AppObject ID to unsubscribe from
+     */
+    unregister(componentId, appObjectId) {
+        const components = this.componentRegistry.get(appObjectId);
+        if (!components) {
+            return;
+        }
+        // Remove component from registry
+        components.delete(componentId);
+        // Last component for this AppObject? Leave SignalR group
+        if (components.size === 0) {
+            this.infrastructure.leaveGroup(appObjectId);
+            this.componentRegistry.delete(appObjectId);
+        }
+    }
+    /**
+     * Wait for specific async operation to complete
+     * Used by TabFormioService for async processRequest operations
+     *
+     * @param correlationId - Correlation ID from backend response
+     * @param timeout - Optional timeout in milliseconds
+     * @returns Observable that emits when operation completes
+     */
+    waitForOperation(correlationId, timeout) {
+        return this.operationTracker.waitForOperation(correlationId, timeout);
+    }
+    /**
+     * Register async operation for tracking
+     * Optional - waitForOperation handles registration automatically
+     *
+     * @param operation - Pending operation details
+     */
+    registerOperation(operation) {
+        this.operationTracker.registerOperation(operation);
+    }
+    /**
+     * Check if operation is pending
+     */
+    isOperationPending(correlationId) {
+        return this.operationTracker.isPending(correlationId);
+    }
+    /**
+     * Notify all registered components for an AppObject
+     * Called when notification received from SignalR hub
+     */
+    notifyComponents(notification) {
+        const components = this.componentRegistry.get(notification.appObjectId);
+        if (!components || components.size === 0) {
+            // No components registered for this AppObject - ignore notification
+            return;
+        }
+        // Call each component's callback
+        components.forEach((callback, componentId) => {
+            try {
+                callback(notification);
+            }
+            catch (error) {
+                console.error(`[SignalR Service] Callback failed for component ${componentId}:`, error);
+            }
+        });
+    }
+    /**
+     * Get active AppObject groups (for debugging)
+     */
+    getActiveGroups() {
+        return Array.from(this.componentRegistry.keys());
+    }
+    /**
+     * Get component count for an AppObject (for debugging)
+     */
+    getComponentCount(appObjectId) {
+        return this.componentRegistry.get(appObjectId)?.size || 0;
+    }
+    /**
+     * Get total registered components across all AppObjects (for debugging)
+     */
+    getTotalComponentCount() {
+        let total = 0;
+        this.componentRegistry.forEach((components) => {
+            total += components.size;
+        });
+        return total;
+    }
+    /**
+     * Get registry state (for debugging)
+     */
+    getRegistryState() {
+        const state = [];
+        this.componentRegistry.forEach((components, appObjectId) => {
+            state.push({
+                appObjectId,
+                componentCount: components.size,
+            });
+        });
+        return state;
+    }
+    /**
+     * Get pending operations count (for debugging)
+     */
+    getPendingOperationsCount() {
+        return this.operationTracker.getPendingCount();
+    }
+    /**
+     * Get all pending operations (for debugging)
+     */
+    getPendingOperations() {
+        return this.operationTracker.getAllPending();
+    }
+    static { this.ɵfac = function SignalRService_Factory(t) { return new (t || SignalRService)(); }; }
+    static { this.ɵprov = /*@__PURE__*/ i0.ɵɵdefineInjectable({ token: SignalRService, factory: SignalRService.ɵfac, providedIn: 'root' }); }
+}
+(() => { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(SignalRService, [{
+        type: Injectable,
+        args: [{
+                providedIn: 'root',
+            }]
+    }], () => [], null); })();
+//# 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}"]}

package/index.d.ts

@@ -36,6 +36,7 @@ export * from './lib/tab-core-utility/app/interfaces/user.interface';
 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/models/api-query.class';
 export * from './lib/tab-core-utility/app/models/app-object.class';
 export * from './lib/tab-core-utility/app/models/common.class';
@@ -56,6 +57,9 @@ export * from './lib/tab-core-utility/core/service/translation.service';
 export * from './lib/tab-core-utility/core/service/notification.service';
 export * from './lib/tab-core-utility/core/service/confirmation.service';
 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/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/api-constants.d.ts

@@ -1,18 +1,15 @@
+import type { APIServiceName } from '../interfaces/common.interface';
 export declare const API: {
     applicationIdentifier: string;
     applicationIdentifierForPMS: string;
     novuBackendUrl: string;
     novuSocketUrl: string;
-    insert: string;
     bulkInsert: string;
-    update: string;
-    delete: string;
     select: string;
-    getDSQ: string;
-    getScreen: string;
-    getListFromDsq: string;
+    screen: string;
+    listsGet: string;
     buildApp: string;
-    getSchema: string;
+    metadataSchema: string;
     login: string;
     pluginUpload: string;
     getFile: string;
@@ -24,12 +21,12 @@ export declare const API: {
     multipleFileUpload: string;
     deleteFile: string;
     getMediaFile: string;
-    getHistory: string;
+    auditGetHistory: string;
     changePassword: string;
     restpassword: string;
     getImage: string;
     pmjayImport: string;
-    getScreenData: string;
+    screenData: string;
     processRequest: string;
     getNextStatus: string;
     updateStatus: string;
@@ -43,7 +40,7 @@ export declare const API: {
     registerAppObjects: string;
     languageResource: string;
     refreshToken: string;
-    search: string;
+    globalSearch: string;
     cloneDsq: string;
     InsertScreenPerformanceAnalytics: string;
     GenerateHttpRequest: string;
@@ -63,4 +60,10 @@ export declare const API: {
     GetAllDocumnets: string;
     GetDocumentById: string;
     ExecuteWorkflow: string;
+    QueriesExecute: string;
+    QueriesSelect: string;
+    recordsInsert: string;
+    recordsUpdate: string;
+    recordsDelete: string;
 };
+export declare const APIServices: Record<APIServiceName, APIServiceName>;

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

@@ -1,3 +1,4 @@
+import { APIServiceUrls } from '../interfaces/common.interface';
 export declare class Common {
     static environmentName: string;
     static applicationCode: string;
@@ -7,5 +8,13 @@ export declare class Common {
     static tabAppObjectAccess: any;
     static staticToken: any;
     static i18n: any;
+    /** Microservice URLs configuration - NEW for microservices architecture */
+    static apiServiceUrls: APIServiceUrls;
+    /** SignalR hub URL for real-time notifications */
+    static signalRHubUrl: string;
+    /**
+     * Initialize the static variables
+     * Called once at application startup from the main app
+     */
     static init(environment: any): void;
 }

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

@@ -22,5 +22,5 @@ export declare const StorageConstants: {
     refreshTokenExpiry: string;
     appNavigationMapping: string;
     tokenInfo: string;
-    Environment: string;
+    EnvironmentId: string;
 };