@luvio/environments 0.62.2 → 0.63.1

package/dist/es/es2018/environments.js

@@ -17,6 +17,13 @@ const DefaultDurableSegment = 'DEFAULT';
 const { keys, create, assign, freeze } = Object;
 const { isArray } = Array;
 
+function appendTTLStrategy(storeLookup, ttlStrategy) {
+    return (sel, refresh) => storeLookup(sel, refresh, ttlStrategy);
+}
+function buildNetworkSnapshot(args) {
+    const { buildNetworkSnapshot, buildSnapshotContext } = args;
+    return buildNetworkSnapshot(buildSnapshotContext).then((snapshot) => snapshot.state === 'Pending' ? args.resolvePendingSnapshot(snapshot) : snapshot);
+}
 function buildTTLStrategy(staleDurationMilliseconds = 0) {
     return (timestamp, metadata, valueIsError) => {
         if (metadata !== undefined) {
@@ -34,15 +41,12 @@ function buildTTLStrategy(staleDurationMilliseconds = 0) {
         }
         return StoreResolveResultState.Found;
     };
-}
-function appendTTLStrategy(storeLookup, ttlStrategy) {
-    return (sel, refresh) => storeLookup(sel, refresh, ttlStrategy);
 }
 
 function buildCacheAndNetworkImplementation(funcs, staleDurationSeconds) {
     return function (args) {
         funcs.validateNotDisposed();
-        const { buildInMemorySnapshot, buildNetworkSnapshot, buildSnapshotContext, dispatchResourceRequest, storeLookup, } = args;
+        const { buildInMemorySnapshot, buildNetworkSnapshot: buildNetworkSnapshot$1, buildSnapshotContext, storeLookup } = args;
         const staleDurationMilliseconds = staleDurationSeconds === undefined ? undefined : staleDurationSeconds * 1000;
         const cachePolicyStoreLookup = appendTTLStrategy(storeLookup, buildTTLStrategy(staleDurationMilliseconds));
         const snapshot = buildInMemorySnapshot(buildSnapshotContext, cachePolicyStoreLookup);
@@ -50,10 +54,16 @@ function buildCacheAndNetworkImplementation(funcs, staleDurationSeconds) {
             // data found in L1 cache
             if (snapshot.state === 'Fulfilled' || snapshot.state === 'Error') {
                 // kick off network request, do not await it
-                buildNetworkSnapshot(buildSnapshotContext, dispatchResourceRequest);
+                buildNetworkSnapshot$1(buildSnapshotContext);
                 // return the cached snapshot to caller
                 return snapshot;
             }
+            // network request outstanding
+            if (snapshot.state === 'Pending') {
+                // kick off another network request, do not await it
+                buildNetworkSnapshot$1(buildSnapshotContext);
+                return args.resolvePendingSnapshot(snapshot);
+            }
             // stale data found in L1 cache
             if (snapshot.state === 'Stale') {
                 // kick off network request, do not await it
@@ -71,11 +81,15 @@ function buildCacheAndNetworkImplementation(funcs, staleDurationSeconds) {
                     if (revivedSnapshot.state === 'Fulfilled' ||
                         revivedSnapshot.state === 'Error') {
                         // kick off network request, do not await it
-                        buildNetworkSnapshot(buildSnapshotContext, dispatchResourceRequest);
+                        buildNetworkSnapshot$1(buildSnapshotContext);
                         // return the L2 cached snapshot to caller
                         return revivedSnapshot;
                     }
-                    if (revivedSnapshot.state === 'Pending') ;
+                    if (revivedSnapshot.state === 'Pending') {
+                        // kick off network request, do not await it
+                        buildNetworkSnapshot$1(buildSnapshotContext);
+                        return args.resolvePendingSnapshot(revivedSnapshot);
+                    }
                     // stale data found in L2 cache
                     if (revivedSnapshot.state === 'Stale') {
                         // kick off network request, do not await it
@@ -85,19 +99,18 @@ function buildCacheAndNetworkImplementation(funcs, staleDurationSeconds) {
                         return revivedSnapshot;
                     }
                     // data not found in L2 cache, go to the network
-                    return buildNetworkSnapshot(buildSnapshotContext, dispatchResourceRequest);
+                    return buildNetworkSnapshot(args);
                 });
             }
-            if (snapshot.state === 'Pending') ;
         }
-        return buildNetworkSnapshot(buildSnapshotContext, dispatchResourceRequest);
+        return buildNetworkSnapshot(args);
     };
 }
 
 function buildCacheThenNetworkImplementation(funcs) {
     return function (args) {
         funcs.validateNotDisposed();
-        const { buildInMemorySnapshot, buildNetworkSnapshot, buildSnapshotContext, dispatchResourceRequest, storeLookup, } = args;
+        const { buildInMemorySnapshot, buildSnapshotContext, storeLookup } = args;
         const cachePolicyStoreLookup = appendTTLStrategy(storeLookup, buildTTLStrategy());
         const snapshot = buildInMemorySnapshot(buildSnapshotContext, cachePolicyStoreLookup);
         if (snapshot !== undefined) {
@@ -105,7 +118,9 @@ function buildCacheThenNetworkImplementation(funcs) {
             if (snapshot.state === 'Fulfilled' || snapshot.state === 'Error') {
                 return snapshot;
             }
-            if (snapshot.state === 'Pending') ;
+            if (snapshot.state === 'Pending') {
+                return args.resolvePendingSnapshot(snapshot);
+            }
             // data not found in L1 cache, try L2 cache
             return funcs
                 .reviveSnapshotWithCachePolicy(snapshot, cachePolicyStoreLookup)
@@ -115,24 +130,22 @@ function buildCacheThenNetworkImplementation(funcs) {
                     revivedSnapshot.state === 'Error') {
                     return revivedSnapshot;
                 }
-                if (revivedSnapshot.state === 'Pending') ;
+                if (revivedSnapshot.state === 'Pending') {
+                    return args.resolvePendingSnapshot(revivedSnapshot);
+                }
                 // data not found in L2 cache, go to the network
-                return buildNetworkSnapshot(buildSnapshotContext, dispatchResourceRequest);
+                return buildNetworkSnapshot(args);
             });
         }
         // L1 lookup could not find enough information to even construct a snapshot, go to the network
-        return buildNetworkSnapshot(buildSnapshotContext, dispatchResourceRequest);
+        return buildNetworkSnapshot(args);
     };
 }
 
 function buildNoCacheImplementation(funcs) {
     return function (args) {
         funcs.validateNotDisposed();
-        const { buildNetworkSnapshot, buildSnapshotContext, dispatchResourceRequest } = args;
-        return buildNetworkSnapshot(buildSnapshotContext, dispatchResourceRequest).then((snapshot) => {
-            if (snapshot.state === 'Pending') ;
-            return snapshot;
-        });
+        return buildNetworkSnapshot(args);
     };
 }
 
@@ -206,7 +219,7 @@ function buildOnlyIfCachedImplementation(funcs) {
 function buildStaleWhileRevalidateImplementation(funcs, staleDurationSeconds) {
     return function (args) {
         funcs.validateNotDisposed();
-        const { buildInMemorySnapshot, buildNetworkSnapshot, buildSnapshotContext, dispatchResourceRequest, storeLookup, } = args;
+        const { buildInMemorySnapshot, buildSnapshotContext, storeLookup } = args;
         const cachePolicyStoreLookup = appendTTLStrategy(storeLookup, buildTTLStrategy(staleDurationSeconds * 1000));
         const snapshot = buildInMemorySnapshot(buildSnapshotContext, cachePolicyStoreLookup);
         if (snapshot !== undefined) {
@@ -214,11 +227,13 @@ function buildStaleWhileRevalidateImplementation(funcs, staleDurationSeconds) {
             if (snapshot.state === 'Fulfilled' || snapshot.state === 'Error') {
                 return snapshot;
             }
-            if (snapshot.state === 'Pending') ;
+            if (snapshot.state === 'Pending') {
+                return args.resolvePendingSnapshot(snapshot);
+            }
             // stale data found in L1 cache
             if (snapshot.state === 'Stale') {
-                // offline environment is already doing this; uncomment once we get rid of offline environment
-                // buildNetworkSnapshot(buildSnapshotContext, dispatchResourceRequest);
+                // TODO [@W-10093408]: offline environment is already doing this; uncomment once we get rid of offline environment
+                // buildNetworkSnapshot(args);
                 return snapshot;
             }
             // data not found in L1 cache, try L2 cache
@@ -230,19 +245,21 @@ function buildStaleWhileRevalidateImplementation(funcs, staleDurationSeconds) {
                     revivedSnapshot.state === 'Error') {
                     return revivedSnapshot;
                 }
-                if (revivedSnapshot.state === 'Pending') ;
+                if (revivedSnapshot.state === 'Pending') {
+                    return args.resolvePendingSnapshot(revivedSnapshot);
+                }
                 // stale data found in L2 cache
                 if (revivedSnapshot.state === 'Stale') {
-                    // offline environment is already doing this; uncomment once we get rid of offline environment
-                    // buildNetworkSnapshot(buildSnapshotContext, dispatchResourceRequest);
+                    // TODO [@W-10093408]: offline environment is already doing this; uncomment once we get rid of offline environment
+                    // buildNetworkSnapshot(args);
                     return revivedSnapshot;
                 }
                 // data not found in L2 cache, go to the network
-                return buildNetworkSnapshot(buildSnapshotContext, dispatchResourceRequest);
+                return buildNetworkSnapshot(args);
             });
         }
         // L1 lookup could not find enough information to even construct a snapshot, go to the network
-        return buildNetworkSnapshot(buildSnapshotContext, dispatchResourceRequest);
+        return buildNetworkSnapshot(args);
     };
 }
 
@@ -780,7 +797,7 @@ function makeDurable(environment, { durableStore, instrumentation }) {
         if (ingestStagingStore === null) {
             ingestStagingStore = new Store();
         }
-        return environment.storeIngest(key, ingest, response, luvio, ingestStagingStore);
+        environment.storeIngest(key, ingest, response, luvio, ingestStagingStore);
     };
     const storeIngestError = function (key, errorSnapshot, storeMetadataParams, _storeOverride) {
         validateNotDisposed();
@@ -973,14 +990,15 @@ function makeDurable(environment, { durableStore, instrumentation }) {
     const applyCachePolicy = function (adapterRequestContext, buildSnapshotContext, buildInMemorySnapshot, buildNetworkSnapshot) {
         validateNotDisposed();
         const cachePolicyImpl = resolveCachePolicy(adapterRequestContext.cachePolicy);
+        const resolvePendingSnapshot = (snapshot) => environment.resolvePendingSnapshot(snapshot);
         const storeLookup = (sel, refresh, ttlStrategy) => environment.storeLookup(sel, environment.createSnapshot, refresh, ttlStrategy);
         const applyCachePolicy = () => {
             return cachePolicyImpl({
                 buildInMemorySnapshot,
                 buildNetworkSnapshot,
                 buildSnapshotContext,
+                resolvePendingSnapshot,
                 storeLookup,
-                dispatchResourceRequest: environment.dispatchResourceRequest,
             });
         };
         return isRevivingTTLOverrides !== undefined

package/dist/es/es2018/makeDurable/cachepolicies/utils.d.ts

@@ -3,5 +3,6 @@ export declare type DurableCachePolicyFunctions = {
     validateNotDisposed: () => void;
     reviveSnapshotWithCachePolicy: <D, V>(unavailableSnapshot: UnAvailableSnapshot<D, V>, storeLookup: StoreLookup<D, V>) => Promise<Snapshot<D, V>>;
 };
-export declare function buildTTLStrategy(staleDurationMilliseconds?: number): TTLStrategy;
 export declare function appendTTLStrategy<C, D>(storeLookup: CachePolicyImplementationArgs<C, D>['storeLookup'], ttlStrategy: TTLStrategy): Parameters<BuildInMemorySnapshot<C, D>>[1];
+export declare function buildNetworkSnapshot<C, D>(args: CachePolicyImplementationArgs<C, D>): Promise<Snapshot<D, unknown>>;
+export declare function buildTTLStrategy(staleDurationMilliseconds?: number): TTLStrategy;

package/dist/umd/es2018/environments.js

@@ -1,8 +1,8 @@
 (function (global, factory) {
     typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports, require('@luvio/engine')) :
     typeof define === 'function' && define.amd ? define(['exports', '@luvio/engine'], factory) :
-    (global = global || self, factory(global.luvioEnvironments = {}, global.luvioEngine));
-}(this, (function (exports, engine) { 'use strict';
+    (global = typeof globalThis !== 'undefined' ? globalThis : global || self, factory(global.luvioEnvironments = {}, global.luvioEngine));
+})(this, (function (exports, engine) { 'use strict';
 
     function isDeprecatedDurableStoreEntry(durableRecord) {
         if (durableRecord.expiration !== undefined) {
@@ -11,6 +11,7 @@
         // Add more deprecated shape checks here
         return false;
     }
+    exports.DurableStoreOperationType = void 0;
     (function (DurableStoreOperationType) {
         DurableStoreOperationType["SetEntries"] = "setEntries";
         DurableStoreOperationType["EvictEntries"] = "evictEntries";
@@ -20,6 +21,13 @@
     const { keys, create, assign, freeze } = Object;
     const { isArray } = Array;
 
+    function appendTTLStrategy(storeLookup, ttlStrategy) {
+        return (sel, refresh) => storeLookup(sel, refresh, ttlStrategy);
+    }
+    function buildNetworkSnapshot(args) {
+        const { buildNetworkSnapshot, buildSnapshotContext } = args;
+        return buildNetworkSnapshot(buildSnapshotContext).then((snapshot) => snapshot.state === 'Pending' ? args.resolvePendingSnapshot(snapshot) : snapshot);
+    }
     function buildTTLStrategy(staleDurationMilliseconds = 0) {
         return (timestamp, metadata, valueIsError) => {
             if (metadata !== undefined) {
@@ -37,15 +45,12 @@
             }
             return engine.StoreResolveResultState.Found;
         };
-    }
-    function appendTTLStrategy(storeLookup, ttlStrategy) {
-        return (sel, refresh) => storeLookup(sel, refresh, ttlStrategy);
     }
 
     function buildCacheAndNetworkImplementation(funcs, staleDurationSeconds) {
         return function (args) {
             funcs.validateNotDisposed();
-            const { buildInMemorySnapshot, buildNetworkSnapshot, buildSnapshotContext, dispatchResourceRequest, storeLookup, } = args;
+            const { buildInMemorySnapshot, buildNetworkSnapshot: buildNetworkSnapshot$1, buildSnapshotContext, storeLookup } = args;
             const staleDurationMilliseconds = staleDurationSeconds === undefined ? undefined : staleDurationSeconds * 1000;
             const cachePolicyStoreLookup = appendTTLStrategy(storeLookup, buildTTLStrategy(staleDurationMilliseconds));
             const snapshot = buildInMemorySnapshot(buildSnapshotContext, cachePolicyStoreLookup);
@@ -53,10 +58,16 @@
                 // data found in L1 cache
                 if (snapshot.state === 'Fulfilled' || snapshot.state === 'Error') {
                     // kick off network request, do not await it
-                    buildNetworkSnapshot(buildSnapshotContext, dispatchResourceRequest);
+                    buildNetworkSnapshot$1(buildSnapshotContext);
                     // return the cached snapshot to caller
                     return snapshot;
                 }
+                // network request outstanding
+                if (snapshot.state === 'Pending') {
+                    // kick off another network request, do not await it
+                    buildNetworkSnapshot$1(buildSnapshotContext);
+                    return args.resolvePendingSnapshot(snapshot);
+                }
                 // stale data found in L1 cache
                 if (snapshot.state === 'Stale') {
                     // kick off network request, do not await it
@@ -74,11 +85,15 @@
                         if (revivedSnapshot.state === 'Fulfilled' ||
                             revivedSnapshot.state === 'Error') {
                             // kick off network request, do not await it
-                            buildNetworkSnapshot(buildSnapshotContext, dispatchResourceRequest);
+                            buildNetworkSnapshot$1(buildSnapshotContext);
                             // return the L2 cached snapshot to caller
                             return revivedSnapshot;
                         }
-                        if (revivedSnapshot.state === 'Pending') ;
+                        if (revivedSnapshot.state === 'Pending') {
+                            // kick off network request, do not await it
+                            buildNetworkSnapshot$1(buildSnapshotContext);
+                            return args.resolvePendingSnapshot(revivedSnapshot);
+                        }
                         // stale data found in L2 cache
                         if (revivedSnapshot.state === 'Stale') {
                             // kick off network request, do not await it
@@ -88,19 +103,18 @@
                             return revivedSnapshot;
                         }
                         // data not found in L2 cache, go to the network
-                        return buildNetworkSnapshot(buildSnapshotContext, dispatchResourceRequest);
+                        return buildNetworkSnapshot(args);
                     });
                 }
-                if (snapshot.state === 'Pending') ;
             }
-            return buildNetworkSnapshot(buildSnapshotContext, dispatchResourceRequest);
+            return buildNetworkSnapshot(args);
         };
     }
 
     function buildCacheThenNetworkImplementation(funcs) {
         return function (args) {
             funcs.validateNotDisposed();
-            const { buildInMemorySnapshot, buildNetworkSnapshot, buildSnapshotContext, dispatchResourceRequest, storeLookup, } = args;
+            const { buildInMemorySnapshot, buildSnapshotContext, storeLookup } = args;
             const cachePolicyStoreLookup = appendTTLStrategy(storeLookup, buildTTLStrategy());
             const snapshot = buildInMemorySnapshot(buildSnapshotContext, cachePolicyStoreLookup);
             if (snapshot !== undefined) {
@@ -108,7 +122,9 @@
                 if (snapshot.state === 'Fulfilled' || snapshot.state === 'Error') {
                     return snapshot;
                 }
-                if (snapshot.state === 'Pending') ;
+                if (snapshot.state === 'Pending') {
+                    return args.resolvePendingSnapshot(snapshot);
+                }
                 // data not found in L1 cache, try L2 cache
                 return funcs
                     .reviveSnapshotWithCachePolicy(snapshot, cachePolicyStoreLookup)
@@ -118,24 +134,22 @@
                         revivedSnapshot.state === 'Error') {
                         return revivedSnapshot;
                     }
-                    if (revivedSnapshot.state === 'Pending') ;
+                    if (revivedSnapshot.state === 'Pending') {
+                        return args.resolvePendingSnapshot(revivedSnapshot);
+                    }
                     // data not found in L2 cache, go to the network
-                    return buildNetworkSnapshot(buildSnapshotContext, dispatchResourceRequest);
+                    return buildNetworkSnapshot(args);
                 });
             }
             // L1 lookup could not find enough information to even construct a snapshot, go to the network
-            return buildNetworkSnapshot(buildSnapshotContext, dispatchResourceRequest);
+            return buildNetworkSnapshot(args);
         };
     }
 
     function buildNoCacheImplementation(funcs) {
         return function (args) {
             funcs.validateNotDisposed();
-            const { buildNetworkSnapshot, buildSnapshotContext, dispatchResourceRequest } = args;
-            return buildNetworkSnapshot(buildSnapshotContext, dispatchResourceRequest).then((snapshot) => {
-                if (snapshot.state === 'Pending') ;
-                return snapshot;
-            });
+            return buildNetworkSnapshot(args);
         };
     }
 
@@ -209,7 +223,7 @@
     function buildStaleWhileRevalidateImplementation(funcs, staleDurationSeconds) {
         return function (args) {
             funcs.validateNotDisposed();
-            const { buildInMemorySnapshot, buildNetworkSnapshot, buildSnapshotContext, dispatchResourceRequest, storeLookup, } = args;
+            const { buildInMemorySnapshot, buildSnapshotContext, storeLookup } = args;
             const cachePolicyStoreLookup = appendTTLStrategy(storeLookup, buildTTLStrategy(staleDurationSeconds * 1000));
             const snapshot = buildInMemorySnapshot(buildSnapshotContext, cachePolicyStoreLookup);
             if (snapshot !== undefined) {
@@ -217,11 +231,13 @@
                 if (snapshot.state === 'Fulfilled' || snapshot.state === 'Error') {
                     return snapshot;
                 }
-                if (snapshot.state === 'Pending') ;
+                if (snapshot.state === 'Pending') {
+                    return args.resolvePendingSnapshot(snapshot);
+                }
                 // stale data found in L1 cache
                 if (snapshot.state === 'Stale') {
-                    // offline environment is already doing this; uncomment once we get rid of offline environment
-                    // buildNetworkSnapshot(buildSnapshotContext, dispatchResourceRequest);
+                    // TODO [@W-10093408]: offline environment is already doing this; uncomment once we get rid of offline environment
+                    // buildNetworkSnapshot(args);
                     return snapshot;
                 }
                 // data not found in L1 cache, try L2 cache
@@ -233,19 +249,21 @@
                         revivedSnapshot.state === 'Error') {
                         return revivedSnapshot;
                     }
-                    if (revivedSnapshot.state === 'Pending') ;
+                    if (revivedSnapshot.state === 'Pending') {
+                        return args.resolvePendingSnapshot(revivedSnapshot);
+                    }
                     // stale data found in L2 cache
                     if (revivedSnapshot.state === 'Stale') {
-                        // offline environment is already doing this; uncomment once we get rid of offline environment
-                        // buildNetworkSnapshot(buildSnapshotContext, dispatchResourceRequest);
+                        // TODO [@W-10093408]: offline environment is already doing this; uncomment once we get rid of offline environment
+                        // buildNetworkSnapshot(args);
                         return revivedSnapshot;
                     }
                     // data not found in L2 cache, go to the network
-                    return buildNetworkSnapshot(buildSnapshotContext, dispatchResourceRequest);
+                    return buildNetworkSnapshot(args);
                 });
             }
             // L1 lookup could not find enough information to even construct a snapshot, go to the network
-            return buildNetworkSnapshot(buildSnapshotContext, dispatchResourceRequest);
+            return buildNetworkSnapshot(args);
         };
     }
 
@@ -783,7 +801,7 @@
             if (ingestStagingStore === null) {
                 ingestStagingStore = new engine.Store();
             }
-            return environment.storeIngest(key, ingest, response, luvio, ingestStagingStore);
+            environment.storeIngest(key, ingest, response, luvio, ingestStagingStore);
         };
         const storeIngestError = function (key, errorSnapshot, storeMetadataParams, _storeOverride) {
             validateNotDisposed();
@@ -976,14 +994,15 @@
         const applyCachePolicy = function (adapterRequestContext, buildSnapshotContext, buildInMemorySnapshot, buildNetworkSnapshot) {
             validateNotDisposed();
             const cachePolicyImpl = resolveCachePolicy(adapterRequestContext.cachePolicy);
+            const resolvePendingSnapshot = (snapshot) => environment.resolvePendingSnapshot(snapshot);
             const storeLookup = (sel, refresh, ttlStrategy) => environment.storeLookup(sel, environment.createSnapshot, refresh, ttlStrategy);
             const applyCachePolicy = () => {
                 return cachePolicyImpl({
                     buildInMemorySnapshot,
                     buildNetworkSnapshot,
                     buildSnapshotContext,
+                    resolvePendingSnapshot,
                     storeLookup,
-                    dispatchResourceRequest: environment.dispatchResourceRequest,
                 });
             };
             return isRevivingTTLOverrides !== undefined
@@ -1100,4 +1119,4 @@
 
     Object.defineProperty(exports, '__esModule', { value: true });
 
-})));
+}));

package/dist/umd/es2018/makeDurable/cachepolicies/utils.d.ts

@@ -3,5 +3,6 @@ export declare type DurableCachePolicyFunctions = {
     validateNotDisposed: () => void;
     reviveSnapshotWithCachePolicy: <D, V>(unavailableSnapshot: UnAvailableSnapshot<D, V>, storeLookup: StoreLookup<D, V>) => Promise<Snapshot<D, V>>;
 };
-export declare function buildTTLStrategy(staleDurationMilliseconds?: number): TTLStrategy;
 export declare function appendTTLStrategy<C, D>(storeLookup: CachePolicyImplementationArgs<C, D>['storeLookup'], ttlStrategy: TTLStrategy): Parameters<BuildInMemorySnapshot<C, D>>[1];
+export declare function buildNetworkSnapshot<C, D>(args: CachePolicyImplementationArgs<C, D>): Promise<Snapshot<D, unknown>>;
+export declare function buildTTLStrategy(staleDurationMilliseconds?: number): TTLStrategy;

package/dist/umd/es5/environments.js

@@ -1,8 +1,8 @@
 (function (global, factory) {
     typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports, require('@luvio/engine')) :
     typeof define === 'function' && define.amd ? define(['exports', '@luvio/engine'], factory) :
-    (global = global || self, factory(global.luvioEnvironments = {}, global.luvioEngine));
-}(this, (function (exports, engine) { 'use strict';
+    (global = typeof globalThis !== 'undefined' ? globalThis : global || self, factory(global.luvioEnvironments = {}, global.luvioEngine));
+})(this, (function (exports, engine) { 'use strict';
 
     function isDeprecatedDurableStoreEntry(durableRecord) {
         if (durableRecord.expiration !== undefined) {
@@ -11,6 +11,7 @@
         // Add more deprecated shape checks here
         return false;
     }
+    exports.DurableStoreOperationType = void 0;
     (function (DurableStoreOperationType) {
         DurableStoreOperationType["SetEntries"] = "setEntries";
         DurableStoreOperationType["EvictEntries"] = "evictEntries";
@@ -54,6 +55,17 @@
     var keys = Object.keys, create = Object.create, assign = Object.assign, freeze = Object.freeze;
     var isArray = Array.isArray;
 
+    function appendTTLStrategy(storeLookup, ttlStrategy) {
+        return function (sel, refresh) {
+            return storeLookup(sel, refresh, ttlStrategy);
+        };
+    }
+    function buildNetworkSnapshot(args) {
+        var buildNetworkSnapshot = args.buildNetworkSnapshot, buildSnapshotContext = args.buildSnapshotContext;
+        return buildNetworkSnapshot(buildSnapshotContext).then(function (snapshot) {
+            return snapshot.state === 'Pending' ? args.resolvePendingSnapshot(snapshot) : snapshot;
+        });
+    }
     function buildTTLStrategy(staleDurationMilliseconds) {
         if (staleDurationMilliseconds === void 0) { staleDurationMilliseconds = 0; }
         return function (timestamp, metadata, valueIsError) {
@@ -72,17 +84,12 @@
             }
             return engine.StoreResolveResultState.Found;
         };
-    }
-    function appendTTLStrategy(storeLookup, ttlStrategy) {
-        return function (sel, refresh) {
-            return storeLookup(sel, refresh, ttlStrategy);
-        };
     }
 
     function buildCacheAndNetworkImplementation(funcs, staleDurationSeconds) {
         return function (args) {
             funcs.validateNotDisposed();
-            var buildInMemorySnapshot = args.buildInMemorySnapshot, buildNetworkSnapshot = args.buildNetworkSnapshot, buildSnapshotContext = args.buildSnapshotContext, dispatchResourceRequest = args.dispatchResourceRequest, storeLookup = args.storeLookup;
+            var buildInMemorySnapshot = args.buildInMemorySnapshot, buildNetworkSnapshot$1 = args.buildNetworkSnapshot, buildSnapshotContext = args.buildSnapshotContext, storeLookup = args.storeLookup;
             var staleDurationMilliseconds = staleDurationSeconds === undefined ? undefined : staleDurationSeconds * 1000;
             var cachePolicyStoreLookup = appendTTLStrategy(storeLookup, buildTTLStrategy(staleDurationMilliseconds));
             var snapshot = buildInMemorySnapshot(buildSnapshotContext, cachePolicyStoreLookup);
@@ -90,10 +97,16 @@
                 // data found in L1 cache
                 if (snapshot.state === 'Fulfilled' || snapshot.state === 'Error') {
                     // kick off network request, do not await it
-                    buildNetworkSnapshot(buildSnapshotContext, dispatchResourceRequest);
+                    buildNetworkSnapshot$1(buildSnapshotContext);
                     // return the cached snapshot to caller
                     return snapshot;
                 }
+                // network request outstanding
+                if (snapshot.state === 'Pending') {
+                    // kick off another network request, do not await it
+                    buildNetworkSnapshot$1(buildSnapshotContext);
+                    return args.resolvePendingSnapshot(snapshot);
+                }
                 // stale data found in L1 cache
                 if (snapshot.state === 'Stale') {
                     // kick off network request, do not await it
@@ -111,11 +124,15 @@
                         if (revivedSnapshot.state === 'Fulfilled' ||
                             revivedSnapshot.state === 'Error') {
                             // kick off network request, do not await it
-                            buildNetworkSnapshot(buildSnapshotContext, dispatchResourceRequest);
+                            buildNetworkSnapshot$1(buildSnapshotContext);
                             // return the L2 cached snapshot to caller
                             return revivedSnapshot;
                         }
-                        if (revivedSnapshot.state === 'Pending') ;
+                        if (revivedSnapshot.state === 'Pending') {
+                            // kick off network request, do not await it
+                            buildNetworkSnapshot$1(buildSnapshotContext);
+                            return args.resolvePendingSnapshot(revivedSnapshot);
+                        }
                         // stale data found in L2 cache
                         if (revivedSnapshot.state === 'Stale') {
                             // kick off network request, do not await it
@@ -125,19 +142,18 @@
                             return revivedSnapshot;
                         }
                         // data not found in L2 cache, go to the network
-                        return buildNetworkSnapshot(buildSnapshotContext, dispatchResourceRequest);
+                        return buildNetworkSnapshot(args);
                     });
                 }
-                if (snapshot.state === 'Pending') ;
             }
-            return buildNetworkSnapshot(buildSnapshotContext, dispatchResourceRequest);
+            return buildNetworkSnapshot(args);
         };
     }
 
     function buildCacheThenNetworkImplementation(funcs) {
         return function (args) {
             funcs.validateNotDisposed();
-            var buildInMemorySnapshot = args.buildInMemorySnapshot, buildNetworkSnapshot = args.buildNetworkSnapshot, buildSnapshotContext = args.buildSnapshotContext, dispatchResourceRequest = args.dispatchResourceRequest, storeLookup = args.storeLookup;
+            var buildInMemorySnapshot = args.buildInMemorySnapshot, buildSnapshotContext = args.buildSnapshotContext, storeLookup = args.storeLookup;
             var cachePolicyStoreLookup = appendTTLStrategy(storeLookup, buildTTLStrategy());
             var snapshot = buildInMemorySnapshot(buildSnapshotContext, cachePolicyStoreLookup);
             if (snapshot !== undefined) {
@@ -145,7 +161,9 @@
                 if (snapshot.state === 'Fulfilled' || snapshot.state === 'Error') {
                     return snapshot;
                 }
-                if (snapshot.state === 'Pending') ;
+                if (snapshot.state === 'Pending') {
+                    return args.resolvePendingSnapshot(snapshot);
+                }
                 // data not found in L1 cache, try L2 cache
                 return funcs
                     .reviveSnapshotWithCachePolicy(snapshot, cachePolicyStoreLookup)
@@ -155,24 +173,22 @@
                         revivedSnapshot.state === 'Error') {
                         return revivedSnapshot;
                     }
-                    if (revivedSnapshot.state === 'Pending') ;
+                    if (revivedSnapshot.state === 'Pending') {
+                        return args.resolvePendingSnapshot(revivedSnapshot);
+                    }
                     // data not found in L2 cache, go to the network
-                    return buildNetworkSnapshot(buildSnapshotContext, dispatchResourceRequest);
+                    return buildNetworkSnapshot(args);
                 });
             }
             // L1 lookup could not find enough information to even construct a snapshot, go to the network
-            return buildNetworkSnapshot(buildSnapshotContext, dispatchResourceRequest);
+            return buildNetworkSnapshot(args);
         };
     }
 
     function buildNoCacheImplementation(funcs) {
         return function (args) {
             funcs.validateNotDisposed();
-            var buildNetworkSnapshot = args.buildNetworkSnapshot, buildSnapshotContext = args.buildSnapshotContext, dispatchResourceRequest = args.dispatchResourceRequest;
-            return buildNetworkSnapshot(buildSnapshotContext, dispatchResourceRequest).then(function (snapshot) {
-                if (snapshot.state === 'Pending') ;
-                return snapshot;
-            });
+            return buildNetworkSnapshot(args);
         };
     }
 
@@ -246,7 +262,7 @@
     function buildStaleWhileRevalidateImplementation(funcs, staleDurationSeconds) {
         return function (args) {
             funcs.validateNotDisposed();
-            var buildInMemorySnapshot = args.buildInMemorySnapshot, buildNetworkSnapshot = args.buildNetworkSnapshot, buildSnapshotContext = args.buildSnapshotContext, dispatchResourceRequest = args.dispatchResourceRequest, storeLookup = args.storeLookup;
+            var buildInMemorySnapshot = args.buildInMemorySnapshot, buildSnapshotContext = args.buildSnapshotContext, storeLookup = args.storeLookup;
             var cachePolicyStoreLookup = appendTTLStrategy(storeLookup, buildTTLStrategy(staleDurationSeconds * 1000));
             var snapshot = buildInMemorySnapshot(buildSnapshotContext, cachePolicyStoreLookup);
             if (snapshot !== undefined) {
@@ -254,11 +270,13 @@
                 if (snapshot.state === 'Fulfilled' || snapshot.state === 'Error') {
                     return snapshot;
                 }
-                if (snapshot.state === 'Pending') ;
+                if (snapshot.state === 'Pending') {
+                    return args.resolvePendingSnapshot(snapshot);
+                }
                 // stale data found in L1 cache
                 if (snapshot.state === 'Stale') {
-                    // offline environment is already doing this; uncomment once we get rid of offline environment
-                    // buildNetworkSnapshot(buildSnapshotContext, dispatchResourceRequest);
+                    // TODO [@W-10093408]: offline environment is already doing this; uncomment once we get rid of offline environment
+                    // buildNetworkSnapshot(args);
                     return snapshot;
                 }
                 // data not found in L1 cache, try L2 cache
@@ -270,19 +288,21 @@
                         revivedSnapshot.state === 'Error') {
                         return revivedSnapshot;
                     }
-                    if (revivedSnapshot.state === 'Pending') ;
+                    if (revivedSnapshot.state === 'Pending') {
+                        return args.resolvePendingSnapshot(revivedSnapshot);
+                    }
                     // stale data found in L2 cache
                     if (revivedSnapshot.state === 'Stale') {
-                        // offline environment is already doing this; uncomment once we get rid of offline environment
-                        // buildNetworkSnapshot(buildSnapshotContext, dispatchResourceRequest);
+                        // TODO [@W-10093408]: offline environment is already doing this; uncomment once we get rid of offline environment
+                        // buildNetworkSnapshot(args);
                         return revivedSnapshot;
                     }
                     // data not found in L2 cache, go to the network
-                    return buildNetworkSnapshot(buildSnapshotContext, dispatchResourceRequest);
+                    return buildNetworkSnapshot(args);
                 });
             }
             // L1 lookup could not find enough information to even construct a snapshot, go to the network
-            return buildNetworkSnapshot(buildSnapshotContext, dispatchResourceRequest);
+            return buildNetworkSnapshot(args);
         };
     }
 
@@ -821,7 +841,7 @@
             if (ingestStagingStore === null) {
                 ingestStagingStore = new engine.Store();
             }
-            return environment.storeIngest(key, ingest, response, luvio, ingestStagingStore);
+            environment.storeIngest(key, ingest, response, luvio, ingestStagingStore);
         };
         var storeIngestError = function (key, errorSnapshot, storeMetadataParams, _storeOverride) {
             validateNotDisposed();
@@ -1017,14 +1037,17 @@
         var applyCachePolicy = function (adapterRequestContext, buildSnapshotContext, buildInMemorySnapshot, buildNetworkSnapshot) {
             validateNotDisposed();
             var cachePolicyImpl = resolveCachePolicy(adapterRequestContext.cachePolicy);
+            var resolvePendingSnapshot = function (snapshot) {
+                return environment.resolvePendingSnapshot(snapshot);
+            };
             var storeLookup = function (sel, refresh, ttlStrategy) { return environment.storeLookup(sel, environment.createSnapshot, refresh, ttlStrategy); };
             var applyCachePolicy = function () {
                 return cachePolicyImpl({
                     buildInMemorySnapshot: buildInMemorySnapshot,
                     buildNetworkSnapshot: buildNetworkSnapshot,
                     buildSnapshotContext: buildSnapshotContext,
+                    resolvePendingSnapshot: resolvePendingSnapshot,
                     storeLookup: storeLookup,
-                    dispatchResourceRequest: environment.dispatchResourceRequest,
                 });
             };
             return isRevivingTTLOverrides !== undefined
@@ -1140,4 +1163,4 @@
 
     Object.defineProperty(exports, '__esModule', { value: true });
 
-})));
+}));

package/dist/umd/es5/makeDurable/cachepolicies/utils.d.ts

@@ -3,5 +3,6 @@ export declare type DurableCachePolicyFunctions = {
     validateNotDisposed: () => void;
     reviveSnapshotWithCachePolicy: <D, V>(unavailableSnapshot: UnAvailableSnapshot<D, V>, storeLookup: StoreLookup<D, V>) => Promise<Snapshot<D, V>>;
 };
-export declare function buildTTLStrategy(staleDurationMilliseconds?: number): TTLStrategy;
 export declare function appendTTLStrategy<C, D>(storeLookup: CachePolicyImplementationArgs<C, D>['storeLookup'], ttlStrategy: TTLStrategy): Parameters<BuildInMemorySnapshot<C, D>>[1];
+export declare function buildNetworkSnapshot<C, D>(args: CachePolicyImplementationArgs<C, D>): Promise<Snapshot<D, unknown>>;
+export declare function buildTTLStrategy(staleDurationMilliseconds?: number): TTLStrategy;

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@luvio/environments",
-    "version": "0.62.2",
+    "version": "0.63.1",
     "description": "Luvio Environments",
     "main": "dist/umd/es2018/environments.js",
     "module": "dist/es/es2018/environments.js",
@@ -17,6 +17,6 @@
         "dist/"
     ],
     "dependencies": {
-        "@luvio/engine": "0.62.2"
+        "@luvio/engine": "0.63.1"
     }
 }