@salesforce/lds-runtime-bridge 1.415.0 → 1.416.1

package/dist/ldsRuntimeBridge.js

@@ -136,7 +136,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, revivingStore, reviveMetrics = { l2Trips: [] }) {
+function reviveSnapshot(baseEnvironment, durableStore, unavailableSnapshot, durableStoreErrorHandler, buildL1Snapshot, revivingStore, reviveMetrics = { l2Trips: [] }, shouldFilterFields) {
     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.
@@ -163,19 +163,55 @@ function reviveSnapshot(baseEnvironment, durableStore, unavailableSnapshot, dura
     }
     keysToReviveSet.merge(missingLinks);
     const keysToRevive = keysToReviveSet.keysAsArray();
-    const canonicalKeys = keysToRevive.map((x) => serializeStructuredKey(baseEnvironment.storeGetCanonicalKey(x)));
     const start = Date.now();
     const { l2Trips } = reviveMetrics;
-    return durableStore.getEntries(canonicalKeys, DefaultDurableSegment).then((durableRecords) => {
+    // Extract requested fields first to determine if filtering is possible
+    let requestedFields;
+    if (select.node.kind === 'Fragment' && 'selections' in select.node && select.node.selections) {
+        requestedFields = extractRequestedFieldNames(select.node.selections);
+    }
+    const canonicalKeys = [];
+    const filteredCanonicalKeys = [];
+    for (let i = 0, len = keysToRevive.length; i < len; i += 1) {
+        const canonicalKey = serializeStructuredKey(baseEnvironment.storeGetCanonicalKey(keysToRevive[i]));
+        // Only filter if we have fields to filter and shouldFilterFields returns true
+        if (requestedFields !== undefined &&
+            requestedFields.size > 0 &&
+            shouldFilterFields(canonicalKey)) {
+            filteredCanonicalKeys.push(canonicalKey);
+        }
+        else {
+            canonicalKeys.push(canonicalKey);
+        }
+    }
+    const fetchPromises = [
+        durableStore.getEntries(canonicalKeys, DefaultDurableSegment),
+    ];
+    if (requestedFields !== undefined &&
+        requestedFields.size > 0 &&
+        filteredCanonicalKeys.length > 0) {
+        fetchPromises.push(durableStore.getEntriesWithSpecificFields(filteredCanonicalKeys, requestedFields, DefaultDurableSegment));
+    }
+    return Promise.all(fetchPromises).then(([durableRecords, filteredDurableRecords]) => {
         l2Trips.push({
             duration: Date.now() - start,
-            keysRequestedCount: canonicalKeys.length,
+            keysRequestedCount: canonicalKeys.length + filteredCanonicalKeys.length,
         });
-        const { revivedKeys, hadUnexpectedShape } = publishDurableStoreEntries(durableRecords, 
-        // TODO [W-10072584]: instead of implicitly using L1 we should take in
-        // publish and publishMetadata funcs, so callers can decide where to
-        // revive to (like they pass in how to do the buildL1Snapshot)
-        baseEnvironment.storePut.bind(baseEnvironment), baseEnvironment.publishStoreMetadata.bind(baseEnvironment));
+        // Process both normal and filtered records in a single pass
+        const revivedKeys = new StoreKeySet();
+        let hadUnexpectedShape = false;
+        // Process normal records
+        if (durableRecords !== undefined) {
+            const normalResult = publishDurableStoreEntries(durableRecords, baseEnvironment.storePut.bind(baseEnvironment), baseEnvironment.publishStoreMetadata.bind(baseEnvironment));
+            revivedKeys.merge(normalResult.revivedKeys);
+            hadUnexpectedShape = hadUnexpectedShape || normalResult.hadUnexpectedShape;
+        }
+        // Process filtered records with merging
+        if (filteredDurableRecords !== undefined) {
+            const filteredResult = publishDurableStoreEntries(filteredDurableRecords, createMergeFilteredPut((key) => baseEnvironment.store.readEntry(key), baseEnvironment.storePut.bind(baseEnvironment)), baseEnvironment.publishStoreMetadata.bind(baseEnvironment));
+            revivedKeys.merge(filteredResult.revivedKeys);
+            hadUnexpectedShape = hadUnexpectedShape || filteredResult.hadUnexpectedShape;
+        }
         // if the data coming back from DS had an unexpected shape then just
         // return the L1 snapshot
         if (hadUnexpectedShape === true) {
@@ -210,7 +246,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, revivingStore, reviveMetrics);
+                    return reviveSnapshot(baseEnvironment, durableStore, snapshot, durableStoreErrorHandler, buildL1Snapshot, revivingStore, reviveMetrics, shouldFilterFields);
                 }
             }
         }
@@ -221,6 +257,59 @@ function reviveSnapshot(baseEnvironment, durableStore, unavailableSnapshot, dura
         return { snapshot: unavailableSnapshot, metrics: reviveMetrics };
     });
 }
+/**
+ * Creates a put function that merges filtered fields with existing L1 records instead of replacing them.
+ * This is used when reviving filtered fields from L2 to preserve existing data in L1.
+ */
+function createMergeFilteredPut(readEntry, storePut) {
+    return (key, filteredData) => {
+        const existingRecord = readEntry(key);
+        if (existingRecord !== undefined &&
+            existingRecord !== null &&
+            typeof filteredData === 'object' &&
+            filteredData !== null &&
+            typeof existingRecord === 'object') {
+            const filteredFields = filteredData;
+            const existingObj = existingRecord;
+            // Check if object is frozen (can happen after deepFreeze)
+            // If frozen, create a shallow copy to merge fields into
+            let targetObj = existingObj;
+            if (Object.isFrozen(existingObj)) {
+                targetObj = { ...existingObj };
+            }
+            const keys = Object.keys(filteredFields);
+            for (let i = 0, len = keys.length; i < len; i += 1) {
+                const fieldKey = keys[i];
+                targetObj[fieldKey] = filteredFields[fieldKey];
+            }
+            storePut(key, targetObj);
+        }
+        else {
+            // No existing record, just put the filtered data
+            storePut(key, filteredData);
+        }
+    };
+}
+/**
+ * Extracts the requested field names from the selections of a 'fields' ObjectSelection.
+ * Returns undefined if no 'fields' selection is found or if it doesn't have selections.
+ */
+function extractRequestedFieldNames(selections) {
+    if (!selections) {
+        return undefined;
+    }
+    // Find the 'fields' ObjectSelection
+    const fieldsSelection = selections.find((sel) => sel.kind === 'Object' && sel.name === 'fields');
+    if (!fieldsSelection || !fieldsSelection.selections) {
+        return undefined;
+    }
+    // Extract all field names from the fields selections
+    const fieldNames = new Set();
+    for (const fieldSel of fieldsSelection.selections) {
+        fieldNames.add(fieldSel.name);
+    }
+    return fieldNames.size > 0 ? fieldNames : undefined;
+}
 
 const TTL_DURABLE_SEGMENT = 'TTL_DURABLE_SEGMENT';
 const TTL_DEFAULT_KEY = 'TTL_DEFAULT_KEY';
@@ -537,7 +626,7 @@ function isUnfulfilledSnapshot(cachedSnapshotResult) {
  * @param durableStore A DurableStore implementation
  * @param instrumentation An instrumentation function implementation
  */
-function makeDurable(environment, { durableStore, instrumentation, useRevivingStore, shouldFlush, enableDurableMetadataRefresh = false, disableDeepFreeze = false, }) {
+function makeDurable(environment, { durableStore, instrumentation, useRevivingStore, shouldFlush, enableDurableMetadataRefresh = false, disableDeepFreeze = false, shouldFilterFieldsOnRevive, }) {
     // runtimes can choose to disable deepFreeze, e.g. headless mobile runtime
     setBypassDeepFreeze(disableDeepFreeze);
     let stagingStore = null;
@@ -1079,7 +1168,7 @@ function makeDurable(environment, { durableStore, instrumentation, useRevivingSt
             const result = buildL1Snapshot();
             stagingStore = tempStore;
             return result;
-        }, revivingStore).finally(() => {
+        }, revivingStore, { l2Trips: [] }, shouldFilterFieldsOnRevive !== null && shouldFilterFieldsOnRevive !== void 0 ? shouldFilterFieldsOnRevive : (() => false)).finally(() => {
         });
     };
     const expirePossibleStaleRecords = async function (keys$1, config, refresh) {
@@ -1178,6 +1267,27 @@ class LdsDataTable {
             }, reject);
         });
     }
+    getByKeysWithSpecificFields(keys, fields, _segment) {
+        // SQLite json_object has a max argument limit (~127 pairs = 254 args)
+        // If too many fields requested, return undefined to indicate filtering not possible
+        if (fields.size > 100) {
+            return Promise.resolve(undefined);
+        }
+        return new Promise((resolve, reject) => {
+            // Build JSON object with only the specified fields from the nested 'fields' property
+            const jsonFields = Array.from(fields)
+                .map((field) => `'${field}', json_extract(${COLUMN_NAME_DATA$2}, '$.fields.${field}')`)
+                .join(', ');
+            const filteredFieldsExpr = `json_object(${jsonFields})`;
+            // Use json_set to replace the 'fields' property in the data with the filtered version
+            const filteredDataExpr = `json_set(${COLUMN_NAME_DATA$2}, '$.fields', ${filteredFieldsExpr})`;
+            const paramList = keys.map(() => '?').join(',');
+            const getQuery = `SELECT ${COLUMN_NAME_KEY$2}, ${filteredDataExpr} as ${COLUMN_NAME_DATA$2}, ${COLUMN_NAME_METADATA$1} FROM ${this.tableName} WHERE ${COLUMN_NAME_KEY$2} IN (${paramList})`;
+            this.plugin.query(getQuery, keys, (x) => {
+                resolve(this.mapToDurableEntries(x));
+            }, 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) => {
@@ -1284,6 +1394,30 @@ class LdsInternalDataTable {
             }, reject);
         });
     }
+    getByKeysWithSpecificFields(keys, fields, namespace) {
+        if (namespace === undefined) {
+            throw Error('LdsInternalDataTable requires namespace');
+        }
+        // SQLite json_object has a max argument limit (~127 pairs = 254 args)
+        // If too many fields requested, return undefined to indicate filtering not possible
+        if (fields.size > 100) {
+            return Promise.resolve(undefined);
+        }
+        return new Promise((resolve, reject) => {
+            // Build JSON object with only the specified fields from the nested 'fields' property
+            const jsonFields = Array.from(fields)
+                .map((field) => `'${field}', json_extract(${COLUMN_NAME_DATA$1}, '$.fields.${field}')`)
+                .join(', ');
+            const filteredFieldsExpr = `json_object(${jsonFields})`;
+            // Use json_set to replace the 'fields' property in the data with the filtered version
+            const filteredDataExpr = `json_set(${COLUMN_NAME_DATA$1}, '$.fields', ${filteredFieldsExpr})`;
+            const paramList = keys.map(() => '?').join(',');
+            const getQuery = `SELECT ${COLUMN_NAME_KEY$1}, ${filteredDataExpr} as ${COLUMN_NAME_DATA$1}, ${COLUMN_NAME_METADATA}, ${COLUMN_NAME_NAMESPACE} FROM ${this.tableName} WHERE ${COLUMN_NAME_NAMESPACE} = ? AND ${COLUMN_NAME_KEY$1} IN (${paramList})`;
+            this.plugin.query(getQuery, [namespace].concat(keys), (x) => {
+                resolve(this.mapToDurableEntries(x));
+            }, reject);
+        });
+    }
     getMetadataByKeys(keys, namespace) {
         if (namespace === undefined) {
             throw Error('LdsInternalDataTable requires namespace');
@@ -1424,6 +1558,12 @@ class NimbusSqliteStore {
             .getByKeys(entryIds, segment)
             .finally(() => tasker.done());
     }
+    async getEntriesWithSpecificFields(entryIds, fields, segment) {
+        tasker.add();
+        return this.getTable(segment)
+            .getByKeysWithSpecificFields(entryIds, fields, segment)
+            .finally(() => tasker.done());
+    }
     async getMetadata(entryIds, segment) {
         tasker.add();
         return this.getTable(segment)
@@ -2011,4 +2151,4 @@ function ldsRuntimeBridge() {
 }
 
 export { ldsRuntimeBridge as default };
-// version: 1.415.0-3636f2a7b2
+// version: 1.416.1-0ee8f9a6ba

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@salesforce/lds-runtime-bridge",
-    "version": "1.415.0",
+    "version": "1.416.1",
     "license": "SEE LICENSE IN LICENSE.txt",
     "description": "LDS runtime for bridge.app.",
     "main": "dist/ldsRuntimeBridge.js",
@@ -34,18 +34,18 @@
         "release:corejar": "yarn build && ../core-build/scripts/core.js --name=lds-runtime-bridge"
     },
     "dependencies": {
-        "@salesforce/lds-bindings": "^1.415.0",
-        "@salesforce/lds-durable-records": "^1.415.0",
-        "@salesforce/lds-instrumentation": "^1.415.0",
-        "@salesforce/lds-runtime-mobile": "^1.415.0",
+        "@salesforce/lds-bindings": "^1.416.1",
+        "@salesforce/lds-durable-records": "^1.416.1",
+        "@salesforce/lds-instrumentation": "^1.416.1",
+        "@salesforce/lds-runtime-mobile": "^1.416.1",
         "@salesforce/user": "0.0.21",
         "o11y": "250.7.0"
     },
     "devDependencies": {
-        "@salesforce/lds-network-aura": "^1.415.0",
-        "@salesforce/lds-runtime-aura": "^1.415.0",
-        "@salesforce/lds-store-nimbus": "^1.415.0",
-        "@salesforce/nimbus-plugin-lds": "^1.415.0",
+        "@salesforce/lds-network-aura": "^1.416.1",
+        "@salesforce/lds-runtime-aura": "^1.416.1",
+        "@salesforce/lds-store-nimbus": "^1.416.1",
+        "@salesforce/nimbus-plugin-lds": "^1.416.1",
         "babel-plugin-dynamic-import-node": "^2.3.3"
     },
     "luvioBundlesize": [