@memberjunction/core 3.4.0 → 4.1.0

package/dist/generic/providerBase.js

@@ -1,22 +1,18 @@
-"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 localCacheManager_1 = require("./localCacheManager");
-const applicationInfo_1 = require("../generic/applicationInfo");
-const securityInfo_1 = require("./securityInfo");
-const global_1 = require("@memberjunction/global");
-const telemetryManager_1 = require("./telemetryManager");
-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");
+import { BaseEntity } from "./baseEntity.js";
+import { EntityDocumentTypeInfo, EntityInfo } from "./entityInfo.js";
+import { AllMetadata } from "./interfaces.js";
+import { LocalCacheManager } from "./localCacheManager.js";
+import { ApplicationInfo } from "../generic/applicationInfo.js";
+import { AuditLogTypeInfo, AuthorizationInfo, RoleInfo, RowLevelSecurityFilterInfo, UserInfo } from "./securityInfo.js";
+import { MJGlobal } from "@memberjunction/global";
+import { TelemetryManager } from "./telemetryManager.js";
+import { LogError, LogStatus, LogStatusEx } from "./logging.js";
+import { QueryCategoryInfo, QueryFieldInfo, QueryInfo, QueryPermissionInfo, QueryEntityInfo, QueryParameterInfo } from "./queryInfo.js";
+import { LibraryInfo } from "./libraryInfo.js";
+import { CompositeKey } from "./compositeKey.js";
+import { ExplorerNavigationItem } from "./explorerNavigationItem.js";
+import { Metadata } from "./metadata.js";
+import { RunView } from "../views/runView.js";
 /**
  * Creates a new instance of AllMetadata from a simple object.
  * Handles deserialization and proper instantiation of all metadata classes.
@@ -24,17 +20,16 @@ const runView_1 = require("../views/runView");
  * @param md - The metadata provider for context
  * @returns A fully populated AllMetadata instance with proper type instances
  */
-function MetadataFromSimpleObject(data, md) {
+export function MetadataFromSimpleObject(data, md) {
     try {
         const newObject = MetadataFromSimpleObjectWithoutUser(data, md);
-        newObject.CurrentUser = data.CurrentUser ? new securityInfo_1.UserInfo(md, data.CurrentUser) : null;
+        newObject.CurrentUser = data.CurrentUser ? new UserInfo(md, data.CurrentUser) : null;
         return newObject;
     }
     catch (e) {
-        (0, logging_1.LogError)(e);
+        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.
@@ -42,11 +37,11 @@ exports.MetadataFromSimpleObject = MetadataFromSimpleObject;
  * @param md - The metadata provider for context
  * @returns A fully populated AllMetadata instance with proper type instances
  */
-function MetadataFromSimpleObjectWithoutUser(data, md) {
+export function MetadataFromSimpleObjectWithoutUser(data, md) {
     try {
-        const returnMetadata = new interfaces_1.AllMetadata();
+        const returnMetadata = new AllMetadata();
         // now iterate through the AllMetadataMapping array and construct the return type
-        for (let m of exports.AllMetadataArrays) {
+        for (let m of AllMetadataArrays) {
             let simpleKey = m.key;
             if (!data.hasOwnProperty(simpleKey)) {
                 simpleKey = simpleKey.substring(3); // remove the All prefix
@@ -62,44 +57,164 @@ function MetadataFromSimpleObjectWithoutUser(data, md) {
         return returnMetadata;
     }
     catch (e) {
-        (0, logging_1.LogError)(e);
+        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 }
+export const AllMetadataArrays = [
+    { key: 'AllEntities', class: EntityInfo },
+    { key: 'AllApplications', class: ApplicationInfo },
+    { key: 'AllRoles', class: RoleInfo },
+    { key: 'AllRowLevelSecurityFilters', class: RowLevelSecurityFilterInfo },
+    { key: 'AllAuditLogTypes', class: AuditLogTypeInfo },
+    { key: 'AllAuthorizations', class: AuthorizationInfo },
+    { key: 'AllQueryCategories', class: QueryCategoryInfo },
+    { key: 'AllQueries', class: QueryInfo },
+    { key: 'AllQueryFields', class: QueryFieldInfo },
+    { key: 'AllQueryPermissions', class: QueryPermissionInfo },
+    { key: 'AllQueryEntities', class: QueryEntityInfo },
+    { key: 'AllQueryParameters', class: QueryParameterInfo },
+    { key: 'AllEntityDocumentTypes', class: EntityDocumentTypeInfo },
+    { key: 'AllLibraries', class: LibraryInfo },
+    { key: 'AllExplorerNavigationItems', class: 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 {
+export class ProviderBase {
     constructor() {
-        this._localMetadata = new interfaces_1.AllMetadata();
+        this._localMetadata = new AllMetadata();
+        this._entityRecordNameCache = new Map();
         this._refresh = false;
         this._cachedVisibleExplorerNavigationItems = null;
     }
+    /**
+     * Helper to generate cache key for entity record names
+     */
+    getCacheKey(entityName, compositeKey) {
+        return `${entityName}|${compositeKey.ToString()}`;
+    }
+    /**
+     * Asynchronous lookup of a cached entity record name. Returns the cached name if available, or undefined if not cached.
+     * Use this for synchronous contexts (like template rendering) where you can't await GetEntityRecordName().
+     * @param entityName - The name of the entity
+     * @param compositeKey - The primary key value(s) for the record
+     * @param loadIfNeeded - If set to true, will load from database if not already cached
+     * @returns The cached display name, or undefined if not in cache
+     */
+    async GetCachedRecordName(entityName, compositeKey, loadIfNeeded) {
+        let cachedEntry = this._entityRecordNameCache.get(this.getCacheKey(entityName, compositeKey));
+        if (!cachedEntry && loadIfNeeded) {
+            cachedEntry = await this.GetEntityRecordName(entityName, compositeKey);
+        }
+        return cachedEntry;
+    }
+    /**
+     * Stores a record name in the cache for later synchronous retrieval via GetCachedRecordName().
+     * Called automatically by BaseEntity after Load(), LoadFromData(), and Save() operations.
+     * @param entityName - The name of the entity
+     * @param compositeKey - The primary key value(s) for the record
+     * @param recordName - The display name to cache
+     */
+    SetCachedRecordName(entityName, compositeKey, recordName) {
+        this._entityRecordNameCache.set(this.getCacheKey(entityName, compositeKey), recordName);
+    }
+    /**
+     * Gets the display name for a single entity record with caching.
+     * Uses the entity's IsNameField or falls back to 'Name' field if available.
+     * @param entityName - The name of the entity
+     * @param compositeKey - The primary key value(s) for the record
+     * @param contextUser - Optional user context for permissions
+     * @param forceRefresh - If true, bypasses cache and queries database
+     * @returns The display name of the record or null if not found
+     */
+    async GetEntityRecordName(entityName, compositeKey, contextUser, forceRefresh = false) {
+        const cacheKey = this.getCacheKey(entityName, compositeKey);
+        // Check cache unless forceRefresh
+        if (!forceRefresh) {
+            const cached = this._entityRecordNameCache.get(cacheKey);
+            if (cached !== undefined) {
+                return cached;
+            }
+        }
+        // Fetch from database via provider-specific implementation
+        const name = await this.InternalGetEntityRecordName(entityName, compositeKey, contextUser);
+        if (name) {
+            this._entityRecordNameCache.set(cacheKey, name);
+        }
+        return name;
+    }
+    /**
+     * Gets display names for multiple entity records in a single operation with caching.
+     * More efficient than multiple GetEntityRecordName calls.
+     * @param info - Array of entity/key pairs to lookup
+     * @param contextUser - Optional user context for permissions
+     * @param forceRefresh - If true, bypasses cache and queries database for all records
+     * @returns Array of results with names and status for each requested record
+     */
+    async GetEntityRecordNames(info, contextUser, forceRefresh = false) {
+        if (!forceRefresh) {
+            // Check cache for each item, collect uncached items
+            const results = [];
+            const uncachedInfo = [];
+            const uncachedIndexes = [];
+            for (let i = 0; i < info.length; i++) {
+                const item = info[i];
+                const cacheKey = this.getCacheKey(item.EntityName, item.CompositeKey);
+                const cached = this._entityRecordNameCache.get(cacheKey);
+                if (cached !== undefined) {
+                    // Cache hit
+                    results[i] = {
+                        EntityName: item.EntityName,
+                        CompositeKey: item.CompositeKey,
+                        Status: 'cached',
+                        Success: true,
+                        RecordName: cached
+                    };
+                }
+                else {
+                    // Cache miss - need to fetch
+                    uncachedInfo.push(item);
+                    uncachedIndexes.push(i);
+                }
+            }
+            // Fetch uncached items from database
+            if (uncachedInfo.length > 0) {
+                const uncachedResults = await this.InternalGetEntityRecordNames(uncachedInfo, contextUser);
+                // Merge results and update cache
+                for (let i = 0; i < uncachedResults.length; i++) {
+                    const result = uncachedResults[i];
+                    const originalIndex = uncachedIndexes[i];
+                    results[originalIndex] = result;
+                    // Cache successful results
+                    if (result.Success && result.RecordName) {
+                        const cacheKey = this.getCacheKey(result.EntityName, result.CompositeKey);
+                        this._entityRecordNameCache.set(cacheKey, result.RecordName);
+                    }
+                }
+            }
+            return results;
+        }
+        else {
+            // Force refresh - bypass cache entirely
+            const results = await this.InternalGetEntityRecordNames(info, contextUser);
+            // Update cache with fresh results
+            for (const result of results) {
+                if (result.Success && result.RecordName) {
+                    const cacheKey = this.getCacheKey(result.EntityName, result.CompositeKey);
+                    this._entityRecordNameCache.set(cacheKey, result.RecordName);
+                }
+            }
+            return results;
+        }
+    }
     // ========================================================================
     // PUBLIC API METHODS - Orchestrate Pre → Cache → Internal → Post flow
     // ========================================================================
@@ -135,7 +250,7 @@ class ProviderBase {
         // Check for cached results - if all are cached, end telemetry and return early
         if (preResult.allCached && preResult.cachedResults) {
             const totalResults = preResult.cachedResults.reduce((sum, r) => sum + (r.Results?.length ?? 0), 0);
-            telemetryManager_1.TelemetryManager.Instance.EndEvent(preResult.telemetryEventId, {
+            TelemetryManager.Instance.EndEvent(preResult.telemetryEventId, {
                 cacheHit: true,
                 allCached: true,
                 batchSize: params.length,
@@ -166,7 +281,7 @@ class ProviderBase {
         const preResult = await this.PreRunQuery(params, contextUser);
         // Check for cached result - end telemetry with cache hit info
         if (preResult.cachedResult) {
-            telemetryManager_1.TelemetryManager.Instance.EndEvent(preResult.telemetryEventId, {
+            TelemetryManager.Instance.EndEvent(preResult.telemetryEventId, {
                 cacheHit: true,
                 cacheStatus: preResult.cacheStatus,
                 resultCount: preResult.cachedResult.Results?.length ?? 0
@@ -192,7 +307,7 @@ class ProviderBase {
         // Check for cached results - if all are cached, end telemetry and return early
         if (preResult.allCached && preResult.cachedResults) {
             const totalResults = preResult.cachedResults.reduce((sum, r) => sum + (r.Results?.length ?? 0), 0);
-            telemetryManager_1.TelemetryManager.Instance.EndEvent(preResult.telemetryEventId, {
+            TelemetryManager.Instance.EndEvent(preResult.telemetryEventId, {
                 cacheHit: true,
                 allCached: true,
                 batchSize: params.length,
@@ -218,12 +333,12 @@ class ProviderBase {
      * @param callerName
      */
     async EntityStatusCheck(params, callerName) {
-        const entityName = await runView_1.RunView.GetEntityNameFromRunViewParams(params, this);
+        const entityName = await 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);
+        EntityInfo.AssertEntityActiveStatus(entity, callerName);
     }
     // Type aliases for cleaner code
     get PreRunViewResult() { return this._preRunViewResultType; }
@@ -244,7 +359,7 @@ class ProviderBase {
         const preViewStart = performance.now();
         // Start telemetry tracking
         const telemetryStart = performance.now();
-        const telemetryEventId = telemetryManager_1.TelemetryManager.Instance.StartEvent('RunView', 'ProviderBase.RunView', {
+        const telemetryEventId = TelemetryManager.Instance.StartEvent('RunView', 'ProviderBase.RunView', {
             EntityName: params.EntityName,
             ViewID: params.ViewID,
             ViewName: params.ViewName,
@@ -275,9 +390,9 @@ class ProviderBase {
         let cacheStatus = 'disabled';
         let cachedResult;
         let fingerprint;
-        if (params.CacheLocal && localCacheManager_1.LocalCacheManager.Instance.IsInitialized) {
-            fingerprint = localCacheManager_1.LocalCacheManager.Instance.GenerateRunViewFingerprint(params, this.InstanceConnectionString);
-            const cached = await localCacheManager_1.LocalCacheManager.Instance.GetRunViewResult(fingerprint);
+        if (params.CacheLocal && LocalCacheManager.Instance.IsInitialized) {
+            fingerprint = LocalCacheManager.Instance.GenerateRunViewFingerprint(params, this.InstanceConnectionString);
+            const cached = await LocalCacheManager.Instance.GetRunViewResult(fingerprint);
             if (cached) {
                 // Reconstruct RunViewResult from cached data
                 cachedResult = {
@@ -299,7 +414,7 @@ class ProviderBase {
         const cacheCheckTime = performance.now() - cacheCheckStart;
         const totalPreTime = performance.now() - preViewStart;
         if (totalPreTime > 50) {
-            console.log(`[PERF-PRE] PreRunView ${params.EntityName}: ${totalPreTime.toFixed(1)}ms (telemetry=${telemetryTime.toFixed(1)}ms, entityCheck=${entityCheckTime.toFixed(1)}ms, entityLookup=${entityLookupTime.toFixed(1)}ms, cache=${cacheCheckTime.toFixed(1)}ms)`);
+            LogStatus(`[PERF-PRE] PreRunView ${params.EntityName}: ${totalPreTime.toFixed(1)}ms (telemetry=${telemetryTime.toFixed(1)}ms, entityCheck=${entityCheckTime.toFixed(1)}ms, entityLookup=${entityLookupTime.toFixed(1)}ms, cache=${cacheCheckTime.toFixed(1)}ms)`);
         }
         return {
             telemetryEventId,
@@ -318,7 +433,7 @@ class ProviderBase {
     async PreRunViews(params, contextUser) {
         // Start telemetry tracking for batch operation
         const fromEngine = params.some(p => p._fromEngine);
-        const telemetryEventId = telemetryManager_1.TelemetryManager.Instance.StartEvent('RunView', 'ProviderBase.RunViews', {
+        const telemetryEventId = TelemetryManager.Instance.StartEvent('RunView', 'ProviderBase.RunViews', {
             BatchSize: params.length,
             Entities: params.map(p => p.EntityName || p.ViewName || p.ViewID).filter(Boolean),
             _fromEngine: fromEngine
@@ -326,7 +441,7 @@ class ProviderBase {
         // Check if any params have CacheLocal enabled - smart caching is always used when caching locally
         const useSmartCacheCheck = params.some(p => p.CacheLocal);
         // If local caching is enabled, use smart cache check flow
-        if (useSmartCacheCheck && localCacheManager_1.LocalCacheManager.Instance.IsInitialized) {
+        if (useSmartCacheCheck && LocalCacheManager.Instance.IsInitialized) {
             return this.prepareSmartCacheCheckParams(params, telemetryEventId, contextUser);
         }
         // Traditional caching flow
@@ -347,9 +462,9 @@ class ProviderBase {
                 param.Fields = entity.Fields.map(f => f.Name);
             }
             // Check local cache if enabled
-            if (param.CacheLocal && localCacheManager_1.LocalCacheManager.Instance.IsInitialized) {
-                const fingerprint = localCacheManager_1.LocalCacheManager.Instance.GenerateRunViewFingerprint(param, this.InstanceConnectionString);
-                const cached = await localCacheManager_1.LocalCacheManager.Instance.GetRunViewResult(fingerprint);
+            if (param.CacheLocal && LocalCacheManager.Instance.IsInitialized) {
+                const fingerprint = LocalCacheManager.Instance.GenerateRunViewFingerprint(param, this.InstanceConnectionString);
+                const cached = await LocalCacheManager.Instance.GetRunViewResult(fingerprint);
                 if (cached) {
                     const cachedViewResult = {
                         Success: true,
@@ -404,9 +519,9 @@ class ProviderBase {
             }
             // Build the cache check param with optional cache status
             let cacheStatus;
-            if (param.CacheLocal && localCacheManager_1.LocalCacheManager.Instance.IsInitialized) {
-                const fingerprint = localCacheManager_1.LocalCacheManager.Instance.GenerateRunViewFingerprint(param, this.InstanceConnectionString);
-                const cached = await localCacheManager_1.LocalCacheManager.Instance.GetRunViewResult(fingerprint);
+            if (param.CacheLocal && LocalCacheManager.Instance.IsInitialized) {
+                const fingerprint = LocalCacheManager.Instance.GenerateRunViewFingerprint(param, this.InstanceConnectionString);
+                const cached = await LocalCacheManager.Instance.GetRunViewResult(fingerprint);
                 if (cached) {
                     cacheStatus = {
                         maxUpdatedAt: cached.maxUpdatedAt,
@@ -442,8 +557,8 @@ class ProviderBase {
         const response = await provider.RunViewsWithCacheCheck(preResult.smartCacheCheckParams, contextUser);
         if (!response.success) {
             // If the smart cache check failed, log and return empty results
-            (0, logging_1.LogError)(`SmartCacheCheck failed: ${response.errorMessage}`);
-            telemetryManager_1.TelemetryManager.Instance.EndEvent(preResult.telemetryEventId, {
+            LogError(`SmartCacheCheck failed: ${response.errorMessage}`);
+            TelemetryManager.Instance.EndEvent(preResult.telemetryEventId, {
                 smartCacheCheck: true,
                 success: false,
                 errorMessage: response.errorMessage
@@ -471,7 +586,7 @@ class ProviderBase {
                 cacheMisses++;
         }
         // End telemetry
-        telemetryManager_1.TelemetryManager.Instance.EndEvent(preResult.telemetryEventId, {
+        TelemetryManager.Instance.EndEvent(preResult.telemetryEventId, {
             smartCacheCheck: true,
             success: true,
             cacheHits,
@@ -503,8 +618,8 @@ class ProviderBase {
         }
         if (checkResult.status === 'current') {
             // Cache is current - use cached data
-            const fingerprint = localCacheManager_1.LocalCacheManager.Instance.GenerateRunViewFingerprint(param, this.InstanceConnectionString);
-            const cached = await localCacheManager_1.LocalCacheManager.Instance.GetRunViewResult(fingerprint);
+            const fingerprint = LocalCacheManager.Instance.GenerateRunViewFingerprint(param, this.InstanceConnectionString);
+            const cached = await LocalCacheManager.Instance.GetRunViewResult(fingerprint);
             if (cached) {
                 const cachedResult = {
                     Success: true,
@@ -539,13 +654,13 @@ class ProviderBase {
         }
         else if (checkResult.status === 'differential') {
             // Cache is stale but we have differential data - merge with cached data
-            const fingerprint = localCacheManager_1.LocalCacheManager.Instance.GenerateRunViewFingerprint(param, this.InstanceConnectionString);
+            const fingerprint = LocalCacheManager.Instance.GenerateRunViewFingerprint(param, this.InstanceConnectionString);
             // Get entity info for primary key field name
             const entity = this.Entities.find(e => e.Name.trim().toLowerCase() === param.EntityName?.trim().toLowerCase());
             const primaryKeyFieldName = entity?.FirstPrimaryKey?.Name || 'ID';
             // Apply differential update to cache
-            if (param.CacheLocal && checkResult.differentialData && localCacheManager_1.LocalCacheManager.Instance.IsInitialized) {
-                const merged = await localCacheManager_1.LocalCacheManager.Instance.ApplyDifferentialUpdate(fingerprint, param, checkResult.differentialData.updatedRows, checkResult.differentialData.deletedRecordIDs, primaryKeyFieldName, checkResult.maxUpdatedAt || new Date().toISOString(), checkResult.rowCount || 0, checkResult.aggregateResults // Pass fresh aggregate results (can't be differentially computed)
+            if (param.CacheLocal && checkResult.differentialData && LocalCacheManager.Instance.IsInitialized) {
+                const merged = await LocalCacheManager.Instance.ApplyDifferentialUpdate(fingerprint, param, checkResult.differentialData.updatedRows, checkResult.differentialData.deletedRecordIDs, primaryKeyFieldName, checkResult.maxUpdatedAt || new Date().toISOString(), checkResult.rowCount || 0, checkResult.aggregateResults // Pass fresh aggregate results (can't be differentially computed)
                 );
                 if (merged) {
                     const mergedResult = {
@@ -584,12 +699,12 @@ class ProviderBase {
                 AggregateResults: checkResult.aggregateResults // Include fresh aggregate results
             };
             // Update the local cache with fresh data (don't await - fire and forget for performance)
-            if (param.CacheLocal && checkResult.maxUpdatedAt && localCacheManager_1.LocalCacheManager.Instance.IsInitialized) {
-                const fingerprint = localCacheManager_1.LocalCacheManager.Instance.GenerateRunViewFingerprint(param, this.InstanceConnectionString);
+            if (param.CacheLocal && checkResult.maxUpdatedAt && LocalCacheManager.Instance.IsInitialized) {
+                const fingerprint = LocalCacheManager.Instance.GenerateRunViewFingerprint(param, this.InstanceConnectionString);
                 // Note: We don't await here to avoid blocking the response
                 // Cache update happens in background
-                localCacheManager_1.LocalCacheManager.Instance.SetRunViewResult(fingerprint, param, checkResult.results || [], checkResult.maxUpdatedAt, checkResult.aggregateResults // Include aggregate results in cache
-                ).catch(e => (0, logging_1.LogError)(`Failed to update cache: ${e}`));
+                LocalCacheManager.Instance.SetRunViewResult(fingerprint, param, checkResult.results || [], checkResult.maxUpdatedAt, checkResult.aggregateResults // Include aggregate results in cache
+                ).catch(e => LogError(`Failed to update cache: ${e}`));
             }
             // Transform to entity objects if needed
             await this.TransformSimpleObjectToEntityObject(param, freshResult, contextUser);
@@ -621,7 +736,7 @@ class ProviderBase {
      */
     async PreRunQuery(params, contextUser) {
         // Start telemetry tracking
-        const telemetryEventId = telemetryManager_1.TelemetryManager.Instance.StartEvent('RunQuery', 'ProviderBase.RunQuery', {
+        const telemetryEventId = TelemetryManager.Instance.StartEvent('RunQuery', 'ProviderBase.RunQuery', {
             QueryID: params.QueryID,
             QueryName: params.QueryName,
             CategoryPath: params.CategoryPath,
@@ -648,7 +763,7 @@ class ProviderBase {
      */
     async PreRunQueries(params, contextUser) {
         // Start telemetry tracking for batch operation
-        const telemetryEventId = telemetryManager_1.TelemetryManager.Instance.StartEvent('RunQuery', 'ProviderBase.RunQueries', {
+        const telemetryEventId = TelemetryManager.Instance.StartEvent('RunQuery', 'ProviderBase.RunQueries', {
             BatchSize: params.length,
             Queries: params.map(p => p.QueryName || p.QueryID).filter(Boolean)
         }, contextUser?.ID);
@@ -676,15 +791,15 @@ class ProviderBase {
         // Transform the result set into BaseEntity-derived objects, if needed
         await this.TransformSimpleObjectToEntityObject(params, result, contextUser);
         // Store in local cache if enabled and we have a successful result
-        if (params.CacheLocal && result.Success && preResult.fingerprint && localCacheManager_1.LocalCacheManager.Instance.IsInitialized) {
+        if (params.CacheLocal && result.Success && preResult.fingerprint && LocalCacheManager.Instance.IsInitialized) {
             // Extract maxUpdatedAt from results if available
             const maxUpdatedAt = this.extractMaxUpdatedAt(result.Results);
-            await localCacheManager_1.LocalCacheManager.Instance.SetRunViewResult(preResult.fingerprint, params, result.Results, maxUpdatedAt, result.AggregateResults // Include aggregate results in cache
+            await LocalCacheManager.Instance.SetRunViewResult(preResult.fingerprint, params, result.Results, maxUpdatedAt, result.AggregateResults // Include aggregate results in cache
             );
         }
         // End telemetry tracking with cache miss info
         if (preResult.telemetryEventId) {
-            telemetryManager_1.TelemetryManager.Instance.EndEvent(preResult.telemetryEventId, {
+            TelemetryManager.Instance.EndEvent(preResult.telemetryEventId, {
                 cacheHit: false,
                 cacheStatus: preResult.cacheStatus,
                 resultCount: result.Results?.length ?? 0,
@@ -706,10 +821,10 @@ class ProviderBase {
         for (let i = 0; i < results.length; i++) {
             promises.push(this.TransformSimpleObjectToEntityObject(params[i], results[i], contextUser));
             // Store in local cache if enabled
-            if (params[i].CacheLocal && results[i].Success && localCacheManager_1.LocalCacheManager.Instance.IsInitialized) {
-                const fingerprint = localCacheManager_1.LocalCacheManager.Instance.GenerateRunViewFingerprint(params[i], this.InstanceConnectionString);
+            if (params[i].CacheLocal && results[i].Success && LocalCacheManager.Instance.IsInitialized) {
+                const fingerprint = LocalCacheManager.Instance.GenerateRunViewFingerprint(params[i], this.InstanceConnectionString);
                 const maxUpdatedAt = this.extractMaxUpdatedAt(results[i].Results);
-                promises.push(localCacheManager_1.LocalCacheManager.Instance.SetRunViewResult(fingerprint, params[i], results[i].Results, maxUpdatedAt, results[i].AggregateResults // Include aggregate results in cache
+                promises.push(LocalCacheManager.Instance.SetRunViewResult(fingerprint, params[i], results[i].Results, maxUpdatedAt, results[i].AggregateResults // Include aggregate results in cache
                 ));
             }
         }
@@ -720,7 +835,7 @@ class ProviderBase {
             const cachedCount = preResult.cacheStatusMap
                 ? [...preResult.cacheStatusMap.values()].filter(s => s.status === 'hit').length
                 : 0;
-            telemetryManager_1.TelemetryManager.Instance.EndEvent(preResult.telemetryEventId, {
+            TelemetryManager.Instance.EndEvent(preResult.telemetryEventId, {
                 cacheHit: false,
                 allCached: false,
                 batchSize: params.length,
@@ -742,7 +857,7 @@ class ProviderBase {
         // Query caching is handled internally by the provider
         // End telemetry tracking with cache miss info
         if (preResult.telemetryEventId) {
-            telemetryManager_1.TelemetryManager.Instance.EndEvent(preResult.telemetryEventId, {
+            TelemetryManager.Instance.EndEvent(preResult.telemetryEventId, {
                 cacheHit: false,
                 cacheStatus: preResult.cacheStatus,
                 resultCount: result.Results?.length ?? 0,
@@ -766,7 +881,7 @@ class ProviderBase {
             const cachedCount = preResult.cacheStatusMap
                 ? [...preResult.cacheStatusMap.values()].filter(s => s.status === 'hit').length
                 : 0;
-            telemetryManager_1.TelemetryManager.Instance.EndEvent(preResult.telemetryEventId, {
+            TelemetryManager.Instance.EndEvent(preResult.telemetryEventId, {
                 cacheHit: false,
                 allCached: false,
                 batchSize: params.length,
@@ -856,7 +971,7 @@ class ProviderBase {
      */
     async PreProcessRunView(params, contextUser) {
         // Start telemetry tracking
-        const eventId = telemetryManager_1.TelemetryManager.Instance.StartEvent('RunView', 'ProviderBase.RunView', {
+        const eventId = TelemetryManager.Instance.StartEvent('RunView', 'ProviderBase.RunView', {
             EntityName: params.EntityName,
             ViewID: params.ViewID,
             ViewName: params.ViewName,
@@ -892,7 +1007,7 @@ class ProviderBase {
         // End telemetry tracking
         const eventId = params._telemetryEventId;
         if (eventId) {
-            telemetryManager_1.TelemetryManager.Instance.EndEvent(eventId);
+            TelemetryManager.Instance.EndEvent(eventId);
             delete params._telemetryEventId;
         }
     }
@@ -906,7 +1021,7 @@ class ProviderBase {
     async PreProcessRunViews(params, contextUser) {
         // Start telemetry tracking for batch operation
         const fromEngine = params.some(p => p._fromEngine);
-        const eventId = telemetryManager_1.TelemetryManager.Instance.StartEvent('RunView', 'ProviderBase.RunViews', {
+        const eventId = TelemetryManager.Instance.StartEvent('RunView', 'ProviderBase.RunViews', {
             BatchSize: params.length,
             Entities: params.map(p => p.EntityName || p.ViewName || p.ViewID).filter(Boolean),
             _fromEngine: fromEngine
@@ -950,7 +1065,7 @@ class ProviderBase {
             // End telemetry tracking for batch operation
             const eventId = params[0]._telemetryBatchEventId;
             if (eventId) {
-                telemetryManager_1.TelemetryManager.Instance.EndEvent(eventId);
+                TelemetryManager.Instance.EndEvent(eventId);
                 delete params[0]._telemetryBatchEventId;
             }
         }
@@ -967,7 +1082,7 @@ class ProviderBase {
             // 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')) {
+                if (item instanceof 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;
@@ -998,7 +1113,7 @@ class ProviderBase {
         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) {
+        if (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()) {
@@ -1015,7 +1130,7 @@ class ProviderBase {
             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`);
+            LogStatusEx({ message: `GetAllMetadata() took ${end - start} ms`, verboseOnly: true });
             if (res) {
                 // Atomic swap via UpdateLocalMetadata: single property assignment is atomic in JavaScript
                 // Readers now see new metadata instead of old
@@ -1027,7 +1142,7 @@ class ProviderBase {
             }
             else {
                 // GetAllMetadata failed - log error but keep existing metadata
-                (0, logging_1.LogError)('GetAllMetadata() returned undefined - metadata not updated');
+                LogError('GetAllMetadata() returned undefined - metadata not updated');
             }
         }
         return true;
@@ -1046,14 +1161,14 @@ class ProviderBase {
      */
     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);
+            if (Metadata.Provider && Metadata.Provider !== this && Metadata.Provider.AllMetadata) {
+                this._localMetadata = this.CloneAllMetadata(Metadata.Provider.AllMetadata);
                 return true;
             }
             return false;
         }
         catch (e) {
-            (0, logging_1.LogError)(`Failed to copy metadata from global provider: ${e.message}`);
+            LogError(`Failed to copy metadata from global provider: ${e.message}`);
             return false; // if we fail to copy the metadata, we will return false
         }
     }
@@ -1077,7 +1192,7 @@ class ProviderBase {
         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`);
+            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) {
@@ -1092,6 +1207,7 @@ class ProviderBase {
         }
         return f;
     }
+    static { this._mjMetadataDatasetName = 'MJ_Metadata'; }
     /**
      * Retrieves all metadata from the server and constructs typed instances.
      * Uses the MJ_Metadata dataset for efficient bulk loading.
@@ -1103,10 +1219,10 @@ class ProviderBase {
             //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);
+            const d = await this.GetDatasetByName(ProviderBase._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);
+                await this.CacheDataset(ProviderBase._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) {
@@ -1118,7 +1234,7 @@ class ProviderBase {
                 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);
+                    return new 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
@@ -1129,11 +1245,11 @@ class ProviderBase {
                 return returnMetadata;
             }
             else {
-                (0, logging_1.LogError)('GetAllMetadata() - Error getting metadata from server' + (d ? ': ' + d.Status : ''));
+                LogError('GetAllMetadata() - Error getting metadata from server' + (d ? ': ' + d.Status : ''));
             }
         }
         catch (e) {
-            (0, logging_1.LogError)(e);
+            LogError(e);
         }
     }
     /**
@@ -1162,7 +1278,7 @@ class ProviderBase {
             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));
+            result.push(new EntityInfo(e));
         }
         return result;
     }
@@ -1333,7 +1449,7 @@ class ProviderBase {
             // Determine which overload was called
             let actualLoadKey;
             let actualContextUser;
-            if (loadKeyOrContextUser instanceof compositeKey_1.CompositeKey) {
+            if (loadKeyOrContextUser instanceof CompositeKey) {
                 // Second overload: entityName, loadKey, contextUser
                 actualLoadKey = loadKeyOrContextUser;
                 actualContextUser = contextUser;
@@ -1352,8 +1468,10 @@ class ProviderBase {
                 // 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);
+                    const newObject = MJGlobal.Instance.ClassFactory.CreateInstance(BaseEntity, entityName, entity, this);
                     await newObject.Config(actualContextUser);
+                    // Initialize IS-A parent entity composition chain before any data operations
+                    await newObject.InitializeParentEntity();
                     if (actualLoadKey) {
                         // Load existing record
                         const loadResult = await newObject.InnerLoad(actualLoadKey);
@@ -1369,7 +1487,7 @@ class ProviderBase {
                     return newObject;
                 }
                 catch (e) {
-                    (0, logging_1.LogError)(e);
+                    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!`);
                 }
             }
@@ -1377,7 +1495,7 @@ class ProviderBase {
                 throw new Error(`Entity ${entityName} not found in metadata`);
         }
         catch (ex) {
-            (0, logging_1.LogError)(ex);
+            LogError(ex);
             return null;
         }
     }
@@ -1406,7 +1524,7 @@ class ProviderBase {
             return result;
         }
         catch (e) {
-            (0, logging_1.LogError)(e);
+            LogError(e);
             throw e;
         }
     }
@@ -1557,7 +1675,7 @@ class ProviderBase {
      * @returns
      */
     GetDatasetCacheKey(datasetName, itemFilters) {
-        return this.LocalStoragePrefix + _a.localStorageRootKey + this.InstanceConnectionString + '__DATASET__' + datasetName + this.ConvertItemFiltersToUniqueKey(itemFilters);
+        return this.LocalStoragePrefix + ProviderBase.localStorageRootKey + this.InstanceConnectionString + '__DATASET__' + datasetName + this.ConvertItemFiltersToUniqueKey(itemFilters);
     }
     /**
      * Converts dataset item filters into a unique string key for caching.
@@ -1608,7 +1726,7 @@ class ProviderBase {
      */
     async GetLatestMetadataUpdates(providerToUse) {
         const f = this.BuildDatasetFilterFromConfig();
-        const d = await this.GetDatasetStatusByName(_a._mjMetadataDatasetName, f.length > 0 ? f : null, this.CurrentUser, providerToUse);
+        const d = await this.GetDatasetStatusByName(ProviderBase._mjMetadataDatasetName, f.length > 0 ? f : null, this.CurrentUser, providerToUse);
         if (d && d.Success) {
             const ret = d.EntityUpdateDates.map(e => {
                 return {
@@ -1699,6 +1817,14 @@ class ProviderBase {
     UpdateLocalMetadata(res) {
         this._localMetadata = res;
     }
+    /**
+     * Returns the filesystem provider for the current environment.
+     * Default implementation returns null (no filesystem access).
+     * Server-side providers should override this to return a NodeFileSystemProvider.
+     */
+    get FileSystemProvider() {
+        return null;
+    }
     /**
      * Loads metadata from local storage if available.
      * Deserializes and reconstructs typed metadata objects.
@@ -1708,8 +1834,8 @@ class ProviderBase {
             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
+                this._latestLocalMetadataTimestamps = JSON.parse(await ls.GetItem(this.LocalStoragePrefix + ProviderBase.localStorageTimestampsKey));
+                const temp = JSON.parse(await ls.GetItem(this.LocalStoragePrefix + ProviderBase.localStorageAllMetadataKey)); // we now have a simple object for all the metadata
                 if (temp) {
                     // we have local metadata
                     const metadata = MetadataFromSimpleObject(temp, this); // create a new object to start this up
@@ -1721,6 +1847,13 @@ class ProviderBase {
             // some enviroments don't support local storage
         }
     }
+    static { this.localStorageRootKey = '___MJCore_Metadata'; }
+    static { this.localStorageTimestampsKey = this.localStorageRootKey + '_Timestamps'; }
+    static { this.localStorageAllMetadataKey = this.localStorageRootKey + '_AllMetadata'; }
+    static { this.localStorageKeys = [
+        ProviderBase.localStorageTimestampsKey,
+        ProviderBase.localStorageAllMetadataKey,
+    ]; }
     /**
      * 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
@@ -1738,14 +1871,14 @@ class ProviderBase {
             const ls = this.LocalStorageProvider;
             if (ls) {
                 // execution environment supports local storage, use it
-                await ls.SetItem(this.LocalStoragePrefix + _a.localStorageTimestampsKey, JSON.stringify(this._latestLocalMetadataTimestamps));
+                await ls.SetItem(this.LocalStoragePrefix + ProviderBase.localStorageTimestampsKey, JSON.stringify(this._latestLocalMetadataTimestamps));
                 // now persist the AllMetadata object
-                await ls.SetItem(this.LocalStoragePrefix + _a.localStorageAllMetadataKey, JSON.stringify(this._localMetadata));
+                await ls.SetItem(this.LocalStoragePrefix + ProviderBase.localStorageAllMetadataKey, JSON.stringify(this._localMetadata));
             }
         }
         catch (e) {
             // some enviroments don't support local storage
-            (0, logging_1.LogError)(e);
+            LogError(e);
         }
     }
     /**
@@ -1755,24 +1888,14 @@ class ProviderBase {
     async RemoveLocalMetadataFromStorage() {
         try {
             const ls = this.LocalStorageProvider;
-            for (let i = 0; i < _a.localStorageKeys.length; i++) {
-                await ls.Remove(this.LocalStoragePrefix + _a.localStorageKeys[i]);
+            for (let i = 0; i < ProviderBase.localStorageKeys.length; i++) {
+                await ls.Remove(this.LocalStoragePrefix + ProviderBase.localStorageKeys[i]);
             }
         }
         catch (e) {
             // some enviroments don't support local storage
-            (0, logging_1.LogError)(e);
+            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