@salesforce/lds-runtime-bridge 1.232.0 → 1.235.0

package/dist/ldsRuntimeBridge.js

@@ -12,7 +12,7 @@
  *  *******************************************************************************************
  */
 import { setDefaultLuvio } from 'force/ldsEngine';
-import { StoreKeySet, serializeStructuredKey, Reader, deepFreeze, emitAdapterEvent, InMemoryStore, Environment, Luvio } from 'force/luvioEngine';
+import { StoreKeySet, serializeStructuredKey, StringKeyInMemoryStore, Reader, deepFreeze, emitAdapterEvent, InMemoryStore, Environment, Luvio } from 'force/luvioEngine';
 import { instrumentLuvio } from 'force/ldsInstrumentation';
 import { keyBuilderRecord } from 'force/ldsAdaptersUiapi';
 import '@salesforce/gate/lds.graphqlEvalExcludeStaleRecords';
@@ -131,7 +131,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.
@@ -141,10 +141,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)));
@@ -194,7 +205,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);
                 }
             }
         }
@@ -283,8 +294,9 @@ class DurableTTLStore {
     }
 }
 
-function flushInMemoryStoreValuesToDurableStore(store, durableStore, durableStoreErrorHandler, redirects, additionalDurableStoreOperations = []) {
+function flushInMemoryStoreValuesToDurableStore(store, durableStore, durableStoreErrorHandler, redirects, additionalDurableStoreOperations = [], enableDurableMetadataRefresh = false) {
     const durableRecords = create$2(null);
+    const refreshedDurableRecords = create$2(null);
     const evictedRecords = create$2(null);
     const { records, metadata: storeMetadata, visitedIds, refreshedIds, } = store.fallbackStringKeyInMemoryStore;
     // TODO: W-8909393 Once metadata is stored in its own segment we need to
@@ -294,32 +306,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$2(durableRecords);
     if (recordKeys.length > 0) {
+        // publishes with data
         durableStoreOperations.push({
             type: 'setEntries',
             entries: durableRecords,
             segment: DefaultDurableSegment,
         });
     }
+    if (keys$2(refreshedDurableRecords).length > 0) {
+        // publishes with only metadata updates
+        durableStoreOperations.push({
+            type: 'setMetadata',
+            entries: refreshedDurableRecords,
+            segment: DefaultDurableSegment,
+        });
+    }
     // redirects
     redirects.forEach((value, key) => {
         durableStoreOperations.push({
@@ -346,6 +362,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) {
@@ -390,6 +417,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$2(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) {
@@ -445,14 +516,16 @@ function isUnfulfilledSnapshot(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$2(null);
@@ -478,6 +551,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++) {
@@ -485,7 +559,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);
@@ -549,9 +628,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$2(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);
         }
@@ -577,10 +673,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
@@ -589,26 +685,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();
@@ -619,19 +715,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
@@ -640,24 +736,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();
@@ -669,7 +765,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;
@@ -710,10 +806,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();
@@ -754,7 +850,7 @@ function makeDurable(environment, { durableStore, instrumentation }) {
             if (isUnfulfilledSnapshot(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,
@@ -779,15 +875,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 {};
     };
@@ -826,22 +922,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();
@@ -870,7 +964,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) {
@@ -881,12 +975,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) {
@@ -937,6 +1031,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',
@@ -971,7 +1086,7 @@ function makeDurable(environment, { durableStore, instrumentation }) {
     });
 }
 
-const { keys: keys$1, create: create$1, assign: assign$1, entries } = Object;
+const { keys: keys$1, create: create$1, assign: assign$1, entries, values: values$1 } = Object;
 const { stringify, parse } = JSON;
 
 function selectColumnsFromTableWhereKeyIn(columnNames, table, keyColumnName, whereIn) {
@@ -1005,6 +1120,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) => {
@@ -1031,6 +1162,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$1(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;
@@ -1077,6 +1226,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) => {
@@ -1110,6 +1278,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$1(entries).reduce((values, key) => {
+                const { metadata } = entries[key];
+                const row = [metadata ? stringify(metadata) : null];
+                values[key] = row;
+                return values;
+            }, {}),
+        };
+    }
+    metadataToUpdateSQLQueries(entries, segment) {
+        return keys$1(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;
@@ -1146,9 +1350,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);
     }
@@ -1157,12 +1368,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));
             }
@@ -1179,8 +1408,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,
@@ -6470,14 +6706,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);
     };
@@ -6567,4 +6819,4 @@ function ldsRuntimeBridge() {
 }
 
 export { ldsRuntimeBridge as default };
-// version: 1.232.0-968cf099f
+// version: 1.235.0-3790decf0

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@salesforce/lds-runtime-bridge",
-    "version": "1.232.0",
+    "version": "1.235.0",
     "license": "SEE LICENSE IN LICENSE.txt",
     "description": "LDS runtime for bridge.app.",
     "main": "dist/ldsRuntimeBridge.js",