@memberjunction/core 5.44.0 → 5.45.1

package/dist/generic/providerBase.js

@@ -5,7 +5,7 @@ import { ComputeRRF } from "./scoring/ReciprocalRankFusion.js";
 import { LocalCacheManager } from "./localCacheManager.js";
 import { ApplicationInfo } from "../generic/applicationInfo.js";
 import { AuditLogTypeInfo, AuthorizationInfo, AuthorizationRoleInfo, RoleInfo, RowLevelSecurityFilterInfo, UserInfo } from "./securityInfo.js";
-import { MJGlobal, NormalizeUUID, UUIDsEqual } from "@memberjunction/global";
+import { MJGlobal, MJEventType, NormalizeUUID, UUIDsEqual } from "@memberjunction/global";
 import { TelemetryManager } from "./telemetryManager.js";
 import { LogError, LogStatus, LogStatusEx } from "./logging.js";
 import { QueryCategoryInfo, QueryFieldInfo, QueryInfo, QueryPermissionInfo, QueryEntityInfo, QueryParameterInfo, QueryDependencyInfo, SQLDialectInfo, QuerySQLInfo } from "./queryInfo.js";
@@ -196,8 +196,16 @@ export class ProviderBase {
          * the RunViewParams batch.  While a request is in-flight, concurrent
          * identical calls share the same promise.  After resolution the entry
          * lingers so that near-sequential identical calls return immediately.
+         *
+         * Entries record the (lowercased) entity names their params touch so that
+         * a BaseEntity save/delete/remote-invalidate can drop them — a lingered
+         * result is a cache, and without write-invalidation a caller re-running
+         * the identical view within the linger window after a save would receive
+         * PRE-save rows (observed live: an engine's debounced post-save refreshes
+         * for multiple sequential saves — only the first save's data ever arrived).
          */
         this._inflightViews = new Map();
+        this._lingerInvalidationWired = false;
         this._clientFingerprintMemo = new WeakMap();
         this._cachedVisibleExplorerNavigationItems = null;
     }
@@ -252,6 +260,62 @@ export class ProviderBase {
      * instead of accumulating result arrays in memory.
      */
     static { this.MaxLingerEntries = 500; }
+    /**
+     * Lazily subscribes (once per provider instance) to BaseEntity events so
+     * in-flight/lingered RunView entries touching a written entity are dropped.
+     * Deleting an IN-FLIGHT entry is deliberate: late joiners must not share a
+     * query that may have read pre-commit data; the original caller still gets
+     * its own result, and the orphaned promise's stash step no-ops safely.
+     */
+    ensureInflightViewInvalidation() {
+        if (this._lingerInvalidationWired) {
+            return;
+        }
+        this._lingerInvalidationWired = true;
+        MJGlobal.Instance.GetEventListener(false).subscribe((event) => {
+            if (event.event !== MJEventType.ComponentEvent || event.eventCode !== BaseEntity.BaseEventCode) {
+                return;
+            }
+            const entityEvent = event.args;
+            if (!entityEvent) {
+                return;
+            }
+            if (entityEvent.type !== 'save' && entityEvent.type !== 'delete' && entityEvent.type !== 'remote-invalidate') {
+                return;
+            }
+            const entityName = (entityEvent.baseEntity?.EntityInfo?.Name ?? entityEvent.entityName)?.trim().toLowerCase();
+            if (entityName) {
+                this.invalidateInflightViewsForEntity(entityName);
+            }
+        });
+    }
+    /**
+     * Drops every in-flight/lingered RunView entry whose params touch the given
+     * entity (lowercased name). Called on BaseEntity save/delete/remote-invalidate.
+     */
+    invalidateInflightViewsForEntity(lowerEntityName) {
+        for (const [key, entry] of this._inflightViews) {
+            if (entry.entityNames?.has(lowerEntityName)) {
+                this._inflightViews.delete(key);
+            }
+        }
+    }
+    /**
+     * Collects the lowercased entity names a RunViewParams batch touches, for
+     * write-invalidation of dedup/linger entries. Params addressed by ViewID /
+     * ViewName only (no EntityName) are not tracked — they keep today's
+     * linger behavior rather than pay a metadata resolution here.
+     */
+    collectParamEntityNames(params) {
+        let names;
+        for (const p of params) {
+            const n = p.EntityName?.trim().toLowerCase();
+            if (n) {
+                (names ??= new Set()).add(n);
+            }
+        }
+        return names;
+    }
     /******** ABSTRACT SECTION ****************************************************************** */
     /**
      * When true, cached RunView/RunQuery results are returned immediately on a
@@ -566,7 +630,8 @@ export class ProviderBase {
             }
             throw err;
         });
-        this._inflightViews.set(key, { promise });
+        this.ensureInflightViewInvalidation();
+        this._inflightViews.set(key, { promise, entityNames: this.collectParamEntityNames(params) });
         const results = await promise;
         return results.map(r => this.ShallowCopyResult(r));
     }
@@ -860,7 +925,8 @@ export class ProviderBase {
             this._inflightViews.delete(key);
             throw err;
         });
-        this._inflightViews.set(key, { promise });
+        this.ensureInflightViewInvalidation();
+        this._inflightViews.set(key, { promise, entityNames: this.collectParamEntityNames(params) });
         const results = await promise;
         return results.map(r => this.ShallowCopyResult(r));
     }
@@ -1270,6 +1336,15 @@ export class ProviderBase {
      * @param contextUser - Optional user context for permissions (required server-side)
      * @returns The query results
      */
+    /**
+     * Whether a saved query is bound to an external data source. The base returns false;
+     * providers that support external data sources override this (consulting query metadata)
+     * so the outer RunQuery CacheLocal layer can defer to InternalRunQuery's own external
+     * TTL caching. Synchronous + non-throwing: resolves from cached metadata only.
+     */
+    IsExternalQuery(_params) {
+        return false;
+    }
     async RunQuery(params, contextUser) {
         // Shallow-clone for symmetry with RunView — pipeline must never mutate caller objects
         params = { ...params };
@@ -1286,6 +1361,11 @@ export class ProviderBase {
         const queryCacheEngaged = params.CacheLocal === true
             && !params.SQL
             && (!!params.QueryID || !!params.QueryName)
+            // External-data-source queries own their own TTL caching inside InternalRunQuery
+            // (runExternalQueryWithCache, keyed to the source's DefaultCacheTTLSeconds). This
+            // outer CacheLocal layer would otherwise write a SECOND, divergent slot with no/foreign
+            // TTL (CacheLocalTTL) — a stale-forever hazard since external data can't be event-invalidated.
+            && !this.IsExternalQuery(params)
             && LocalCacheManager.Instance.IsInitialized;
         let queryFingerprint;
         if (queryCacheEngaged) {