@techextensor/tab-sdk 0.0.58 → 0.0.59

package/fesm2022/techextensor-tab-sdk.mjs

@@ -1,6 +1,6 @@
 import * as i0 from '@angular/core';
 import { inject, Injectable } from '@angular/core';
-import { NotificationService, ConfirmationService, NotificationType, AuthService, TabFormioService, TemplateHelper, TabBlueprintService, AppHelper, MediaUploadHelper, ApiService, API, TabReleaseService, TranslationService, TabCrudService, TabGetService, LocalStorageService, SessionStorageService, StorageConstants, TabWorkflowService, MetadataHelper } from '@techextensor/tab-core-utility';
+import { NotificationService, ConfirmationService, NotificationType, AuthService, TabFormioService, TemplateHelper, TabBlueprintService, AppHelper, MediaUploadHelper, ApiService, API, TabReleaseService, TranslationService, TabCrudService, TabGetService, LocalStorageService, SessionStorageService, StorageConstants, TabWorkflowService, SignalRService, NotificationInboxService, MetadataHelper } from '@techextensor/tab-core-utility';
 import { firstValueFrom } from 'rxjs';
 
 var ScreenDisplayMode;
@@ -2829,6 +2829,189 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.2.16", ngImpo
                 }]
         }] });
 
+/**
+ * SDK facade over the core SignalR service.
+ *
+ * Exposes only the surface that app/extension code needs:
+ *  - lifecycle (connect / disconnect)
+ *  - per-component subscription (register / unregister) for live CRUD push
+ *
+ * Async correlation-id tracking (`waitForOperation`) is intentionally NOT exposed —
+ * that's an internal concern of the core CRUD services in tab-core-utility.
+ *
+ * @example
+ * ```ts
+ * // In a route resolver (route waits until the first connection attempt settles)
+ * await TabSdk.signalR.connect();
+ *
+ * // In a component
+ * ngOnInit() {
+ *   TabSdk.signalR.register(this.componentId, this.appObjectId, n => this.handle(n));
+ * }
+ * ngOnDestroy() {
+ *   TabSdk.signalR.unregister(this.componentId, this.appObjectId);
+ * }
+ *
+ * // In auth signOut
+ * await TabSdk.signalR.disconnect();
+ * ```
+ */
+class SignalRSdkService {
+    signalR = inject(SignalRService);
+    /**
+     * Establish a connection to the SignalR hub.
+     *
+     * Awaitable — resolves when the first connection attempt settles (success or
+     * failure). Idempotent: repeated calls are de-duplicated; if already
+     * CONNECTED, resolves immediately. Any stale (non-Connected) connection is
+     * torn down before rebuild.
+     *
+     * Use in route resolvers to gate navigation until the hub is ready.
+     */
+    async connect() {
+        await this.signalR.connect();
+    }
+    /**
+     * Tear down the connection (call from auth signOut / cross-tab logout).
+     *
+     * Stops the hub, clears component registrations, and errors any in-flight
+     * waitForOperation observers so CRUD UIs resolve immediately instead of
+     * stranding until the 120s timeout.
+     */
+    async disconnect() {
+        await this.signalR.disconnect();
+    }
+    /**
+     * Subscribe a component to real-time CRUD notifications for an AppObject.
+     * Refcounted — the first registrant for an `appObjectId` joins the hub group;
+     * the last `unregister` leaves it.
+     */
+    register(componentId, appObjectId, callback) {
+        this.signalR.register(componentId, appObjectId, callback);
+    }
+    /**
+     * Unsubscribe a component (call from `ngOnDestroy`).
+     */
+    unregister(componentId, appObjectId) {
+        this.signalR.unregister(componentId, appObjectId);
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "19.2.16", ngImport: i0, type: SignalRSdkService, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "19.2.16", ngImport: i0, type: SignalRSdkService, providedIn: 'root' });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.2.16", ngImport: i0, type: SignalRSdkService, decorators: [{
+            type: Injectable,
+            args: [{ providedIn: 'root' }]
+        }] });
+
+/**
+ * SDK facade over the core notification inbox service.
+ *
+ * The app passes the auth identifiers at connect time — the core services don't
+ * read them from storage. This facade is the single place that knows how to
+ * compose the BE's `workspaceKey` from the four IDs.
+ *
+ * Exposes only the surface that app/extension code needs:
+ *  - lifecycle (connect / disconnect)
+ *  - inbox actions (loadMore, markAsRead, markAllAsRead, clearOne, clearAll)
+ *  - state streams for UI (latestNotifications$, unreadCount$, etc.)
+ *
+ * @example
+ * ```ts
+ * // In a route resolver
+ * await TabSdk.notification.connect({
+ *   userId: TabSdk.store.userId,
+ *   appId: TabSdk.store.appId,
+ *   tenantId: TabSdk.store.tenantId,
+ *   environmentId: TabSdk.store.environmentId,
+ * });
+ *
+ * // In header for the badge
+ * TabSdk.notification.unreadCount$.subscribe(count => this.badge = count);
+ *
+ * // In notification list
+ * TabSdk.notification.loadMore(1);
+ * TabSdk.notification.markAsRead(id);
+ *
+ * // In auth signOut
+ * await TabSdk.notification.disconnect();
+ * ```
+ */
+class NotificationSdkService {
+    inbox = inject(NotificationInboxService);
+    // ----------- lifecycle -----------
+    /**
+     * Connect to the notification WebSocket. Awaitable, idempotent.
+     *
+     * The app supplies the auth identifiers — the core services stay pure
+     * (no storage / auth coupling). This facade composes the BE's workspaceKey
+     * from the four IDs and passes everything down.
+     */
+    async connect(params) {
+        const workspaceKey = `${params.tenantId}.${params.appId}.${params.environmentId}`;
+        await this.inbox.connect({
+            userId: params.userId,
+            appId: params.appId,
+            tenantId: params.tenantId,
+            workspaceKey,
+        });
+    }
+    /**
+     * Tear down the connection (call from auth signOut / cross-tab logout).
+     */
+    async disconnect() {
+        await this.inbox.disconnect();
+    }
+    // ----------- actions -----------
+    /** Fetch a page of notifications from the inbox. */
+    loadMore(pageNumber, pageSize) {
+        this.inbox.loadMore(pageNumber, pageSize);
+    }
+    /** Re-request unread count (header badge auto-refreshes via the stream). */
+    requestUnreadCount() {
+        this.inbox.requestUnreadCount();
+    }
+    /** Mark a single notification as read. */
+    markAsRead(notificationId) {
+        this.inbox.markAsRead(notificationId);
+    }
+    /** Mark all notifications as read. */
+    markAllAsRead() {
+        this.inbox.markAllAsRead();
+    }
+    /** Clear a single notification from the inbox. */
+    clearOne(notificationId) {
+        this.inbox.clearOne(notificationId);
+    }
+    /** Clear all notifications from the inbox. */
+    clearAll() {
+        this.inbox.clearAll();
+    }
+    // ----------- streams -----------
+    /**
+     * Emits notifications as they arrive.
+     * - Inbox page fetch → emits an array.
+     * - Live push → emits a single notification (component should prepend it).
+     * Component logic should branch on Array.isArray(value).
+     */
+    latestNotifications$ = this.inbox.getLatestNotifications();
+    /** Current unread count. Header subscribes for the badge. */
+    unreadCount$ = this.inbox.getUnreadCount();
+    /** Emits notificationId when a notification is marked read; null when all are. */
+    markAsReadEvents$ = this.inbox.getMarkAsReadEvents();
+    /** Emits cleared notification IDs; null when all are cleared. */
+    clearEvents$ = this.inbox.getClearEvents();
+    /** Loading state — true while a page fetch is in flight. */
+    loading$ = this.inbox.getLoadingState();
+    /** Total pages (page-based pagination per BE). */
+    totalPages$ = this.inbox.getTotalPages();
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "19.2.16", ngImport: i0, type: NotificationSdkService, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "19.2.16", ngImport: i0, type: NotificationSdkService, providedIn: 'root' });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.2.16", ngImport: i0, type: NotificationSdkService, decorators: [{
+            type: Injectable,
+            args: [{ providedIn: 'root' }]
+        }] });
+
 class TabSdk {
     static app;
     static auth;
@@ -2847,6 +3030,8 @@ class TabSdk {
     static workflow;
     static util;
     static state;
+    static signalR;
+    static notification;
     /**
      * Initialize the SDK with necessary services
      */
@@ -2869,6 +3054,8 @@ class TabSdk {
         this.http = injector.get(HttpService);
         this.store = injector.get(StoreService);
         this.workflow = injector.get(WorkflowService);
+        this.signalR = injector.get(SignalRSdkService);
+        this.notification = injector.get(NotificationSdkService);
         // Extract StateService from context before passing to util
         const { StateService: stateService, ...utilContext } = context || {};
         // Initialize util service with context (excluding StateService)
@@ -2895,6 +3082,8 @@ class TabSdk {
         Object.freeze(this.store);
         Object.freeze(this.util);
         Object.freeze(this.state);
+        Object.freeze(this.signalR);
+        Object.freeze(this.notification);
     }
     static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "19.2.16", ngImport: i0, type: TabSdk, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
     static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "19.2.16", ngImport: i0, type: TabSdk, providedIn: 'root' });