@techextensor/tab-core-utility 2.2.187 → 2.2.188

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

@@ -14,15 +14,14 @@ export interface RecordInfo {
     primaryKey: string;
 }
 export interface CommonApiResponse {
-    RequestId: string;
     IsSuccess: boolean;
     Result: any;
-    StatusCode: string;
     RecordAffectted: number;
     TotalRecords: number;
     TotalExecutionTime: number;
     Log: any[];
     Errors: any[];
+    CorrelationId?: string;
 }
 export interface GetScreenConfig {
     layoutId?: string;
@@ -165,3 +164,53 @@ export interface executeTABWorkflowPayload {
     AppObjectId: string;
     Reqtokens?: any;
 }
+/**
+ * Standard API response format (camelCase - NEW BACKEND)
+ * All new APIs return this consistent structure
+ */
+export interface StandardApiResponse {
+    /** Indicates if the request was successful */
+    isSuccess: boolean;
+    /** Error information (null if successful) */
+    error: ApiError | null;
+    /** Response data (null if error) */
+    result: any | null;
+    /** Request execution time in milliseconds */
+    executionTimeMs: number;
+    /** Log entries from the request */
+    logs: string[];
+    /** Additional metadata about the request */
+    metadata: Record<string, any>;
+    /** Number of records affected (for mutations) */
+    affectedRecords?: number;
+    /** Total number of records (for queries) */
+    totalRecords?: number;
+    /** Correlation ID for async operations (null for sync operations) */
+    correlationId?: string;
+}
+/**
+ * Error information in new API format
+ */
+export interface ApiError {
+    /** Error code (e.g., "UNEXPECTED_ERROR", "VALIDATION_ERROR") */
+    code: string;
+    /** User-friendly error message */
+    message: string;
+    /** Technical error details for debugging */
+    details: string;
+}
+/**
+ * Microservice URLs configuration
+ */
+export interface APIServiceUrls {
+    crudService: string;
+    metadataService: string;
+    formioService: string;
+    identityService: string;
+    codeExecutorService: string;
+    notificationService: string;
+    workflowService: string;
+    kibanaService: string;
+    reportService: string;
+}
+export type APIServiceName = keyof APIServiceUrls;

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

@@ -0,0 +1,84 @@
+/**
+ * Raw SignalR message wrapper
+ */
+export interface SignalRMessage {
+    type: number;
+    target: string;
+    arguments: CrudNotification[];
+}
+/**
+ * CRUD notification payload received from SignalR hub
+ */
+export interface CrudNotification {
+    correlationId: string;
+    result: any;
+    entityName: string;
+    appObjectId: string;
+    isSuccess: boolean;
+    errorMessage: string | null;
+    errorCode: string | null;
+    executionTimeMs: number;
+    affectedRecords: number | null;
+    operation?: CrudOperation;
+    receivedAt?: Date;
+}
+/**
+ * Pending async operation tracked by OperationTrackerService
+ */
+export interface PendingOperation {
+    correlationId: string;
+    timestamp: Date;
+    timeout: number;
+}
+/**
+ * Callback function type for component notifications
+ */
+export type NotificationCallback = (notification: CrudNotification) => void;
+/**
+ * CRUD operation types
+ */
+export type CrudOperation = typeof CRUD_OPERATION[keyof typeof CRUD_OPERATION];
+/**
+ * SignalR connection state types
+ */
+export type ConnectionState = typeof CONNECTION_STATE[keyof typeof CONNECTION_STATE];
+/**
+ * SignalR hub method names
+ */
+export declare const SIGNALR_HUB_METHODS: {
+    readonly JOIN_GROUP: "JoinGroupAsync";
+    readonly LEAVE_GROUP: "LeaveGroupAsync";
+};
+/**
+ * SignalR event names from backend
+ */
+export declare const SIGNALR_EVENTS: {
+    readonly INSERT_COMPLETED: "InsertOperationCompleted";
+    readonly UPDATE_COMPLETED: "UpdateOperationCompleted";
+    readonly DELETE_COMPLETED: "DeleteOperationCompleted";
+};
+/**
+ * CRUD operation types
+ */
+export declare const CRUD_OPERATION: {
+    readonly INSERT: "INSERT";
+    readonly UPDATE: "UPDATE";
+    readonly DELETE: "DELETE";
+};
+/**
+ * SignalR connection states
+ */
+export declare const CONNECTION_STATE: {
+    readonly DISCONNECTED: "Disconnected";
+    readonly CONNECTING: "Connecting";
+    readonly CONNECTED: "Connected";
+    readonly RECONNECTING: "Reconnecting";
+    readonly FAILED: "Failed";
+};
+/**
+ * SignalR configuration constants
+ */
+export declare const SIGNALR_CONFIG: {
+    readonly DEFAULT_TIMEOUT: 120000;
+    readonly RECONNECT_DELAYS: readonly [0, 2000, 10000, 30000, 60000];
+};

package/lib/tab-core-utility/app/models/api-query.class.d.ts

@@ -37,20 +37,19 @@ export declare class ChildRelationShip {
     childDetails: LookUpDetails;
 }
 export declare class APIFilterCriteria {
-    Filters: APIFilter[] | any;
-    FilterLogic: string | any;
+    filters: APIFilter[] | any;
+    filterLogic: string | any;
     SQLQuery: string | any;
 }
 export declare class APIFilter {
-    ConjuctionClause: ConjuctionClause | any;
-    FieldID: string | any;
-    RelationalOperator: RelationalOperator | any;
-    ValueType: FilterValueType | any;
+    conjunction: ConjuctionClause | any;
+    fieldName: string | any;
+    operator: RelationalOperator | any;
+    valueType: FilterValueType | any;
     value: string | any;
-    Sequence: number | any;
-    GroupID: number | any;
+    sequence: number | any;
+    groupId: number | any;
     parameterName: string | any;
-    Value: string | any;
 }
 export declare class APIValueSets {
     AppFieldID: string | any;
@@ -72,3 +71,49 @@ export declare class APIParameters {
     DataSourceQueryID: string | any;
     MappingFieldName: string | any;
 }
+/**
+ * New CRUD API Select Query Payload
+ * Used for the new microservice-based select query endpoint
+ */
+export declare class CRUDSelectPayload {
+    EntityName: string | any;
+    SelectedFields: string[];
+    includes?: any[];
+    Pager?: CRUDPager;
+    whereClause?: CRUDWhereClause;
+    Distinct?: boolean;
+    Sort?: CRUDSort[];
+}
+/**
+ * Pager configuration for CRUD API
+ */
+export declare class CRUDPager {
+    pageNumber: number;
+    pageSize: number;
+    returnTotalCount: boolean;
+}
+/**
+ * Where clause structure for CRUD API
+ */
+export declare class CRUDWhereClause {
+    filters: CRUDFilter[];
+}
+/**
+ * Filter structure for CRUD API
+ */
+export declare class CRUDFilter {
+    fieldName: string | any;
+    operator: number | any;
+    value: any;
+    valueType: number | any;
+    conjunction: number | any;
+    groupId: number | any;
+    sequence: number | any;
+}
+/**
+ * Sort structure for CRUD API
+ */
+export declare class CRUDSort {
+    FieldName: string | any;
+    Direction: number | any;
+}

package/lib/tab-core-utility/app/models/app-field.model.d.ts

@@ -49,8 +49,10 @@ export declare class AppFieldModel {
      */
     search(term: string): boolean;
     /**
-     * Converts the AppFieldModel instance to a JSON representation.
-     * @returns {any} The raw data of the instance.
+     * Converts the AppFieldModel instance to JSON in the old API format (PascalCase).
+     * This ensures backward compatibility with code expecting the old format.
+     *
+     * @returns {any} The data in old API format.
      */
     toJSON(): any;
 }

package/lib/tab-core-utility/app/models/app-object.model.d.ts

@@ -40,13 +40,14 @@ export declare class AppObjectModel {
     readonly AccessList: Array<ObjectAccess>;
     readonly Resources: Array<Resources>;
     readonly ChildRelationShips: Array<ChildRelationShip>;
-    readonly parsedAppObjectConfiguration: any;
     readonly AppId: string | null;
     private readonly fieldMap;
     private readonly dsqMap;
     private allFields;
     private allDSQs;
+    private parsedAppObjectJson;
     constructor(raw: any, metadataHelper: MetadataHelper);
+    private parseAppObjectJson;
     /**
      * Returns all fields associated with this AppObject. The fields are cached so that subsequent calls
      * are faster. The cache is stored in a map by ID.
@@ -121,9 +122,10 @@ export declare class AppObjectModel {
         dsqs: DataSourceQueryModel[];
     };
     /**
-     * Converts the current object to a JSON object.
+     * Converts the current object to JSON in the old API format (PascalCase).
+     * This ensures backward compatibility with code expecting the old format.
      *
-     * @returns {any} The raw data as a JSON object.
+     * @returns {any} The data in old API format.
      */
     toJSON(): any;
 }

package/lib/tab-core-utility/app/models/app-screen.model.d.ts

@@ -25,9 +25,9 @@ export declare class AppScreenModel {
      */
     search(term: string): boolean;
     /**
-     * Converts the current object to a JSON object.
+     * Converts the model to JSON in the old API format (PascalCase).
      *
-     * @returns A JSON representation of the current object.
+     * @returns A JSON representation in old format.
      */
     toJSON(): any;
 }

package/lib/tab-core-utility/app/models/data-source-query.model.d.ts

@@ -18,9 +18,12 @@ export declare class DataSourceQueryModel {
     private cachedParameters;
     private cachedFilters;
     private cachedSorts;
+    private parsedConfiguration;
     constructor(raw: any, parentAppObject: AppObjectModel, metadataHelper: MetadataHelper);
+    private parseConfiguration;
     /**
      * Gets the fields for the data source query. The fields are enriched with the corresponding `AppFieldModel` objects.
+     * Handles both old format (array of objects) and new format (array of field ID strings).
      * @returns {DataSourceQueries_Fields[]} The array of enriched fields.
      */
     fields(): DataSourceQueries_Fields[];
@@ -64,8 +67,10 @@ export declare class DataSourceQueryModel {
      */
     search(term: string): boolean;
     /**
-     * Converts the DataSourceQueryModel instance to a JSON representation.
-     * @returns {any} The raw data in JSON format.
+     * Converts the DataSourceQueryModel instance to JSON in the old API format (PascalCase).
+     * This ensures backward compatibility with code expecting the old format.
+     *
+     * @returns {any} The data in old API format.
      */
     toJSON(): any;
 }

package/lib/tab-core-utility/app/models/filter.model.d.ts

@@ -13,9 +13,9 @@ export declare class FilterModel {
     readonly FieldID: string;
     constructor(raw: any);
     /**
-     * Converts the current object to a JSON object.
+     * Converts the model to JSON in the old API format (PascalCase).
      *
-     * @returns A JSON representation of the current object.
+     * @returns A JSON representation in old format.
      */
     toJSON(): any;
 }

package/lib/tab-core-utility/app/models/parameter.model.d.ts

@@ -7,8 +7,8 @@ export declare class ParameterModel {
     readonly IsMandatory: boolean;
     constructor(raw: any);
     /**
-     * Converts the model to JSON.
-     * @returns {any} The model as a JSON object.
+     * Converts the model to JSON in the old API format (PascalCase).
+     * @returns {any} The model as a JSON object in old format.
      */
     toJSON(): any;
 }

package/lib/tab-core-utility/app/models/sort.model.d.ts

@@ -9,7 +9,7 @@ export declare class SortModel {
     readonly AppFieldID: string;
     constructor(raw: any);
     /**
-     * Get raw data for this app object
+     * Converts the model to JSON in the old API format (PascalCase).
      */
     toJSON(): any;
 }

package/lib/tab-core-utility/app/utils/json.util.d.ts

@@ -5,9 +5,10 @@
  */
 export declare function validateJSON(str: string): boolean;
 /**
- * Creates dynamic data based on the input object
+ * Creates dynamic data based on the input object for new API format
+ * Transforms object into array of {fieldName, value} pairs
  * @param obj The input object to create dynamic data from
- * @returns The formatted array
+ * @returns The formatted array with {fieldName, value} pairs
  */
 export declare function createDynamicData(obj: any): any;
 /**

package/lib/tab-core-utility/app/utils/req-res.util.d.ts

@@ -1,6 +1,5 @@
 import { HttpHeaders } from '@angular/common/http';
 import { AppObject } from '../models/app-object.class';
-import { AppFields } from '../models/data-source-queries.class';
 /**
  * Delete a key from the response object
  *
@@ -37,7 +36,7 @@ export declare function getHeaders(headers?: any): any;
  * @param appObject - The AppObject
  * @returns AppFields[] | null - The array of primary key fields or null
  */
-export declare function getPrimaryKeyFields(appObject: AppObject): AppFields[] | null;
+export declare function getPrimaryKeyFields(appObject: AppObject): import("@techextensor/tab-core-utility").AppFields[] | null;
 /**
  * Get the edit record ID from the response object
  *
@@ -46,13 +45,6 @@ export declare function getPrimaryKeyFields(appObject: AppObject): AppFields[] |
  * @returns any - The edit record ID
  */
 export declare function getEditRecordId(response: any, fieldName: any): any;
-/**
- * Generate the fields schema based on the AppFields
- *
- * @param fields - The AppFields object
- * @returns any - The generated fields schema
- */
-export declare function generateFieldsSchema(url: any, fields: AppFields): {};
 /**
  * Get the HttpHeaders for form data requests
  *

package/lib/tab-core-utility/app/utils/tab-app.util.d.ts

@@ -1,36 +1,4 @@
 import { AppObject } from '../models/app-object.class';
-/** Get the DataSourceQuery ID from the selected AppObject's DataSourceQuery array
- * @param dsqList - The list of DataSourceQueries
- * @param table - The table name
- * @param like - The like string
- * @returns string - The ID of the DataSourceQuery
- */
-export declare function getDsqIdfromSelectedAppObjectDSQArray(dsqList: any, table: string, like: string): any;
-/** Get the AppObject based on the provided ID
- * @param id - The ID of the AppObject
- * @returns AppObject | null - The found AppObject or null
- */
-export declare function getAppObject(id: string): any;
-/**
- * Get the AppObject from the DataSourceQuery ID
- * @param dsqId - The DataSourceQuery ID
- * @returns AppObject | null - The found AppObject or null
- */
-export declare function getAppObjectFromDataSourceQueryID(dsqId: string): any;
-/**
- * Get the DataSourceQuery ID from the QueryName and table
- * @param table - The table name
- * @param dsq - The DataSourceQuery name
- * @returns any - The found DataSourceQuery
- */
-export declare function getDsqIDFromQueryName(table: string, dsq: string): any;
-/**
- * Get the Data from the DataSourceQuery ID
- *
- * @param dsqId - The DataSourceQuery ID
- * @returns any - The found Data
- */
-export declare function getDataFromDataSourceQueryID(dsqId: string): any;
 /**
  * Synchronize AppObject fields with the response
  *
@@ -39,32 +7,3 @@ export declare function getDataFromDataSourceQueryID(dsqId: string): any;
  * @returns any - The synchronized response object
  */
 export declare function syncAppObjectFields(response: any, appObject: AppObject): any;
-/**
- * Get the AppObject based on the SystemDBTableName
- *
- * @param tableName - The SystemDBTableName
- * @returns AppObject | null - The found AppObject or null
- */
-export declare function getAppObjectFromSystemDBTableName(tableName: string): any;
-/**
- * Get the fields based on the appobjectid
- *
- * @param appObjectId - The appobjectid
- * @returns AppObject | null - The found AppObject or null
- */
-export declare function getAppfieldsFromAppObjectId(appObjectId: string): any;
-export declare function getLookupAppfieldsFromAppObjectId(appObjectId: string): any;
-export declare function getViewAppObjectDetailsFromDSQID(dsqID: string): any;
-/**
- * Retrieves all appObjects and their DSQs in a single list
- * suitable for tree view representation.
- * @author : Parth B Thakkar
- * @Usage : HTTP Request
- * @returns Array<{ id: string; name: string; hasChildren: boolean; parentID: string | null }>
- */
-export declare function getAllAppObjectsForTreeViewJson(): {
-    id: string;
-    name: string;
-    hasChildren: boolean;
-    parentID: string | null;
-}[];

package/lib/tab-core-utility/core/http-client/api.service.d.ts

@@ -1,5 +1,6 @@
 import { HttpParams, HttpHeaders } from '@angular/common/http';
 import { Observable } from 'rxjs';
+import { APIServiceName, CommonApiResponse } from '../../app/interfaces/common.interface';
 import * as i0 from "@angular/core";
 export declare class ApiService {
     private readonly http;
@@ -81,6 +82,51 @@ export declare class ApiService {
      * @returns An Observable emitting the response data of type T.
      */
     deleteByUrl<T>(url: string, options?: any): Observable<any>;
+    /**
+     * Makes an HTTP GET request to a specific microservice
+     * @param serviceName - Name of the microservice (e.g., 'crudService', 'metadataService')
+     * @param endPointName - Endpoint path relative to the service
+     * @param params - Query parameters for the request
+     * @param reqHeader - Custom headers for the request
+     * @returns An Observable emitting the response data (auto-normalized to CommonApiResponse format)
+     */
+    getFromService(serviceName: APIServiceName, endPointName: string, params?: HttpParams, reqHeader?: HttpHeaders): Observable<CommonApiResponse>;
+    /**
+     * Makes an HTTP POST request to a specific microservice
+     * @param serviceName - Name of the microservice (e.g., 'crudService', 'formioService')
+     * @param endPointName - Endpoint path relative to the service
+     * @param data - Data to send with the request
+     * @param reqHeader - Custom headers for the request
+     * @returns An Observable emitting the response data (auto-normalized to CommonApiResponse format)
+     */
+    postToService<T, D>(serviceName: APIServiceName, endPointName: string, data?: D, reqHeader?: HttpHeaders): Observable<CommonApiResponse>;
+    /**
+     * Makes an HTTP PUT request to a specific microservice
+     * @param serviceName - Name of the microservice
+     * @param endPointName - Endpoint path relative to the service
+     * @param data - Data to send with the request
+     * @param reqHeader - Custom headers for the request
+     * @returns An Observable emitting the response data (auto-normalized to CommonApiResponse format)
+     */
+    putToService<T, D>(serviceName: APIServiceName, endPointName: string, data: D, reqHeader?: HttpHeaders): Observable<CommonApiResponse>;
+    /**
+     * Makes an HTTP DELETE request to a specific microservice
+     * @param serviceName - Name of the microservice
+     * @param endPointName - Endpoint path relative to the service
+     * @param data - Data to send with the request (optional, for DELETE with body)
+     * @param reqHeader - Custom headers for the request
+     * @returns An Observable emitting the response data (auto-normalized to CommonApiResponse format)
+     */
+    deleteFromService<D>(serviceName: APIServiceName, endPointName: string, data?: D, reqHeader?: HttpHeaders): Observable<CommonApiResponse>;
+    /**
+     * Makes an HTTP POST request to a specific microservice and returns a Blob response
+     * @param serviceName - Name of the microservice (e.g., 'reportService')
+     * @param endPointName - Endpoint path relative to the service
+     * @param data - Data to send with the request
+     * @param reqHeader - Custom headers for the request
+     * @returns An Observable emitting the response as a Blob
+     */
+    postBlobToService<D>(serviceName: APIServiceName, endPointName: string, data?: D, reqHeader?: HttpHeaders): Observable<Blob>;
     static ɵfac: i0.ɵɵFactoryDeclaration<ApiService, never>;
     static ɵprov: i0.ɵɵInjectableDeclaration<ApiService>;
 }

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

@@ -0,0 +1,40 @@
+import { Observable } from 'rxjs';
+import { CrudNotification, PendingOperation } from '../../../app/interfaces/signalr.interface';
+import * as i0 from "@angular/core";
+/**
+ * Operation Tracker Service
+ * Tracks async operations by correlationId and matches them with SignalR notifications
+ * Used by TabFormioService for handling async processRequest operations
+ */
+export declare class OperationTrackerService {
+    private pendingOperations;
+    private operationCompleted$;
+    /**
+     * 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
+     */
+    waitForOperation(correlationId: string, timeoutMs?: number): Observable<CrudNotification>;
+    /**
+     * Handle incoming SignalR notification
+     * Called by SignalRService when notification is received
+     */
+    handleNotification(notification: CrudNotification): void;
+    /**
+     * Check if operation is pending
+     */
+    isPending(correlationId: string): boolean;
+    /**
+     * Get pending operations count (for debugging)
+     */
+    getPendingCount(): number;
+    /**
+     * Get all pending operations (for debugging)
+     */
+    getAllPending(): PendingOperation[];
+    static ɵfac: i0.ɵɵFactoryDeclaration<OperationTrackerService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<OperationTrackerService>;
+}

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

@@ -0,0 +1,73 @@
+import { Subject } from 'rxjs';
+import { ConnectionState, CrudNotification } from '../../../app/interfaces/signalr.interface';
+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 declare class SignalRInfrastructure {
+    private hubConnection;
+    readonly sessionStorageService: SessionStorageService;
+    readonly localStorageService: LocalStorageService;
+    readonly connectionState: import("@angular/core").WritableSignal<ConnectionState>;
+    readonly notifications$: Subject<CrudNotification>;
+    private activeGroups;
+    /**
+     * 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
+     */
+    private getFromStorage;
+    get appId(): string | null;
+    get environmentId(): string | null;
+    get tenantId(): string | null;
+    get token(): string | null;
+    /**
+     * Connect to SignalR hub
+     */
+    connect(): Promise<void>;
+    /**
+     * Register SignalR event handlers for CRUD notifications
+     */
+    private registerEventHandlers;
+    /**
+     * Extract notification from SignalR callback args
+     * Handles both unwrapped (direct object) and wrapped ({ type, target, arguments }) formats
+     */
+    private extractNotification;
+    /**
+     * Register connection lifecycle handlers
+     */
+    private registerConnectionLifecycle;
+    /**
+     * Join SignalR group for an AppObject
+     */
+    joinGroup(appObjectId: string): Promise<void>;
+    /**
+     * Leave SignalR group
+     */
+    leaveGroup(appObjectId: string): Promise<void>;
+    /**
+     * Rejoin all active groups after reconnection
+     * This ensures components continue receiving notifications after network interruption
+     */
+    private rejoinGroups;
+    /**
+     * Check if connected
+     */
+    isConnected(): boolean;
+    /**
+     * Disconnect from SignalR hub (cleanup)
+     */
+    disconnect(): Promise<void>;
+    /**
+     * Get active groups (for debugging)
+     */
+    getActiveGroups(): string[];
+    static ɵfac: i0.ɵɵFactoryDeclaration<SignalRInfrastructure, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<SignalRInfrastructure>;
+}