@techextensor/tab-core-utility 2.2.130 → 2.2.132

package/esm2022/index.mjs

@@ -24,6 +24,7 @@ export * from './lib/tab-core-utility/app/helpers/common/dsq.helpers';
 export * from './lib/tab-core-utility/app/helpers/common/req-res.helpers';
 export * from './lib/tab-core-utility/app/helpers/common/where-clause.helpers';
 export * from './lib/tab-core-utility/app/helpers/common/template.helpers';
+export * from './lib/tab-core-utility/app/helpers/common/meta-data.helpers';
 export * from './lib/tab-core-utility/app/helpers/screen/forms.helpers';
 export * from './lib/tab-core-utility/app/helpers/screen/grid-column-data.helpers';
 export * from './lib/tab-core-utility/app/helpers/screen/grid.helpers';
@@ -66,4 +67,4 @@ export * from './lib/tab-core-utility/core/util/auth.utils';
 export * from './lib/tab-core-utility/store/orginfo.store';
 // export * from './lib/tab-core-utility/store/schema.store'
 export * from './lib/tab-core-utility/store/auth.store';
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/lib/tab-core-utility/app/constants/storage-constants.mjs

@@ -18,6 +18,7 @@ export const StorageConstants = {
     AppId: 'AppId',
     screenContext: 'screenContext',
     environmentMode: 'environmentMode',
+    environmentId: 'environmentId',
     tabAppObjectAccess: 'tabAppObjectAccess'
 };
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoic3RvcmFnZS1jb25zdGFudHMuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi8uLi8uLi9saWJzL2RhdGEtYWNjZXNzL3NyYy9saWIvdGFiLWNvcmUtdXRpbGl0eS9hcHAvY29uc3RhbnRzL3N0b3JhZ2UtY29uc3RhbnRzLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE1BQU0sQ0FBQyxNQUFNLGdCQUFnQixHQUFHO0lBQzlCLE9BQU8sRUFBRSxTQUFTO0lBQ2xCLFFBQVEsRUFBRSxVQUFVO0lBQ3BCLFVBQVUsRUFBRSxZQUFZO0lBQ3hCLE9BQU8sRUFBRSxTQUFTO0lBQ2xCLGVBQWUsRUFBRSxpQkFBaUI7SUFDbEMsR0FBRyxFQUFFLEtBQUs7SUFDVixRQUFRLEVBQUUsVUFBVTtJQUNwQixLQUFLLEVBQUUsT0FBTztJQUNkLFdBQVcsRUFBRSxhQUFhO0lBQzFCLFFBQVEsRUFBRSxVQUFVO0lBQ3BCLG9CQUFvQixFQUFFLHNCQUFzQjtJQUM1QyxjQUFjLEVBQUUsZ0JBQWdCO0lBQ2hDLFNBQVMsRUFBRSxXQUFXO0lBQ3RCLFFBQVEsRUFBRSxVQUFVO0lBQ3BCLGFBQWEsRUFBRSxlQUFlO0lBQzlCLHVCQUF1QixFQUFFLHlCQUF5QjtJQUNsRCxLQUFLLEVBQUMsT0FBTztJQUNiLGFBQWEsRUFBQyxlQUFlO0lBQzdCLGVBQWUsRUFBQyxpQkFBaUI7SUFDakMsa0JBQWtCLEVBQUUsb0JBQW9CO0NBQ3pDLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyJleHBvcnQgY29uc3QgU3RvcmFnZUNvbnN0YW50cyA9IHtcclxuICB0YWJEYXRhOiAndGFiRGF0YScsXHJcbiAgZm9ybUpzb246ICdGb3JtSnNvbicsXHJcbiAgc2NoZW1hSlNPTjogJ3NjaGVtYUpTT04nLFxyXG4gIG9yZ0luZm86ICdvcmdJbmZvJyxcclxuICBhcHBsaWNhdGlvbkNvZGU6ICdhcHBsaWNhdGlvbkNvZGUnLFxyXG4gIFRBQjogJ1RBQicsXHJcbiAgdXNlckluZm86ICd1c2VySW5mbycsXHJcbiAgdG9rZW46ICd0b2tlbicsXHJcbiAgc3RhdGljVG9rZW46ICdzdGF0aWNUb2tlbicsXHJcbiAgc2NyZWVuSWQ6ICdzY3JlZW5JZCcsXHJcbiAgZWRpdFNjcmVlblF1ZXJ5UGFyYW06ICdlZGl0U2NyZWVuUXVlcnlQYXJhbScsXHJcbiAgbGF5b3V0U2NyZWVuSWQ6ICdsYXlvdXRTY3JlZW5JZCcsXHJcbiAgdGFiU2NyZWVuOiAndGFiU2NyZWVuJyxcclxuICBUZW5hbnRJZDogJ1RlbmFudElkJyxcclxuICBBdXRob3JpemF0aW9uOiAnQXV0aG9yaXphdGlvbicsXHJcbiAgdGFiVXNlclBlcnNvbmFsaXplZERhdGE6ICd0YWJVc2VyUGVyc29uYWxpemVkRGF0YScsXHJcbiAgQXBwSWQ6J0FwcElkJyxcclxuICBzY3JlZW5Db250ZXh0OidzY3JlZW5Db250ZXh0JyxcclxuICBlbnZpcm9ubWVudE1vZGU6J2Vudmlyb25tZW50TW9kZScsXHJcbiAgdGFiQXBwT2JqZWN0QWNjZXNzOiAndGFiQXBwT2JqZWN0QWNjZXNzJ1xyXG59O1xyXG4iXX0=
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoic3RvcmFnZS1jb25zdGFudHMuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi8uLi8uLi9saWJzL2RhdGEtYWNjZXNzL3NyYy9saWIvdGFiLWNvcmUtdXRpbGl0eS9hcHAvY29uc3RhbnRzL3N0b3JhZ2UtY29uc3RhbnRzLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE1BQU0sQ0FBQyxNQUFNLGdCQUFnQixHQUFHO0lBQzlCLE9BQU8sRUFBRSxTQUFTO0lBQ2xCLFFBQVEsRUFBRSxVQUFVO0lBQ3BCLFVBQVUsRUFBRSxZQUFZO0lBQ3hCLE9BQU8sRUFBRSxTQUFTO0lBQ2xCLGVBQWUsRUFBRSxpQkFBaUI7SUFDbEMsR0FBRyxFQUFFLEtBQUs7SUFDVixRQUFRLEVBQUUsVUFBVTtJQUNwQixLQUFLLEVBQUUsT0FBTztJQUNkLFdBQVcsRUFBRSxhQUFhO0lBQzFCLFFBQVEsRUFBRSxVQUFVO0lBQ3BCLG9CQUFvQixFQUFFLHNCQUFzQjtJQUM1QyxjQUFjLEVBQUUsZ0JBQWdCO0lBQ2hDLFNBQVMsRUFBRSxXQUFXO0lBQ3RCLFFBQVEsRUFBRSxVQUFVO0lBQ3BCLGFBQWEsRUFBRSxlQUFlO0lBQzlCLHVCQUF1QixFQUFFLHlCQUF5QjtJQUNsRCxLQUFLLEVBQUMsT0FBTztJQUNiLGFBQWEsRUFBQyxlQUFlO0lBQzdCLGVBQWUsRUFBQyxpQkFBaUI7SUFDakMsYUFBYSxFQUFDLGVBQWU7SUFDN0Isa0JBQWtCLEVBQUUsb0JBQW9CO0NBQ3pDLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyJleHBvcnQgY29uc3QgU3RvcmFnZUNvbnN0YW50cyA9IHtcclxuICB0YWJEYXRhOiAndGFiRGF0YScsXHJcbiAgZm9ybUpzb246ICdGb3JtSnNvbicsXHJcbiAgc2NoZW1hSlNPTjogJ3NjaGVtYUpTT04nLFxyXG4gIG9yZ0luZm86ICdvcmdJbmZvJyxcclxuICBhcHBsaWNhdGlvbkNvZGU6ICdhcHBsaWNhdGlvbkNvZGUnLFxyXG4gIFRBQjogJ1RBQicsXHJcbiAgdXNlckluZm86ICd1c2VySW5mbycsXHJcbiAgdG9rZW46ICd0b2tlbicsXHJcbiAgc3RhdGljVG9rZW46ICdzdGF0aWNUb2tlbicsXHJcbiAgc2NyZWVuSWQ6ICdzY3JlZW5JZCcsXHJcbiAgZWRpdFNjcmVlblF1ZXJ5UGFyYW06ICdlZGl0U2NyZWVuUXVlcnlQYXJhbScsXHJcbiAgbGF5b3V0U2NyZWVuSWQ6ICdsYXlvdXRTY3JlZW5JZCcsXHJcbiAgdGFiU2NyZWVuOiAndGFiU2NyZWVuJyxcclxuICBUZW5hbnRJZDogJ1RlbmFudElkJyxcclxuICBBdXRob3JpemF0aW9uOiAnQXV0aG9yaXphdGlvbicsXHJcbiAgdGFiVXNlclBlcnNvbmFsaXplZERhdGE6ICd0YWJVc2VyUGVyc29uYWxpemVkRGF0YScsXHJcbiAgQXBwSWQ6J0FwcElkJyxcclxuICBzY3JlZW5Db250ZXh0OidzY3JlZW5Db250ZXh0JyxcclxuICBlbnZpcm9ubWVudE1vZGU6J2Vudmlyb25tZW50TW9kZScsXHJcbiAgZW52aXJvbm1lbnRJZDonZW52aXJvbm1lbnRJZCcsXHJcbiAgdGFiQXBwT2JqZWN0QWNjZXNzOiAndGFiQXBwT2JqZWN0QWNjZXNzJ1xyXG59O1xyXG4iXX0=

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

@@ -0,0 +1,661 @@
+/* eslint-disable @typescript-eslint/no-explicit-any */
+import { Injectable } from "@angular/core";
+import { MetadataEntityType } from "../../interfaces/schema.interface";
+import { Common } from "../../constants/common";
+import * as i0 from "@angular/core";
+/**
+   * MetadataUtils - Utility service for retrieving and manipulating application metadata
+   *
+   * This service provides methods to extract, filter, and format different parts of the
+   * application metadata, including objects, fields, screens, menus, etc.
+   */
+export class MetadataHelper {
+    // Helper method to consistently format results
+    formatResults(items, columns) {
+        if (!columns || columns.length === 0) {
+            return items;
+        }
+        return items.map(item => {
+            const result = {};
+            columns.forEach(col => {
+                result[col] = item[col];
+            });
+            return result;
+        });
+    }
+    /**
+     * Search across all metadata for a term
+     *
+     * @param searchTerm Term to search for
+     * @param entityTypes Optional types of entities to search (if not provided, searches all)
+     * @returns Search results grouped by entity type
+     *
+     * @example
+     * // Search across all metadata
+     * const results = metadataUtils.searchAcrossMetadata('Blueprint');
+     *
+     * // Search only in app objects and screens
+     * const results = metadataUtils.searchAcrossMetadata(
+     *   'Role',
+     *   [MetadataEntityType.APP_OBJECTS, MetadataEntityType.APP_SCREENS]
+     * );
+     */
+    searchAcrossMetadata(searchTerm, entityTypes) {
+        try {
+            if (!searchTerm || searchTerm.trim() === '') {
+                return {};
+            }
+            const term = searchTerm.toLowerCase();
+            const results = {};
+            // If entityTypes not provided, search all entity types
+            const typesToSearch = entityTypes || Object.values(MetadataEntityType);
+            // Execute search for each entity type
+            if (typesToSearch.includes(MetadataEntityType.APP_OBJECTS)) {
+                results[MetadataEntityType.APP_OBJECTS] = this.searchAppObjects(term);
+            }
+            if (typesToSearch.includes(MetadataEntityType.APP_FIELDS)) {
+                results[MetadataEntityType.APP_FIELDS] = this.searchAppFields(term);
+            }
+            if (typesToSearch.includes(MetadataEntityType.DATA_SOURCE_QUERIES)) {
+                results[MetadataEntityType.DATA_SOURCE_QUERIES] = this.searchDataSourceQueries(term);
+            }
+            if (typesToSearch.includes(MetadataEntityType.APP_SCREENS)) {
+                results[MetadataEntityType.APP_SCREENS] = this.searchAppScreens(term);
+            }
+            if (typesToSearch.includes(MetadataEntityType.APP_MENUS)) {
+                results[MetadataEntityType.APP_MENUS] = this.searchAppMenus(term);
+            }
+            return results;
+        }
+        catch (error) {
+            console.error('Error in searchMetadata:', error);
+            return {};
+        }
+    }
+    /**
+     * Search for a term within App Objects
+     * @private
+     */
+    searchAppObjects(term) {
+        return this.getAppObjects(obj => this.containsTerm(obj.ObjectName, term) ||
+            this.containsTerm(obj.DisplayName, term) ||
+            this.containsTerm(obj.Description, term) ||
+            this.containsTerm(obj.SystemDBTableName, term));
+    }
+    /**
+     * Search for a term within App Fields
+     * @private
+     */
+    searchAppFields(term) {
+        return this.getAppFields(field => this.containsTerm(field.FieldName, term) ||
+            this.containsTerm(field.DisplayName, term) ||
+            this.containsTerm(field.Description, term) ||
+            this.containsTerm(field.SystemDBFieldName, term));
+    }
+    /**
+     * Search for a term within Data Source Queries
+     * @private
+     */
+    searchDataSourceQueries(term) {
+        return this.getDataSourceQueries(query => this.containsTerm(query.QueryName, term) ||
+            this.containsTerm(query.DisplayName, term));
+    }
+    /**
+     * Search for a term within App Screens
+     * @private
+     */
+    searchAppScreens(term) {
+        return this.getAppScreens(screen => this.containsTerm(screen.Name, term) ||
+            this.containsTerm(screen.Description, term));
+    }
+    /**
+     * Search for a term within App Menus
+     * @private
+     */
+    searchAppMenus(term) {
+        return this.getAppMenus(menu => this.containsTerm(menu.MenuName, term) ||
+            this.containsTerm(menu.DisplayName, term));
+    }
+    /**
+     * Helper method to check if a string contains a search term
+     * @private
+     */
+    containsTerm(value, term) {
+        return !!value && value.toLowerCase().includes(term);
+    }
+    /**
+     * Gets App Objects based on filter criteria
+     *
+     * @param filterFn Optional filter function to apply to app objects
+     * @param columns Optional columns to include in the result
+     * @returns Array of filtered app objects
+     *
+     * @example
+     * // Get all system app objects
+     * const systemObjects = metadataUtils.getAppObjects(obj => obj.IsSystem === true);
+     *
+     * // Get specific columns from non-deprecated objects
+     * const objects = metadataUtils.getAppObjects(
+     *   obj => !obj.IsDeprecated,
+     *   ['ID', 'DisplayName', 'ObjectName']
+     * );
+     */
+    getAppObjects(filterFn, columns) {
+        try {
+            let appObjects = Common.tabJson.AppObjects || [];
+            // Apply filter if provided
+            if (filterFn) {
+                appObjects = appObjects.filter(filterFn);
+            }
+            // Return all object data if no columns specified
+            return this.formatResults(appObjects, columns);
+        }
+        catch (error) {
+            console.error('Error in getAppObjects:', error);
+            return [];
+        }
+    }
+    /**
+     * Gets a specific App Object by ID or Name
+     *
+     * @param appObject ID or Name of the app object to retrieve
+     * @param columns Optional columns to include in the result
+     * @returns The app object with specified columns or null if not found
+     *
+     * @example
+     * // Get a specific app object with all properties
+     * const appObj = metadataUtils.getAppObjectDetails('b4887d4d-bb1e-4d52-a7e8-2f943d69e44c' or 'TABMD_SYSTEM');
+     *
+     * // Get specific columns from an app object
+     * const appObj = metadataUtils.getAppObjectDetails(
+     *   'b4887d4d-bb1e-4d52-a7e8-2f943d69e44c',
+     *   ['ID', 'DisplayName', 'ObjectName']
+     * );
+     */
+    getAppObjectDetails(appObject, columns) {
+        try {
+            return this.getAppObjects(obj => obj.ID?.toLowerCase() === appObject?.toLowerCase() || obj.ObjectName === appObject, columns)?.[0] ?? null;
+        }
+        catch (error) {
+            console.error('Error in getAppObjectById:', error);
+            return null;
+        }
+    }
+    /**
+     * Gets all fields across all app objects with filter criteria
+     *
+     * @param filterFn Optional filter function to apply to fields
+     * @param columns Optional columns to include in the result
+     * @returns Array of filtered fields
+     *
+     * @example
+     * // Get all required fields across all objects
+     * const requiredFields = metadataUtils.getAppFields(field => field.IsRequired === true);
+     *
+     * // Get specific columns from searchable fields
+     * const fields = metadataUtils.getAppFields(
+     *   field => field.IsSearchable === true,
+     *   ['ID', 'DisplayName', 'FieldName']
+     * );
+     */
+    getAppFields(filterFn, columns) {
+        try {
+            // Get all fields from all app objects
+            const allFields = [];
+            Common.tabJson.AppObjects.forEach((obj) => {
+                allFields.push(...obj.Fields);
+            });
+            // Apply filter if provided
+            let filteredFields = allFields;
+            if (filterFn) {
+                filteredFields = allFields.filter(filterFn);
+            }
+            // Return all field data if no columns specified
+            return this.formatResults(filteredFields, columns);
+        }
+        catch (error) {
+            console.error('Error in getAppFields:', error);
+            return [];
+        }
+    }
+    /**
+     * Gets fields for a specific app object
+     *
+     * @param appObject ID or Name of the app object
+     * @param filterFn Optional filter function for fields
+     * @returns Array of fields for the specified object
+     *
+     * @example
+     * // Get all fields for an object
+     * const fields = metadataUtils.getAppFieldsByAppObject('b4887d4d-bb1e-4d52-a7e8-2f943d69e44c' or 'TABMD_SYSTEM');
+     *
+     * // Get only required fields
+     * const requiredFields = metadataUtils.getAppFieldsByAppObject(
+     *   'b4887d4d-bb1e-4d52-a7e8-2f943d69e44c',
+     *   field => field.IsRequired === true
+     * );
+     */
+    getAppFieldsByAppObject(appObject, filterFn, columns) {
+        try {
+            const filteredAppObject = this.getAppObjectDetails(appObject);
+            if (!filteredAppObject) {
+                return [];
+            }
+            let fields = filteredAppObject.Fields || [];
+            // Apply filter if provided
+            if (filterFn) {
+                fields = fields.filter(filterFn);
+            }
+            return this.formatResults(fields, columns);
+        }
+        catch (error) {
+            console.error('Error in getAppFieldById:', error);
+            return [];
+        }
+    }
+    /**
+    * Gets lookup fields for a specific app object
+    *
+    * @param appObject ID or Name of the app object
+    * @param filterFn Optional filter function for lookup fields
+    * @param columns Optional columns to include in the result
+    * @returns Array of lookup fields for the specified object
+    *
+    * @example
+    * // Get all lookup fields for an object
+    * const lookupFields = metadataUtils.getLookupFieldsByAppObject('TABD_Blueprint_SLASchemes');
+    *
+    * // Get specific lookup fields
+    * const fields = metadataUtils.getLookupFieldsByAppObject(
+    *   'b4887d4d-bb1e-4d52-a7e8-2f943d69e44c',
+    *   field => field.IsRequired === true
+    * );
+    */
+    getLookupFieldsByAppObject(appObject, filterFn, columns) {
+        try {
+            // Get fields for the specified object that are lookups
+            return this.getAppFieldsByAppObject(appObject, field => {
+                // Check if the field is a lookup type
+                const isLookup = field.LookUpDetails != null;
+                // Apply additional user filter if provided
+                return isLookup && (!filterFn || filterFn(field));
+            }, columns);
+        }
+        catch (error) {
+            console.error('Error in getAppObjectLookupFields:', error);
+            return [];
+        }
+    }
+    /**
+     * Gets data source queries with filter criteria
+     *
+     * @param filterFn Optional filter function to apply to queries
+     * @param columns Optional columns to include in the result
+     * @returns Array of filtered data source queries
+     *
+     * @example
+     * // Get all queries with a specific naming pattern
+     * const queries = metadataUtils.getDataSourceQueries(query => query.QueryName.includes('List'));
+     *
+     * // Get specific columns from all queries
+     * const queries = metadataUtils.getDataSourceQueries(
+     *   undefined,
+     *   ['ID', 'QueryName', 'DisplayName']
+     * );
+     */
+    getDataSourceQueries(filterFn, columns) {
+        try {
+            // Get all data source queries from all app objects
+            const allQueries = [];
+            Common.tabJson.AppObjects.forEach((obj) => {
+                if (obj.DataSourceQueries && obj.DataSourceQueries.length > 0) {
+                    allQueries.push(...obj.DataSourceQueries);
+                }
+            });
+            // Apply filter if provided
+            let filteredQueries = allQueries;
+            if (filterFn) {
+                filteredQueries = allQueries.filter(filterFn);
+            }
+            return this.formatResults(filteredQueries, columns);
+        }
+        catch (error) {
+            console.error('Error in getDataSourceQueries:', error);
+            return [];
+        }
+    }
+    /**
+     * Gets data source queries for a specific app object
+     *
+     * @param appObject ID or Name of the app object
+     * @param filterFn Optional filter function for queries
+     * @param columns Optional columns to include in the result
+     * @returns Array of queries for the specified object
+     *
+     * @example
+     * // Get all queries for an object
+     * const queries = metadataUtils.getDataSourceQueriesByAppObject('b4887d4d-bb1e-4d52-a7e8-2f943d69e44c');
+     *
+     * // Get queries with specific pattern
+     * const filteredQueries = metadataUtils.getDataSourceQueriesByAppObject(
+     *   'TABD_Blueprint_SLASchemes',
+     *   query => query.QueryName.includes('List')
+     * );
+     */
+    getDataSourceQueriesByAppObject(appObject, filterFn, columns) {
+        try {
+            const filteredAppObject = this.getAppObjectDetails(appObject);
+            if (!filteredAppObject || !filteredAppObject.DataSourceQueries) {
+                return [];
+            }
+            let queries = filteredAppObject.DataSourceQueries;
+            // Apply filter if provided
+            if (filterFn) {
+                queries = queries.filter(filterFn);
+            }
+            return this.formatResults(queries, columns);
+        }
+        catch (error) {
+            console.error('Error in getAppObjectQueries:', error);
+            return [];
+        }
+    }
+    /**
+     * Gets a specific Data Source Query by ID or Name
+     *
+     * @param query ID or Name of the data source query to retrieve
+     * @param columns Optional columns to include in the result
+     * @returns The data source query with specified columns or null if not found
+     *
+     * @example
+     * // Get a specific query with all properties
+     * const query = metadataUtils.getDataSourceQueryDetails('73e590d0-c4eb-464d-abf9-01943e30ae09');
+     *
+     * // Get specific columns from a query by name
+     * const query = metadataUtils.getDataSourceQueryDetails(
+     *   'Get_SLASchemes_List',
+     *   ['ID', 'QueryName', 'DisplayName']
+     * );
+     */
+    getDataSourceQueryDetails(query, columns) {
+        try {
+            return this.getDataSourceQueries(q => q.ID?.toLowerCase() === query?.toLowerCase() || q.QueryName === query, columns)?.[0] ?? null;
+        }
+        catch (error) {
+            console.error('Error in getDataSourceQuery:', error);
+            return null;
+        }
+    }
+    /**
+     * Gets fields from a data source query
+     *
+     * @param query ID or Name of the data source query
+     * @param filterFn Optional filter function for query fields
+     * @param columns Optional columns to include in the result
+     * @returns Array of fields for the specified query with app field details
+     *
+     * @example
+     * // Get all fields for a query
+     * const queryFields = metadataUtils.getDataSourceQueryFields('73e590d0-c4eb-464d-abf9-01943e30ae09');
+     *
+     * // Get fields for a query by name
+     * const queryFields = metadataUtils.getDataSourceQueryFields('Get_SLASchemes_List');
+     *
+     * // Get fields with filter and specific columns
+     * const fields = metadataUtils.getDataSourceQueryFields(
+     *   '73e590d0-c4eb-464d-abf9-01943e30ae09',
+     *   field => field.FieldType === 1,
+     *   ['ID', 'AppFieldID', 'FieldType']
+     * );
+     */
+    getFieldsByDSQ(query, filterFn, columns) {
+        try {
+            // Find the query using our existing method
+            const dsQuery = this.getDataSourceQueryDetails(query);
+            if (!dsQuery || !dsQuery.Fields?.length) {
+                return [];
+            }
+            // Get enhanced fields with app field details
+            let queryFields = this.enhanceQueryFieldsWithAppFields(dsQuery);
+            // Apply filter if provided
+            if (filterFn) {
+                queryFields = queryFields.filter(filterFn);
+            }
+            return this.formatResults(queryFields, columns);
+        }
+        catch (error) {
+            console.error('Error in getDataSourceQueryFields:', error);
+            return [];
+        }
+    }
+    /**
+     * Enhances query fields with their corresponding app field details
+     * @private
+     */
+    enhanceQueryFieldsWithAppFields(dsQuery) {
+        if (!dsQuery || !dsQuery.Fields?.length) {
+            return [];
+        }
+        // Find the parent app object
+        const parentAppObject = this.findParentAppObjectForQuery(dsQuery);
+        if (!parentAppObject) {
+            return dsQuery.Fields;
+        }
+        // Add app field details to each query field
+        return dsQuery.Fields.map((field) => {
+            const appField = this.findAppFieldById(parentAppObject, field.AppFieldID);
+            return {
+                ...field,
+                Field: appField || {}
+            };
+        });
+    }
+    /**
+     * Finds the parent app object that contains a specific data source query
+     * @private
+     */
+    findParentAppObjectForQuery(dsQuery) {
+        return this.getAppObjects(obj => obj.DataSourceQueries?.some((q) => q.ID?.toLowerCase() === dsQuery.ID?.toLowerCase() ||
+            q.QueryName === dsQuery.QueryName))[0];
+    }
+    /**
+     * Finds an app field by ID within a specific app object
+     * @private
+     */
+    findAppFieldById(appObject, fieldId) {
+        if (!appObject || !appObject.Fields?.length || !fieldId) {
+            return undefined;
+        }
+        return appObject.Fields.find((field) => field.ID?.toLowerCase() === fieldId?.toLowerCase());
+    }
+    /**
+     * Gets query parameters from a data source query
+     *
+     * @param query ID or Name of the data source query
+     * @param filterFn Optional filter function for query parameters
+     * @param columns Optional columns to include in the result
+     * @returns Array of parameters for the specified query
+     *
+     * @example
+     * // Get all parameters for a query
+     * const queryParams = metadataUtils.getParametersByDSQ('73e590d0-c4eb-464d-abf9-01943e30ae09');
+     *
+     * // Get all parameters for a query by name
+     * const queryParams = metadataUtils.getParametersByDSQ('Get_SLASchemes_List');
+     *
+     * // Get mandatory parameters only
+     * const mandatoryParams = metadataUtils.getParametersByDSQ(
+     *   '73e590d0-c4eb-464d-abf9-01943e30ae09',
+     *   param => param.IsMandatory === true
+     * );
+     */
+    getParametersByDSQ(query, filterFn, columns) {
+        try {
+            // Find the query using our existing method
+            const dsQuery = this.getDataSourceQueryDetails(query);
+            if (!dsQuery || !dsQuery.Parameters?.length) {
+                return [];
+            }
+            let queryParameters = dsQuery.Parameters || [];
+            // Apply filter if provided
+            if (filterFn) {
+                queryParameters = queryParameters.filter(filterFn);
+            }
+            return this.formatResults(queryParameters, columns);
+        }
+        catch (error) {
+            console.error('Error in getDataSourceQueryParameters:', error);
+            return [];
+        }
+    }
+    /**
+    * Gets App Screens with filter criteria
+    *
+    * @param filterFn Optional filter function to apply to app screens
+    * @param columns Optional columns to include in the result
+    * @returns Array of filtered app screens
+    *
+    * @example
+    * // Get all system screens
+    * const systemScreens = metadataUtils.getAppScreens(screen => screen.IsSystemRecord === true);
+    *
+    * // Get specific columns from all screens
+    * const screens = metadataUtils.getAppScreens(
+    *   undefined,
+    *   ['ID', 'Name', 'ScreenType']
+    * );
+    */
+    getAppScreens(filterFn, columns) {
+        try {
+            let appScreens = Common.tabJson.AppScreens || [];
+            // Apply filter if provided
+            if (filterFn) {
+                appScreens = appScreens.filter(filterFn);
+            }
+            return this.formatResults(appScreens, columns);
+        }
+        catch (error) {
+            console.error('Error in getAppScreens:', error);
+            return [];
+        }
+    }
+    /**
+     * Gets a specific App Screen by ID or Name
+     *
+     * @param screen ID or Name of the app screen to retrieve
+     * @param columns Optional columns to include in the result
+     * @returns The app screen with specified columns or null if not found
+     *
+     * @example
+     * // Get a specific screen with all properties
+     * const screen = metadataUtils.getAppScreen('a5cd639e-31ba-4d33-8800-005a5248dfb2');
+     *
+     * // Get specific columns from a screen by name
+     * const screen = metadataUtils.getAppScreen(
+     *   'New Detail Role/Permission Appoject acess wise',
+     *   ['ID', 'Name', 'ScreenType']
+     * );
+     */
+    getAppScreen(screen, columns) {
+        try {
+            return this.getAppScreens(scr => scr.ID?.toLowerCase() === screen?.toLowerCase() || scr.Name === screen, columns)?.[0] ?? null;
+        }
+        catch (error) {
+            console.error('Error in getAppScreen:', error);
+            return null;
+        }
+    }
+    /**
+     * Gets App Menus with filter criteria
+     *
+     * @param filterFn Optional filter function to apply to app menus
+     * @param columns Optional columns to include in the result
+     * @returns Array of filtered app menus
+     *
+     * @example
+     * // Get all top-level menus
+     * const topMenus = metadataUtils.getAppMenus(menu => !menu.ParentID);
+     *
+     * // Get specific columns from all menus
+     * const menus = metadataUtils.getAppMenus(
+     *   undefined,
+     *   ['ID', 'MenuName', 'DisplayName', 'ScreenID']
+     * );
+     */
+    getAppMenus(filterFn, columns) {
+        try {
+            let appMenus = Common.tabJson.AppMenus || [];
+            // Apply filter if provided
+            if (filterFn) {
+                appMenus = appMenus.filter(filterFn);
+            }
+            return this.formatResults(appMenus, columns);
+        }
+        catch (error) {
+            console.error('Error in getAppMenus:', error);
+            return [];
+        }
+    }
+    /**
+     * Gets organization information with filter criteria
+     *
+     * @param filterFn Optional filter function to apply to organizations
+     * @param columns Optional columns to include in the result
+     * @returns Array of filtered organizations
+     *
+     * @example
+     * // Get all organizations
+     * const orgs = metadataUtils.getOrgs();
+     *
+     * // Get organizations with specific subdomain pattern
+     * const specificOrgs = metadataUtils.getOrgs(
+     *   org => org.Subdomain?.includes('test')
+     * );
+     */
+    getOrgs(filterFn, columns) {
+        try {
+            let organizations = Common.tabJson.OrgInfos || [];
+            // Apply filter if provided
+            if (filterFn) {
+                organizations = organizations.filter(filterFn);
+            }
+            return this.formatResults(organizations, columns);
+        }
+        catch (error) {
+            console.error('Error in getOrganizations:', error);
+            return [];
+        }
+    }
+    /**
+     * Gets a specific organization by ID or Name
+     *
+     * @param organization ID or OrganizationName of the organization
+     * @param columns Optional columns to include in the result
+     * @returns The organization or null if not found
+     *
+     * @example
+     * // Get organization by ID
+     * const org = metadataUtils.getOrgInfoDetails('0ec3d0f1-b2ec-47b7-8305-b767d0e5ea63');
+     *
+     * // Get organization by name
+     * const org = metadataUtils.getOrgInfoDetails('SquadFocus');
+     */
+    getOrgInfoDetails(organization, columns) {
+        try {
+            return this.getOrgs(org => org.ID?.toLowerCase() === organization?.toLowerCase() ||
+                org.OrganizationName === organization ||
+                org.Subdomain === organization, columns)[0] || null;
+        }
+        catch (error) {
+            console.error('Error in getOrganization:', error);
+            return null;
+        }
+    }
+    static { this.ɵfac = function MetadataHelper_Factory(t) { return new (t || MetadataHelper)(); }; }
+    static { this.ɵprov = /*@__PURE__*/ i0.ɵɵdefineInjectable({ token: MetadataHelper, factory: MetadataHelper.ɵfac, providedIn: 'root' }); }
+}
+(() => { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(MetadataHelper, [{
+        type: Injectable,
+        args: [{ providedIn: 'root' }]
+    }], null, null); })();
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"meta-data.helpers.js","sourceRoot":"","sources":["../../../../../../../../../libs/data-access/src/lib/tab-core-utility/app/helpers/common/meta-data.helpers.ts"],"names":[],"mappings":"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","sourcesContent":["/* eslint-disable @typescript-eslint/no-explicit-any */\nimport { Injectable } from \"@angular/core\";\nimport { MetadataEntityType, OrgInfo } from \"../../interfaces/schema.interface\";\nimport { Common } from \"../../constants/common\";\nimport { AppMenu, AppObject, AppScreen } from \"../../models/app-object.class\";\nimport { AppFields, DataSourceQueries, DataSourceQueries_Fields, Parameters } from \"../../models/data-source-queries.class\";\n\n/**\n   * MetadataUtils - Utility service for retrieving and manipulating application metadata\n   * \n   * This service provides methods to extract, filter, and format different parts of the\n   * application metadata, including objects, fields, screens, menus, etc.\n   */\n@Injectable({ providedIn: 'root' })\nexport class MetadataHelper {\n    // Helper method to consistently format results\n    private formatResults<T>(items: T[], columns?: string[]): any[] {\n        if (!columns || columns.length === 0) {\n            return items;\n        }\n\n        return items.map(item => {\n            const result: any = {};\n            columns.forEach(col => {\n                result[col] = (item as any)[col];\n            });\n            return result;\n        });\n    }\n\n    /**\n     * Search across all metadata for a term\n     * \n     * @param searchTerm Term to search for\n     * @param entityTypes Optional types of entities to search (if not provided, searches all)\n     * @returns Search results grouped by entity type\n     * \n     * @example\n     * // Search across all metadata\n     * const results = metadataUtils.searchAcrossMetadata('Blueprint');\n     * \n     * // Search only in app objects and screens\n     * const results = metadataUtils.searchAcrossMetadata(\n     *   'Role', \n     *   [MetadataEntityType.APP_OBJECTS, MetadataEntityType.APP_SCREENS]\n     * );\n     */\n    public searchAcrossMetadata(\n        searchTerm: string,\n        entityTypes?: MetadataEntityType[]\n    ): Record<string, any[]> {\n        try {\n            if (!searchTerm || searchTerm.trim() === '') {\n                return {};\n            }\n\n            const term = searchTerm.toLowerCase();\n            const results: Record<string, any[]> = {};\n\n            // If entityTypes not provided, search all entity types\n            const typesToSearch = entityTypes || Object.values(MetadataEntityType);\n\n            // Execute search for each entity type\n            if (typesToSearch.includes(MetadataEntityType.APP_OBJECTS)) {\n                results[MetadataEntityType.APP_OBJECTS] = this.searchAppObjects(term);\n            }\n\n            if (typesToSearch.includes(MetadataEntityType.APP_FIELDS)) {\n                results[MetadataEntityType.APP_FIELDS] = this.searchAppFields(term);\n            }\n\n            if (typesToSearch.includes(MetadataEntityType.DATA_SOURCE_QUERIES)) {\n                results[MetadataEntityType.DATA_SOURCE_QUERIES] = this.searchDataSourceQueries(term);\n            }\n\n            if (typesToSearch.includes(MetadataEntityType.APP_SCREENS)) {\n                results[MetadataEntityType.APP_SCREENS] = this.searchAppScreens(term);\n            }\n\n            if (typesToSearch.includes(MetadataEntityType.APP_MENUS)) {\n                results[MetadataEntityType.APP_MENUS] = this.searchAppMenus(term);\n            }\n\n            return results;\n        } catch (error) {\n            console.error('Error in searchMetadata:', error);\n            return {};\n        }\n    }\n\n    /**\n     * Search for a term within App Objects\n     * @private\n     */\n    private searchAppObjects(term: string): any[] {\n        return this.getAppObjects(obj =>\n            this.containsTerm(obj.ObjectName, term) ||\n            this.containsTerm(obj.DisplayName, term) ||\n            this.containsTerm(obj.Description, term) ||\n            this.containsTerm(obj.SystemDBTableName, term)\n        );\n    }\n\n    /**\n     * Search for a term within App Fields\n     * @private\n     */\n    private searchAppFields(term: string): any[] {\n        return this.getAppFields(field =>\n            this.containsTerm(field.FieldName, term) ||\n            this.containsTerm(field.DisplayName, term) ||\n            this.containsTerm(field.Description, term) ||\n            this.containsTerm(field.SystemDBFieldName, term)\n        );\n    }\n\n    /**\n     * Search for a term within Data Source Queries\n     * @private\n     */\n    private searchDataSourceQueries(term: string): any[] {\n        return this.getDataSourceQueries(query =>\n            this.containsTerm(query.QueryName, term) ||\n            this.containsTerm(query.DisplayName, term)\n        );\n    }\n\n    /**\n     * Search for a term within App Screens\n     * @private\n     */\n    private searchAppScreens(term: string): any[] {\n        return this.getAppScreens(screen =>\n            this.containsTerm(screen.Name, term) ||\n            this.containsTerm(screen.Description, term)\n        );\n    }\n\n    /**\n     * Search for a term within App Menus\n     * @private\n     */\n    private searchAppMenus(term: string): any[] {\n        return this.getAppMenus(menu =>\n            this.containsTerm(menu.MenuName, term) ||\n            this.containsTerm(menu.DisplayName, term)\n        );\n    }\n\n    /**\n     * Helper method to check if a string contains a search term\n     * @private\n     */\n    private containsTerm(value: string | undefined | null, term: string): boolean {\n        return !!value && value.toLowerCase().includes(term);\n    }\n\n    /**\n     * Gets App Objects based on filter criteria\n     * \n     * @param filterFn Optional filter function to apply to app objects\n     * @param columns Optional columns to include in the result\n     * @returns Array of filtered app objects\n     * \n     * @example\n     * // Get all system app objects\n     * const systemObjects = metadataUtils.getAppObjects(obj => obj.IsSystem === true);\n     * \n     * // Get specific columns from non-deprecated objects\n     * const objects = metadataUtils.getAppObjects(\n     *   obj => !obj.IsDeprecated, \n     *   ['ID', 'DisplayName', 'ObjectName']\n     * );\n     */\n    public getAppObjects(filterFn?: ((value: AppObject) => boolean), columns?: string[]): any[] {\n        try {\n            let appObjects = Common.tabJson.AppObjects || [];\n\n            // Apply filter if provided\n            if (filterFn) {\n                appObjects = appObjects.filter(filterFn);\n            }\n\n\n            // Return all object data if no columns specified\n            return this.formatResults(appObjects, columns);\n\n        } catch (error) {\n            console.error('Error in getAppObjects:', error);\n            return [];\n        }\n    }\n\n    /**\n     * Gets a specific App Object by ID or Name\n     * \n     * @param appObject ID or Name of the app object to retrieve\n     * @param columns Optional columns to include in the result\n     * @returns The app object with specified columns or null if not found\n     * \n     * @example\n     * // Get a specific app object with all properties\n     * const appObj = metadataUtils.getAppObjectDetails('b4887d4d-bb1e-4d52-a7e8-2f943d69e44c' or 'TABMD_SYSTEM');\n     * \n     * // Get specific columns from an app object\n     * const appObj = metadataUtils.getAppObjectDetails(\n     *   'b4887d4d-bb1e-4d52-a7e8-2f943d69e44c', \n     *   ['ID', 'DisplayName', 'ObjectName']\n     * );\n     */\n    public getAppObjectDetails(appObject: string, columns?: string[]): any {\n        try {\n            return this.getAppObjects(obj => obj.ID?.toLowerCase() === appObject?.toLowerCase() || obj.ObjectName === appObject, columns)?.[0] ?? null;\n\n        } catch (error) {\n            console.error('Error in getAppObjectById:', error);\n            return null;\n        }\n    }\n\n    /**\n     * Gets all fields across all app objects with filter criteria\n     * \n     * @param filterFn Optional filter function to apply to fields\n     * @param columns Optional columns to include in the result\n     * @returns Array of filtered fields\n     * \n     * @example\n     * // Get all required fields across all objects\n     * const requiredFields = metadataUtils.getAppFields(field => field.IsRequired === true);\n     * \n     * // Get specific columns from searchable fields\n     * const fields = metadataUtils.getAppFields(\n     *   field => field.IsSearchable === true, \n     *   ['ID', 'DisplayName', 'FieldName']\n     * );\n     */\n    public getAppFields(filterFn?: ((value: AppFields) => boolean), columns?: string[]): any[] {\n        try {\n            // Get all fields from all app objects\n            const allFields: AppFields[] = [];\n            Common.tabJson.AppObjects.forEach((obj: any) => {\n                allFields.push(...obj.Fields);\n            });\n\n            // Apply filter if provided\n            let filteredFields = allFields;\n            if (filterFn) {\n                filteredFields = allFields.filter(filterFn);\n            }\n\n            // Return all field data if no columns specified\n            return this.formatResults(filteredFields, columns);\n        } catch (error) {\n            console.error('Error in getAppFields:', error);\n            return [];\n        }\n    }\n\n    /**\n     * Gets fields for a specific app object\n     * \n     * @param appObject ID or Name of the app object\n     * @param filterFn Optional filter function for fields\n     * @returns Array of fields for the specified object\n     * \n     * @example\n     * // Get all fields for an object\n     * const fields = metadataUtils.getAppFieldsByAppObject('b4887d4d-bb1e-4d52-a7e8-2f943d69e44c' or 'TABMD_SYSTEM');\n     * \n     * // Get only required fields\n     * const requiredFields = metadataUtils.getAppFieldsByAppObject(\n     *   'b4887d4d-bb1e-4d52-a7e8-2f943d69e44c',\n     *   field => field.IsRequired === true\n     * );\n     */\n    public getAppFieldsByAppObject(\n        appObject: string,\n        filterFn?: ((value: AppFields, index: number, array: AppFields[]) => boolean),\n        columns?: string[]\n    ): any[] {\n        try {\n            const filteredAppObject: any = this.getAppObjectDetails(appObject);\n            if (!filteredAppObject) {\n                return [];\n            }\n\n            let fields = filteredAppObject.Fields || [];\n\n            // Apply filter if provided\n            if (filterFn) {\n                fields = fields.filter(filterFn);\n            }\n\n            return this.formatResults(fields, columns);\n        } catch (error) {\n            console.error('Error in getAppFieldById:', error);\n            return [];\n        }\n    }\n\n    /**\n    * Gets lookup fields for a specific app object\n    * \n    * @param appObject ID or Name of the app object\n    * @param filterFn Optional filter function for lookup fields\n    * @param columns Optional columns to include in the result\n    * @returns Array of lookup fields for the specified object\n    * \n    * @example\n    * // Get all lookup fields for an object\n    * const lookupFields = metadataUtils.getLookupFieldsByAppObject('TABD_Blueprint_SLASchemes');\n    * \n    * // Get specific lookup fields\n    * const fields = metadataUtils.getLookupFieldsByAppObject(\n    *   'b4887d4d-bb1e-4d52-a7e8-2f943d69e44c',\n    *   field => field.IsRequired === true\n    * );\n    */\n    public getLookupFieldsByAppObject(\n        appObject: string,\n        filterFn?: ((value: AppFields) => boolean),\n        columns?: string[]\n    ): any[] {\n        try {\n            // Get fields for the specified object that are lookups\n            return this.getAppFieldsByAppObject(\n                appObject,\n                field => {\n                    // Check if the field is a lookup type\n                    const isLookup = field.LookUpDetails != null;\n\n                    // Apply additional user filter if provided\n                    return isLookup && (!filterFn || filterFn(field));\n                },\n                columns\n            );\n        } catch (error) {\n            console.error('Error in getAppObjectLookupFields:', error);\n            return [];\n        }\n    }\n\n    /**\n     * Gets data source queries with filter criteria\n     * \n     * @param filterFn Optional filter function to apply to queries\n     * @param columns Optional columns to include in the result\n     * @returns Array of filtered data source queries\n     * \n     * @example\n     * // Get all queries with a specific naming pattern\n     * const queries = metadataUtils.getDataSourceQueries(query => query.QueryName.includes('List'));\n     * \n     * // Get specific columns from all queries\n     * const queries = metadataUtils.getDataSourceQueries(\n     *   undefined, \n     *   ['ID', 'QueryName', 'DisplayName']\n     * );\n     */\n    public getDataSourceQueries(filterFn?: ((value: DataSourceQueries) => boolean), columns?: string[]): any[] {\n        try {\n            // Get all data source queries from all app objects\n            const allQueries: DataSourceQueries[] = [];\n            Common.tabJson.AppObjects.forEach((obj: any) => {\n                if (obj.DataSourceQueries && obj.DataSourceQueries.length > 0) {\n                    allQueries.push(...obj.DataSourceQueries);\n                }\n            });\n\n            // Apply filter if provided\n            let filteredQueries = allQueries;\n            if (filterFn) {\n                filteredQueries = allQueries.filter(filterFn);\n            }\n\n            return this.formatResults(filteredQueries, columns);\n        } catch (error) {\n            console.error('Error in getDataSourceQueries:', error);\n            return [];\n        }\n    }\n\n    /**\n     * Gets data source queries for a specific app object\n     * \n     * @param appObject ID or Name of the app object\n     * @param filterFn Optional filter function for queries\n     * @param columns Optional columns to include in the result\n     * @returns Array of queries for the specified object\n     * \n     * @example\n     * // Get all queries for an object\n     * const queries = metadataUtils.getDataSourceQueriesByAppObject('b4887d4d-bb1e-4d52-a7e8-2f943d69e44c');\n     * \n     * // Get queries with specific pattern\n     * const filteredQueries = metadataUtils.getDataSourceQueriesByAppObject(\n     *   'TABD_Blueprint_SLASchemes',\n     *   query => query.QueryName.includes('List')\n     * );\n     */\n    public getDataSourceQueriesByAppObject(\n        appObject: string,\n        filterFn?: ((value: DataSourceQueries) => boolean),\n        columns?: string[]\n    ): any[] {\n        try {\n            const filteredAppObject: any = this.getAppObjectDetails(appObject);\n            if (!filteredAppObject || !filteredAppObject.DataSourceQueries) {\n                return [];\n            }\n\n            let queries = filteredAppObject.DataSourceQueries;\n\n            // Apply filter if provided\n            if (filterFn) {\n                queries = queries.filter(filterFn);\n            }\n\n            return this.formatResults(queries, columns);\n        } catch (error) {\n            console.error('Error in getAppObjectQueries:', error);\n            return [];\n        }\n    }\n\n    /**\n     * Gets a specific Data Source Query by ID or Name\n     * \n     * @param query ID or Name of the data source query to retrieve\n     * @param columns Optional columns to include in the result\n     * @returns The data source query with specified columns or null if not found\n     * \n     * @example\n     * // Get a specific query with all properties\n     * const query = metadataUtils.getDataSourceQueryDetails('73e590d0-c4eb-464d-abf9-01943e30ae09');\n     * \n     * // Get specific columns from a query by name\n     * const query = metadataUtils.getDataSourceQueryDetails(\n     *   'Get_SLASchemes_List',\n     *   ['ID', 'QueryName', 'DisplayName']\n     * );\n     */\n    public getDataSourceQueryDetails(query: string, columns?: string[]): any {\n        try {\n            return this.getDataSourceQueries(q =>\n                q.ID?.toLowerCase() === query?.toLowerCase() || q.QueryName === query,\n                columns\n            )?.[0] ?? null;\n        } catch (error) {\n            console.error('Error in getDataSourceQuery:', error);\n            return null;\n        }\n    }\n\n    /**\n     * Gets fields from a data source query\n     * \n     * @param query ID or Name of the data source query\n     * @param filterFn Optional filter function for query fields\n     * @param columns Optional columns to include in the result\n     * @returns Array of fields for the specified query with app field details\n     * \n     * @example\n     * // Get all fields for a query\n     * const queryFields = metadataUtils.getDataSourceQueryFields('73e590d0-c4eb-464d-abf9-01943e30ae09');\n     * \n     * // Get fields for a query by name\n     * const queryFields = metadataUtils.getDataSourceQueryFields('Get_SLASchemes_List');\n     * \n     * // Get fields with filter and specific columns\n     * const fields = metadataUtils.getDataSourceQueryFields(\n     *   '73e590d0-c4eb-464d-abf9-01943e30ae09',\n     *   field => field.FieldType === 1,\n     *   ['ID', 'AppFieldID', 'FieldType']\n     * );\n     */\n    public getFieldsByDSQ(\n        query: string,\n        filterFn?: ((value: DataSourceQueries_Fields) => boolean),\n        columns?: string[]\n    ): any[] {\n        try {\n            // Find the query using our existing method\n            const dsQuery = this.getDataSourceQueryDetails(query);\n            if (!dsQuery || !dsQuery.Fields?.length) {\n                return [];\n            }\n\n            // Get enhanced fields with app field details\n            let queryFields = this.enhanceQueryFieldsWithAppFields(dsQuery);\n\n            // Apply filter if provided\n            if (filterFn) {\n                queryFields = queryFields.filter(filterFn);\n            }\n\n            return this.formatResults(queryFields, columns);\n        } catch (error) {\n            console.error('Error in getDataSourceQueryFields:', error);\n            return [];\n        }\n    }\n\n    /**\n     * Enhances query fields with their corresponding app field details\n     * @private\n     */\n    private enhanceQueryFieldsWithAppFields(dsQuery: DataSourceQueries): any[] {\n        if (!dsQuery || !dsQuery.Fields?.length) {\n            return [];\n        }\n\n        // Find the parent app object\n        const parentAppObject = this.findParentAppObjectForQuery(dsQuery);\n        if (!parentAppObject) {\n            return dsQuery.Fields;\n        }\n\n        // Add app field details to each query field\n        return dsQuery.Fields.map((field: any) => {\n            const appField = this.findAppFieldById(parentAppObject, field.AppFieldID);\n            return {\n                ...field,\n                Field: appField || {}\n            };\n        });\n    }\n\n    /**\n     * Finds the parent app object that contains a specific data source query\n     * @private\n     */\n    private findParentAppObjectForQuery(dsQuery: DataSourceQueries): AppObject | undefined {\n        return this.getAppObjects(obj =>\n            obj.DataSourceQueries?.some((q: any) =>\n                q.ID?.toLowerCase() === dsQuery.ID?.toLowerCase() ||\n                q.QueryName === dsQuery.QueryName\n            )\n        )[0];\n    }\n\n    /**\n     * Finds an app field by ID within a specific app object\n     * @private\n     */\n    private findAppFieldById(appObject: AppObject, fieldId: string): any {\n        if (!appObject || !appObject.Fields?.length || !fieldId) {\n            return undefined;\n        }\n\n        return appObject.Fields.find(\n            (field: any) => field.ID?.toLowerCase() === fieldId?.toLowerCase()\n        );\n    }\n\n    /**\n     * Gets query parameters from a data source query\n     * \n     * @param query ID or Name of the data source query\n     * @param filterFn Optional filter function for query parameters\n     * @param columns Optional columns to include in the result\n     * @returns Array of parameters for the specified query\n     * \n     * @example\n     * // Get all parameters for a query\n     * const queryParams = metadataUtils.getParametersByDSQ('73e590d0-c4eb-464d-abf9-01943e30ae09');\n     * \n     * // Get all parameters for a query by name\n     * const queryParams = metadataUtils.getParametersByDSQ('Get_SLASchemes_List');\n     * \n     * // Get mandatory parameters only\n     * const mandatoryParams = metadataUtils.getParametersByDSQ(\n     *   '73e590d0-c4eb-464d-abf9-01943e30ae09',\n     *   param => param.IsMandatory === true\n     * );\n     */\n    public getParametersByDSQ(\n        query: string,\n        filterFn?: ((value: Parameters) => boolean),\n        columns?: string[]\n    ): any[] {\n        try {\n            // Find the query using our existing method\n            const dsQuery = this.getDataSourceQueryDetails(query);\n            if (!dsQuery || !dsQuery.Parameters?.length) {\n                return [];\n            }\n\n            let queryParameters: Parameters[] = dsQuery.Parameters || [];\n\n            // Apply filter if provided\n            if (filterFn) {\n                queryParameters = queryParameters.filter(filterFn);\n            }\n\n            return this.formatResults(queryParameters, columns);\n        } catch (error) {\n            console.error('Error in getDataSourceQueryParameters:', error);\n            return [];\n        }\n    }\n\n    /**\n    * Gets App Screens with filter criteria\n    * \n    * @param filterFn Optional filter function to apply to app screens\n    * @param columns Optional columns to include in the result\n    * @returns Array of filtered app screens\n    * \n    * @example\n    * // Get all system screens\n    * const systemScreens = metadataUtils.getAppScreens(screen => screen.IsSystemRecord === true);\n    * \n    * // Get specific columns from all screens\n    * const screens = metadataUtils.getAppScreens(\n    *   undefined, \n    *   ['ID', 'Name', 'ScreenType']\n    * );\n    */\n    public getAppScreens(filterFn?: ((value: AppScreen) => boolean), columns?: string[]): any[] {\n        try {\n            let appScreens = Common.tabJson.AppScreens || [];\n\n            // Apply filter if provided\n            if (filterFn) {\n                appScreens = appScreens.filter(filterFn);\n            }\n\n            return this.formatResults(appScreens, columns);\n        } catch (error) {\n            console.error('Error in getAppScreens:', error);\n            return [];\n        }\n    }\n\n    /**\n     * Gets a specific App Screen by ID or Name\n     * \n     * @param screen ID or Name of the app screen to retrieve\n     * @param columns Optional columns to include in the result\n     * @returns The app screen with specified columns or null if not found\n     * \n     * @example\n     * // Get a specific screen with all properties\n     * const screen = metadataUtils.getAppScreen('a5cd639e-31ba-4d33-8800-005a5248dfb2');\n     * \n     * // Get specific columns from a screen by name\n     * const screen = metadataUtils.getAppScreen(\n     *   'New Detail Role/Permission Appoject acess wise',\n     *   ['ID', 'Name', 'ScreenType']\n     * );\n     */\n    public getAppScreen(screen: string, columns?: string[]): any {\n        try {\n            return this.getAppScreens(scr =>\n                scr.ID?.toLowerCase() === screen?.toLowerCase() || scr.Name === screen,\n                columns\n            )?.[0] ?? null;\n        } catch (error) {\n            console.error('Error in getAppScreen:', error);\n            return null;\n        }\n    }\n\n    /**\n     * Gets App Menus with filter criteria\n     * \n     * @param filterFn Optional filter function to apply to app menus\n     * @param columns Optional columns to include in the result\n     * @returns Array of filtered app menus\n     * \n     * @example\n     * // Get all top-level menus\n     * const topMenus = metadataUtils.getAppMenus(menu => !menu.ParentID);\n     * \n     * // Get specific columns from all menus\n     * const menus = metadataUtils.getAppMenus(\n     *   undefined, \n     *   ['ID', 'MenuName', 'DisplayName', 'ScreenID']\n     * );\n     */\n    public getAppMenus(filterFn?: ((value: AppMenu) => boolean), columns?: string[]): any[] {\n        try {\n            let appMenus = Common.tabJson.AppMenus || [];\n\n            // Apply filter if provided\n            if (filterFn) {\n                appMenus = appMenus.filter(filterFn);\n            }\n\n            return this.formatResults(appMenus, columns);\n        } catch (error) {\n            console.error('Error in getAppMenus:', error);\n            return [];\n        }\n    }\n\n    /**\n     * Gets organization information with filter criteria\n     * \n     * @param filterFn Optional filter function to apply to organizations\n     * @param columns Optional columns to include in the result\n     * @returns Array of filtered organizations\n     * \n     * @example\n     * // Get all organizations\n     * const orgs = metadataUtils.getOrgs();\n     * \n     * // Get organizations with specific subdomain pattern\n     * const specificOrgs = metadataUtils.getOrgs(\n     *   org => org.Subdomain?.includes('test')\n     * );\n     */\n    public getOrgs(filterFn?: ((value: OrgInfo) => boolean), columns?: string[]): any[] {\n        try {\n            let organizations = Common.tabJson.OrgInfos || [];\n\n            // Apply filter if provided\n            if (filterFn) {\n                organizations = organizations.filter(filterFn);\n            }\n\n            return this.formatResults(organizations, columns);\n        } catch (error) {\n            console.error('Error in getOrganizations:', error);\n            return [];\n        }\n    }\n\n    /**\n     * Gets a specific organization by ID or Name\n     * \n     * @param organization ID or OrganizationName of the organization\n     * @param columns Optional columns to include in the result\n     * @returns The organization or null if not found\n     * \n     * @example\n     * // Get organization by ID\n     * const org = metadataUtils.getOrgInfoDetails('0ec3d0f1-b2ec-47b7-8305-b767d0e5ea63');\n     * \n     * // Get organization by name\n     * const org = metadataUtils.getOrgInfoDetails('SquadFocus');\n     */\n    public getOrgInfoDetails(organization: string, columns?: string[]): any {\n        try {\n            return this.getOrgs(org =>\n                org.ID?.toLowerCase() === organization?.toLowerCase() ||\n                org.OrganizationName === organization ||\n                org.Subdomain === organization,\n                columns\n            )[0] || null;\n        } catch (error) {\n            console.error('Error in getOrganization:', error);\n            return null;\n        }\n    }\n}"]}

package/esm2022/lib/tab-core-utility/app/interfaces/schema.interface.mjs

@@ -1,2 +1,9 @@
-export {};
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoic2NoZW1hLmludGVyZmFjZS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uLy4uLy4uLy4uL2xpYnMvZGF0YS1hY2Nlc3Mvc3JjL2xpYi90YWItY29yZS11dGlsaXR5L2FwcC9pbnRlcmZhY2VzL3NjaGVtYS5pbnRlcmZhY2UudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IiIsInNvdXJjZXNDb250ZW50IjpbImV4cG9ydCBpbnRlcmZhY2UgU2NoZW1hUmVzcG9uc2Uge1xuICBSZXF1ZXN0SWQ6IHN0cmluZ1xuICBJc1N1Y2Nlc3M6IGJvb2xlYW5cbiAgUmVzdWx0OiBzdHJpbmdcbiAgU3RhdHVzQ29kZTogc3RyaW5nXG4gIFJlY29yZEFmZmVjdHRlZDogbnVtYmVyXG4gIFRvdGFsUmVjb3JkczogbnVtYmVyXG4gIFRvdGFsRXhlY3V0aW9uVGltZTogbnVtYmVyXG4gIExvZzogYW55W11cbiAgRXJyb3JzOiBhbnlbXVxufSJdfQ==
+export var MetadataEntityType;
+(function (MetadataEntityType) {
+    MetadataEntityType["APP_OBJECTS"] = "AppObjects";
+    MetadataEntityType["APP_FIELDS"] = "AppFields";
+    MetadataEntityType["DATA_SOURCE_QUERIES"] = "DataSourceQueries";
+    MetadataEntityType["APP_SCREENS"] = "AppScreens";
+    MetadataEntityType["APP_MENUS"] = "AppMenus";
+})(MetadataEntityType || (MetadataEntityType = {}));
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoic2NoZW1hLmludGVyZmFjZS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uLy4uLy4uLy4uL2xpYnMvZGF0YS1hY2Nlc3Mvc3JjL2xpYi90YWItY29yZS11dGlsaXR5L2FwcC9pbnRlcmZhY2VzL3NjaGVtYS5pbnRlcmZhY2UudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBc0JBLE1BQU0sQ0FBTixJQUFZLGtCQU1YO0FBTkQsV0FBWSxrQkFBa0I7SUFDNUIsZ0RBQTBCLENBQUE7SUFDMUIsOENBQXdCLENBQUE7SUFDeEIsK0RBQXlDLENBQUE7SUFDekMsZ0RBQTBCLENBQUE7SUFDMUIsNENBQXNCLENBQUE7QUFDeEIsQ0FBQyxFQU5XLGtCQUFrQixLQUFsQixrQkFBa0IsUUFNN0IiLCJzb3VyY2VzQ29udGVudCI6WyJleHBvcnQgaW50ZXJmYWNlIFNjaGVtYVJlc3BvbnNlIHtcbiAgUmVxdWVzdElkOiBzdHJpbmdcbiAgSXNTdWNjZXNzOiBib29sZWFuXG4gIFJlc3VsdDogc3RyaW5nXG4gIFN0YXR1c0NvZGU6IHN0cmluZ1xuICBSZWNvcmRBZmZlY3R0ZWQ6IG51bWJlclxuICBUb3RhbFJlY29yZHM6IG51bWJlclxuICBUb3RhbEV4ZWN1dGlvblRpbWU6IG51bWJlclxuICBMb2c6IGFueVtdXG4gIEVycm9yczogYW55W11cbn1cblxuZXhwb3J0IGludGVyZmFjZSBPcmdJbmZvIHtcbiAgSUQ6IHN0cmluZztcbiAgT3JnYW5pemF0aW9uTmFtZTogc3RyaW5nO1xuICBQcmltYXJ5Q29udGFjdDogYW55O1xuICBBZGRyZXNzOiBhbnk7XG4gIExvY2FsZVNldHRpbmdzOiBzdHJpbmcgfCBudWxsO1xuICBTdWJkb21haW46IHN0cmluZztcbiAgVGVuYW50Q29kZTogc3RyaW5nIHwgbnVsbDtcbn1cblxuZXhwb3J0IGVudW0gTWV0YWRhdGFFbnRpdHlUeXBlIHtcbiAgQVBQX09CSkVDVFMgPSAnQXBwT2JqZWN0cycsXG4gIEFQUF9GSUVMRFMgPSAnQXBwRmllbGRzJyxcbiAgREFUQV9TT1VSQ0VfUVVFUklFUyA9ICdEYXRhU291cmNlUXVlcmllcycsXG4gIEFQUF9TQ1JFRU5TID0gJ0FwcFNjcmVlbnMnLFxuICBBUFBfTUVOVVMgPSAnQXBwTWVudXMnXG59Il19

package/index.d.ts

@@ -20,6 +20,7 @@ export * from './lib/tab-core-utility/app/helpers/common/dsq.helpers';
 export * from './lib/tab-core-utility/app/helpers/common/req-res.helpers';
 export * from './lib/tab-core-utility/app/helpers/common/where-clause.helpers';
 export * from './lib/tab-core-utility/app/helpers/common/template.helpers';
+export * from './lib/tab-core-utility/app/helpers/common/meta-data.helpers';
 export * from './lib/tab-core-utility/app/helpers/screen/forms.helpers';
 export * from './lib/tab-core-utility/app/helpers/screen/grid-column-data.helpers';
 export * from './lib/tab-core-utility/app/helpers/screen/grid.helpers';

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

@@ -18,5 +18,6 @@ export declare const StorageConstants: {
     AppId: string;
     screenContext: string;
     environmentMode: string;
+    environmentId: string;
     tabAppObjectAccess: string;
 };

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

@@ -0,0 +1,355 @@
+import { MetadataEntityType, OrgInfo } from "../../interfaces/schema.interface";
+import { AppMenu, AppObject, AppScreen } from "../../models/app-object.class";
+import { AppFields, DataSourceQueries, DataSourceQueries_Fields, Parameters } from "../../models/data-source-queries.class";
+import * as i0 from "@angular/core";
+/**
+   * MetadataUtils - Utility service for retrieving and manipulating application metadata
+   *
+   * This service provides methods to extract, filter, and format different parts of the
+   * application metadata, including objects, fields, screens, menus, etc.
+   */
+export declare class MetadataHelper {
+    private formatResults;
+    /**
+     * Search across all metadata for a term
+     *
+     * @param searchTerm Term to search for
+     * @param entityTypes Optional types of entities to search (if not provided, searches all)
+     * @returns Search results grouped by entity type
+     *
+     * @example
+     * // Search across all metadata
+     * const results = metadataUtils.searchAcrossMetadata('Blueprint');
+     *
+     * // Search only in app objects and screens
+     * const results = metadataUtils.searchAcrossMetadata(
+     *   'Role',
+     *   [MetadataEntityType.APP_OBJECTS, MetadataEntityType.APP_SCREENS]
+     * );
+     */
+    searchAcrossMetadata(searchTerm: string, entityTypes?: MetadataEntityType[]): Record<string, any[]>;
+    /**
+     * Search for a term within App Objects
+     * @private
+     */
+    private searchAppObjects;
+    /**
+     * Search for a term within App Fields
+     * @private
+     */
+    private searchAppFields;
+    /**
+     * Search for a term within Data Source Queries
+     * @private
+     */
+    private searchDataSourceQueries;
+    /**
+     * Search for a term within App Screens
+     * @private
+     */
+    private searchAppScreens;
+    /**
+     * Search for a term within App Menus
+     * @private
+     */
+    private searchAppMenus;
+    /**
+     * Helper method to check if a string contains a search term
+     * @private
+     */
+    private containsTerm;
+    /**
+     * Gets App Objects based on filter criteria
+     *
+     * @param filterFn Optional filter function to apply to app objects
+     * @param columns Optional columns to include in the result
+     * @returns Array of filtered app objects
+     *
+     * @example
+     * // Get all system app objects
+     * const systemObjects = metadataUtils.getAppObjects(obj => obj.IsSystem === true);
+     *
+     * // Get specific columns from non-deprecated objects
+     * const objects = metadataUtils.getAppObjects(
+     *   obj => !obj.IsDeprecated,
+     *   ['ID', 'DisplayName', 'ObjectName']
+     * );
+     */
+    getAppObjects(filterFn?: ((value: AppObject) => boolean), columns?: string[]): any[];
+    /**
+     * Gets a specific App Object by ID or Name
+     *
+     * @param appObject ID or Name of the app object to retrieve
+     * @param columns Optional columns to include in the result
+     * @returns The app object with specified columns or null if not found
+     *
+     * @example
+     * // Get a specific app object with all properties
+     * const appObj = metadataUtils.getAppObjectDetails('b4887d4d-bb1e-4d52-a7e8-2f943d69e44c' or 'TABMD_SYSTEM');
+     *
+     * // Get specific columns from an app object
+     * const appObj = metadataUtils.getAppObjectDetails(
+     *   'b4887d4d-bb1e-4d52-a7e8-2f943d69e44c',
+     *   ['ID', 'DisplayName', 'ObjectName']
+     * );
+     */
+    getAppObjectDetails(appObject: string, columns?: string[]): any;
+    /**
+     * Gets all fields across all app objects with filter criteria
+     *
+     * @param filterFn Optional filter function to apply to fields
+     * @param columns Optional columns to include in the result
+     * @returns Array of filtered fields
+     *
+     * @example
+     * // Get all required fields across all objects
+     * const requiredFields = metadataUtils.getAppFields(field => field.IsRequired === true);
+     *
+     * // Get specific columns from searchable fields
+     * const fields = metadataUtils.getAppFields(
+     *   field => field.IsSearchable === true,
+     *   ['ID', 'DisplayName', 'FieldName']
+     * );
+     */
+    getAppFields(filterFn?: ((value: AppFields) => boolean), columns?: string[]): any[];
+    /**
+     * Gets fields for a specific app object
+     *
+     * @param appObject ID or Name of the app object
+     * @param filterFn Optional filter function for fields
+     * @returns Array of fields for the specified object
+     *
+     * @example
+     * // Get all fields for an object
+     * const fields = metadataUtils.getAppFieldsByAppObject('b4887d4d-bb1e-4d52-a7e8-2f943d69e44c' or 'TABMD_SYSTEM');
+     *
+     * // Get only required fields
+     * const requiredFields = metadataUtils.getAppFieldsByAppObject(
+     *   'b4887d4d-bb1e-4d52-a7e8-2f943d69e44c',
+     *   field => field.IsRequired === true
+     * );
+     */
+    getAppFieldsByAppObject(appObject: string, filterFn?: ((value: AppFields, index: number, array: AppFields[]) => boolean), columns?: string[]): any[];
+    /**
+    * Gets lookup fields for a specific app object
+    *
+    * @param appObject ID or Name of the app object
+    * @param filterFn Optional filter function for lookup fields
+    * @param columns Optional columns to include in the result
+    * @returns Array of lookup fields for the specified object
+    *
+    * @example
+    * // Get all lookup fields for an object
+    * const lookupFields = metadataUtils.getLookupFieldsByAppObject('TABD_Blueprint_SLASchemes');
+    *
+    * // Get specific lookup fields
+    * const fields = metadataUtils.getLookupFieldsByAppObject(
+    *   'b4887d4d-bb1e-4d52-a7e8-2f943d69e44c',
+    *   field => field.IsRequired === true
+    * );
+    */
+    getLookupFieldsByAppObject(appObject: string, filterFn?: ((value: AppFields) => boolean), columns?: string[]): any[];
+    /**
+     * Gets data source queries with filter criteria
+     *
+     * @param filterFn Optional filter function to apply to queries
+     * @param columns Optional columns to include in the result
+     * @returns Array of filtered data source queries
+     *
+     * @example
+     * // Get all queries with a specific naming pattern
+     * const queries = metadataUtils.getDataSourceQueries(query => query.QueryName.includes('List'));
+     *
+     * // Get specific columns from all queries
+     * const queries = metadataUtils.getDataSourceQueries(
+     *   undefined,
+     *   ['ID', 'QueryName', 'DisplayName']
+     * );
+     */
+    getDataSourceQueries(filterFn?: ((value: DataSourceQueries) => boolean), columns?: string[]): any[];
+    /**
+     * Gets data source queries for a specific app object
+     *
+     * @param appObject ID or Name of the app object
+     * @param filterFn Optional filter function for queries
+     * @param columns Optional columns to include in the result
+     * @returns Array of queries for the specified object
+     *
+     * @example
+     * // Get all queries for an object
+     * const queries = metadataUtils.getDataSourceQueriesByAppObject('b4887d4d-bb1e-4d52-a7e8-2f943d69e44c');
+     *
+     * // Get queries with specific pattern
+     * const filteredQueries = metadataUtils.getDataSourceQueriesByAppObject(
+     *   'TABD_Blueprint_SLASchemes',
+     *   query => query.QueryName.includes('List')
+     * );
+     */
+    getDataSourceQueriesByAppObject(appObject: string, filterFn?: ((value: DataSourceQueries) => boolean), columns?: string[]): any[];
+    /**
+     * Gets a specific Data Source Query by ID or Name
+     *
+     * @param query ID or Name of the data source query to retrieve
+     * @param columns Optional columns to include in the result
+     * @returns The data source query with specified columns or null if not found
+     *
+     * @example
+     * // Get a specific query with all properties
+     * const query = metadataUtils.getDataSourceQueryDetails('73e590d0-c4eb-464d-abf9-01943e30ae09');
+     *
+     * // Get specific columns from a query by name
+     * const query = metadataUtils.getDataSourceQueryDetails(
+     *   'Get_SLASchemes_List',
+     *   ['ID', 'QueryName', 'DisplayName']
+     * );
+     */
+    getDataSourceQueryDetails(query: string, columns?: string[]): any;
+    /**
+     * Gets fields from a data source query
+     *
+     * @param query ID or Name of the data source query
+     * @param filterFn Optional filter function for query fields
+     * @param columns Optional columns to include in the result
+     * @returns Array of fields for the specified query with app field details
+     *
+     * @example
+     * // Get all fields for a query
+     * const queryFields = metadataUtils.getDataSourceQueryFields('73e590d0-c4eb-464d-abf9-01943e30ae09');
+     *
+     * // Get fields for a query by name
+     * const queryFields = metadataUtils.getDataSourceQueryFields('Get_SLASchemes_List');
+     *
+     * // Get fields with filter and specific columns
+     * const fields = metadataUtils.getDataSourceQueryFields(
+     *   '73e590d0-c4eb-464d-abf9-01943e30ae09',
+     *   field => field.FieldType === 1,
+     *   ['ID', 'AppFieldID', 'FieldType']
+     * );
+     */
+    getFieldsByDSQ(query: string, filterFn?: ((value: DataSourceQueries_Fields) => boolean), columns?: string[]): any[];
+    /**
+     * Enhances query fields with their corresponding app field details
+     * @private
+     */
+    private enhanceQueryFieldsWithAppFields;
+    /**
+     * Finds the parent app object that contains a specific data source query
+     * @private
+     */
+    private findParentAppObjectForQuery;
+    /**
+     * Finds an app field by ID within a specific app object
+     * @private
+     */
+    private findAppFieldById;
+    /**
+     * Gets query parameters from a data source query
+     *
+     * @param query ID or Name of the data source query
+     * @param filterFn Optional filter function for query parameters
+     * @param columns Optional columns to include in the result
+     * @returns Array of parameters for the specified query
+     *
+     * @example
+     * // Get all parameters for a query
+     * const queryParams = metadataUtils.getParametersByDSQ('73e590d0-c4eb-464d-abf9-01943e30ae09');
+     *
+     * // Get all parameters for a query by name
+     * const queryParams = metadataUtils.getParametersByDSQ('Get_SLASchemes_List');
+     *
+     * // Get mandatory parameters only
+     * const mandatoryParams = metadataUtils.getParametersByDSQ(
+     *   '73e590d0-c4eb-464d-abf9-01943e30ae09',
+     *   param => param.IsMandatory === true
+     * );
+     */
+    getParametersByDSQ(query: string, filterFn?: ((value: Parameters) => boolean), columns?: string[]): any[];
+    /**
+    * Gets App Screens with filter criteria
+    *
+    * @param filterFn Optional filter function to apply to app screens
+    * @param columns Optional columns to include in the result
+    * @returns Array of filtered app screens
+    *
+    * @example
+    * // Get all system screens
+    * const systemScreens = metadataUtils.getAppScreens(screen => screen.IsSystemRecord === true);
+    *
+    * // Get specific columns from all screens
+    * const screens = metadataUtils.getAppScreens(
+    *   undefined,
+    *   ['ID', 'Name', 'ScreenType']
+    * );
+    */
+    getAppScreens(filterFn?: ((value: AppScreen) => boolean), columns?: string[]): any[];
+    /**
+     * Gets a specific App Screen by ID or Name
+     *
+     * @param screen ID or Name of the app screen to retrieve
+     * @param columns Optional columns to include in the result
+     * @returns The app screen with specified columns or null if not found
+     *
+     * @example
+     * // Get a specific screen with all properties
+     * const screen = metadataUtils.getAppScreen('a5cd639e-31ba-4d33-8800-005a5248dfb2');
+     *
+     * // Get specific columns from a screen by name
+     * const screen = metadataUtils.getAppScreen(
+     *   'New Detail Role/Permission Appoject acess wise',
+     *   ['ID', 'Name', 'ScreenType']
+     * );
+     */
+    getAppScreen(screen: string, columns?: string[]): any;
+    /**
+     * Gets App Menus with filter criteria
+     *
+     * @param filterFn Optional filter function to apply to app menus
+     * @param columns Optional columns to include in the result
+     * @returns Array of filtered app menus
+     *
+     * @example
+     * // Get all top-level menus
+     * const topMenus = metadataUtils.getAppMenus(menu => !menu.ParentID);
+     *
+     * // Get specific columns from all menus
+     * const menus = metadataUtils.getAppMenus(
+     *   undefined,
+     *   ['ID', 'MenuName', 'DisplayName', 'ScreenID']
+     * );
+     */
+    getAppMenus(filterFn?: ((value: AppMenu) => boolean), columns?: string[]): any[];
+    /**
+     * Gets organization information with filter criteria
+     *
+     * @param filterFn Optional filter function to apply to organizations
+     * @param columns Optional columns to include in the result
+     * @returns Array of filtered organizations
+     *
+     * @example
+     * // Get all organizations
+     * const orgs = metadataUtils.getOrgs();
+     *
+     * // Get organizations with specific subdomain pattern
+     * const specificOrgs = metadataUtils.getOrgs(
+     *   org => org.Subdomain?.includes('test')
+     * );
+     */
+    getOrgs(filterFn?: ((value: OrgInfo) => boolean), columns?: string[]): any[];
+    /**
+     * Gets a specific organization by ID or Name
+     *
+     * @param organization ID or OrganizationName of the organization
+     * @param columns Optional columns to include in the result
+     * @returns The organization or null if not found
+     *
+     * @example
+     * // Get organization by ID
+     * const org = metadataUtils.getOrgInfoDetails('0ec3d0f1-b2ec-47b7-8305-b767d0e5ea63');
+     *
+     * // Get organization by name
+     * const org = metadataUtils.getOrgInfoDetails('SquadFocus');
+     */
+    getOrgInfoDetails(organization: string, columns?: string[]): any;
+    static ɵfac: i0.ɵɵFactoryDeclaration<MetadataHelper, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<MetadataHelper>;
+}

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

@@ -9,3 +9,19 @@ export interface SchemaResponse {
     Log: any[];
     Errors: any[];
 }
+export interface OrgInfo {
+    ID: string;
+    OrganizationName: string;
+    PrimaryContact: any;
+    Address: any;
+    LocaleSettings: string | null;
+    Subdomain: string;
+    TenantCode: string | null;
+}
+export declare enum MetadataEntityType {
+    APP_OBJECTS = "AppObjects",
+    APP_FIELDS = "AppFields",
+    DATA_SOURCE_QUERIES = "DataSourceQueries",
+    APP_SCREENS = "AppScreens",
+    APP_MENUS = "AppMenus"
+}

package/lib/tab-core-utility/store/auth.store.d.ts

@@ -2,18 +2,18 @@ import { Observable } from "rxjs";
 import { LoginUserRequest } from "../app/interfaces/auth.interface";
 export declare const authStore: import("@angular/core").Type<{
     token: import("@angular/core").Signal<string>;
-    name: import("@angular/core").Signal<string>;
     id: import("@angular/core").Signal<any>;
     email: import("@angular/core").Signal<string>;
+    name: import("@angular/core").Signal<string>;
     avatar: import("@angular/core").Signal<string>;
     status: import("@angular/core").Signal<string>;
     checkUserlogin: () => boolean;
     login: (API_URL: string, credentials: LoginUserRequest) => Observable<any>;
 } & import("@ngrx/signals").StateSignal<{
     token: string;
-    name: string;
     id: any;
     email: string;
+    name: string;
     avatar: string;
     status: string;
 }>>;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@techextensor/tab-core-utility",
-  "version": "2.2.130",
+  "version": "2.2.132",
   "peerDependencies": {
     "@angular/common": "^17.3.0",
     "@angular/core": "^17.3.0",