@salesforce/lds-runtime-mobile 1.232.0 → 1.235.0

package/dist/main.js

@@ -13,7 +13,7 @@
  */
 import { withRegistration, register } from '@salesforce/lds-default-luvio';
 import { setupInstrumentation, instrumentAdapter as instrumentAdapter$1, instrumentLuvio, setLdsAdaptersUiapiInstrumentation, setLdsNetworkAdapterInstrumentation } from '@salesforce/lds-instrumentation';
-import { HttpStatusCode, StoreKeySet, serializeStructuredKey, Reader, deepFreeze, emitAdapterEvent, createCustomAdapterEventEmitter, StoreKeyMap, isFileReference, Environment, Luvio, InMemoryStore } from '@luvio/engine';
+import { HttpStatusCode, StoreKeySet, serializeStructuredKey, StringKeyInMemoryStore, Reader, deepFreeze, emitAdapterEvent, createCustomAdapterEventEmitter, StoreKeyMap, isFileReference, Environment, Luvio, InMemoryStore } from '@luvio/engine';
 import excludeStaleRecordsGate from '@salesforce/gate/lds.graphqlEvalExcludeStaleRecords';
 import { parseAndVisit, Kind, visit, execute, buildSchema, isObjectType, defaultFieldResolver } from '@luvio/graphql-parser';
 import { getRecordId18, keyBuilderQuickActionExecutionRepresentation, ingestQuickActionExecutionRepresentation, keyBuilderContentDocumentCompositeRepresentation, getResponseCacheKeysContentDocumentCompositeRepresentation, keyBuilderFromTypeContentDocumentCompositeRepresentation, ingestContentDocumentCompositeRepresentation, keyBuilderRecord, getTypeCacheKeysRecord, keyBuilderFromTypeRecordRepresentation, ingestRecord, RecordRepresentationRepresentationType, ObjectInfoRepresentationType, getRecordAdapterFactory, getObjectInfoAdapterFactory, getObjectInfosAdapterFactory, UiApiNamespace, RecordRepresentationType, RecordRepresentationTTL, RecordRepresentationVersion, getRecordsAdapterFactory } from '@salesforce/lds-adapters-uiapi';
@@ -33,6 +33,7 @@ import eagerEvalValidAt from '@salesforce/gate/lds.eagerEvalValidAt';
 import eagerEvalStaleWhileRevalidate from '@salesforce/gate/lds.eagerEvalStaleWhileRevalidate';
 import eagerEvalDefaultCachePolicy from '@salesforce/gate/lds.eagerEvalDefaultCachePolicy';
 import ldsPrimingGraphqlBatch from '@salesforce/gate/lds.primingGraphqlBatch';
+import ldsMetadataRefreshEnabled from '@salesforce/gate/lds.metadataRefreshEnabled';
 
 /**
  * Copyright (c) 2022, Salesforce, Inc.,
@@ -615,7 +616,7 @@ function publishDurableStoreEntries(durableRecords, put, publishMetadata) {
  * will refresh the snapshot from network, and then run the results from network
  * through L2 ingestion, returning the subsequent revived snapshot.
  */
-function reviveSnapshot(baseEnvironment, durableStore, unavailableSnapshot, durableStoreErrorHandler, buildL1Snapshot, reviveMetrics = { l2Trips: [] }) {
+function reviveSnapshot(baseEnvironment, durableStore, unavailableSnapshot, durableStoreErrorHandler, buildL1Snapshot, revivingStore, reviveMetrics = { l2Trips: [] }) {
     const { recordId, select, missingLinks, seenRecords, state } = unavailableSnapshot;
     // L2 can only revive Unfulfilled snapshots that have a selector since they have the
     // info needed to revive (like missingLinks) and rebuild.  Otherwise return L1 snapshot.
@@ -625,10 +626,21 @@ function reviveSnapshot(baseEnvironment, durableStore, unavailableSnapshot, dura
             metrics: reviveMetrics,
         });
     }
-    // in case L1 store changes/deallocs a record while we are doing the async read
-    // we attempt to read all keys from L2 - so combine recordId with any seenRecords
-    const keysToReviveSet = new StoreKeySet().add(recordId);
-    keysToReviveSet.merge(seenRecords);
+    const keysToReviveSet = new StoreKeySet();
+    if (revivingStore) {
+        // Any stale keys since the last l2 read should be cleared and fetched again
+        for (const staleKey of revivingStore.staleEntries) {
+            keysToReviveSet.add(staleKey);
+        }
+        revivingStore.clearStale();
+    }
+    else {
+        // when not using a reviving store:
+        // in case L1 store changes/deallocs a record while we are doing the async read
+        // we attempt to read all keys from L2 - so combine recordId with any seenRecords
+        keysToReviveSet.add(recordId);
+        keysToReviveSet.merge(seenRecords);
+    }
     keysToReviveSet.merge(missingLinks);
     const keysToRevive = keysToReviveSet.keysAsArray();
     const canonicalKeys = keysToRevive.map((x) => serializeStructuredKey(baseEnvironment.storeGetCanonicalKey(x)));
@@ -678,7 +690,7 @@ function reviveSnapshot(baseEnvironment, durableStore, unavailableSnapshot, dura
             for (let i = 0, len = newKeys.length; i < len; i++) {
                 const newSnapshotSeenKey = newKeys[i];
                 if (!alreadyRequestedOrRevivedSet.has(newSnapshotSeenKey)) {
-                    return reviveSnapshot(baseEnvironment, durableStore, snapshot, durableStoreErrorHandler, buildL1Snapshot, reviveMetrics);
+                    return reviveSnapshot(baseEnvironment, durableStore, snapshot, durableStoreErrorHandler, buildL1Snapshot, revivingStore, reviveMetrics);
                 }
             }
         }
@@ -767,8 +779,9 @@ class DurableTTLStore {
     }
 }
 
-function flushInMemoryStoreValuesToDurableStore(store, durableStore, durableStoreErrorHandler, redirects, additionalDurableStoreOperations = []) {
+function flushInMemoryStoreValuesToDurableStore(store, durableStore, durableStoreErrorHandler, redirects, additionalDurableStoreOperations = [], enableDurableMetadataRefresh = false) {
     const durableRecords = create$6(null);
+    const refreshedDurableRecords = create$6(null);
     const evictedRecords = create$6(null);
     const { records, metadata: storeMetadata, visitedIds, refreshedIds, } = store.fallbackStringKeyInMemoryStore;
     // TODO: W-8909393 Once metadata is stored in its own segment we need to
@@ -778,32 +791,36 @@ function flushInMemoryStoreValuesToDurableStore(store, durableStore, durableStor
     for (let i = 0, len = keys$1.length; i < len; i += 1) {
         const key = keys$1[i];
         const record = records[key];
+        const wasVisited = visitedIds[key] !== undefined;
         // this record has been evicted, evict from DS
-        if (record === undefined) {
+        if (wasVisited && record === undefined) {
             evictedRecords[key] = true;
             continue;
         }
         const metadata = storeMetadata[key];
-        durableRecords[key] = {
-            data: record,
-        };
-        if (metadata !== undefined) {
-            durableRecords[key].metadata = {
-                ...metadata,
-                metadataVersion: DURABLE_METADATA_VERSION,
-            };
-        }
+        const entries = wasVisited === true || enableDurableMetadataRefresh === false
+            ? durableRecords
+            : refreshedDurableRecords;
+        setRecordTo(entries, key, record, metadata);
     }
     const durableStoreOperations = additionalDurableStoreOperations;
-    // publishes
     const recordKeys = keys$7(durableRecords);
     if (recordKeys.length > 0) {
+        // publishes with data
         durableStoreOperations.push({
             type: 'setEntries',
             entries: durableRecords,
             segment: DefaultDurableSegment,
         });
     }
+    if (keys$7(refreshedDurableRecords).length > 0) {
+        // publishes with only metadata updates
+        durableStoreOperations.push({
+            type: 'setMetadata',
+            entries: refreshedDurableRecords,
+            segment: DefaultDurableSegment,
+        });
+    }
     // redirects
     redirects.forEach((value, key) => {
         durableStoreOperations.push({
@@ -830,6 +847,17 @@ function flushInMemoryStoreValuesToDurableStore(store, durableStore, durableStor
     }
     return Promise.resolve();
 }
+function setRecordTo(entries, key, record, metadata) {
+    entries[key] = {
+        data: record,
+    };
+    if (metadata !== undefined) {
+        entries[key].metadata = {
+            ...metadata,
+            metadataVersion: DURABLE_METADATA_VERSION,
+        };
+    }
+}
 
 const DurableEnvironmentEventDiscriminator = 'durable';
 function emitDurableEnvironmentAdapterEvent(eventData, observers) {
@@ -874,6 +902,50 @@ async function reviveRedirects(durableStore, env) {
     }
 }
 
+function buildRevivingStagingStore(upstreamStore) {
+    const localStore = new StringKeyInMemoryStore();
+    const staleEntries = new Set();
+    function readEntry(key) {
+        if (typeof key !== 'string') {
+            return upstreamStore.readEntry(key);
+        }
+        let storeEntry = localStore.readEntry(key);
+        if (!storeEntry) {
+            // read from upstream store...
+            storeEntry = upstreamStore.readEntry(key);
+            // put it in our store to avoid it getting evicted prior to the next durable store read
+            localStore.put(key, storeEntry);
+        }
+        return storeEntry;
+    }
+    // Entries are marked stale by the durable store change listener. They are not
+    // immediately evicted so as to not result in a cache miss during a rebuild.
+    // The revive process will clear stale entries and read them from the durable store
+    // on the next revive loop.
+    function markStale(key) {
+        staleEntries.add(key);
+    }
+    // The revive loop clears stale entries right before reading from the durable store.
+    // Any stale entries will be revived to ensure they are present in L1 and match the
+    // latest data.
+    function clearStale() {
+        for (const key of staleEntries) {
+            localStore.dealloc(key);
+        }
+        staleEntries.clear();
+    }
+    // All functions other than `readEntry` pass through to the upstream store.
+    // A reviving store is only "active" during a call to `environment.storeLookup`, and will
+    // be used by the reader attempting to build an L1 snapshot. Immediately after the L1 rebuild
+    // the reviving store becomes inactive other than receiving change notifications.
+    return create$6(upstreamStore, {
+        readEntry: { value: readEntry },
+        markStale: { value: markStale },
+        clearStale: { value: clearStale },
+        staleEntries: { value: staleEntries },
+    });
+}
+
 const AdapterContextSegment = 'ADAPTER-CONTEXT';
 const ADAPTER_CONTEXT_ID_SUFFIX = '__NAMED_CONTEXT';
 async function reviveOrCreateContext(adapterId, durableStore, durableStoreErrorHandler, contextStores, pendingContextStoreKeys, onContextLoaded) {
@@ -929,14 +1001,16 @@ function isUnfulfilledSnapshot$1(cachedSnapshotResult) {
  * @param durableStore A DurableStore implementation
  * @param instrumentation An instrumentation function implementation
  */
-function makeDurable(environment, { durableStore, instrumentation }) {
-    let ingestStagingStore = null;
+function makeDurable(environment, { durableStore, instrumentation, useRevivingStore, enableDurableMetadataRefresh = false, }) {
+    let stagingStore = null;
     const durableTTLStore = new DurableTTLStore(durableStore);
     const mergeKeysPromiseMap = new Map();
     // When a context store is mutated we write it to L2, which causes DS on change
     // event. If this instance of makeDurable caused that L2 write we can ignore that
     // on change event. This Set helps us do that.
     const pendingContextStoreKeys = new Set();
+    // Reviving stores are tracked so that they can be notified of durable store change notifications.
+    const revivingStores = new Set();
     // redirects that need to be flushed to the durable store
     const pendingStoreRedirects = new Map();
     const contextStores = create$6(null);
@@ -962,6 +1036,7 @@ function makeDurable(environment, { durableStore, instrumentation }) {
         const defaultSegmentKeys = [];
         const adapterContextSegmentKeys = [];
         const redirectSegmentKeys = [];
+        const metadataRefreshSegmentKeys = [];
         const messagingSegmentKeys = [];
         let shouldBroadcast = false;
         for (let i = 0, len = changes.length; i < len; i++) {
@@ -969,7 +1044,12 @@ function makeDurable(environment, { durableStore, instrumentation }) {
             // we only care about changes to the data which is stored in the default
             // segment or the adapter context
             if (change.segment === DefaultDurableSegment) {
-                defaultSegmentKeys.push(...change.ids);
+                if (change.type === 'setMetadata') {
+                    metadataRefreshSegmentKeys.push(...change.ids);
+                }
+                else {
+                    defaultSegmentKeys.push(...change.ids);
+                }
             }
             else if (change.segment === AdapterContextSegment) {
                 adapterContextSegmentKeys.push(...change.ids);
@@ -1033,9 +1113,26 @@ function makeDurable(environment, { durableStore, instrumentation }) {
                 // and go through an entire broadcast/revive cycle for unchanged data
                 // call base environment storeEvict so this evict is not tracked for durable deletion
                 environment.storeEvict(key);
+                for (const revivingStore of revivingStores) {
+                    revivingStore.markStale(key);
+                }
             }
             shouldBroadcast = true;
         }
+        // process metadata only refreshes
+        if (metadataRefreshSegmentKeys.length > 0) {
+            const entries = await durableStore.getMetadata(metadataRefreshSegmentKeys, DefaultDurableSegment);
+            if (entries !== undefined) {
+                const entryKeys = keys$7(entries);
+                for (let i = 0, len = entryKeys.length; i < len; i++) {
+                    const entryKey = entryKeys[i];
+                    const { metadata } = entries[entryKey];
+                    if (metadata !== undefined) {
+                        environment.putStoreMetadata(entryKey, metadata, false);
+                    }
+                }
+            }
+        }
         if (shouldBroadcast) {
             await environment.storeBroadcast(rebuildSnapshot, environment.snapshotAvailable);
         }
@@ -1061,10 +1158,10 @@ function makeDurable(environment, { durableStore, instrumentation }) {
     };
     const storePublish = function (key, data) {
         validateNotDisposed();
-        if (ingestStagingStore === null) {
-            ingestStagingStore = buildIngestStagingStore(environment);
+        if (stagingStore === null) {
+            stagingStore = buildIngestStagingStore(environment);
         }
-        ingestStagingStore.publish(key, data);
+        stagingStore.publish(key, data);
         // remove record from main luvio L1 cache while we are on the synchronous path
         // because we do not want some other code attempting to use the
         // in-memory values before the durable store onChanged handler
@@ -1073,26 +1170,26 @@ function makeDurable(environment, { durableStore, instrumentation }) {
     };
     const publishStoreMetadata = function (recordId, storeMetadata) {
         validateNotDisposed();
-        if (ingestStagingStore === null) {
-            ingestStagingStore = buildIngestStagingStore(environment);
+        if (stagingStore === null) {
+            stagingStore = buildIngestStagingStore(environment);
         }
-        ingestStagingStore.publishMetadata(recordId, storeMetadata);
+        stagingStore.publishMetadata(recordId, storeMetadata);
     };
     const storeIngest = function (key, ingest, response, luvio) {
         validateNotDisposed();
         // we don't ingest to the luvio L1 store from network directly, we ingest to
         // L2 and let DurableStore on change event revive keys into luvio L1 store
-        if (ingestStagingStore === null) {
-            ingestStagingStore = buildIngestStagingStore(environment);
+        if (stagingStore === null) {
+            stagingStore = buildIngestStagingStore(environment);
         }
-        environment.storeIngest(key, ingest, response, luvio, ingestStagingStore);
+        environment.storeIngest(key, ingest, response, luvio, stagingStore);
     };
     const storeIngestError = function (key, errorSnapshot, storeMetadataParams, _storeOverride) {
         validateNotDisposed();
-        if (ingestStagingStore === null) {
-            ingestStagingStore = buildIngestStagingStore(environment);
+        if (stagingStore === null) {
+            stagingStore = buildIngestStagingStore(environment);
         }
-        environment.storeIngestError(key, errorSnapshot, storeMetadataParams, ingestStagingStore);
+        environment.storeIngestError(key, errorSnapshot, storeMetadataParams, stagingStore);
     };
     const storeBroadcast = function (_rebuildSnapshot, _snapshotDataAvailable) {
         validateNotDisposed();
@@ -1103,19 +1200,19 @@ function makeDurable(environment, { durableStore, instrumentation }) {
     };
     const publishChangesToDurableStore = function (additionalDurableStoreOperations) {
         validateNotDisposed();
-        if (ingestStagingStore === null) {
+        if (stagingStore === null) {
             return Promise.resolve();
         }
-        const promise = flushInMemoryStoreValuesToDurableStore(ingestStagingStore, durableStore, durableStoreErrorHandler, new Map(pendingStoreRedirects), additionalDurableStoreOperations);
+        const promise = flushInMemoryStoreValuesToDurableStore(stagingStore, durableStore, durableStoreErrorHandler, new Map(pendingStoreRedirects), additionalDurableStoreOperations, enableDurableMetadataRefresh);
         pendingStoreRedirects.clear();
-        ingestStagingStore = null;
+        stagingStore = null;
         return promise;
     };
     const storeLookup = function (sel, createSnapshot, refresh, ttlStrategy) {
         validateNotDisposed();
-        // if this lookup is right after an ingest there will be a staging store
-        if (ingestStagingStore !== null) {
-            const reader = new Reader(ingestStagingStore, sel.variables, refresh, undefined, ttlStrategy);
+        // if this lookup is right after an ingest or during a revive there will be a staging store
+        if (stagingStore !== null) {
+            const reader = new Reader(stagingStore, sel.variables, refresh, undefined, ttlStrategy);
             return reader.read(sel);
         }
         // otherwise this is from buildCachedSnapshot and we should use the luvio
@@ -1124,24 +1221,24 @@ function makeDurable(environment, { durableStore, instrumentation }) {
     };
     const storeEvict = function (key) {
         validateNotDisposed();
-        if (ingestStagingStore === null) {
-            ingestStagingStore = buildIngestStagingStore(environment);
+        if (stagingStore === null) {
+            stagingStore = buildIngestStagingStore(environment);
         }
-        ingestStagingStore.evict(key);
+        stagingStore.evict(key);
     };
     const getNode = function (key) {
         validateNotDisposed();
-        if (ingestStagingStore === null) {
-            ingestStagingStore = buildIngestStagingStore(environment);
+        if (stagingStore === null) {
+            stagingStore = buildIngestStagingStore(environment);
         }
-        return environment.getNode(key, ingestStagingStore);
+        return environment.getNode(key, stagingStore);
     };
     const wrapNormalizedGraphNode = function (normalized) {
         validateNotDisposed();
-        if (ingestStagingStore === null) {
-            ingestStagingStore = buildIngestStagingStore(environment);
+        if (stagingStore === null) {
+            stagingStore = buildIngestStagingStore(environment);
         }
-        return environment.wrapNormalizedGraphNode(normalized, ingestStagingStore);
+        return environment.wrapNormalizedGraphNode(normalized, stagingStore);
     };
     const rebuildSnapshot = function (snapshot, onRebuild) {
         validateNotDisposed();
@@ -1153,7 +1250,7 @@ function makeDurable(environment, { durableStore, instrumentation }) {
                 return;
             }
             // Do an L2 revive and emit to subscriber using the callback.
-            reviveSnapshot(environment, durableStore, rebuilt, durableStoreErrorHandler, () => {
+            reviveSnapshotWrapper(rebuilt, () => {
                 // reviveSnapshot will revive into L1, and since "records" is a reference
                 // (and not a copy) to the L1 records we can use it for rebuild
                 let rebuiltSnap;
@@ -1194,10 +1291,10 @@ function makeDurable(environment, { durableStore, instrumentation }) {
         // the next publishChangesToDurableStore.  NOTE: we don't need to call
         // redirect on the base environment store because staging store and base
         // L1 store share the same redirect and reverseRedirectKeys
-        if (ingestStagingStore === null) {
-            ingestStagingStore = buildIngestStagingStore(environment);
+        if (stagingStore === null) {
+            stagingStore = buildIngestStagingStore(environment);
         }
-        ingestStagingStore.redirect(existingKey, canonicalKey);
+        stagingStore.redirect(existingKey, canonicalKey);
     };
     const storeSetTTLOverride = function (namespace, representationName, ttl) {
         validateNotDisposed();
@@ -1238,7 +1335,7 @@ function makeDurable(environment, { durableStore, instrumentation }) {
             if (isUnfulfilledSnapshot$1(snapshot)) {
                 const start = Date.now();
                 emitDurableEnvironmentAdapterEvent({ type: 'l2-revive-start' }, adapterRequestContext.eventObservers);
-                const revivedSnapshot = reviveSnapshot(environment, durableStore, snapshot, durableStoreErrorHandler, () => injectedStoreLookup(snapshot.select, snapshot.refresh)).then((result) => {
+                const revivedSnapshot = reviveSnapshotWrapper(snapshot, () => injectedStoreLookup(snapshot.select, snapshot.refresh)).then((result) => {
                     emitDurableEnvironmentAdapterEvent({
                         type: 'l2-revive-end',
                         snapshot: result.snapshot,
@@ -1263,15 +1360,15 @@ function makeDurable(environment, { durableStore, instrumentation }) {
     };
     const getIngestStagingStoreRecords = function () {
         validateNotDisposed();
-        if (ingestStagingStore !== null) {
-            return ingestStagingStore.fallbackStringKeyInMemoryStore.records;
+        if (stagingStore !== null) {
+            return stagingStore.fallbackStringKeyInMemoryStore.records;
         }
         return {};
     };
     const getIngestStagingStoreMetadata = function () {
         validateNotDisposed();
-        if (ingestStagingStore !== null) {
-            return ingestStagingStore.fallbackStringKeyInMemoryStore.metadata;
+        if (stagingStore !== null) {
+            return stagingStore.fallbackStringKeyInMemoryStore.metadata;
         }
         return {};
     };
@@ -1310,22 +1407,20 @@ function makeDurable(environment, { durableStore, instrumentation }) {
                 }
                 await Promise.all(pendingPromises);
                 const entries = await durableStore.getEntries(keysToReviveAsArray, DefaultDurableSegment);
-                ingestStagingStore = buildIngestStagingStore(environment);
+                stagingStore = buildIngestStagingStore(environment);
                 publishDurableStoreEntries(entries, (key, record) => {
                     if (typeof key === 'string') {
-                        ingestStagingStore.fallbackStringKeyInMemoryStore.records[key] =
-                            record;
+                        stagingStore.fallbackStringKeyInMemoryStore.records[key] = record;
                     }
                     else {
-                        ingestStagingStore.recordsMap.set(key, record);
+                        stagingStore.recordsMap.set(key, record);
                     }
                 }, (key, metadata) => {
                     if (typeof key === 'string') {
-                        ingestStagingStore.fallbackStringKeyInMemoryStore.metadata[key] =
-                            metadata;
+                        stagingStore.fallbackStringKeyInMemoryStore.metadata[key] = metadata;
                     }
                     else {
-                        ingestStagingStore.metadataMap.set(key, metadata);
+                        stagingStore.metadataMap.set(key, metadata);
                     }
                 });
                 snapshotFromMemoryIngest = await ingestAndBroadcastFunc();
@@ -1354,7 +1449,7 @@ function makeDurable(environment, { durableStore, instrumentation }) {
             // we aren't doing any merging so we don't have to synchronize, the
             // underlying DurableStore implementation takes care of R/W sync
             // so all we have to do is ingest then write to L2
-            ingestStagingStore = buildIngestStagingStore(environment);
+            stagingStore = buildIngestStagingStore(environment);
             snapshotFromMemoryIngest = await ingestAndBroadcastFunc();
         }
         if (snapshotFromMemoryIngest === undefined) {
@@ -1365,12 +1460,12 @@ function makeDurable(environment, { durableStore, instrumentation }) {
         }
         // if snapshot from staging store lookup is unfulfilled then do an L2 lookup
         const { select, refresh } = snapshotFromMemoryIngest;
-        const result = await reviveSnapshot(environment, durableStore, snapshotFromMemoryIngest, durableStoreErrorHandler, () => environment.storeLookup(select, environment.createSnapshot, refresh));
+        const result = await reviveSnapshotWrapper(snapshotFromMemoryIngest, () => environment.storeLookup(select, environment.createSnapshot, refresh));
         return result.snapshot;
     };
     const handleErrorResponse = async function (ingestAndBroadcastFunc) {
         validateNotDisposed();
-        ingestStagingStore = buildIngestStagingStore(environment);
+        stagingStore = buildIngestStagingStore(environment);
         return ingestAndBroadcastFunc();
     };
     const getNotifyChangeStoreEntries = function (keys) {
@@ -1421,6 +1516,27 @@ function makeDurable(environment, { durableStore, instrumentation }) {
         await durableStore.setEntries({ notifyStoreUpdateAvailable: { data: entryKeys } }, MessagingDurableSegment);
         return Promise.resolve(undefined);
     };
+    const reviveSnapshotWrapper = function (unavailableSnapshot, buildL1Snapshot) {
+        let revivingStore = undefined;
+        if (useRevivingStore) {
+            // NOTE: `store` is private, there doesn't seem to be a better,
+            // cleaner way of accessing it from a derived environment.
+            let baseStore = environment.store;
+            // If we're rebuilding during an ingest, the existing staging store should be the base store.
+            if (stagingStore) {
+                baseStore = stagingStore;
+            }
+            let revivingStore = buildRevivingStagingStore(baseStore);
+            revivingStores.add(revivingStore);
+        }
+        return reviveSnapshot(environment, durableStore, unavailableSnapshot, durableStoreErrorHandler, () => {
+            const tempStore = stagingStore;
+            const result = buildL1Snapshot();
+            stagingStore = tempStore;
+            return result;
+        }, revivingStore).finally(() => {
+        });
+    };
     // set the default cache policy of the base environment
     environment.setDefaultCachePolicy({
         type: 'stale-while-revalidate',
@@ -1455,6 +1571,72 @@ function makeDurable(environment, { durableStore, instrumentation }) {
     });
 }
 
+/**
+ * Copyright (c) 2022, Salesforce, Inc.,
+ * All rights reserved.
+ * For full license text, see the LICENSE.txt file
+ */
+
+const API_NAMESPACE = 'UiApi';
+const RECORD_REPRESENTATION_NAME = 'RecordRepresentation';
+const RECORD_VIEW_ENTITY_REPRESENTATION_NAME = 'RecordViewEntityRepresentation';
+const RECORD_ID_PREFIX = `${API_NAMESPACE}::${RECORD_REPRESENTATION_NAME}:`;
+const RECORD_VIEW_ENTITY_ID_PREFIX = `${API_NAMESPACE}::${RECORD_VIEW_ENTITY_REPRESENTATION_NAME}:Name:`;
+const RECORD_FIELDS_KEY_JUNCTION = '__fields__';
+function isStoreKeyRecordId(key) {
+    return key.indexOf(RECORD_ID_PREFIX) > -1 && key.indexOf(RECORD_FIELDS_KEY_JUNCTION) === -1;
+}
+function isStoreKeyRecordViewEntity(key) {
+    return (key.indexOf(RECORD_VIEW_ENTITY_ID_PREFIX) > -1 &&
+        key.indexOf(RECORD_FIELDS_KEY_JUNCTION) === -1);
+}
+function isStoreKeyRecordField(key) {
+    return key.indexOf(RECORD_ID_PREFIX) > -1 && key.indexOf(RECORD_FIELDS_KEY_JUNCTION) > -1;
+}
+function extractRecordIdFromStoreKey(key) {
+    if (key === undefined ||
+        (key.indexOf(RECORD_ID_PREFIX) === -1 && key.indexOf(RECORD_VIEW_ENTITY_ID_PREFIX) === -1)) {
+        return undefined;
+    }
+    const parts = key.split(':');
+    return parts[parts.length - 1].split('_')[0];
+}
+function buildRecordFieldStoreKey(recordKey, fieldName) {
+    return `${recordKey}${RECORD_FIELDS_KEY_JUNCTION}${fieldName}`;
+}
+function objectsDeepEqual(lhs, rhs) {
+    if (lhs === rhs)
+        return true;
+    if (typeof lhs !== 'object' || typeof rhs !== 'object' || lhs === null || rhs === null)
+        return false;
+    const lhsKeys = Object.keys(lhs);
+    const rhsKeys = Object.keys(rhs);
+    if (lhsKeys.length !== rhsKeys.length)
+        return false;
+    for (let key of lhsKeys) {
+        if (!rhsKeys.includes(key))
+            return false;
+        if (typeof lhs[key] === 'function' || typeof rhs[key] === 'function') {
+            if (lhs[key].toString() !== rhs[key].toString())
+                return false;
+        }
+        else {
+            if (!objectsDeepEqual(lhs[key], rhs[key]))
+                return false;
+        }
+    }
+    return true;
+}
+
+function isStoreRecordError(storeRecord) {
+    return storeRecord.__type === 'error';
+}
+function isEntryDurableRecordRepresentation(entry, key) {
+    // Either a DurableRecordRepresentation or StoreRecordError can live at a record key
+    return ((isStoreKeyRecordId(key) || isStoreKeyRecordViewEntity(key)) &&
+        entry.data.__type === undefined);
+}
+
 /**
  * Copyright (c) 2022, Salesforce, Inc.,
  * All rights reserved.
@@ -1839,7 +2021,7 @@ function isFailure(result) {
 function errors(result) {
     return result.error;
 }
-function values$3(result) {
+function values$4(result) {
     return result.value;
 }
 function flattenResults(results) {
@@ -1847,7 +2029,7 @@ function flattenResults(results) {
     if (fails.length > 0) {
         return failure(fails);
     }
-    return success(results.filter(isSuccess).map(values$3));
+    return success(results.filter(isSuccess).map(values$4));
 }
 
 function getFieldInfo(apiName, fieldName, infoMap) {
@@ -2733,7 +2915,7 @@ function fieldsToFilters(fieldValues, joinAlias, apiName, input, compoundOperato
     if (failures.length > 0) {
         return failure(failures);
     }
-    const containers = results.filter(isSuccess).map(values$3);
+    const containers = results.filter(isSuccess).map(values$4);
     const predicates = [];
     containers.forEach((c) => {
         if (c.predicate !== undefined) {
@@ -3025,7 +3207,7 @@ function dateFunctions(operatorNode, extract, dataType) {
     if (fails.length > 0) {
         return failure(fails);
     }
-    const vals = results.filter(isSuccess).reduce(flatMap(values$3), []);
+    const vals = results.filter(isSuccess).reduce(flatMap(values$4), []);
     return success(vals);
 }
 function isFilterFunction(name) {
@@ -3035,7 +3217,7 @@ function fieldOperators(operatorNode, dataType) {
     const results = Object.entries(operatorNode.fields)
         .filter(([key, _]) => isFilterFunction(key) === false)
         .map(([key, value]) => operatorWithValue(key, value, dataType));
-    const _values = results.filter(isSuccess).map(values$3);
+    const _values = results.filter(isSuccess).map(values$4);
     const fails = results.filter(isFailure).reduce(flatMap(errors), []);
     if (fails.length > 0) {
         return failure(fails);
@@ -3956,7 +4138,7 @@ function selectionToQueryField(node, names, parentApiName, parentAlias, input, j
 }
 function recordFields(luvioSelections, names, parentApiName, parentAlias, input, joins) {
     const results = luvioSelections.map((selection) => selectionToQueryField(selection, names, parentApiName, parentAlias, input, joins));
-    const fields = results.filter(isSuccess).reduce(flatMap(values$3), []);
+    const fields = results.filter(isSuccess).reduce(flatMap(values$4), []);
     const fails = results.filter(isFailure).reduce(flatMap(errors), []);
     if (fails.length > 0) {
         return failure(fails);
@@ -4202,7 +4384,7 @@ function rootRecordQuery(selection, input) {
 }
 function rootQuery(recordNodes, input) {
     const results = recordNodes.map((record) => rootRecordQuery(record, input));
-    const connections = results.filter(isSuccess).map(values$3);
+    const connections = results.filter(isSuccess).map(values$4);
     const fails = results.filter(isFailure).reduce(flatMap(errors), []);
     if (fails.length > 0) {
         return failure(fails);
@@ -4653,7 +4835,11 @@ function makeStoreEval(preconditioner, objectInfoService, userId, contextProvide
         try {
             const { data, seenRecords } = await queryEvaluator(rootQuery, context, eventEmitter);
             const rebuildWithStoreEval = ((originalSnapshot) => {
-                return storeEval(config, originalSnapshot, observers, connectionKeyBuilder);
+                return storeEval(config, originalSnapshot, observers, connectionKeyBuilder).then((rebuiltSnapshot) => {
+                    return objectsDeepEqual(originalSnapshot.data, rebuiltSnapshot.data)
+                        ? originalSnapshot
+                        : rebuiltSnapshot;
+                });
             });
             const recordId = generateUniqueRecordId$1();
             // if the non-eval'ed snapshot was an error then we return a synthetic
@@ -4956,7 +5142,7 @@ function createDraftSynthesisErrorResponse(message = 'failed to synthesize draft
     return new DraftErrorFetchResponse(HttpStatusCode.BadRequest, error);
 }
 
-const { keys: keys$5, create: create$5, assign: assign$5, values: values$2 } = Object;
+const { keys: keys$5, create: create$5, assign: assign$5, values: values$3 } = Object;
 const { stringify: stringify$5, parse: parse$5 } = JSON;
 const { isArray: isArray$3 } = Array;
 
@@ -5391,7 +5577,7 @@ class DurableDraftQueue {
                 const queueOperations = handler.getQueueOperationsForCompletingDrafts(queue, action);
                 // write the queue operations to the store prior to ingesting the result
                 await this.draftStore.completeAction(queueOperations);
-                await handler.handleActionCompleted(action, queueOperations, values$2(this.handlers));
+                await handler.handleActionCompleted(action, queueOperations, values$3(this.handlers));
                 this.retryIntervalMilliseconds = 0;
                 this.uploadingActionId = undefined;
                 await this.notifyChangedListeners({
@@ -6613,49 +6799,6 @@ function makeEnvironmentDraftAware(luvio, env, durableStore, handlers, draftQueu
     });
 }
 
-/**
- * Copyright (c) 2022, Salesforce, Inc.,
- * All rights reserved.
- * For full license text, see the LICENSE.txt file
- */
-
-const API_NAMESPACE = 'UiApi';
-const RECORD_REPRESENTATION_NAME = 'RecordRepresentation';
-const RECORD_VIEW_ENTITY_REPRESENTATION_NAME = 'RecordViewEntityRepresentation';
-const RECORD_ID_PREFIX = `${API_NAMESPACE}::${RECORD_REPRESENTATION_NAME}:`;
-const RECORD_VIEW_ENTITY_ID_PREFIX = `${API_NAMESPACE}::${RECORD_VIEW_ENTITY_REPRESENTATION_NAME}:Name:`;
-const RECORD_FIELDS_KEY_JUNCTION = '__fields__';
-function isStoreKeyRecordId(key) {
-    return key.indexOf(RECORD_ID_PREFIX) > -1 && key.indexOf(RECORD_FIELDS_KEY_JUNCTION) === -1;
-}
-function isStoreKeyRecordViewEntity(key) {
-    return (key.indexOf(RECORD_VIEW_ENTITY_ID_PREFIX) > -1 &&
-        key.indexOf(RECORD_FIELDS_KEY_JUNCTION) === -1);
-}
-function isStoreKeyRecordField(key) {
-    return key.indexOf(RECORD_ID_PREFIX) > -1 && key.indexOf(RECORD_FIELDS_KEY_JUNCTION) > -1;
-}
-function extractRecordIdFromStoreKey(key) {
-    if (key === undefined ||
-        (key.indexOf(RECORD_ID_PREFIX) === -1 && key.indexOf(RECORD_VIEW_ENTITY_ID_PREFIX) === -1)) {
-        return undefined;
-    }
-    const parts = key.split(':');
-    return parts[parts.length - 1].split('_')[0];
-}
-function buildRecordFieldStoreKey(recordKey, fieldName) {
-    return `${recordKey}${RECORD_FIELDS_KEY_JUNCTION}${fieldName}`;
-}
-
-function isStoreRecordError(storeRecord) {
-    return storeRecord.__type === 'error';
-}
-function isEntryDurableRecordRepresentation(entry, key) {
-    // Either a DurableRecordRepresentation or StoreRecordError can live at a record key
-    return ((isStoreKeyRecordId(key) || isStoreKeyRecordViewEntity(key)) &&
-        entry.data.__type === undefined);
-}
-
 function serializeFieldArguments(argumentNodes, variables) {
     const mutableArgumentNodes = Object.assign([], argumentNodes);
     return `args__(${mutableArgumentNodes
@@ -6887,7 +7030,7 @@ function isArrayLike(x) {
         (x.length === 0 || (x.length > 0 && Object.prototype.hasOwnProperty.call(x, x.length - 1))));
 }
 
-const { create: create$4, keys: keys$4, values: values$1, entries: entries$3, assign: assign$4 } = Object;
+const { create: create$4, keys: keys$4, values: values$2, entries: entries$3, assign: assign$4 } = Object;
 const { stringify: stringify$4, parse: parse$4 } = JSON;
 const { isArray: isArray$2 } = Array;
 
@@ -7220,7 +7363,7 @@ function dateTimePredicate(input, operator, field, alias) {
         return predicate;
     }
     else if (literal !== undefined) {
-        const isAvailableLiteral = values$1(DateLiteral).includes(literal);
+        const isAvailableLiteral = values$2(DateLiteral).includes(literal);
         // eslint-disable-next-line @salesforce/lds/no-error-in-production
         if (!isAvailableLiteral)
             throw new Error(`${literal} is not a valid DateLiteral`);
@@ -7894,7 +8037,7 @@ function dedupeJoins(joins) {
     for (const join of joins) {
         deduped[join.alias + join.to] = join;
     }
-    return values$1(deduped);
+    return values$2(deduped);
 }
 function buildJoins(config) {
     let sql = '';
@@ -8542,7 +8685,7 @@ function flatten(previous, current) {
     return previous.concat(current);
 }
 function findFieldInfo(objectInfo, fieldName) {
-    return values$1(objectInfo.fields).find((field) => field.apiName === fieldName ||
+    return values$2(objectInfo.fields).find((field) => field.apiName === fieldName ||
         (field.dataType === 'Reference' && field.relationshipName === fieldName));
 }
 
@@ -8562,10 +8705,10 @@ function orderByToPredicate(orderBy, recordType, alias, objectInfoMap, joins) {
         for (let i = 0, len = keys$1.length; i < len; i++) {
             const key = keys$1[i];
             const parentFields = objectInfoMap[recordType].fields;
-            const fieldInfo = values$1(parentFields).find(findSpanningField(key));
+            const fieldInfo = values$2(parentFields).find(findSpanningField(key));
             if (fieldInfo && fieldInfo.referenceToInfos.length > 0) {
                 const { apiName } = fieldInfo.referenceToInfos[0];
-                const parentFieldInfo = values$1(objectInfoMap[recordType].fields).find(findSpanningField(fieldInfo.apiName));
+                const parentFieldInfo = values$2(objectInfoMap[recordType].fields).find(findSpanningField(fieldInfo.apiName));
                 if (parentFieldInfo !== undefined) {
                     const path = {
                         leftPath: `$.fields.${parentFieldInfo.apiName}.value`,
@@ -8707,7 +8850,7 @@ function addResolversToSchema(schema, polyFields) {
     let baseRecord = undefined;
     // Concrete types for Polymorphic field
     const polyTypes = [];
-    for (const type of values$1(schema.getTypeMap())) {
+    for (const type of values$2(schema.getTypeMap())) {
         if (type.name === 'Record') {
             recordInterface = type;
         }
@@ -8720,7 +8863,7 @@ function addResolversToSchema(schema, polyFields) {
         if (polyFields.find((fieldTypeName) => fieldTypeName === type.name) !== undefined) {
             polyTypes.push(type);
         }
-        const fields = values$1(type.getFields());
+        const fields = values$2(type.getFields());
         // initialize the fields of current type with default behavior
         for (const field of fields) {
             field.resolve = defaultFieldResolver;
@@ -9122,26 +9265,20 @@ function generateRecordQueries(objectInfos) {
     let recordConnections = ``;
     const polymorphicFieldTypeNames = new Set();
     let typedScalars = new Set();
-    for (const objectInfo of values$1(objectInfos)) {
+    let parentRelationshipFields = new Set();
+    for (const objectInfo of values$2(objectInfos)) {
         const { apiName, childRelationships } = objectInfo;
         let fields = ``;
         typedScalars.add(`${apiName}_Filter`);
         typedScalars.add(`${apiName}_OrderBy`);
-        for (const childRelationship of childRelationships) {
-            const { childObjectApiName } = childRelationship;
-            // Only add the relationship if there is relevant objectinfos for it,
-            // otherwise we'd be defining types we cannot satisfy and aren't referenced in
-            // the query.
-            if (objectInfos[childObjectApiName] !== undefined) {
-                fields += `${childRelationship.relationshipName}(first: Int, where: ${childObjectApiName}_Filter, orderBy: ${childObjectApiName}_OrderBy, scope: SupportedScopes): ${childObjectApiName}Connection \n`;
-                typedScalars.add(`${childObjectApiName}_Filter`);
-                typedScalars.add(`${childObjectApiName}_OrderBy`);
-            }
-        }
-        for (const field of values$1(objectInfo.fields)) {
+        for (const field of values$2(objectInfo.fields)) {
             if (!fieldsStaticallyAdded.includes(field.apiName)) {
                 fields += `${field.apiName}: ${dataTypeToType(field.dataType, field.apiName)}\n`;
             }
+            //handles parent relationship
+            if (field.relationshipName === null) {
+                continue;
+            }
             // For spanning parent relationships with no union types
             if (field.referenceToInfos.length === 1) {
                 const [relation] = field.referenceToInfos;
@@ -9149,11 +9286,13 @@ function generateRecordQueries(objectInfos) {
                 // otherwise we'd be defining types we cannot satisfy and aren't referenced in
                 // the query.
                 if (objectInfos[relation.apiName] !== undefined) {
+                    parentRelationshipFields.add(field.relationshipName);
                     fields += `${field.relationshipName}: ${relation.apiName}\n`;
                 }
                 // For polymorphic field, its type is 'Record' inteface. The concrete entity type name is saved for field resolving of next phase
             }
             else if (field.referenceToInfos.length > 1) {
+                parentRelationshipFields.add(field.relationshipName);
                 fields += `${field.relationshipName}: Record\n`;
                 for (const relation of field.referenceToInfos) {
                     if (objectInfos[relation.apiName] !== undefined) {
@@ -9162,6 +9301,20 @@ function generateRecordQueries(objectInfos) {
                 }
             }
         }
+        // handles child relationship
+        for (const childRelationship of childRelationships) {
+            const { childObjectApiName } = childRelationship;
+            // Only add the relationship if there is relevant objectinfos for it,
+            // otherwise we'd be defining types we cannot satisfy and aren't referenced in
+            // the query.
+            // If one field has both parent relationship and child relationship with the same name, the child relationship is ignored. This is how the server GQL has implemented as date of 08/07/2023
+            if (objectInfos[childObjectApiName] !== undefined &&
+                !parentRelationshipFields.has(childRelationship.relationshipName)) {
+                fields += `${childRelationship.relationshipName}(first: Int, where: ${childObjectApiName}_Filter, orderBy: ${childObjectApiName}_OrderBy, scope: SupportedScopes): ${childObjectApiName}Connection \n`;
+                typedScalars.add(`${childObjectApiName}_Filter`);
+                typedScalars.add(`${childObjectApiName}_OrderBy`);
+            }
+        }
         recordQueries += `${apiName}(first: Int, where: ${apiName}_Filter, orderBy: ${apiName}_OrderBy, scope: SupportedScopes): ${apiName}Connection\n`;
         const isServiceAppointment = apiName === 'ServiceAppointment';
         recordConnections += /* GraphQL */ `
@@ -9641,7 +9794,7 @@ function isMineScopeAvailable(apiNamePath, objectInfoApiMap, objectInfos) {
     const objectInfo = objectInfos[apiName[0]];
     if (!objectInfo)
         return false;
-    return values$1(objectInfo.fields).some((fieldInfo) => {
+    return values$2(objectInfo.fields).some((fieldInfo) => {
         return (fieldInfo.apiName === 'OwnerId' &&
             fieldInfo.referenceToInfos.some((referenceToInfo) => {
                 return referenceToInfo.apiName === 'User';
@@ -10892,7 +11045,7 @@ function referenceIdFieldForRelationship(relationshipName) {
  * For full license text, see the LICENSE.txt file
  */
 
-const { keys: keys$3, values, create: create$3, assign: assign$3, freeze } = Object;
+const { keys: keys$3, values: values$1, create: create$3, assign: assign$3, freeze } = Object;
 const { stringify: stringify$3, parse: parse$3 } = JSON;
 const { shift } = Array.prototype;
 const { isArray: isArray$1 } = Array;
@@ -11742,7 +11895,7 @@ class UiApiActionHandler extends AbstractResourceRequestActionHandler {
                 return;
             }
             const objectInfo = objectInfoMap[apiName];
-            const optionalFields = values(objectInfo.fields).map((field) => `${apiName}.${field.apiName}`);
+            const optionalFields = values$1(objectInfo.fields).map((field) => `${apiName}.${field.apiName}`);
             await getAdapterData(this.getRecordAdapter, {
                 recordId: referenceFieldInfo.id,
                 optionalFields,
@@ -11761,7 +11914,7 @@ class UiApiActionHandler extends AbstractResourceRequestActionHandler {
         const referenceToInfos = fieldInfo.referenceToInfos;
         const apiNames = referenceToInfos.map((referenceToInfo) => referenceToInfo.apiName);
         const objectInfoMap = await this.objectInfoService.getObjectInfos(apiNames);
-        for (const objectInfo of values(objectInfoMap)) {
+        for (const objectInfo of values$1(objectInfoMap)) {
             const { apiName, keyPrefix } = objectInfo;
             if (keyPrefix !== null && id.startsWith(keyPrefix)) {
                 return apiName;
@@ -12271,14 +12424,30 @@ function makeRecordDenormalizingDurableStore(luvio, durableStore, getStoreRecord
         const operationsWithDenormedRecords = [];
         for (let i = 0, len = operations.length; i < len; i++) {
             const operation = operations[i];
-            if (operation.segment !== DefaultDurableSegment || operation.type !== 'setEntries') {
-                operationsWithDenormedRecords.push(operation);
-                continue;
+            if (durableStore.plugin !== undefined &&
+                durableStore.plugin.supportsBatchUpdates !== undefined &&
+                durableStore.plugin.supportsBatchUpdates() === true) {
+                if (operation.segment !== DefaultDurableSegment ||
+                    operation.type !== 'setEntries') {
+                    operationsWithDenormedRecords.push(operation);
+                    continue;
+                }
+                operationsWithDenormedRecords.push({
+                    ...operation,
+                    entries: denormalizeEntries(operation.entries),
+                });
+            }
+            else {
+                if (operation.segment !== DefaultDurableSegment ||
+                    operation.type === 'evictEntries') {
+                    operationsWithDenormedRecords.push(operation);
+                    continue;
+                }
+                operationsWithDenormedRecords.push({
+                    ...operation,
+                    entries: denormalizeEntries(operation.entries),
+                });
             }
-            operationsWithDenormedRecords.push({
-                ...operation,
-                entries: denormalizeEntries(operation.entries),
-            });
         }
         return durableStore.batchOperations(operationsWithDenormedRecords);
     };
@@ -12826,6 +12995,9 @@ function draftAwareGraphQLAdapterFactory(userId, objectInfoService, store, luvio
             if (!rebuildResult.errors) {
                 rebuildResult = removeSyntheticFields(rebuildResult, config.query);
             }
+            if (objectsDeepEqual(rebuildResult, originalSnapshot.data)) {
+                return originalSnapshot;
+            }
             // 'originalSnapshot' is the local eval snapshot subscribed. It is always in 'Fulfilled' state. This behavior would change once W-1273462(rebuild non-evaluated snapshot when the graphql local eval rebuild is triggered) is resolved.
             return {
                 ...originalSnapshot,
@@ -14990,7 +15162,7 @@ function registerReportObserver(reportObserver) {
     };
 }
 
-const { keys, create, assign, entries } = Object;
+const { keys, create, assign, entries, values } = Object;
 const { stringify, parse } = JSON;
 
 function selectColumnsFromTableWhereKeyIn(columnNames, table, keyColumnName, whereIn) {
@@ -15024,6 +15196,22 @@ class LdsDataTable {
             }, reject);
         });
     }
+    getMetadataByKeys(keys) {
+        const query = selectColumnsFromTableWhereKeyIn([COLUMN_NAME_KEY$2, COLUMN_NAME_METADATA$1], this.tableName, COLUMN_NAME_KEY$2, keys);
+        return new Promise((resolve, reject) => {
+            this.plugin.query(query, keys, (results) => {
+                resolve(results.rows.reduce((entries, row) => {
+                    const [key, stringifiedMetadata] = row;
+                    if (stringifiedMetadata !== undefined) {
+                        entries[key] = {
+                            metadata: parse(stringifiedMetadata),
+                        };
+                    }
+                    return entries;
+                }, {}));
+            }, reject);
+        });
+    }
     getAll() {
         return new Promise((resolve, reject) => {
             this.plugin.query(this.getAllQuery, [], (x) => {
@@ -15050,6 +15238,24 @@ class LdsDataTable {
             }, []),
         };
     }
+    metadataToUpdateOperations(entries, segment) {
+        return {
+            type: 'update',
+            table: this.tableName,
+            keyColumn: COLUMN_NAME_KEY$2,
+            context: {
+                segment,
+                type: 'setMetadata',
+            },
+            columns: [COLUMN_NAME_METADATA$1],
+            values: keys(entries).reduce((values, key) => {
+                const { metadata } = entries[key];
+                const row = [metadata ? stringify(metadata) : null];
+                values[key] = row;
+                return values;
+            }, {}),
+        };
+    }
     mapToDurableEntries(sqliteResult) {
         return sqliteResult.rows.reduce((entries, row) => {
             const [key, stringifiedData, stringifiedMetadata] = row;
@@ -15096,6 +15302,25 @@ class LdsInternalDataTable {
             }, reject);
         });
     }
+    getMetadataByKeys(keys, namespace) {
+        if (namespace === undefined) {
+            throw Error('LdsInternalDataTable requires namespace');
+        }
+        const query = selectColumnsFromTableWhereKeyInNamespaced([COLUMN_NAME_KEY$1, COLUMN_NAME_METADATA], this.tableName, COLUMN_NAME_KEY$1, keys, COLUMN_NAME_NAMESPACE);
+        return new Promise((resolve, reject) => {
+            this.plugin.query(query, [namespace].concat(keys), (results) => {
+                resolve(results.rows.reduce((entries, row) => {
+                    const [key, stringifiedMetadata] = row;
+                    if (stringifiedMetadata !== undefined) {
+                        entries[key] = {
+                            metadata: parse(stringifiedMetadata),
+                        };
+                    }
+                    return entries;
+                }, {}));
+            }, reject);
+        });
+    }
     getAll(namespace) {
         return new Promise((resolve, reject) => {
             this.plugin.query(this.getAllQuery, [namespace], (x) => {
@@ -15129,6 +15354,42 @@ class LdsInternalDataTable {
             }, []),
         };
     }
+    metadataToUpdateOperations(entries, segment) {
+        return {
+            type: 'update',
+            table: this.tableName,
+            keyColumn: COLUMN_NAME_KEY$1,
+            context: {
+                segment,
+                type: 'setMetadata',
+            },
+            columns: [COLUMN_NAME_METADATA],
+            values: keys(entries).reduce((values, key) => {
+                const { metadata } = entries[key];
+                const row = [metadata ? stringify(metadata) : null];
+                values[key] = row;
+                return values;
+            }, {}),
+        };
+    }
+    metadataToUpdateSQLQueries(entries, segment) {
+        return keys(entries).reduce((accu, key) => {
+            const { metadata } = entries[key];
+            if (metadata !== undefined) {
+                accu.push({
+                    sql: `UPDATE ${this.tableName} SET ${COLUMN_NAME_METADATA} = ? WHERE (${COLUMN_NAME_KEY$1} IS ? AND ${COLUMN_NAME_NAMESPACE} IS ?)`,
+                    params: [stringify(metadata), key, segment],
+                    change: {
+                        ids: [key],
+                        segment,
+                        type: 'setMetadata',
+                        isExternalChange: false,
+                    },
+                });
+            }
+            return accu;
+        }, []);
+    }
     mapToDurableEntries(sqliteResult) {
         return sqliteResult.rows.reduce((entries, row) => {
             const [key, stringifiedData, stringifiedMetadata] = row;
@@ -15165,9 +15426,16 @@ class NimbusSqliteStore {
             });
         });
     }
+    batchQuery(queries) {
+        const promises = queries.map((q) => this.query(q.sql, q.params));
+        return Promise.all(promises);
+    }
     async getEntries(entryIds, segment) {
         return this.getTable(segment).getByKeys(entryIds, segment);
     }
+    async getMetadata(entryIds, segment) {
+        return this.getTable(segment).getMetadataByKeys(entryIds, segment);
+    }
     getAllEntries(segment) {
         return this.getTable(segment).getAll(segment);
     }
@@ -15176,12 +15444,30 @@ class NimbusSqliteStore {
         const upsertOperation = table.entriesToUpsertOperations(entries, segment);
         return this.batchOperationAsPromise([upsertOperation]);
     }
+    setMetadata(entries, segment) {
+        const table = this.getTable(segment);
+        const operation = this.plugin.supportsBatchUpdates === undefined ||
+            this.plugin.supportsBatchUpdates() === false
+            ? table.entriesToUpsertOperations(entries, segment)
+            : table.metadataToUpdateOperations(entries, segment);
+        return this.batchOperationAsPromise([operation]);
+    }
     batchOperations(operations) {
         const sqliteOperations = operations.reduce((acc, cur) => {
             if (cur.type === 'setEntries') {
                 const table = this.getTable(cur.segment);
                 acc.push(table.entriesToUpsertOperations(cur.entries, cur.segment));
             }
+            else if (cur.type === 'setMetadata') {
+                const table = this.getTable(cur.segment);
+                if (this.plugin.supportsBatchUpdates === undefined ||
+                    this.plugin.supportsBatchUpdates() === false) {
+                    acc.push(table.entriesToUpsertOperations(cur.entries, cur.segment));
+                }
+                else {
+                    acc.push(table.metadataToUpdateOperations(cur.entries, cur.segment));
+                }
+            }
             else {
                 acc.push(this.idsToDeleteOperation(cur.ids, cur.segment));
             }
@@ -15198,8 +15484,15 @@ class NimbusSqliteStore {
         this.plugin
             .registerOnChangedListener(async (changes) => {
             const durableChanges = changes.map((c) => {
+                let type = c.type === 'upsert' ? 'setEntries' : 'evictEntries';
+                // if our context contains a type then set that as our main level type
+                // allows us in the future of updates to specify the segment change happening
+                // example being update call on metadata only or updating data
+                if (c.type === 'update' && c.context.type !== undefined) {
+                    type = c.context.type;
+                }
                 return {
-                    type: c.type === 'upsert' ? 'setEntries' : 'evictEntries',
+                    type,
                     ids: c.keys,
                     isExternalChange: false,
                     segment: c.context.segment,
@@ -15266,6 +15559,10 @@ class AbstractKeyValueDataTable {
             }, reject);
         });
     }
+    getMetadataByKeys(_keys) {
+        // eslint-disable-next-line @salesforce/lds/no-error-in-production
+        throw new Error(`There is no metadata in the ${this.tableName} table.`);
+    }
     getAll() {
         const getAllQuery = `SELECT ${this.columnNames.join(',')} FROM ${this.tableName}`;
         return new Promise((resolve, reject) => {
@@ -15291,6 +15588,10 @@ class AbstractKeyValueDataTable {
             }, []),
         };
     }
+    metadataToUpdateOperations(_entries, _segment) {
+        // eslint-disable-next-line @salesforce/lds/no-error-in-production
+        throw new Error(`There is no metadata in the ${this.tableName} table.`);
+    }
     mapToDurableEntries(sqliteResult) {
         return sqliteResult.rows.reduce((entries, row) => {
             const [key, stringifiedData] = row;
@@ -16630,6 +16931,7 @@ function getRuntime() {
         const gqlEnv = makeEnvironmentGraphqlAware(baseEnv);
         const durableEnv = makeDurable(gqlEnv, {
             durableStore: recordDenormingStore,
+            enableDurableMetadataRefresh: ldsMetadataRefreshEnabled.isOpen({ fallback: false }),
         });
         getIngestRecords = durableEnv.getIngestStagingStoreRecords;
         getIngestMetadata = durableEnv.getIngestStagingStoreMetadata;
@@ -16731,4 +17033,4 @@ register({
 });
 
 export { getRuntime, registerReportObserver, reportGraphqlQueryParseError };
-// version: 1.232.0-968cf099f
+// version: 1.235.0-3790decf0