@memberjunction/global 2.112.0 → 2.113.0

package/dist/generic/providerBase.js

@@ -1,999 +0,0 @@
-"use strict";
-var _a;
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.ProviderBase = exports.AllMetadataArrays = exports.MetadataFromSimpleObjectWithoutUser = exports.MetadataFromSimpleObject = void 0;
-const baseEntity_1 = require("./baseEntity");
-const entityInfo_1 = require("./entityInfo");
-const interfaces_1 = require("./interfaces");
-const applicationInfo_1 = require("../generic/applicationInfo");
-const securityInfo_1 = require("./securityInfo");
-const logging_1 = require("./logging");
-const queryInfo_1 = require("./queryInfo");
-const libraryInfo_1 = require("./libraryInfo");
-const compositeKey_1 = require("./compositeKey");
-const explorerNavigationItem_1 = require("./explorerNavigationItem");
-const metadata_1 = require("./metadata");
-const runView_1 = require("../views/runView");
-const Global_1 = require("../Global");
-/**
- * Creates a new instance of AllMetadata from a simple object.
- * Handles deserialization and proper instantiation of all metadata classes.
- * @param data - The raw metadata object to convert
- * @param md - The metadata provider for context
- * @returns A fully populated AllMetadata instance with proper type instances
- */
-function MetadataFromSimpleObject(data, md) {
-    try {
-        const newObject = MetadataFromSimpleObjectWithoutUser(data, md);
-        newObject.CurrentUser = data.CurrentUser ? new securityInfo_1.UserInfo(md, data.CurrentUser) : null;
-        return newObject;
-    }
-    catch (e) {
-        (0, logging_1.LogError)(e);
-    }
-}
-exports.MetadataFromSimpleObject = MetadataFromSimpleObject;
-/**
- * Creates a new instance of AllMetadata from a simple object, but does NOT set the CurrentUser property
- * Handles deserialization and proper instantiation of all metadata classes.
- * @param data - The raw metadata object to convert
- * @param md - The metadata provider for context
- * @returns A fully populated AllMetadata instance with proper type instances
- */
-function MetadataFromSimpleObjectWithoutUser(data, md) {
-    try {
-        const returnMetadata = new interfaces_1.AllMetadata();
-        // now iterate through the AllMetadataMapping array and construct the return type
-        for (let m of exports.AllMetadataArrays) {
-            let simpleKey = m.key;
-            if (!data.hasOwnProperty(simpleKey)) {
-                simpleKey = simpleKey.substring(3); // remove the All prefix
-            }
-            if (data.hasOwnProperty(simpleKey)) {
-                // at this point, only do this particular property if we have a match, it is either prefixed with All or not
-                // for example in our strongly typed AllMetadata class we have AllQueryCategories, but in the simple allMetadata object we have QueryCategories
-                // so we need to check for both which is what the above is doing.
-                // Build the array of the correct type and initialize with the simple object
-                returnMetadata[m.key] = data[simpleKey].map((d) => new m.class(d, md));
-            }
-        }
-        return returnMetadata;
-    }
-    catch (e) {
-        (0, logging_1.LogError)(e);
-    }
-}
-exports.MetadataFromSimpleObjectWithoutUser = MetadataFromSimpleObjectWithoutUser;
-/**
- * This is a list of all metadata classes that are used in the AllMetadata class.
- * Used to automatically determine the class type when deserializing the metadata and
- * for iterating through all metadata collections.
- * Each entry maps a property key to its corresponding class constructor.
- */
-exports.AllMetadataArrays = [
-    { key: 'AllEntities', class: entityInfo_1.EntityInfo },
-    { key: 'AllApplications', class: applicationInfo_1.ApplicationInfo },
-    { key: 'AllRoles', class: securityInfo_1.RoleInfo },
-    { key: 'AllRowLevelSecurityFilters', class: securityInfo_1.RowLevelSecurityFilterInfo },
-    { key: 'AllAuditLogTypes', class: securityInfo_1.AuditLogTypeInfo },
-    { key: 'AllAuthorizations', class: securityInfo_1.AuthorizationInfo },
-    { key: 'AllQueryCategories', class: queryInfo_1.QueryCategoryInfo },
-    { key: 'AllQueries', class: queryInfo_1.QueryInfo },
-    { key: 'AllQueryFields', class: queryInfo_1.QueryFieldInfo },
-    { key: 'AllQueryPermissions', class: queryInfo_1.QueryPermissionInfo },
-    { key: 'AllQueryEntities', class: queryInfo_1.QueryEntityInfo },
-    { key: 'AllQueryParameters', class: queryInfo_1.QueryParameterInfo },
-    { key: 'AllEntityDocumentTypes', class: entityInfo_1.EntityDocumentTypeInfo },
-    { key: 'AllLibraries', class: libraryInfo_1.LibraryInfo },
-    { key: 'AllExplorerNavigationItems', class: explorerNavigationItem_1.ExplorerNavigationItem },
-];
-/**
- * Base class for all metadata providers in MemberJunction.
- * Implements common functionality for metadata caching, refresh, and dataset management.
- * Subclasses must implement abstract methods for provider-specific operations.
- */
-class ProviderBase {
-    constructor() {
-        this._localMetadata = new interfaces_1.AllMetadata();
-        this._refresh = false;
-        this._cachedVisibleExplorerNavigationItems = null;
-    }
-    /**
-     * Used to check to see if the entity in question is active or not
-     * If it is not active, it will throw an exception or log a warning depending on the status of the entity being
-     * either Deprecated or Disabled.
-     * @param entityName
-     * @param callerName
-     */
-    async EntityStatusCheck(params, callerName) {
-        const entityName = await runView_1.RunView.GetEntityNameFromRunViewParams(params, this);
-        const entity = this.Entities.find((e) => e.Name.trim().toLowerCase() === entityName?.trim().toLowerCase());
-        if (!entity) {
-            throw new Error(`Entity ${entityName} not found in metadata`);
-        }
-        entityInfo_1.EntityInfo.AssertEntityActiveStatus(entity, callerName);
-    }
-    /**
-     * Base class pre-processor that all sub-classes should call before they start their RunView process
-     * @param params
-     * @param contextUser
-     */
-    async PreProcessRunView(params, contextUser) {
-        await this.EntityStatusCheck(params, 'PreProcessRunView');
-        // FIRST, if the resultType is entity_object, we need to run the view with ALL fields in the entity
-        // so that we can get the data to populate the entity object with.
-        if (params.ResultType === 'entity_object') {
-            // we need to get the entity definition and then get all the fields for it
-            const entity = this.Entities.find((e) => e.Name.trim().toLowerCase() === params.EntityName.trim().toLowerCase());
-            if (!entity)
-                throw new Error(`Entity ${params.EntityName} not found in metadata`);
-            params.Fields = entity.Fields.map((f) => f.Name); // just override whatever was passed in with all the fields - or if nothing was passed in, we set it. For loading the entity object, we need ALL the fields.
-        }
-    }
-    /**
-     * Base class post-processor that all sub-classes should call after they finish their RunView process
-     * @param params
-     * @param contextUser
-     * @returns
-     */
-    async PostProcessRunView(result, params, contextUser) {
-        // Transform the result set into BaseEntity-derived objects, if needed
-        await this.TransformSimpleObjectToEntityObject(params, result, contextUser);
-    }
-    /**
-     * Base class implementation for handling pre-processing of RunViews() each sub-class should call this
-     * within their RunViews() method implementation
-     * @param params
-     * @param contextUser
-     * @returns
-     */
-    async PreProcessRunViews(params, contextUser) {
-        if (params && params.length > 0) {
-            for (const param of params) {
-                this.EntityStatusCheck(param, 'PreProcessRunViews');
-                // FIRST, if the resultType is entity_object, we need to run the view with ALL fields in the entity
-                // so that we can get the data to populate the entity object with.
-                if (param.ResultType === 'entity_object') {
-                    // we need to get the entity definition and then get all the fields for it
-                    const entity = this.Entities.find((e) => e.Name.trim().toLowerCase() === param.EntityName.trim().toLowerCase());
-                    if (!entity) {
-                        throw new Error(`Entity ${param.EntityName} not found in metadata`);
-                    }
-                    param.Fields = entity.Fields.map((f) => f.Name); // just override whatever was passed in with all the fields - or if nothing was passed in, we set it. For loading the entity object, we need ALL the fields.
-                }
-            }
-        }
-    }
-    /**
-     * Base class utilty method that should be called after each sub-class handles its internal RunViews() process before returning results
-     * This handles the optional conversion of simple objects to entity objects for each requested view depending on if the params requests
-     * a result_type === 'entity_object'
-     * @param results
-     * @param params
-     * @param contextUser
-     */
-    async PostProcessRunViews(results, params, contextUser) {
-        if (params && params.length > 0) {
-            const promises = [];
-            for (let i = 0; i < results.length; i++) {
-                promises.push(this.TransformSimpleObjectToEntityObject(params[i], results[i], contextUser));
-            }
-            // await the promises for all transformations
-            await Promise.all(promises);
-        }
-    }
-    /**
-     * Transforms the result set from simple objects to entity objects if needed.
-     * @param param - The RunViewParams used for the request
-     * @param result - The RunViewResult returned from the request
-     * @param contextUser - The user context for permissions
-     */
-    async TransformSimpleObjectToEntityObject(param, result, contextUser) {
-        // only if needed (e.g. ResultType==='entity_object'), transform the result set into BaseEntity-derived objects
-        if (param.ResultType === 'entity_object' && result && result.Success) {
-            // we need to transform each of the items in the result set into a BaseEntity-derived object
-            // Create entities and load data in parallel for better performance
-            const entityPromises = result.Results.map(async (item) => {
-                if (item instanceof baseEntity_1.BaseEntity || typeof item.Save === 'function') {
-                    // the second check is a "duck-typing" check in case we have different runtime
-                    // loading sources where the instanceof will fail
-                    return item;
-                }
-                else {
-                    // not a base entity sub-class already so convert
-                    const entity = await this.GetEntityObject(param.EntityName, contextUser);
-                    await entity.LoadFromData(item);
-                    return entity;
-                }
-            });
-            result.Results = await Promise.all(entityPromises);
-        }
-    }
-    /**
-     * Returns the currently loaded local metadata from within the instance
-     */
-    get AllMetadata() {
-        return this._localMetadata;
-    }
-    /**
-     * Configures the provider with the specified configuration data.
-     * Handles metadata refresh if needed and initializes the provider.
-     * @param data - Configuration including schema filters and connection info
-     * @returns True if configuration was successful
-     */
-    async Config(data, providerToUse) {
-        this._ConfigData = data;
-        // first, let's check to see if we have an existing Metadata.Provider registered, if so
-        // unless our data.IgnoreExistingMetadata is set to true, we will not refresh the metadata
-        if (metadata_1.Metadata.Provider && !data.IgnoreExistingMetadata) {
-            // we have an existing globally registered provider AND we are not
-            // requested to ignore the existing metadata, so we will not refresh it
-            if (this.CopyMetadataFromGlobalProvider()) {
-                return true; // we're done, if we fail here, we keep going and do normal logic
-            }
-        }
-        if (this._refresh || (await this.CheckToSeeIfRefreshNeeded(providerToUse))) {
-            // either a hard refresh flag was set within Refresh(), or LocalMetadata is Obsolete
-            // first, make sure we reset the flag to false so that if another call to this function happens
-            // while we are waiting for the async call to finish, we dont do it again
-            this._refresh = false;
-            // start with fresh metadata
-            this._localMetadata = new interfaces_1.AllMetadata();
-            this._cachedVisibleExplorerNavigationItems = null; // reset this so it gets rebuilt next time it is requested
-            const start = new Date().getTime();
-            const res = await this.GetAllMetadata(providerToUse);
-            const end = new Date().getTime();
-            (0, logging_1.LogStatus)(`GetAllMetadata() took ${end - start} ms`);
-            if (res) {
-                this.UpdateLocalMetadata(res);
-                this._latestLocalMetadataTimestamps = this._latestRemoteMetadataTimestamps; // update this since we just used server to get all the stuff
-                await this.SaveLocalMetadataToStorage();
-            }
-        }
-        return true;
-    }
-    CloneAllMetadata(toClone) {
-        // we need to create a copy but can't do it the standard way becuase we need object instances
-        // for various things like EntityInfo
-        const newmd = MetadataFromSimpleObjectWithoutUser(toClone, this);
-        newmd.CurrentUser = this.CurrentUser;
-        return newmd;
-    }
-    /**
-     * Copies metadata from the global provider to the local instance.
-     * This is used to ensure that the local instance has the latest metadata
-     * information available without having to reload it from the server.
-     */
-    CopyMetadataFromGlobalProvider() {
-        try {
-            if (metadata_1.Metadata.Provider && metadata_1.Metadata.Provider !== this && metadata_1.Metadata.Provider.AllMetadata) {
-                this._localMetadata = this.CloneAllMetadata(metadata_1.Metadata.Provider.AllMetadata);
-                return true;
-            }
-            return false;
-        }
-        catch (e) {
-            (0, logging_1.LogError)(`Failed to copy metadata from global provider: ${e.message}`);
-            return false; // if we fail to copy the metadata, we will return false
-        }
-    }
-    /**
-     * Builds dataset filters based on the provider configuration.
-     * Ensures MJ Core schema is always included and never excluded.
-     * @returns Array of filters to apply when loading metadata
-     */
-    BuildDatasetFilterFromConfig() {
-        // setup the schema filters as needed
-        const f = [];
-        // make sure that the MJ Core schema is always included if includeSchemas are provided because if the user doesn't include them stuff will break
-        const includeSchemaList = this.ConfigData.IncludeSchemas;
-        const excludeSchemaList = this.ConfigData.ExcludeSchemas;
-        const mjcSchema = this.ConfigData.MJCoreSchemaName;
-        // check to see if the MJ Core schema is already in the list, if not add it
-        // TODO: The logic here doesn't match the comment above
-        if (includeSchemaList && includeSchemaList.length > 0 && includeSchemaList.indexOf(mjcSchema) === -1)
-            includeSchemaList.push(mjcSchema);
-        // check to make sure that if exclude schemas are provided, the list DOES NOT include the MJ Core schema, if it does, remove it
-        if (excludeSchemaList && excludeSchemaList.length > 0 && excludeSchemaList.indexOf(mjcSchema) !== -1) {
-            const index = excludeSchemaList.indexOf(mjcSchema);
-            excludeSchemaList.splice(index, 1);
-            (0, logging_1.LogStatus)(`Removed MJ Core schema (${mjcSchema}) from ExcludeSchemas list because it is required for the API to function correctly`);
-        }
-        let schemaFilter = '';
-        if (includeSchemaList && includeSchemaList.length > 0) {
-            schemaFilter = 'SchemaName IN (' + includeSchemaList.map((s) => `'${s}'`).join(',') + ')';
-        }
-        if (excludeSchemaList && excludeSchemaList.length > 0) {
-            schemaFilter =
-                (schemaFilter.length > 0 ? ' AND ' : '') + 'SchemaName NOT IN (' + excludeSchemaList.map((s) => `'${s}'`).join(',') + ')';
-        }
-        if (schemaFilter.length > 0) {
-            f.push({ ItemCode: 'Entities', Filter: schemaFilter });
-            f.push({ ItemCode: 'EntityFields', Filter: schemaFilter });
-        }
-        return f;
-    }
-    /**
-     * Retrieves all metadata from the server and constructs typed instances.
-     * Uses the MJ_Metadata dataset for efficient bulk loading.
-     * @returns Complete metadata collection with all relationships
-     */
-    async GetAllMetadata(providerToUse) {
-        try {
-            // we are now using datasets instead of the custom metadata to GraphQL to simplify GraphQL's work as it was very slow preivously
-            //const start1 = new Date().getTime();
-            const f = this.BuildDatasetFilterFromConfig();
-            // Get the dataset and cache it for anyone else who wants to use it
-            const d = await this.GetDatasetByName(_a._mjMetadataDatasetName, f.length > 0 ? f : null, this.CurrentUser, providerToUse);
-            if (d && d.Success) {
-                // cache the dataset for anyone who wants to use it
-                await this.CacheDataset(_a._mjMetadataDatasetName, f.length > 0 ? f : null, d);
-                // got the results, let's build our response in the format we need
-                const simpleMetadata = {};
-                for (let r of d.Results) {
-                    simpleMetadata[r.Code] = r.Results;
-                }
-                // Post Process Entities because there's some special handling of the sub-objects
-                simpleMetadata.AllEntities = this.PostProcessEntityMetadata(simpleMetadata.Entities, simpleMetadata.EntityFields, simpleMetadata.EntityFieldValues, simpleMetadata.EntityPermissions, simpleMetadata.EntityRelationships, simpleMetadata.EntitySettings);
-                // Post Process the Applications, because we want to handle the sub-objects properly.
-                simpleMetadata.AllApplications = simpleMetadata.Applications.map((a) => {
-                    a.ApplicationEntities = simpleMetadata.ApplicationEntities.filter((ae) => ae.ApplicationID === a.ID);
-                    a.ApplicationSettings = simpleMetadata.ApplicationSettings.filter((as) => as.ApplicationID === a.ID);
-                    return new applicationInfo_1.ApplicationInfo(a, this);
-                });
-                // now we need to construct our return type. The way the return type works, which is an instance of AllMetadata, we have to
-                // construst each item so it contains an array of the correct type. This is because the AllMetadata class has an array of each type of metadata
-                // rather than just plain JavaScript objects that we have in the allMetadata object.
-                // build the base return type
-                const returnMetadata = MetadataFromSimpleObjectWithoutUser(simpleMetadata, this);
-                returnMetadata.CurrentUser = await this.GetCurrentUser();
-                return returnMetadata;
-            }
-            else {
-                (0, logging_1.LogError)('GetAllMetadata() - Error getting metadata from server' + (d ? ': ' + d.Status : ''));
-            }
-        }
-        catch (e) {
-            (0, logging_1.LogError)(e);
-        }
-    }
-    /**
-     * Post-processes entity metadata to establish relationships between entities and their child objects.
-     * Links fields, permissions, relationships, and settings to their parent entities.
-     * @param entities - Array of entity metadata
-     * @param fields - Array of entity field metadata
-     * @param fieldValues - Array of entity field value metadata
-     * @param permissions - Array of entity permission metadata
-     * @param relationships - Array of entity relationship metadata
-     * @param settings - Array of entity settings metadata
-     * @returns Processed array of EntityInfo instances with all relationships established
-     */
-    PostProcessEntityMetadata(entities, fields, fieldValues, permissions, relationships, settings) {
-        const result = [];
-        if (fieldValues && fieldValues.length > 0)
-            for (let f of fields) {
-                // populate the field values for each field, if we have them
-                f.EntityFieldValues = fieldValues.filter((fv) => fv.EntityFieldID === f.ID);
-            }
-        for (let e of entities) {
-            e.EntityFields = fields.filter((f) => f.EntityID === e.ID).sort((a, b) => a.Sequence - b.Sequence);
-            e.EntityPermissions = permissions.filter((p) => p.EntityID === e.ID);
-            e.EntityRelationships = relationships.filter((r) => r.EntityID === e.ID);
-            e.EntitySettings = settings.filter((s) => s.EntityID === e.ID);
-            result.push(new entityInfo_1.EntityInfo(e));
-        }
-        return result;
-    }
-    /**
-     * Gets the configuration data that was provided to the provider.
-     * @returns The provider configuration including schema filters
-     */
-    get ConfigData() {
-        return this._ConfigData;
-    }
-    /**
-     * Gets all entity metadata in the system.
-     * @returns Array of EntityInfo objects representing all entities
-     */
-    get Entities() {
-        return this._localMetadata.AllEntities;
-    }
-    /**
-     * Gets all application metadata in the system.
-     * @returns Array of ApplicationInfo objects representing all applications
-     */
-    get Applications() {
-        return this._localMetadata.AllApplications;
-    }
-    /**
-     * Gets the current user's information including roles and permissions.
-     * @returns UserInfo object for the authenticated user
-     */
-    get CurrentUser() {
-        return this._localMetadata.CurrentUser;
-    }
-    /**
-     * Gets all security roles defined in the system.
-     * @returns Array of RoleInfo objects representing all roles
-     */
-    get Roles() {
-        return this._localMetadata.AllRoles;
-    }
-    /**
-     * Gets all row-level security filters defined in the system.
-     * @returns Array of RowLevelSecurityFilterInfo objects for data access control
-     */
-    get RowLevelSecurityFilters() {
-        return this._localMetadata.AllRowLevelSecurityFilters;
-    }
-    /**
-     * Gets all audit log types defined for tracking system activities.
-     * @returns Array of AuditLogTypeInfo objects
-     */
-    get AuditLogTypes() {
-        return this._localMetadata.AllAuditLogTypes;
-    }
-    /**
-     * Gets all authorization definitions in the system.
-     * @returns Array of AuthorizationInfo objects defining permissions
-     */
-    get Authorizations() {
-        return this._localMetadata.AllAuthorizations;
-    }
-    /**
-     * Gets all saved queries in the system.
-     * @returns Array of QueryInfo objects representing stored queries
-     */
-    get Queries() {
-        return this._localMetadata.AllQueries;
-    }
-    /**
-     * Gets all query category definitions.
-     * @returns Array of QueryCategoryInfo objects for query organization
-     */
-    get QueryCategories() {
-        return this._localMetadata.AllQueryCategories;
-    }
-    /**
-     * Gets all query field definitions.
-     * @returns Array of QueryFieldInfo objects defining query result columns
-     */
-    get QueryFields() {
-        return this._localMetadata.AllQueryFields;
-    }
-    /**
-     * Gets all query permission assignments.
-     * @returns Array of QueryPermissionInfo objects defining query access
-     */
-    get QueryPermissions() {
-        return this._localMetadata.AllQueryPermissions;
-    }
-    /**
-     * Gets all query entity associations.
-     * @returns Array of QueryEntityInfo objects linking queries to entities
-     */
-    get QueryEntities() {
-        return this._localMetadata.AllQueryEntities;
-    }
-    /**
-     * Gets all query parameter definitions.
-     * @returns Array of QueryParameterInfo objects for parameterized queries
-     */
-    get QueryParameters() {
-        return this._localMetadata.AllQueryParameters;
-    }
-    /**
-     * Gets all library definitions in the system.
-     * @returns Array of LibraryInfo objects representing code libraries
-     */
-    get Libraries() {
-        return this._localMetadata.AllLibraries;
-    }
-    /**
-     * Gets all explorer navigation items including inactive ones.
-     * @returns Array of all ExplorerNavigationItem objects
-     */
-    get AllExplorerNavigationItems() {
-        return this._localMetadata.AllExplorerNavigationItems;
-    }
-    /**
-     * Gets only active explorer navigation items sorted by sequence.
-     * Results are cached for performance.
-     * @returns Array of active ExplorerNavigationItem objects
-     */
-    get VisibleExplorerNavigationItems() {
-        // filter and sort once and cache
-        if (!this._cachedVisibleExplorerNavigationItems)
-            this._cachedVisibleExplorerNavigationItems = this._localMetadata.AllExplorerNavigationItems.filter((e) => e.IsActive).sort((a, b) => a.Sequence - b.Sequence);
-        return this._cachedVisibleExplorerNavigationItems;
-    }
-    /**
-     * Refreshes all metadata from the server.
-     * Respects the AllowRefresh flag from subclasses.
-     * @returns True if refresh was initiated or allowed
-     */
-    async Refresh(providerToUse) {
-        // do nothing here, but set a _refresh flag for next time things are requested
-        if (this.AllowRefresh) {
-            this._refresh = true;
-            return this.Config(this._ConfigData, providerToUse);
-        }
-        else
-            return true; // subclass is telling us not to do any refresh ops right now
-    }
-    /**
-     * Checks if local metadata is out of date and needs refreshing.
-     * Compares local timestamps with server timestamps.
-     * @returns True if refresh is needed, false otherwise
-     */
-    async CheckToSeeIfRefreshNeeded(providerToUse) {
-        if (this.AllowRefresh) {
-            await this.RefreshRemoteMetadataTimestamps(providerToUse); // get the latest timestamps from the server first
-            await this.LoadLocalMetadataFromStorage(); // then, attempt to load before we check to see if it is obsolete
-            return this.LocalMetadataObsolete();
-        } //subclass is telling us not to do any refresh ops right now
-        else
-            return false;
-    }
-    /**
-     * Refreshes metadata only if needed based on timestamp comparison.
-     * Combines check and refresh into a single operation.
-     * @returns True if refresh was successful or not needed
-     */
-    async RefreshIfNeeded(providerToUse) {
-        if (await this.CheckToSeeIfRefreshNeeded(providerToUse))
-            return this.Refresh(providerToUse);
-        else
-            return true;
-    }
-    async GetEntityObject(entityName, loadKeyOrContextUser, contextUser) {
-        try {
-            // Determine which overload was called
-            let actualLoadKey;
-            let actualContextUser;
-            if (loadKeyOrContextUser instanceof compositeKey_1.CompositeKey) {
-                // Second overload: entityName, loadKey, contextUser
-                actualLoadKey = loadKeyOrContextUser;
-                actualContextUser = contextUser;
-            }
-            else if (contextUser !== undefined) {
-                // Second overload with null/undefined loadKey: entityName, null/undefined, contextUser
-                actualLoadKey = undefined;
-                actualContextUser = contextUser;
-            }
-            else {
-                // First overload: entityName, contextUser
-                actualContextUser = loadKeyOrContextUser;
-            }
-            const entity = this.Metadata.Entities.find((e) => e.Name == entityName);
-            if (entity) {
-                // Use the MJGlobal Class Factory to do our object instantiation - we do NOT use metadata for this anymore, doesn't work well to have file paths with node dynamically at runtime
-                // type reference registration by any module via MJ Global is the way to go as it is reliable across all platforms.
-                try {
-                    const newObject = Global_1.MJGlobal.Instance.ClassFactory.CreateInstance(baseEntity_1.BaseEntity, entityName, entity, this);
-                    await newObject.Config(actualContextUser);
-                    if (actualLoadKey) {
-                        // Load existing record
-                        const loadResult = await newObject.InnerLoad(actualLoadKey);
-                        if (!loadResult) {
-                            throw new Error(`Failed to load ${entityName} with key: ${actualLoadKey.ToString()}`);
-                        }
-                    }
-                    else {
-                        // whenever we create a new object we want it to start
-                        // out as a new record, so we call NewRecord() on it
-                        newObject.NewRecord();
-                    }
-                    return newObject;
-                }
-                catch (e) {
-                    (0, logging_1.LogError)(e);
-                    throw new Error(`Entity ${entityName} could not be instantiated via MJGlobal Class Factory.  Make sure you have registered the class reference with MJGlobal.Instance.ClassFactory.Register(). ALSO, make sure you call LoadGeneratedEntities() from the GeneratedEntities project within your project as tree-shaking sometimes removes subclasses and could be causing this error!`);
-                }
-            }
-            else
-                throw new Error(`Entity ${entityName} not found in metadata`);
-        }
-        catch (ex) {
-            (0, logging_1.LogError)(ex);
-            return null;
-        }
-    }
-    /**
-     * Returns a list of entity dependencies, basically metadata that tells you the links to this entity from all other entities.
-     * @param entityName
-     * @returns
-     */
-    async GetEntityDependencies(entityName) {
-        // using our metadata, find all of the foreign keys that point to this entity
-        // go through each entity and find all the fields that have a RelatedEntity = entityName
-        try {
-            const eName = entityName.trim().toLowerCase();
-            const result = [];
-            for (let re of this.Entities) {
-                const relatedFields = re.Fields.filter((f) => f.RelatedEntity?.trim().toLowerCase() === eName);
-                // we now have all the fields, so let's create the EntityDependency objects
-                relatedFields.map((f) => {
-                    result.push({
-                        EntityName: entityName,
-                        RelatedEntityName: re.Name,
-                        FieldName: f.Name,
-                    });
-                });
-            }
-            return result;
-        }
-        catch (e) {
-            (0, logging_1.LogError)(e);
-            throw e;
-        }
-    }
-    /**
-     * Gets a database by name, if required, and caches it in a format available to the client (e.g. IndexedDB, LocalStorage, File, etc). The cache method is Provider specific
-     * If itemFilters are provided, the combination of datasetName and the filters are used to determine a match in the cache
-     * @param datasetName
-     * @param itemFilters
-     */
-    async GetAndCacheDatasetByName(datasetName, itemFilters, contextUser, providerToUse) {
-        // first see if we have anything in cache at all, no reason to check server dates if we dont
-        if (await this.IsDatasetCached(datasetName, itemFilters)) {
-            // compare the local version, if exists to the server version dates
-            if (await this.IsDatasetCacheUpToDate(datasetName, itemFilters)) {
-                // we're up to date, all we need to do is get the local cache and return it
-                return this.GetCachedDataset(datasetName, itemFilters);
-            }
-            else {
-                // we're out of date, so get the dataset from the server
-                const dataset = await this.GetDatasetByName(datasetName, itemFilters, contextUser, providerToUse);
-                // cache it
-                await this.CacheDataset(datasetName, itemFilters, dataset);
-                return dataset;
-            }
-        }
-        else {
-            // get the dataset from the server
-            const dataset = await this.GetDatasetByName(datasetName, itemFilters, contextUser, providerToUse);
-            // cache it
-            await this.CacheDataset(datasetName, itemFilters, dataset);
-            return dataset;
-        }
-    }
-    /**
-     * Returns the timestamp of the local cached version of a given datasetName or null if there is no local cache for the
-     * specified dataset
-     * @param datasetName the name of the dataset to check
-     * @param itemFilters optional filters to apply to the dataset
-     */
-    async GetLocalDatasetTimestamp(datasetName, itemFilters) {
-        const ls = this.LocalStorageProvider;
-        if (ls) {
-            const key = this.GetDatasetCacheKey(datasetName, itemFilters);
-            const dateKey = key + '_date';
-            const val = await ls.GetItem(dateKey);
-            if (val) {
-                return new Date(val);
-            }
-        }
-    }
-    /**
-     * This routine checks to see if the local cache version of a given datasetName/itemFilters combination is up to date with the server or not
-     * @param datasetName
-     * @param itemFilters
-     * @returns
-     */
-    async IsDatasetCacheUpToDate(datasetName, itemFilters) {
-        const localDate = await this.GetLocalDatasetTimestamp(datasetName, itemFilters);
-        if (localDate) {
-            // we have a local cached timestamp, so compare it to the server timestamp
-            const status = await this.GetDatasetStatusByName(datasetName, itemFilters);
-            if (status) {
-                const serverTimestamp = status.LatestUpdateDate.getTime();
-                if (localDate.getTime() >= serverTimestamp) {
-                    // this situation means our local cache timestamp is >= the server timestamp, so we're most likely up to date
-                    // in this situation, the last thing we check is for each entity, if the rowcount is the same as the server, if it is, we're good
-                    // iterate through all of the entities and check the row counts
-                    const localDataset = await this.GetCachedDataset(datasetName, itemFilters);
-                    for (const eu of status.EntityUpdateDates) {
-                        const localEntity = localDataset.Results.find((e) => e.EntityID === eu.EntityID);
-                        if (!localEntity || localEntity.Results.length !== eu.RowCount) {
-                            // we either couldn't find the entity in the local cache or the row count is different, so we're out of date
-                            // the RowCount being different picks up on DELETED rows. The UpdatedAt check which is handled above would pick up
-                            // on any new rows or updated rows. This approach makes sure we detect deleted rows and refresh the cache.
-                            return false;
-                        }
-                    }
-                    // if we get here that means that the row counts are the same for all entities and we're up to date
-                    return true;
-                }
-                else {
-                    // our local cache timestamp is < the server timestamp, so we're out of date
-                    return false;
-                }
-            }
-            else {
-                // we couldn't get the server status, so we're out of date
-                return false;
-            }
-        }
-        else {
-            // we don't have a local cache timestamp, so we're out of date
-            return false;
-        }
-    }
-    /**
-     * This routine gets the local cached version of a given datasetName/itemFilters combination, it does NOT check the server status first and does not fall back on the server if there isn't a local cache version of this dataset/itemFilters combination
-     * @param datasetName
-     * @param itemFilters
-     * @returns
-     */
-    async GetCachedDataset(datasetName, itemFilters) {
-        const ls = this.LocalStorageProvider;
-        if (ls) {
-            const key = this.GetDatasetCacheKey(datasetName, itemFilters);
-            const val = await ls.GetItem(key);
-            if (val) {
-                const dataset = JSON.parse(val);
-                return dataset;
-            }
-        }
-    }
-    /**
-     * Stores a dataset in the local cache. If itemFilters are provided, the combination of datasetName and the filters are used to build a key and determine a match in the cache
-     * @param datasetName
-     * @param itemFilters
-     * @param dataset
-     */
-    async CacheDataset(datasetName, itemFilters, dataset) {
-        const ls = this.LocalStorageProvider;
-        if (ls) {
-            const key = this.GetDatasetCacheKey(datasetName, itemFilters);
-            const val = JSON.stringify(dataset);
-            await ls.SetItem(key, val);
-            const dateKey = key + '_date';
-            const dateVal = dataset.LatestUpdateDate.toISOString();
-            await ls.SetItem(dateKey, dateVal);
-        }
-    }
-    /**
-     * Determines if a given datasetName/itemFilters combination is cached locally or not
-     * @param datasetName
-     * @param itemFilters
-     * @returns
-     */
-    async IsDatasetCached(datasetName, itemFilters) {
-        const ls = this.LocalStorageProvider;
-        if (ls) {
-            const key = this.GetDatasetCacheKey(datasetName, itemFilters);
-            const val = await ls.GetItem(key);
-            return val !== null && val !== undefined;
-        }
-    }
-    /**
-     * Creates a unique key for the given datasetName and itemFilters combination coupled with the instance connection string to ensure uniqueness when 2+ connections exist
-     * @param datasetName
-     * @param itemFilters
-     * @returns
-     */
-    GetDatasetCacheKey(datasetName, itemFilters) {
-        return (this.LocalStoragePrefix +
-            _a.localStorageRootKey +
-            this.InstanceConnectionString +
-            '__DATASET__' +
-            datasetName +
-            this.ConvertItemFiltersToUniqueKey(itemFilters));
-    }
-    /**
-     * Converts dataset item filters into a unique string key for caching.
-     * @param itemFilters - Array of filters to convert
-     * @returns JSON-formatted string representing the filters
-     */
-    ConvertItemFiltersToUniqueKey(itemFilters) {
-        if (itemFilters) {
-            const key = '{' + itemFilters.map((f) => `"${f.ItemCode}":"${f.Filter}"`).join(',') + '}'; // this is a unique key for the item filters
-            return key;
-        }
-        else
-            return '';
-    }
-    /**
-     * If the specified datasetName is cached, this method will clear the cache. If itemFilters are provided, the combination of datasetName and the filters are used to determine a match in the cache
-     * @param datasetName
-     * @param itemFilters
-     */
-    async ClearDatasetCache(datasetName, itemFilters) {
-        const ls = this.LocalStorageProvider;
-        if (ls) {
-            const key = this.GetDatasetCacheKey(datasetName, itemFilters);
-            await ls.Remove(key);
-            const dateKey = key + '_date';
-            await ls.Remove(dateKey);
-        }
-    }
-    /**
-     * Gets the latest metadata timestamps from the remote server.
-     * Used to determine if local cache is out of date.
-     * @returns Array of metadata timestamp information
-     */
-    get LatestRemoteMetadata() {
-        return this._latestRemoteMetadataTimestamps;
-    }
-    /**
-     * Gets the latest metadata timestamps from local cache.
-     * Used for comparison with remote timestamps.
-     * @returns Array of locally cached metadata timestamps
-     */
-    get LatestLocalMetadata() {
-        return this._latestLocalMetadataTimestamps;
-    }
-    /**
-     * Retrieves the latest metadata update timestamps from the server.
-     * @returns Array of metadata update information
-     */
-    async GetLatestMetadataUpdates(providerToUse) {
-        const f = this.BuildDatasetFilterFromConfig();
-        const d = await this.GetDatasetStatusByName(_a._mjMetadataDatasetName, f.length > 0 ? f : null, this.CurrentUser, providerToUse);
-        if (d && d.Success) {
-            const ret = d.EntityUpdateDates.map((e) => {
-                return {
-                    ID: e.EntityID,
-                    Type: e.EntityName,
-                    UpdatedAt: e.UpdateDate,
-                    RowCount: e.RowCount,
-                };
-            });
-            // combine the entityupdate dates with a single top level entry for the dataset itself
-            ret.push({
-                ID: '',
-                Type: 'All Entity Metadata',
-                UpdatedAt: d.LatestUpdateDate,
-                RowCount: d.EntityUpdateDates.reduce((a, b) => a + b.RowCount, 0),
-            });
-            return ret;
-        }
-    }
-    /**
-     * Refreshes the remote metadata timestamps from the server.
-     * Updates the internal cache of remote timestamps.
-     * @returns True if timestamps were successfully refreshed
-     */
-    async RefreshRemoteMetadataTimestamps(providerToUse) {
-        const mdTimeStamps = await this.GetLatestMetadataUpdates(providerToUse);
-        if (mdTimeStamps) {
-            this._latestRemoteMetadataTimestamps = mdTimeStamps;
-            return true;
-        }
-        else
-            return false;
-    }
-    /**
-     * Checks if local metadata is obsolete compared to remote metadata.
-     * Compares timestamps and row counts to detect changes.
-     * @param type - Optional specific metadata type to check
-     * @returns True if local metadata is out of date
-     */
-    LocalMetadataObsolete(type) {
-        const mdLocal = this.LatestLocalMetadata;
-        const mdRemote = this.LatestRemoteMetadata;
-        if (!mdLocal || !mdRemote || !mdLocal.length || !mdRemote.length || mdLocal.length === 0 || mdRemote.length === 0)
-            return true;
-        for (let i = 0; i < mdRemote.length; ++i) {
-            let bProcess = true;
-            if (type && type.length > 0)
-                bProcess = mdRemote[i].Type.toLowerCase().trim() === type.trim().toLowerCase();
-            if (bProcess) {
-                const l = mdLocal.find((md) => md.Type.trim().toLowerCase() === mdRemote[i].Type.trim().toLowerCase());
-                if (!l)
-                    return true; // no match, obsolete in this case
-                else {
-                    // we have a match, now test various things
-                    if (!l.UpdatedAt && !mdRemote[i].UpdatedAt) {
-                        // both are null, so we're good
-                        // do nothing, keep on truckin'
-                        // console.log('TEST: both are null, so we\'re good')
-                    }
-                    else if (l.UpdatedAt && mdRemote[i].UpdatedAt) {
-                        // both are not null, so we need to compare them
-                        const localTime = new Date(l.UpdatedAt);
-                        const remoteTime = new Date(mdRemote[i].UpdatedAt);
-                        if (localTime.getTime() !== remoteTime.getTime()) {
-                            return true; // we can short circuit the entire rest of the function
-                            // as one obsolete is good enough to obsolete the entire local metadata
-                        }
-                        else {
-                            // here we have a match for the local and remote timestamps, so we need to check the row counts
-                            // if the row counts are different, we're obsolete
-                            if (l.RowCount !== mdRemote[i].RowCount) {
-                                return true;
-                            }
-                        }
-                    }
-                    else
-                        return true; // one is null and the other is not, so we're obsolete without even comparing
-                }
-            }
-        }
-        // if we get here, we're not obsolete!!
-        return false;
-    }
-    /**
-     * Updates the local metadata cache with new data.
-     * @param res - The new metadata to store locally
-     */
-    UpdateLocalMetadata(res) {
-        this._localMetadata = res;
-    }
-    /**
-     * Loads metadata from local storage if available.
-     * Deserializes and reconstructs typed metadata objects.
-     */
-    async LoadLocalMetadataFromStorage() {
-        try {
-            const ls = this.LocalStorageProvider;
-            if (ls) {
-                // execution environment supports local storage, use it
-                this._latestLocalMetadataTimestamps = JSON.parse(await ls.GetItem(this.LocalStoragePrefix + _a.localStorageTimestampsKey));
-                const temp = JSON.parse(await ls.GetItem(this.LocalStoragePrefix + _a.localStorageAllMetadataKey)); // we now have a simple object for all the metadata
-                if (temp) {
-                    // we have local metadata
-                    (0, logging_1.LogStatus)('Metadata loaded from local storage');
-                    const metadata = MetadataFromSimpleObject(temp, this); // create a new object to start this up
-                    this.UpdateLocalMetadata(metadata);
-                }
-            }
-        }
-        catch (e) {
-            // some enviroments don't support local storage
-        }
-    }
-    /**
-     * This property will return the prefix to use for local storage keys. This is useful if you have multiple instances of a provider running in the same environment
-     * and you want to keep their local storage keys separate. The default implementation returns an empty string, but subclasses can override this to return a unique string
-     * based on the connection or other distinct identifier.
-     */
-    get LocalStoragePrefix() {
-        return '';
-    }
-    /**
-     * Saves current metadata to local storage for caching.
-     * Serializes both timestamps and full metadata collections.
-     */
-    async SaveLocalMetadataToStorage() {
-        try {
-            const ls = this.LocalStorageProvider;
-            if (ls) {
-                // execution environment supports local storage, use it
-                await ls.SetItem(this.LocalStoragePrefix + _a.localStorageTimestampsKey, JSON.stringify(this._latestLocalMetadataTimestamps));
-                // now persist the AllMetadata object
-                await ls.SetItem(this.LocalStoragePrefix + _a.localStorageAllMetadataKey, JSON.stringify(this._localMetadata));
-            }
-        }
-        catch (e) {
-            // some enviroments don't support local storage
-            (0, logging_1.LogError)(e);
-        }
-    }
-    /**
-     * Removes all cached metadata from local storage.
-     * Clears both timestamps and metadata collections.
-     */
-    async RemoveLocalMetadataFromStorage() {
-        try {
-            const ls = this.LocalStorageProvider;
-            for (let i = 0; i < _a.localStorageKeys.length; i++) {
-                await ls.Remove(this.LocalStoragePrefix + _a.localStorageKeys[i]);
-            }
-        }
-        catch (e) {
-            // some enviroments don't support local storage
-            (0, logging_1.LogError)(e);
-        }
-    }
-}
-exports.ProviderBase = ProviderBase;
-_a = ProviderBase;
-ProviderBase._mjMetadataDatasetName = 'MJ_Metadata';
-ProviderBase.localStorageRootKey = '___MJCore_Metadata';
-ProviderBase.localStorageTimestampsKey = _a.localStorageRootKey + '_Timestamps';
-ProviderBase.localStorageAllMetadataKey = _a.localStorageRootKey + '_AllMetadata';
-ProviderBase.localStorageKeys = [_a.localStorageTimestampsKey, _a.localStorageAllMetadataKey];
-//# sourceMappingURL=providerBase.js.map