@luvio/environments 0.158.6 → 0.159.0

package/dist/environments.js

@@ -115,7 +115,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.
@@ -142,19 +142,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) {
@@ -189,7 +225,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);
                 }
             }
         }
@@ -200,6 +236,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';
@@ -519,7 +608,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;
@@ -1061,7 +1150,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) {

package/dist/types/DurableStore.d.ts

@@ -102,6 +102,41 @@ export interface DurableStore {
      * @returns {Promise<DurableStoreEntries | undefined>}
      */
     getEntries<T>(entryIds: string[], segment: string): Promise<DurableStoreEntries<T> | undefined>;
+    /**
+     * Given a list of cache entryIds and a set of field names, this method asynchronously
+     * returns DurableStoreEntries with only the specified fields included in the data.
+     *
+     * This overload allows for selective field retrieval, which can improve performance
+     * when only a subset of fields is needed from large entries. The fields set specifies
+     * which top-level properties should be included in the returned data objects.
+     *
+     * If the segment isn't found this will return undefined.
+     *
+     * If the segment is found this will return a map of results, even if not all entries
+     * are present in the DS. Each entry's data will contain only the fields specified in
+     * the fields parameter.
+     *
+     * Only the store segment specified is queried.
+     *
+     * @param {string[]} entryIds - The list of entry IDs to retrieve
+     * @param {Set<string>} fields - A set of field names to include in the returned data.
+     *                                Only these top-level fields will be present in each
+     *                                entry's data object. If empty, no data fields are returned.
+     * @param {string} segment - The durable store segment to query
+     * @returns {Promise<DurableStoreEntries | undefined>} A promise resolving to entries
+     *                                                       with filtered data, or undefined
+     *                                                       if the segment is not found
+     *
+     * @example
+     * // Retrieve only 'id' and 'name' fields from user entries
+     * const entries = await durableStore.getEntries(
+     *   ['user1', 'user2'],
+     *   new Set(['id', 'name']),
+     *   'DEFAULT'
+     * );
+     * // entries['user1'].data will only contain { id: '...', name: '...' }
+     */
+    getEntriesWithSpecificFields<T>(entryIds: string[], fields: Set<string>, segment: string): Promise<DurableStoreEntries<T> | undefined>;
     /**
      * Given alist of cache entryId's this method will asynchronously return only the DurableStoreMetadata
      * of DurableStoreEntries

package/dist/types/makeDurable/revive.d.ts

@@ -7,6 +7,7 @@ type ReviveResponse = {
     revivedKeys: StoreKeySet<string | NormalizedKeyMetadata>;
     hadUnexpectedShape: boolean;
 };
+type ShouldReviveFilterFields = (recordId: string) => boolean;
 /**
  * Takes a set of entries from DurableStore and publishes them via the passed in funcs.
  * This respects expiration and checks for valid DurableStore data shapes.  This should
@@ -35,5 +36,5 @@ export interface ReviveResult<D, V> {
  * will refresh the snapshot from network, and then run the results from network
  * through L2 ingestion, returning the subsequent revived snapshot.
  */
-export declare function reviveSnapshot<D, V = unknown>(baseEnvironment: Environment, durableStore: DurableStore, unavailableSnapshot: UnfulfilledSnapshot<D, V>, durableStoreErrorHandler: DurableStoreRejectionHandler, buildL1Snapshot: () => Snapshot<D, V>, revivingStore: RevivingStore | undefined, reviveMetrics?: ReviveMetrics): Promise<ReviveResult<D, V>>;
+export declare function reviveSnapshot<D, V = unknown>(baseEnvironment: Environment, durableStore: DurableStore, unavailableSnapshot: UnfulfilledSnapshot<D, V>, durableStoreErrorHandler: DurableStoreRejectionHandler, buildL1Snapshot: () => Snapshot<D, V>, revivingStore: RevivingStore | undefined, reviveMetrics: ReviveMetrics | undefined, shouldFilterFields: ShouldReviveFilterFields): Promise<ReviveResult<D, V>>;
 export {};

package/dist/types/makeDurable.d.ts

@@ -44,6 +44,7 @@ interface MakeDurableOptions {
     useRevivingStore?: boolean;
     disableDeepFreeze?: boolean;
     shouldFlush?: ShouldFlushFn;
+    shouldFilterFieldsOnRevive?: (key: string) => boolean;
 }
 /**
  * Configures the environment to persist data into a durable store and attempt to resolve
@@ -54,5 +55,5 @@ interface MakeDurableOptions {
  * @param durableStore A DurableStore implementation
  * @param instrumentation An instrumentation function implementation
  */
-export declare function makeDurable(environment: Environment, { durableStore, instrumentation, useRevivingStore, shouldFlush, enableDurableMetadataRefresh, disableDeepFreeze, }: MakeDurableOptions): DurableEnvironment;
+export declare function makeDurable(environment: Environment, { durableStore, instrumentation, useRevivingStore, shouldFlush, enableDurableMetadataRefresh, disableDeepFreeze, shouldFilterFieldsOnRevive, }: MakeDurableOptions): DurableEnvironment;
 export {};

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@luvio/environments",
-    "version": "0.158.6",
+    "version": "0.159.0",
     "description": "Luvio Environments",
     "repository": {
         "type": "git",
@@ -27,7 +27,7 @@
         "watch": "yarn build --watch"
     },
     "dependencies": {
-        "@luvio/engine": "^0.158.6"
+        "@luvio/engine": "^0.159.0"
     },
     "volta": {
         "extends": "../../../package.json"
@@ -36,9 +36,9 @@
         {
             "path": "./dist/environments.js",
             "maxSize": {
-                "none": "50.0 kB",
-                "min": "15.0 kB",
-                "compressed": "10.0 kB"
+                "none": "55.0 kB",
+                "min": "15.5 kB",
+                "compressed": "10.5 kB"
             }
         }
     ],