@techextensor/tab-core-utility 2.2.199 → 2.2.201

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

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

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

@@ -9,46 +9,77 @@ export declare const ChangeType: {
     readonly Deleted: "Deleted";
 };
 export type ChangeTypeValue = typeof ChangeType[keyof typeof ChangeType];
+export interface EnvironmentSnapshot {
+    id: string;
+    name: string;
+    sequence: number;
+    releaseVersion: string | null;
+    connectionId?: string;
+}
 export interface DiffSection<T> {
     added: T[];
     updated: T[];
     deleted: T[];
 }
-export interface AppObjectDiff {
+export interface FieldDiff {
     id: string;
-    name: string;
-    displayName?: string;
-    [key: string]: any;
+    referenceName: string;
+    oldValue?: any;
+    newValue?: any;
 }
 export interface QueryDiff {
     id: string;
-    queryName: string;
-    appObject?: string;
-    [key: string]: any;
+    referenceName: string;
+    oldValue?: any;
+    newValue?: any;
+}
+export interface AppObjectDiff {
+    id: string;
+    referenceName: string;
+    properties?: {
+        oldValue: any;
+        newValue: any;
+    };
+    fields?: DiffSection<FieldDiff> | null;
+    queries?: DiffSection<QueryDiff> | null;
 }
 export interface ScreenDiff {
     id: string;
-    screenName: string;
-    [key: string]: any;
+    referenceName: string;
+    properties?: {
+        oldValue: any;
+        newValue: any;
+    };
 }
 export interface CustomScriptDiff {
     id: string;
-    name?: string;
-    type?: string;
-    [key: string]: any;
+    referenceName: string;
+    properties?: {
+        oldValue: any;
+        newValue: any;
+    };
 }
 export interface RecordDiff {
     id: string;
-    [key: string]: any;
+    referenceName?: string;
+    oldValue?: any;
+    newValue?: any;
 }
 export interface MetadataDiffResponse {
-    appObjects: DiffSection<AppObjectDiff>;
-    queries: DiffSection<QueryDiff>;
-    screens: DiffSection<ScreenDiff>;
-    customScripts: DiffSection<CustomScriptDiff>;
+    sourceEnvironment: EnvironmentSnapshot;
+    targetEnvironment: EnvironmentSnapshot;
+    metadataDiff: {
+        appObjects: DiffSection<AppObjectDiff>;
+        screens: DiffSection<ScreenDiff>;
+        customScripts: DiffSection<CustomScriptDiff>;
+    };
 }
 export interface DataDiffResponse {
-    tables: Record<string, DiffSection<RecordDiff>>;
+    sourceEnvironment: EnvironmentSnapshot;
+    targetEnvironment: EnvironmentSnapshot;
+    dataDiff: {
+        tables: Record<string, DiffSection<RecordDiff>>;
+    };
 }
 export interface ApplyReleaseRequest {
     releaseId: string;

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

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

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

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

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

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

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

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

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

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

package/package.json

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

package/esm2022/lib/tab-core-utility/app/helpers/common/dsq.helpers.mjs

@@ -1,67 +0,0 @@
-/* eslint-disable @typescript-eslint/no-explicit-any */
-import { Injectable, inject } from '@angular/core';
-import { ApiService } from '../../../core/http-client/api.service';
-import { QueryType } from '../../enums/query.enum';
-import { API } from '../../constants/api-constants';
-import { getHeaders } from '../../utils/req-res.util';
-import { MetadataHelper } from './meta-data.helpers';
-import { AccessPermission } from '../../enums/permission.enum';
-import * as i0 from "@angular/core";
-export class DSQHelper {
-    constructor() {
-        this.apiService = inject(ApiService);
-        this.metadataHelper = inject(MetadataHelper);
-    }
-    /**
-     * Executes a query based on the query type
-     * NOTE: INSERT, UPDATE, and DELETE now use new /records/* endpoints
-     * This helper now only handles legacy endpoints: BulkInsert and Select
-     * @param data The data to be executed
-     * @param queryType The type of query to be executed
-     * @returns The result of the query execution
-     */
-    executeQuery(data, queryType, headers) {
-        switch (queryType) {
-            case QueryType.BulkInsert:
-                return this.execution(data, API.bulkInsert, headers);
-            case QueryType.Select:
-                return this.execution(data, API.select, headers);
-            default:
-                return null;
-        }
-    }
-    /**
-     * Executes an HTTP POST request with the provided data and URL
-     * @param data The data to be sent in the POST request
-     * @param endPointName The URL to send the POST request to
-     * @returns The result of the POST request if headers are available, otherwise null
-     */
-    execution(data, endPointName, headers) {
-        const header = getHeaders(headers);
-        return this.apiService.post(endPointName, data, header);
-    }
-    /**
-     * Checks if the user has access to the specified object based on roles and access type
-     * @param dsqId The DataSourceQuery ID to check access for
-     * @param accessType The type of access to check (e.g., read, write)
-     * @param roles The roles of the user with IDs
-     * @returns True if the user has access, false otherwise
-     */
-    doesHaveObjectAccess(dsqId, accessType, roles) {
-        const dsq = this.metadataHelper.getDataSourceQueryByIdOrName(dsqId);
-        const appObject = dsq?.parentAppObject;
-        if (appObject) {
-            const accessList = appObject.AccessList?.filter((access) => roles.some((role) => access.RoleID.toLowerCase() === role.ID.toLowerCase() &&
-                access.IsEnabled)) || [];
-            return accessList.some((access) => access[accessType] === AccessPermission.All);
-        }
-        return false;
-    }
-    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "19.2.21", ngImport: i0, type: DSQHelper, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
-    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "19.2.21", ngImport: i0, type: DSQHelper, providedIn: 'root' }); }
-}
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.2.21", ngImport: i0, type: DSQHelper, decorators: [{
-            type: Injectable,
-            args: [{ providedIn: 'root' }]
-        }] });
-//# sourceMappingURL=data:application/json;base64,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

package/esm2022/lib/tab-core-utility/app/helpers/common/req-res.helpers.mjs

@@ -1,44 +0,0 @@
-/* eslint-disable @typescript-eslint/no-explicit-any */
-import { Injectable } from '@angular/core';
-import { QueryType } from '../../enums/query.enum';
-import * as i0 from "@angular/core";
-export class RequestResponseHelper {
-    /**
-     * Generates the payload for inserting data into a table in bulk
-     * @param table The table name to insert data into
-     * @param whereClause The filter criteria for the insert operation
-     * @param value The value sets to be inserted
-     * @param fields Optional list of fields to include in the insert operation
-     * @returns The payload for the bulk insert operation
-     */
-    bulkInsertPayload(table, whereClause, value, fields) {
-        return {
-            QueryObjectID: table,
-            QueryType: QueryType.BulkInsert,
-            Joins: [],
-            WhereClause: whereClause,
-            Values: value,
-            Fields: fields,
-        };
-    }
-    /**
-     * Generates the payload for deleting data from a table
-     * NEW: Returns new format for /records/delete endpoint
-     * @param tableName The table name (entityName) to delete data from
-     * @param whereClause The filter criteria for the delete operation (NEW format with lowercase)
-     * @returns The payload for the delete operation in NEW format
-     */
-    deletePayload(tableName, whereClause) {
-        return {
-            entityName: tableName,
-            whereClause: whereClause,
-        };
-    }
-    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "19.2.21", ngImport: i0, type: RequestResponseHelper, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
-    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "19.2.21", ngImport: i0, type: RequestResponseHelper, providedIn: 'root' }); }
-}
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.2.21", ngImport: i0, type: RequestResponseHelper, decorators: [{
-            type: Injectable,
-            args: [{ providedIn: 'root' }]
-        }] });
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicmVxLXJlcy5oZWxwZXJzLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vLi4vLi4vLi4vLi4vbGlicy9kYXRhLWFjY2Vzcy9zcmMvbGliL3RhYi1jb3JlLXV0aWxpdHkvYXBwL2hlbHBlcnMvY29tbW9uL3JlcS1yZXMuaGVscGVycy50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSx1REFBdUQ7QUFFdkQsT0FBTyxFQUFFLFVBQVUsRUFBRSxNQUFNLGVBQWUsQ0FBQztBQUUzQyxPQUFPLEVBQUUsU0FBUyxFQUFFLE1BQU0sd0JBQXdCLENBQUM7O0FBRW5ELE1BQU0sT0FBTyxxQkFBcUI7SUFDaEM7Ozs7Ozs7T0FPRztJQUNILGlCQUFpQixDQUNmLEtBQWEsRUFDYixXQUE4QixFQUM5QixLQUFxQyxFQUNyQyxNQUFpQjtRQUVqQixPQUFPO1lBQ0wsYUFBYSxFQUFFLEtBQUs7WUFDcEIsU0FBUyxFQUFFLFNBQVMsQ0FBQyxVQUFVO1lBQy9CLEtBQUssRUFBRSxFQUFFO1lBQ1QsV0FBVyxFQUFFLFdBQVc7WUFDeEIsTUFBTSxFQUFFLEtBQUs7WUFDYixNQUFNLEVBQUUsTUFBTTtTQUNmLENBQUM7SUFDSixDQUFDO0lBRUQ7Ozs7OztPQU1HO0lBQ0gsYUFBYSxDQUFDLFNBQWlCLEVBQUUsV0FBOEI7UUFDN0QsT0FBTztZQUNMLFVBQVUsRUFBRSxTQUFTO1lBQ3JCLFdBQVcsRUFBRSxXQUFXO1NBQ3pCLENBQUM7SUFDSixDQUFDOytHQXJDVSxxQkFBcUI7bUhBQXJCLHFCQUFxQixjQURSLE1BQU07OzRGQUNuQixxQkFBcUI7a0JBRGpDLFVBQVU7bUJBQUMsRUFBRSxVQUFVLEVBQUUsTUFBTSxFQUFFIiwic291cmNlc0NvbnRlbnQiOlsiLyogZXNsaW50LWRpc2FibGUgQHR5cGVzY3JpcHQtZXNsaW50L25vLWV4cGxpY2l0LWFueSAqL1xyXG5cclxuaW1wb3J0IHsgSW5qZWN0YWJsZSB9IGZyb20gJ0Bhbmd1bGFyL2NvcmUnO1xyXG5pbXBvcnQgeyBBUElCdWxrSW5zZXJ0RmllbGRzVmFsdWVTZXRzLCBBUElGaWx0ZXJDcml0ZXJpYSB9IGZyb20gJy4uLy4uL21vZGVscy9hcGktcXVlcnkuY2xhc3MnO1xyXG5pbXBvcnQgeyBRdWVyeVR5cGUgfSBmcm9tICcuLi8uLi9lbnVtcy9xdWVyeS5lbnVtJztcclxuQEluamVjdGFibGUoeyBwcm92aWRlZEluOiAncm9vdCcgfSlcclxuZXhwb3J0IGNsYXNzIFJlcXVlc3RSZXNwb25zZUhlbHBlciB7XHJcbiAgLyoqXHJcbiAgICogR2VuZXJhdGVzIHRoZSBwYXlsb2FkIGZvciBpbnNlcnRpbmcgZGF0YSBpbnRvIGEgdGFibGUgaW4gYnVsa1xyXG4gICAqIEBwYXJhbSB0YWJsZSBUaGUgdGFibGUgbmFtZSB0byBpbnNlcnQgZGF0YSBpbnRvXHJcbiAgICogQHBhcmFtIHdoZXJlQ2xhdXNlIFRoZSBmaWx0ZXIgY3JpdGVyaWEgZm9yIHRoZSBpbnNlcnQgb3BlcmF0aW9uXHJcbiAgICogQHBhcmFtIHZhbHVlIFRoZSB2YWx1ZSBzZXRzIHRvIGJlIGluc2VydGVkXHJcbiAgICogQHBhcmFtIGZpZWxkcyBPcHRpb25hbCBsaXN0IG9mIGZpZWxkcyB0byBpbmNsdWRlIGluIHRoZSBpbnNlcnQgb3BlcmF0aW9uXHJcbiAgICogQHJldHVybnMgVGhlIHBheWxvYWQgZm9yIHRoZSBidWxrIGluc2VydCBvcGVyYXRpb25cclxuICAgKi9cclxuICBidWxrSW5zZXJ0UGF5bG9hZChcclxuICAgIHRhYmxlOiBzdHJpbmcsXHJcbiAgICB3aGVyZUNsYXVzZTogQVBJRmlsdGVyQ3JpdGVyaWEsXHJcbiAgICB2YWx1ZTogQVBJQnVsa0luc2VydEZpZWxkc1ZhbHVlU2V0c1tdLFxyXG4gICAgZmllbGRzPzogc3RyaW5nW11cclxuICApIHtcclxuICAgIHJldHVybiB7XHJcbiAgICAgIFF1ZXJ5T2JqZWN0SUQ6IHRhYmxlLFxyXG4gICAgICBRdWVyeVR5cGU6IFF1ZXJ5VHlwZS5CdWxrSW5zZXJ0LFxyXG4gICAgICBKb2luczogW10sXHJcbiAgICAgIFdoZXJlQ2xhdXNlOiB3aGVyZUNsYXVzZSxcclxuICAgICAgVmFsdWVzOiB2YWx1ZSxcclxuICAgICAgRmllbGRzOiBmaWVsZHMsXHJcbiAgICB9O1xyXG4gIH1cclxuXHJcbiAgLyoqXHJcbiAgICogR2VuZXJhdGVzIHRoZSBwYXlsb2FkIGZvciBkZWxldGluZyBkYXRhIGZyb20gYSB0YWJsZVxyXG4gICAqIE5FVzogUmV0dXJucyBuZXcgZm9ybWF0IGZvciAvcmVjb3Jkcy9kZWxldGUgZW5kcG9pbnRcclxuICAgKiBAcGFyYW0gdGFibGVOYW1lIFRoZSB0YWJsZSBuYW1lIChlbnRpdHlOYW1lKSB0byBkZWxldGUgZGF0YSBmcm9tXHJcbiAgICogQHBhcmFtIHdoZXJlQ2xhdXNlIFRoZSBmaWx0ZXIgY3JpdGVyaWEgZm9yIHRoZSBkZWxldGUgb3BlcmF0aW9uIChORVcgZm9ybWF0IHdpdGggbG93ZXJjYXNlKVxyXG4gICAqIEByZXR1cm5zIFRoZSBwYXlsb2FkIGZvciB0aGUgZGVsZXRlIG9wZXJhdGlvbiBpbiBORVcgZm9ybWF0XHJcbiAgICovXHJcbiAgZGVsZXRlUGF5bG9hZCh0YWJsZU5hbWU6IHN0cmluZywgd2hlcmVDbGF1c2U6IEFQSUZpbHRlckNyaXRlcmlhKSB7XHJcbiAgICByZXR1cm4ge1xyXG4gICAgICBlbnRpdHlOYW1lOiB0YWJsZU5hbWUsXHJcbiAgICAgIHdoZXJlQ2xhdXNlOiB3aGVyZUNsYXVzZSxcclxuICAgIH07XHJcbiAgfVxyXG59XHJcbiJdfQ==

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

@@ -1,35 +0,0 @@
-import { QueryType } from '../../enums/query.enum';
-import { AccessType } from '../../enums/permission.enum';
-import * as i0 from "@angular/core";
-export declare class DSQHelper {
-    private readonly apiService;
-    private readonly metadataHelper;
-    /**
-     * Executes a query based on the query type
-     * NOTE: INSERT, UPDATE, and DELETE now use new /records/* endpoints
-     * This helper now only handles legacy endpoints: BulkInsert and Select
-     * @param data The data to be executed
-     * @param queryType The type of query to be executed
-     * @returns The result of the query execution
-     */
-    executeQuery(data: any, queryType: QueryType, headers?: any): import("rxjs").Observable<any> | null;
-    /**
-     * Executes an HTTP POST request with the provided data and URL
-     * @param data The data to be sent in the POST request
-     * @param endPointName The URL to send the POST request to
-     * @returns The result of the POST request if headers are available, otherwise null
-     */
-    private execution;
-    /**
-     * Checks if the user has access to the specified object based on roles and access type
-     * @param dsqId The DataSourceQuery ID to check access for
-     * @param accessType The type of access to check (e.g., read, write)
-     * @param roles The roles of the user with IDs
-     * @returns True if the user has access, false otherwise
-     */
-    doesHaveObjectAccess(dsqId: string, accessType: AccessType, roles: [{
-        ID: string;
-    }]): boolean;
-    static ɵfac: i0.ɵɵFactoryDeclaration<DSQHelper, never>;
-    static ɵprov: i0.ɵɵInjectableDeclaration<DSQHelper>;
-}