@memberjunction/core 6.2.0-edge.7 → 6.2.0

package/dist/generic/providerBase.js

@@ -238,6 +238,21 @@ export class ProviderBase {
          */
         this._inflightViews = new Map();
         this._lingerInvalidationWired = false;
+        /**
+         * Per-entity monotonic mutation counter incremented whenever an entity receives a
+         * BaseEntity save/delete/remote-invalidate or an explicit {@link InvalidateRunViewDedupCache}
+         * call. Used by dataset reads (`GetDatasetByName`) to detect that an entity was mutated while
+         * SQL execution or post-processing was in flight and avoid writing stale pre-mutation rows
+         * back into `LocalCacheManager`.
+         */
+        this._entityMutationVersions = new Map();
+        /**
+         * Monotonic counter incremented whenever any metadata-member entity is mutated against this
+         * provider's backend. Checked by `GetAllMetadata()` before caching `MJ_Metadata` into
+         * `DatasetCache` so an in-flight background reload does not overwrite `DatasetCache` with a
+         * pre-mutation snapshot after a save/delete has already landed.
+         */
+        this._metadataMemberMutationSeq = 0;
         /**
          * Lowercased names of the entities whose rows COMPOSE this provider's metadata — the
          * MJ_Metadata dataset's item entities, recorded each time the dataset is loaded (and restored
@@ -427,6 +442,23 @@ export class ProviderBase {
             if (!entityName) {
                 return;
             }
+            const cascadeRelatedEntities = [];
+            const isaRelatedEntities = [];
+            const entityInfo = entityEvent.baseEntity?.EntityInfo;
+            if (entityEvent.type === 'delete' && entityInfo?.CascadeDeletes && Array.isArray(entityInfo.RelatedEntities)) {
+                for (const rel of entityInfo.RelatedEntities) {
+                    const relName = rel?.RelatedEntity?.trim().toLowerCase();
+                    const relType = (rel?.Type ?? 'One To Many').trim().toUpperCase();
+                    if (relName && relName !== entityName && relType === 'ONE TO MANY' && !cascadeRelatedEntities.includes(relName)) {
+                        cascadeRelatedEntities.push(relName);
+                    }
+                }
+            }
+            if ((entityEvent.type === 'save' || entityEvent.type === 'delete') && entityInfo) {
+                for (const isaLower of ProviderBase.collectISAHierarchyEntityNamesLower(entityInfo, entityName)) {
+                    isaRelatedEntities.push(isaLower);
+                }
+            }
             for (const ref of ProviderBase._invalidationTargets) {
                 const instance = ref.deref();
                 if (!instance) {
@@ -437,9 +469,50 @@ export class ProviderBase {
                 }
                 instance.invalidateInflightViewsForEntity(entityName);
                 instance.handleMetadataMemberEntityEvent(entityName, entityEvent);
+                for (const relLower of cascadeRelatedEntities) {
+                    instance.invalidateInflightViewsForEntity(relLower);
+                    instance.handleMetadataMemberEntityEvent(relLower, entityEvent);
+                }
+                for (const isaLower of isaRelatedEntities) {
+                    instance.invalidateInflightViewsForEntity(isaLower);
+                    instance.handleMetadataMemberEntityEvent(isaLower, entityEvent);
+                }
             }
         });
     }
+    /**
+     * Collects all lowercased entity names in the same IS-A hierarchy (`ParentEntityInfo` ancestors
+     * and `ChildEntities` descendants) as `entityInfo`, excluding `excludeLower`.
+     */
+    static collectISAHierarchyEntityNamesLower(entityInfo, excludeLower) {
+        if (!entityInfo.IsChildType && !entityInfo.IsParentType) {
+            return [];
+        }
+        let root = entityInfo;
+        const seenAncestors = new Set();
+        while (root.ParentEntityInfo && !seenAncestors.has(root.ParentEntityInfo)) {
+            seenAncestors.add(root);
+            root = root.ParentEntityInfo;
+        }
+        const results = [];
+        const visited = new Set();
+        const queue = [root];
+        while (queue.length > 0) {
+            const current = queue.shift();
+            const lower = current?.Name?.trim().toLowerCase();
+            if (!lower || visited.has(lower)) {
+                continue;
+            }
+            visited.add(lower);
+            if (lower !== excludeLower) {
+                results.push(lower);
+            }
+            if (Array.isArray(current.ChildEntities) && current.ChildEntities.length > 0) {
+                queue.push(...current.ChildEntities);
+            }
+        }
+        return results;
+    }
     /**
      * Lazily registers this instance (once per provider instance) for write-invalidation
      * of in-flight/lingered RunView entries touching a written entity. Deleting an IN-FLIGHT
@@ -460,6 +533,17 @@ export class ProviderBase {
         this._lingerInvalidationWired = true;
         ProviderBase._invalidationTargets.add(new WeakRef(this));
     }
+    /**
+     * Returns the current monotonic mutation version for `entityName` (case-insensitive).
+     */
+    GetEntityMutationVersion(entityName) {
+        this.ensureInflightViewInvalidation();
+        const lower = entityName?.trim().toLowerCase();
+        if (!lower) {
+            return 0;
+        }
+        return this._entityMutationVersions.get(lower) ?? 0;
+    }
     /**
      * Drops this provider's in-flight/lingered RunView dedup entries so the next identical
      * RunView goes to the server instead of replaying a result from the last
@@ -482,6 +566,9 @@ export class ProviderBase {
         const names = (entityNames ?? []).map(n => n?.trim().toLowerCase()).filter((n) => !!n);
         if (names.length === 0) {
             this._inflightViews.clear();
+            for (const [k, v] of this._entityMutationVersions) {
+                this._entityMutationVersions.set(k, v + 1);
+            }
             return;
         }
         for (const n of names) {
@@ -493,6 +580,7 @@ export class ProviderBase {
      * entity (lowercased name). Called on BaseEntity save/delete/remote-invalidate.
      */
     invalidateInflightViewsForEntity(lowerEntityName) {
+        this._entityMutationVersions.set(lowerEntityName, (this._entityMutationVersions.get(lowerEntityName) ?? 0) + 1);
         for (const [key, entry] of this._inflightViews) {
             if (entry.entityNames?.has(lowerEntityName)) {
                 this._inflightViews.delete(key);
@@ -672,6 +760,7 @@ export class ProviderBase {
         if (!this.eventTargetsThisProviderBackend(entityEvent)) {
             return;
         }
+        this._metadataMemberMutationSeq++;
         this.scheduleMetadataMemberRefresh();
     }
     /**
@@ -890,6 +979,14 @@ export class ProviderBase {
             return true;
         }
         this._metadataMemberRefreshWaits = 0;
+        if (this._metadataReloadInFlight) {
+            // A metadata reload is already in flight. Do not call RefreshRemoteMetadataTimestamps()
+            // concurrently here, because that mutates _latestRemoteMetadataTimestamps out from under
+            // the in-flight pass before it runs adoptServerMetadata(). Instead, delegate directly to
+            // ReloadMetadata, which sets _metadataReloadQueued = true and re-reads authoritative
+            // remote timestamps at the start of the queued follow-up pass.
+            return this.ReloadMetadata(true, undefined, true);
+        }
         // The writer holds positive evidence, so the timestamps are re-read from the authoritative
         // status query. When they attribute the change entirely to the saved-query family (see
         // PartialRefreshMetadataItemCodes) only that family is reloaded, cache layers bypassed as a
@@ -1299,6 +1396,7 @@ export class ProviderBase {
             // allCached ⇒ every param produced a hit and was pushed in order (PreRunViews only
             // pushes a null placeholder on the path that clears allCached), so index i of
             // cachedResults corresponds to params[i].
+            await this.TransformBatchRunViewResults(params, preResult.cachedResults, undefined, preResult.callerFieldsMap, contextUser);
             for (let i = 0; i < preResult.cachedResults.length; i++) {
                 await this.ApplyPostRunViewHooksToCacheHit(params[i], preResult.cachedResults[i], contextUser);
             }
@@ -2334,22 +2432,24 @@ export class ProviderBase {
             queryDefinition = queryAuth.definition;
             // TTL-enforced, and a miss when the slot was written under another query definition.
             const cached = queryFingerprint ? await LocalCacheManager.Instance.GetRunQueryResult(queryFingerprint, queryDefinition) : null;
-            if (cached && queryFingerprint) {
-                const serveFromSlot = () => ({
-                    QueryID: cached.queryId ?? params.QueryID ?? '',
-                    QueryName: params.QueryName ?? '',
-                    Success: true,
-                    // Transport boundary: `cached.results` is readonly (shared, deep-frozen cache
-                    // rows) while the outbound Results is mutable — the runtime freeze is the
-                    // enforcement. Same cast as the RunView hit paths above.
-                    Results: cached.results,
-                    RowCount: cached.results.length,
-                    TotalRowCount: cached.rowCount ?? cached.results.length,
-                    ExecutionTime: 0,
-                    ErrorMessage: '',
-                    CacheHit: true,
-                    CacheKey: queryFingerprint
-                });
+            if (queryFingerprint) {
+                const serveFromSlot = cached
+                    ? () => ({
+                        QueryID: cached.queryId ?? params.QueryID ?? '',
+                        QueryName: params.QueryName ?? '',
+                        Success: true,
+                        // Transport boundary: `cached.results` is readonly (shared, deep-frozen cache
+                        // rows) while the outbound Results is mutable — the runtime freeze is the
+                        // enforcement. Same cast as the RunView hit paths above.
+                        Results: cached.results,
+                        RowCount: cached.results.length,
+                        TotalRowCount: cached.rowCount ?? cached.results.length,
+                        ExecutionTime: 0,
+                        ErrorMessage: '',
+                        CacheHit: true,
+                        CacheKey: queryFingerprint
+                    })
+                    : undefined;
                 const checker = this.RunQueriesWithCacheCheck?.bind(this);
                 if (!checker || this.TrustLocalCacheCompletely) {
                     // TTL mode (server providers / no validation transport).
@@ -2366,69 +2466,71 @@ export class ProviderBase {
                     // authorizes with the proper error message. Query metadata missing from the
                     // provider cache ⇒ ALSO fall through (never serve rows we cannot authorize);
                     // that costs one query run, not correctness.
-                    if (contextUser) {
-                        if (queryAuth.resolvable) {
-                            // Metadata can answer — enforce it. `authorized` comes from the
-                            // provider's STRONGEST available check (B45): the base enforces
-                            // roles-only QueryInfo.UserCanRun; GenericDatabaseProvider's
-                            // override enforces the full MJQueryEntityExtended.UserCanRun
-                            // (roles + entity CanRead + recursive composition) — the identical
-                            // check ValidateQueryForExecution applies on the miss path, so a
-                            // hit is never easier to read than a miss.
-                            if (queryAuth.authorized) {
+                    if (cached && serveFromSlot) {
+                        if (contextUser) {
+                            if (queryAuth.resolvable) {
+                                // Metadata can answer — enforce it. `authorized` comes from the
+                                // provider's STRONGEST available check (B45): the base enforces
+                                // roles-only QueryInfo.UserCanRun; GenericDatabaseProvider's
+                                // override enforces the full MJQueryEntityExtended.UserCanRun
+                                // (roles + entity CanRead + recursive composition) — the identical
+                                // check ValidateQueryForExecution applies on the miss path, so a
+                                // hit is never easier to read than a miss.
+                                if (queryAuth.authorized) {
+                                    return serveFromSlot();
+                                }
+                                LogStatusEx({ message: `RunQuery cache: user '${contextUser.Email}' lacks run permission on '${queryAuth.queryName ?? params.QueryName ?? params.QueryID}' — falling through to authorized execution.`, verboseOnly: true });
+                            }
+                            else if (cached.warmedForUserID && UUIDsEqual(cached.warmedForUserID, contextUser.ID)) {
+                                // Metadata CANNOT answer — runtime-created queries never appear in the
+                                // provider's Queries cache (it does not refresh in-process; verified:
+                                // a saved Query stays invisible, 21 -> 21). But a slot only exists
+                                // because its WARMER executed the fully-authorized miss path — so the
+                                // warmer's own permission is already proven. Serve the warmer;
+                                // anyone ELSE falls through and pays one authorized execution.
+                                //
+                                // The first version of this gate failed closed on unresolvable
+                                // metadata, which silently disabled TTL caching for every
+                                // runtime-created query — caught by Q2/Q5/Q10 going red.
                                 return serveFromSlot();
                             }
-                            LogStatusEx({ message: `RunQuery cache: user '${contextUser.Email}' lacks run permission on '${queryAuth.queryName ?? params.QueryName ?? params.QueryID}' — falling through to authorized execution.`, verboseOnly: true });
-                        }
-                        else if (cached.warmedForUserID && UUIDsEqual(cached.warmedForUserID, contextUser.ID)) {
-                            // Metadata CANNOT answer — runtime-created queries never appear in the
-                            // provider's Queries cache (it does not refresh in-process; verified:
-                            // a saved Query stays invisible, 21 -> 21). But a slot only exists
-                            // because its WARMER executed the fully-authorized miss path — so the
-                            // warmer's own permission is already proven. Serve the warmer;
-                            // anyone ELSE falls through and pays one authorized execution.
-                            //
-                            // The first version of this gate failed closed on unresolvable
-                            // metadata, which silently disabled TTL caching for every
-                            // runtime-created query — caught by Q2/Q5/Q10 going red.
-                            return serveFromSlot();
+                            else {
+                                LogStatusEx({ message: `RunQuery cache: '${params.QueryID ?? params.QueryName}' not in cached metadata and requester is not the slot's warmer — falling through to authorized execution.`, verboseOnly: true });
+                            }
                         }
                         else {
-                            LogStatusEx({ message: `RunQuery cache: '${params.QueryID ?? params.QueryName}' not in cached metadata and requester is not the slot's warmer — falling through to authorized execution.`, verboseOnly: true });
+                            return serveFromSlot();
                         }
                     }
-                    else {
-                        return serveFromSlot();
-                    }
-                }
-                // Client smart validation round trip.
-                //
-                // Guarded on `checker` (R4-2): the block above is entered when `!checker ||
-                // TrustLocalCacheCompletely`. If we got here via `!checker` AND the B43 permission
-                // gate DECLINED to serve (denied user / non-warmer), execution used to fall
-                // straight into `await checker(...)` = `await undefined(...)` — a TypeError instead
-                // of the promised "fall through to authorized execution". Every in-tree provider
-                // implements the optional `RunQueriesWithCacheCheck`, so this was latent, but the
-                // pre-B43 code handled `!checker` and this must too: skip the round trip and let
-                // the normal PreRunQuery/InternalRunQuery path below authorize and execute.
-                if (!checker) {
-                    // fall through to normal execution below
                 }
                 else {
+                    // Client smart validation round trip (both cold first-fetch and warm revalidation).
+                    // Routing cold CacheLocal requests through RunQueriesWithCacheCheck with no cacheStatus
+                    // engages the server's firstFetchWithValidation path so the initial client slot is
+                    // stamped with maxUpdatedAt, rowCount, and definitionHash — allowing the very first
+                    // subsequent refresh (F5) to validate as 'current' instead of missing.
                     const response = await checker([{
                             params,
-                            // '' for a slot written without a hash: the server answers `stale` and returns
-                            // its hash, so the rewrite below stamps the slot.
-                            cacheStatus: { maxUpdatedAt: cached.maxUpdatedAt, rowCount: cached.rowCount, definitionHash: cached.definitionHash ?? '' }
+                            ...(cached
+                                ? {
+                                    // '' for a slot written without a hash: the server answers `stale` and returns
+                                    // its hash, so the rewrite below stamps the slot.
+                                    cacheStatus: {
+                                        maxUpdatedAt: cached.maxUpdatedAt,
+                                        rowCount: cached.rowCount,
+                                        definitionHash: cached.definitionHash ?? ''
+                                    }
+                                }
+                                : {})
                         }], contextUser);
                     const check = response.results?.[0];
                     if (response.success && check) {
-                        if (check.status === 'current') {
+                        if (check.status === 'current' && serveFromSlot) {
                             return serveFromSlot();
                         }
                         if ((check.status === 'stale' || check.status === 'no_validation') && check.results) {
                             const freshRows = check.results;
-                            // Fire-and-forget slot rewrite — same pattern as the RunView client path
+                            // Fire-and-forget slot write/rewrite — same pattern as the RunView client path
                             LocalCacheManager.Instance.SetRunQueryResult(queryFingerprint, params.QueryName ?? '', freshRows, check.maxUpdatedAt ?? '', check.rowCount, check.queryId, params.CacheLocalTTL, contextUser?.ID, check.definitionHash ? { QueryID: check.queryId, Hash: check.definitionHash } : undefined).catch(e => LogError(`RunQuery cache rewrite failed: ${e}`));
                             return {
                                 QueryID: check.queryId ?? params.QueryID ?? '',
@@ -2438,12 +2540,25 @@ export class ProviderBase {
                                 RowCount: freshRows.length,
                                 TotalRowCount: check.rowCount ?? freshRows.length,
                                 ExecutionTime: 0,
-                                ErrorMessage: ''
+                                ErrorMessage: '',
+                                CacheKey: queryFingerprint
+                            };
+                        }
+                        if (check.status === 'error') {
+                            return {
+                                QueryID: check.queryId ?? params.QueryID ?? '',
+                                QueryName: params.QueryName ?? '',
+                                Success: false,
+                                Results: [],
+                                RowCount: 0,
+                                TotalRowCount: 0,
+                                ExecutionTime: 0,
+                                ErrorMessage: check.errorMessage ?? response.errorMessage ?? 'Query execution failed'
                             };
                         }
                     }
+                    // validation transport failed — fall through to a normal execution
                 }
-                // validation transport failed — fall through to a normal execution
             }
         }
         // Pre-processing: telemetry, cache check
@@ -3378,6 +3493,7 @@ export class ProviderBase {
                     let results = await this.MaterializeCachedRowsForCaller(cached.results, batchEntity, contextUser, Boolean(param.PreserveRestrictedApiCiphertext));
                     if (projectedCallerFields && param.ResultType !== 'entity_object') {
                         results = ProjectRowsToFields(results, projectedCallerFields);
+                        callerFieldsMap.set(i, projectedCallerFields);
                     }
                     // Field-level security on the batch cache-hit path — same reasoning as the
                     // single-view path in PreRunView: this result is returned without
@@ -3396,8 +3512,9 @@ export class ProviderBase {
                         // different Aggregates[] order — remap to THIS caller's requested order.
                         AggregateResults: LocalCacheManager.Instance.ReorderAggregateResultsToRequest(cached.aggregateResults, param.Aggregates)
                     };
-                    // if needed this will transform each result into an entity object
-                    await this.TransformSimpleObjectToEntityObject(param, cachedViewResult, contextUser);
+                    // Entity transformation (`ResultType: 'entity_object'`) is deferred to
+                    // TransformBatchRunViewResults in runAdmittedViewStages / PostRunViews so
+                    // cache hits and DB misses participate together in two-phase sibling IS-A hydration.
                     this.logDeprecatedAlternateBaseViewIfAny(param, 'PreRunViews');
                     if (!param.CacheLocal && this.TrustLocalCacheCompletely) {
                         LogStatusEx({ message: `    ✅ [Server Cache HIT] RunViews "${param.EntityName || param.ViewName || 'unknown'}" — ${cached.results.length} rows served from server cache (no DB query)`, verboseOnly: true });
@@ -3573,6 +3690,14 @@ export class ProviderBase {
         // pre-resolved map instead of issuing their own GetRunViewResult calls.
         const processingPromises = params.map((param, i) => this.processSingleSmartCacheResult(param, i, serverResultsByViewIndex.get(i), preResolvedCache, contextUser));
         const processedResults = await Promise.all(processingPromises);
+        const batchResults = processedResults.map(r => r.result);
+        const alreadyTransformedIndices = new Set();
+        for (let i = 0; i < processedResults.length; i++) {
+            if (processedResults[i].alreadyTransformed) {
+                alreadyTransformedIndices.add(i);
+            }
+        }
+        await this.TransformBatchRunViewResults(params, batchResults, alreadyTransformedIndices, undefined, contextUser);
         // Aggregate telemetry stats
         let cacheHits = 0;
         let cacheMisses = 0;
@@ -3590,7 +3715,7 @@ export class ProviderBase {
             cacheMisses,
             batchSize: params.length
         });
-        return processedResults.map(r => r.result);
+        return batchResults;
     }
     /**
      * Processes a single smart cache check result.
@@ -3636,8 +3761,6 @@ export class ProviderBase {
                     // different Aggregates[] order — remap to THIS caller's requested order.
                     AggregateResults: LocalCacheManager.Instance.ReorderAggregateResultsToRequest(cached.aggregateResults, param.Aggregates)
                 };
-                // Transform to entity objects if needed
-                await this.TransformSimpleObjectToEntityObject(param, cachedResult, contextUser);
                 return { result: cachedResult, cacheHit: true, cacheMiss: false };
             }
             else {
@@ -3688,8 +3811,6 @@ export class ProviderBase {
                         // Include aggregate results - either fresh from server or from merged cache
                         AggregateResults: checkResult.aggregateResults || merged.aggregateResults
                     };
-                    // Transform to entity objects if needed
-                    await this.TransformSimpleObjectToEntityObject(param, mergedResult, contextUser);
                     return { result: mergedResult, cacheHit: true, cacheMiss: false };
                 }
             }
@@ -3704,14 +3825,23 @@ export class ProviderBase {
             //     `r.result` straight to the caller, so null became the caller's RESULT.
             //
             // The only correct remedy is what a cache miss does anyway: fetch in full. The
-            // declined slot was already invalidated by ApplyDifferentialUpdate, so the refetch
-            // repopulates it. CacheLocal is stripped and BypassCache set so this single call
-            // takes the plain path — it cannot re-enter the smart-cache transport, which is what
-            // makes the recursion impossible rather than merely unlikely.
+            // declined slot was already invalidated by ApplyDifferentialUpdate, and because
+            // fallbackParam sets CacheLocal:false + BypassCache:true (so the refetch takes the
+            // plain path and cannot re-enter the smart-cache transport), PostRunViews does not
+            // write to LocalCacheManager — so we repopulate the slot explicitly here.
             LogStatusEx({ message: `Differential merge declined for '${param.EntityName}' — refetching in full.`, verboseOnly: true });
             const fallbackParam = { ...param, CacheLocal: false, BypassCache: true };
             const freshFetch = await this.RunView(fallbackParam, contextUser);
-            return { result: freshFetch, cacheHit: false, cacheMiss: true };
+            if (this.runViewCacheEligibleForWrite(param) && freshFetch.Success && LocalCacheManager.Instance.IsInitialized) {
+                const plainRows = (freshFetch.Results || []).map(row => row && typeof row.GetAll === 'function'
+                    ? row.GetAll()
+                    : row);
+                const maxUpdatedAt = checkResult.maxUpdatedAt || this.extractMaxUpdatedAt(plainRows) || '';
+                if (maxUpdatedAt) {
+                    LocalCacheManager.Instance.SetRunViewResult(fingerprint, param, plainRows, maxUpdatedAt, freshFetch.AggregateResults ?? checkResult.aggregateResults, freshFetch.TotalRowCount ?? checkResult.rowCount, this).catch(e => LogError(`Failed to update cache after differential fallback: ${e}`));
+                }
+            }
+            return { result: freshFetch, cacheHit: false, cacheMiss: true, alreadyTransformed: true };
         }
         else if (checkResult.status === 'stale') {
             // Cache is stale - use fresh data and update cache (entity doesn't support differential)
@@ -3736,8 +3866,6 @@ export class ProviderBase {
                 LocalCacheManager.Instance.SetRunViewResult(fingerprint, param, checkResult.results || [], checkResult.maxUpdatedAt, checkResult.aggregateResults, // Include aggregate results in cache
                 checkResult.rowCount, this).catch(e => LogError(`Failed to update cache: ${e}`));
             }
-            // Transform to entity objects if needed
-            await this.TransformSimpleObjectToEntityObject(param, freshResult, contextUser);
             return { result: freshResult, cacheHit: false, cacheMiss: true };
         }
         else {
@@ -3986,17 +4114,8 @@ export class ProviderBase {
             results[i].Results = this.ApplyFieldSecurityProjection(results[i].Results, params[i], contextUser);
             results[i].Results = this.ApplyRecordChangeFieldSecurityProjection(results[i].Results, params[i], contextUser);
         }
-        // Transform results to entity objects AFTER caching plain objects.
-        // Skip results that came from cache hits — they're already entity objects.
-        const transformPromises = [];
-        for (let i = 0; i < results.length; i++) {
-            const cacheInfo = preResult.cacheStatusMap?.get(i);
-            if (cacheInfo?.status === 'hit') {
-                continue;
-            }
-            transformPromises.push(this.TransformSimpleObjectToEntityObject(params[i], results[i], contextUser));
-        }
-        await Promise.all(transformPromises);
+        // Transform results (both cache hits and DB misses) to entity objects AFTER caching plain objects.
+        await this.TransformBatchRunViewResults(params, results, undefined, preResult.callerFieldsMap, contextUser);
         // Run registered PostRunView hooks on each result in the batch
         for (let i = 0; i < results.length; i++) {
             results[i] = await this.RunPostRunViewHooks(params[i], results[i], contextUser);
@@ -4417,12 +4536,7 @@ export class ProviderBase {
      */
     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);
+            await this.TransformBatchRunViewResults(params, results, undefined, undefined, contextUser);
             // End telemetry tracking for batch operation
             const eventId = params[0]._telemetryBatchEventId;
             if (eventId) {
@@ -4431,18 +4545,113 @@ export class ProviderBase {
             }
         }
     }
+    /**
+     * Two-phase batch entity transformation for `RunViews`:
+     * 1. Transforms all non-IS-A-parent views in parallel first so lookup tables (`SubtypeSelector`)
+     *    and IS-A child tables in the same batch are hydrated before parent views run.
+     * 2. Registers all unfiltered full-entity views from this batch on `BaseEntity` for the duration
+     *    of Phase 2, then transforms IS-A parent views so they can resolve child records and
+     *    `SubtypeSelector` targets directly from memory with 0 extra queries.
+     */
+    async TransformBatchRunViewResults(params, results, skipTransformIndices, callerFieldsMap, contextUser) {
+        if (!params || params.length === 0) {
+            return;
+        }
+        const nonParentIndices = [];
+        const isaParentIndices = [];
+        for (let i = 0; i < results.length; i++) {
+            if (skipTransformIndices?.has(i)) {
+                continue;
+            }
+            const firstRow = results[i]?.Results?.[0];
+            if (firstRow instanceof BaseEntity) {
+                continue;
+            }
+            const param = params[i];
+            if (!param) {
+                continue;
+            }
+            const entity = param.EntityName ? this.EntityByName(param.EntityName) : undefined;
+            if (param.ResultType === 'entity_object' && entity?.IsParentType && entity.ChildEntities.length > 0) {
+                isaParentIndices.push(i);
+            }
+            else {
+                nonParentIndices.push(i);
+            }
+        }
+        if (nonParentIndices.length > 0) {
+            await Promise.all(nonParentIndices.map(i => this.TransformSimpleObjectToEntityObject(params[i], results[i], contextUser)));
+        }
+        if (isaParentIndices.length === 0) {
+            return;
+        }
+        const batchUnfilteredCache = new Map();
+        for (let i = 0; i < results.length; i++) {
+            const param = params[i];
+            if (param && this.isUnfilteredFullEntityBatchView(param, results[i], callerFieldsMap, i)) {
+                const key = param.EntityName.trim().toLowerCase();
+                if (!batchUnfilteredCache.has(key)) {
+                    batchUnfilteredCache.set(key, results[i].Results);
+                }
+            }
+        }
+        const batchCache = batchUnfilteredCache.size > 0 ? batchUnfilteredCache : undefined;
+        await Promise.all(isaParentIndices.map(i => this.TransformSimpleObjectToEntityObject(params[i], results[i], contextUser, batchCache)));
+    }
+    isUnfilteredFullEntityBatchView(param, result, callerFieldsMap, viewIndex) {
+        if (!param.EntityName || !result?.Success || !Array.isArray(result.Results)) {
+            return false;
+        }
+        if (param.ResultType === 'count_only') {
+            return false;
+        }
+        const filter = typeof param.ExtraFilter === 'string' ? param.ExtraFilter.trim() : '';
+        const search = typeof param.UserSearchString === 'string' ? param.UserSearchString.trim() : '';
+        if (filter.length > 0 || search.length > 0) {
+            return false;
+        }
+        if (param.ViewID || param.ViewName || param.ViewEntity) {
+            return false;
+        }
+        const alternateBaseView = param.AlternateBaseView;
+        if (alternateBaseView && alternateBaseView.trim().length > 0) {
+            return false;
+        }
+        if (param.MaxRows || param.StartRow || param.AfterKey) {
+            return false;
+        }
+        if (typeof result.TotalRowCount === 'number' &&
+            result.TotalRowCount > result.Results.length) {
+            return false;
+        }
+        if (param.IgnoreMaxRows !== true) {
+            const entity = this.EntityByName(param.EntityName);
+            const maxRowsCap = entity?.UserViewMaxRows ?? 0;
+            if (maxRowsCap > 0 && result.Results.length >= maxRowsCap) {
+                return false;
+            }
+        }
+        if (viewIndex !== undefined && callerFieldsMap?.has(viewIndex)) {
+            return false;
+        }
+        if (param.Fields && param.Fields.length > 0 && !this.isFullCoverageFieldList(param)) {
+            return false;
+        }
+        return true;
+    }
     /**
      * 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
+     * @param batchUnfilteredCache - Optional map of unfiltered full-entity sibling views from the same RunViews call
      */
-    async TransformSimpleObjectToEntityObject(param, result, contextUser) {
+    async TransformSimpleObjectToEntityObject(param, result, contextUser, batchUnfilteredCache) {
         // Mutually exclusive with the entity branch below: entity objects get real types from
         // BaseEntity's Get/Set conversion, so normalization applies only to non-entity results.
         this.NormalizeSimpleRowTypes(param, result);
         if (param.ResultType === 'entity_object' && result && result.Success && result.Results?.length > 0) {
-            result.Results = await TransformSimpleObjectToEntityObject(this, param.EntityName, result.Results, contextUser);
+            result.Results = await TransformSimpleObjectToEntityObject(this, param.EntityName, result.Results, contextUser, batchUnfilteredCache);
             // Opt-in batched child loading: ONE query per named collection across the whole result
             // set, not one per row. Companion eager loading is deliberately kept out of
             // LoadFromData() (which is the per-row path above) precisely so that populating children
@@ -4870,6 +5079,9 @@ export class ProviderBase {
                 LogWarning(`[Metadata Cache] Row count mismatch when adopting server metadata for "${remoteEntry.Type}": ` +
                     `received ${receivedRowCount} rows but remote status reported ${remoteEntry.RowCount} rows. ` +
                     `Not advancing local timestamp for "${remoteEntry.Type}" so the next check self-heals.`, 'Metadata');
+                if (LocalCacheManager.Instance.IsInitialized && remoteEntry.Type) {
+                    LocalCacheManager.Instance.InvalidateEntityCaches(remoteEntry.Type).catch(() => { });
+                }
                 const priorEntry = prevLocal.find(m => norm(m.Type) === norm(remoteEntry.Type));
                 if (priorEntry) {
                     reconciled.push({
@@ -4897,6 +5109,7 @@ export class ProviderBase {
         if (!hasMismatch) {
             return remote;
         }
+        this.ClearDatasetCache(ProviderBase._mjMetadataDatasetName).catch(() => { });
         const remoteRollup = remote.find(r => norm(r.Type) === rollup);
         if (remoteRollup) {
             const priorRollup = prevLocal.find(m => norm(m.Type) === rollup);
@@ -5282,6 +5495,40 @@ export class ProviderBase {
         return f;
     }
     static { this._mjMetadataDatasetName = 'MJ_Metadata'; }
+    /**
+     * Checks whether any item in a freshly fetched `MJ_Metadata` dataset has a row count that
+     * disagrees with `_latestRemoteMetadataTimestamps` (when remote timestamps are populated).
+     * Used to prevent `GetAllMetadata()` from caching a dataset snapshot into `DatasetCache`
+     * whose row counts are already stale relative to remote status.
+     */
+    hasDatasetRemoteRowCountMismatch(dataset) {
+        const remote = this._latestRemoteMetadataTimestamps;
+        if (!remote || remote.length === 0 || !Array.isArray(dataset?.Results)) {
+            return false;
+        }
+        const norm = (v) => (v ?? '').trim().toLowerCase();
+        const rollup = norm(ProviderBase._allMetadataTypeName);
+        const nonRollupRemote = remote.filter(r => norm(r.Type) !== rollup);
+        const remoteByID = IndexByUUID(nonRollupRemote.filter(r => Boolean(r.ID)), r => r.ID);
+        const remoteByType = new Map();
+        for (const r of nonRollupRemote) {
+            if (r.Type) {
+                remoteByType.set(norm(r.Type), r);
+            }
+        }
+        for (const item of dataset.Results) {
+            if (!Array.isArray(item.Results)) {
+                continue;
+            }
+            const remoteEntry = (item.EntityID ? remoteByID.Get(item.EntityID) : undefined)
+                ?? remoteByType.get(norm(item.EntityName))
+                ?? remoteByType.get(norm(item.Code));
+            if (remoteEntry && remoteEntry.RowCount !== undefined && item.Results.length !== remoteEntry.RowCount) {
+                return true;
+            }
+        }
+        return false;
+    }
     /**
      * Retrieves all metadata from the server and constructs typed instances.
      * Uses the MJ_Metadata dataset for efficient bulk loading.
@@ -5292,6 +5539,7 @@ export class ProviderBase {
             // we are now using datasets instead of the custom metadata to GraphQL to simplify GraphQL's work as it was very slow preivously
             // NOTE: Schema filters (IncludeSchemas/ExcludeSchemas) are for CodeGen only, not for runtime
             // metadata loading. We always load all schemas — there are no sys/staging entities in metadata anyway.
+            const mutationSeqAtStart = this._metadataMemberMutationSeq;
             // Get the dataset and cache it for anyone else who wants to use it
             // When forceRefresh is true (from a hard Refresh() call), bypass LocalCacheManager
             const d = await this.GetDatasetByName(ProviderBase._mjMetadataDatasetName, null, this.CurrentUser, providerToUse, forceRefresh);
@@ -5306,12 +5554,24 @@ export class ProviderBase {
                 this.recordMetadataLoadFailure(new Error(`GetAllMetadata() - the ${ProviderBase._mjMetadataDatasetName} dataset returned no entities; keeping the metadata already loaded`));
             }
             else if (d && d.Success) {
-                // cache the dataset for anyone who wants to use it
-                await this.CacheDataset(ProviderBase._mjMetadataDatasetName, null, d);
                 // Record which entities this metadata is built from, so a write to any of them
                 // schedules a debounced refresh of this provider's metadata (see
                 // registerMetadataDatasetMembership — membership is the dataset definition, not a list).
                 this.registerMetadataDatasetMembership(d);
+                // Only cache the dataset in DatasetCache when no metadata-member mutation occurred
+                // while GetDatasetByName was in flight, no follow-up reload is already queued, and
+                // item row counts match _latestRemoteMetadataTimestamps. Otherwise a slow background
+                // GetAllMetadata() that started before a delete can overwrite DatasetCache with
+                // pre-delete rows right after the delete has already completed.
+                const mutatedDuringLoad = this._metadataReloadQueued ||
+                    this._metadataMemberMutationSeq !== mutationSeqAtStart ||
+                    this.hasDatasetRemoteRowCountMismatch(d);
+                if (!mutatedDuringLoad) {
+                    await this.CacheDataset(ProviderBase._mjMetadataDatasetName, null, d);
+                }
+                else {
+                    await this.ClearDatasetCache(ProviderBase._mjMetadataDatasetName);
+                }
                 // got the results, let's build our response in the format we need
                 const simpleMetadata = {};
                 for (let r of d.Results) {