@luvio/environments 0.59.0 → 0.61.0-236.1

package/dist/es/es2018/environments.js

@@ -1,4 +1,4 @@
-import { StoreResolveResultState, Store, buildStaleWhileRevalidateImplementation as buildStaleWhileRevalidateImplementation$1 } from '@luvio/engine';
+import { StoreResolveResultState, HttpStatusCode, Store, buildStaleWhileRevalidateImplementation as buildStaleWhileRevalidateImplementation$1 } from '@luvio/engine';
 
 function isDeprecatedDurableStoreEntry(durableRecord) {
     if (durableRecord.expiration !== undefined) {
@@ -17,12 +17,20 @@ const DefaultDurableSegment = 'DEFAULT';
 const { keys, create, assign, freeze } = Object;
 const { isArray } = Array;
 
-function buildTTLStrategy(staleDuration = 0) {
+function appendTTLStrategy(storeLookup, ttlStrategy) {
+    return (sel, refresh) => storeLookup(sel, refresh, ttlStrategy);
+}
+function buildNetworkSnapshot(args) {
+    const { buildNetworkSnapshot, buildSnapshotContext, dispatchResourceRequest } = args;
+    return buildNetworkSnapshot(buildSnapshotContext, dispatchResourceRequest).then((snapshot) => snapshot.state === 'Pending' ? args.resolvePendingSnapshot(snapshot) : snapshot);
+}
+function buildTTLStrategy(staleDurationMilliseconds = 0) {
     return (timestamp, metadata, valueIsError) => {
         if (metadata !== undefined) {
             const { expirationTimestamp } = metadata;
             if (timestamp > expirationTimestamp) {
-                if (timestamp <= expirationTimestamp + staleDuration && valueIsError !== true) {
+                if (timestamp <= expirationTimestamp + staleDurationMilliseconds &&
+                    valueIsError !== true) {
                     return StoreResolveResultState.Stale;
                 }
                 return StoreResolveResultState.NotPresent;
@@ -33,29 +41,86 @@ function buildTTLStrategy(staleDuration = 0) {
         }
         return StoreResolveResultState.Found;
     };
-}
-function appendTTLStrategy(storeLookup, ttlStrategy) {
-    return (sel, refresh) => storeLookup(sel, refresh, ttlStrategy);
 }
 
-function buildStaleWhileRevalidateImplementation(funcs, staleDuration) {
+function buildCacheAndNetworkImplementation(funcs, staleDurationSeconds) {
     return function (args) {
         funcs.validateNotDisposed();
-        const { buildInMemorySnapshot, buildNetworkSnapshot, buildSnapshotContext, dispatchResourceRequest, storeLookup, } = args;
-        const cachePolicyStoreLookup = appendTTLStrategy(storeLookup, buildTTLStrategy(staleDuration));
+        const { buildInMemorySnapshot, buildNetworkSnapshot: buildNetworkSnapshot$1, buildSnapshotContext, dispatchResourceRequest, storeLookup, } = args;
+        const staleDurationMilliseconds = staleDurationSeconds === undefined ? undefined : staleDurationSeconds * 1000;
+        const cachePolicyStoreLookup = appendTTLStrategy(storeLookup, buildTTLStrategy(staleDurationMilliseconds));
         const snapshot = buildInMemorySnapshot(buildSnapshotContext, cachePolicyStoreLookup);
         if (snapshot !== undefined) {
             // data found in L1 cache
             if (snapshot.state === 'Fulfilled' || snapshot.state === 'Error') {
+                // kick off network request, do not await it
+                buildNetworkSnapshot$1(buildSnapshotContext, dispatchResourceRequest);
+                // return the cached snapshot to caller
                 return snapshot;
             }
-            if (snapshot.state === 'Pending') ;
+            // network request outstanding
+            if (snapshot.state === 'Pending') {
+                // kick off another network request, do not await it
+                buildNetworkSnapshot$1(buildSnapshotContext, dispatchResourceRequest);
+                return args.resolvePendingSnapshot(snapshot);
+            }
             // stale data found in L1 cache
             if (snapshot.state === 'Stale') {
+                // kick off network request, do not await it
                 // offline environment is already doing this; uncomment once we get rid of offline environment
                 // buildNetworkSnapshot(buildSnapshotContext, dispatchResourceRequest);
+                // return the cached snapshot to caller
                 return snapshot;
             }
+            // if unfulfilled we have enough info to do an L2 lookup
+            if (snapshot.state === 'Unfulfilled') {
+                return funcs
+                    .reviveSnapshotWithCachePolicy(snapshot, cachePolicyStoreLookup)
+                    .then((revivedSnapshot) => {
+                    // data found in L2 cache
+                    if (revivedSnapshot.state === 'Fulfilled' ||
+                        revivedSnapshot.state === 'Error') {
+                        // kick off network request, do not await it
+                        buildNetworkSnapshot$1(buildSnapshotContext, dispatchResourceRequest);
+                        // return the L2 cached snapshot to caller
+                        return revivedSnapshot;
+                    }
+                    if (revivedSnapshot.state === 'Pending') {
+                        // kick off network request, do not await it
+                        buildNetworkSnapshot$1(buildSnapshotContext, dispatchResourceRequest);
+                        return args.resolvePendingSnapshot(revivedSnapshot);
+                    }
+                    // stale data found in L2 cache
+                    if (revivedSnapshot.state === 'Stale') {
+                        // kick off network request, do not await it
+                        // offline environment is already doing this; uncomment once we get rid of offline environment
+                        // buildNetworkSnapshot(buildSnapshotContext, dispatchResourceRequest);
+                        // return the L2 cached snapshot to caller
+                        return revivedSnapshot;
+                    }
+                    // data not found in L2 cache, go to the network
+                    return buildNetworkSnapshot(args);
+                });
+            }
+        }
+        return buildNetworkSnapshot(args);
+    };
+}
+
+function buildCacheThenNetworkImplementation(funcs) {
+    return function (args) {
+        funcs.validateNotDisposed();
+        const { buildInMemorySnapshot, buildSnapshotContext, storeLookup } = args;
+        const cachePolicyStoreLookup = appendTTLStrategy(storeLookup, buildTTLStrategy());
+        const snapshot = buildInMemorySnapshot(buildSnapshotContext, cachePolicyStoreLookup);
+        if (snapshot !== undefined) {
+            // data found in L1 cache
+            if (snapshot.state === 'Fulfilled' || snapshot.state === 'Error') {
+                return snapshot;
+            }
+            if (snapshot.state === 'Pending') {
+                return args.resolvePendingSnapshot(snapshot);
+            }
             // data not found in L1 cache, try L2 cache
             return funcs
                 .reviveSnapshotWithCachePolicy(snapshot, cachePolicyStoreLookup)
@@ -65,19 +130,136 @@ function buildStaleWhileRevalidateImplementation(funcs, staleDuration) {
                     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(args);
+            });
+        }
+        // L1 lookup could not find enough information to even construct a snapshot, go to the network
+        return buildNetworkSnapshot(args);
+    };
+}
+
+function buildNoCacheImplementation(funcs) {
+    return function (args) {
+        funcs.validateNotDisposed();
+        return buildNetworkSnapshot(args);
+    };
+}
+
+function deepFreeze(value) {
+    // No need to freeze primitives
+    if (typeof value !== 'object' || value === null) {
+        return;
+    }
+    if (isArray(value)) {
+        for (let i = 0, len = value.length; i < len; i += 1) {
+            deepFreeze(value[i]);
+        }
+    }
+    else {
+        const keys$1 = keys(value);
+        for (let i = 0, len = keys$1.length; i < len; i += 1) {
+            deepFreeze(value[keys$1[i]]);
+        }
+    }
+    freeze(value);
+}
+
+// TODO[@W-10165595]: consolidate this code with the corresponding logic in the default environment's only-if-cached.ts
+function buildNotCachedErrorSnapshot() {
+    const error = {
+        body: undefined,
+        headers: {},
+        ok: false,
+        status: HttpStatusCode.GatewayTimeout,
+        statusText: 'Gateway Timeout',
+    };
+    deepFreeze(error);
+    return {
+        error,
+        state: 'Error',
+        data: undefined,
+    };
+}
+function buildOnlyIfCachedImplementation(funcs) {
+    return function (args) {
+        funcs.validateNotDisposed();
+        const { buildInMemorySnapshot, buildSnapshotContext, storeLookup } = args;
+        const cachePolicyStoreLookup = appendTTLStrategy(storeLookup, buildTTLStrategy());
+        const snapshot = buildInMemorySnapshot(buildSnapshotContext, cachePolicyStoreLookup);
+        if (snapshot !== undefined) {
+            // data found in L1 cache
+            if (snapshot.state === 'Fulfilled' || snapshot.state === 'Error') {
+                return snapshot;
+            }
+            // network request outstanding, data is not cached
+            if (snapshot.state === 'Pending') {
+                return buildNotCachedErrorSnapshot();
+            }
+            // data not found in L1 cache, try L2 cache
+            return funcs
+                .reviveSnapshotWithCachePolicy(snapshot, cachePolicyStoreLookup)
+                .then((revivedSnapshot) => {
+                // data found in L2 cache
+                if (revivedSnapshot.state === 'Fulfilled' ||
+                    revivedSnapshot.state === 'Error') {
+                    return revivedSnapshot;
+                }
+                // data is not cached
+                return buildNotCachedErrorSnapshot();
+            });
+        }
+        return buildNotCachedErrorSnapshot();
+    };
+}
+
+function buildStaleWhileRevalidateImplementation(funcs, staleDurationSeconds) {
+    return function (args) {
+        funcs.validateNotDisposed();
+        const { buildInMemorySnapshot, buildSnapshotContext, storeLookup } = args;
+        const cachePolicyStoreLookup = appendTTLStrategy(storeLookup, buildTTLStrategy(staleDurationSeconds * 1000));
+        const snapshot = buildInMemorySnapshot(buildSnapshotContext, cachePolicyStoreLookup);
+        if (snapshot !== undefined) {
+            // data found in L1 cache
+            if (snapshot.state === 'Fulfilled' || snapshot.state === 'Error') {
+                return snapshot;
+            }
+            if (snapshot.state === 'Pending') {
+                return args.resolvePendingSnapshot(snapshot);
+            }
+            // stale data found in L1 cache
+            if (snapshot.state === 'Stale') {
+                // 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
+            return funcs
+                .reviveSnapshotWithCachePolicy(snapshot, cachePolicyStoreLookup)
+                .then((revivedSnapshot) => {
+                // data found in L2 cache
+                if (revivedSnapshot.state === 'Fulfilled' ||
+                    revivedSnapshot.state === 'Error') {
+                    return revivedSnapshot;
+                }
+                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);
     };
 }
 
@@ -105,25 +287,6 @@ function handleDurableStoreRejection(instrument) {
     };
 }
 
-function deepFreeze(value) {
-    // No need to freeze primitives
-    if (typeof value !== 'object' || value === null) {
-        return;
-    }
-    if (isArray(value)) {
-        for (let i = 0, len = value.length; i < len; i += 1) {
-            deepFreeze(value[i]);
-        }
-    }
-    else {
-        const keys$1 = keys(value);
-        for (let i = 0, len = keys$1.length; i < len; i += 1) {
-            deepFreeze(value[keys$1[i]]);
-        }
-    }
-    freeze(value);
-}
-
 const SELECTOR_PAGINATION_TOKEN = 'tokenDataKey';
 function isFragmentUnionSelection(sel) {
     return sel.union === true;
@@ -272,7 +435,9 @@ function publishDurableStoreEntries(durableRecords, publish, 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) {
+function reviveSnapshot(baseEnvironment, durableStore, 
+// TODO [W-10165787]: We should only allow Unfulfilled snapshot be passed in
+unavailableSnapshot, durableStoreErrorHandler, buildL1Snapshot) {
     const { recordId, select, 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.
@@ -764,7 +929,27 @@ function makeDurable(environment, { durableStore, instrumentation }) {
                 return buildStaleWhileRevalidateImplementation({
                     validateNotDisposed,
                     reviveSnapshotWithCachePolicy,
-                }, cachePolicy.staleDuration);
+                }, cachePolicy.staleDurationSeconds);
+            case 'cache-and-network':
+                return buildCacheAndNetworkImplementation({
+                    validateNotDisposed,
+                    reviveSnapshotWithCachePolicy,
+                }, cachePolicy.staleDurationSeconds);
+            case 'cache-then-network':
+                return buildCacheThenNetworkImplementation({
+                    validateNotDisposed,
+                    reviveSnapshotWithCachePolicy,
+                });
+            case 'no-cache':
+                return buildNoCacheImplementation({
+                    validateNotDisposed,
+                    reviveSnapshotWithCachePolicy,
+                });
+            case 'only-if-cached':
+                return buildOnlyIfCachedImplementation({
+                    validateNotDisposed,
+                    reviveSnapshotWithCachePolicy,
+                });
             default: {
                 if (process.env.NODE_ENV !== 'production') {
                     throw new Error(`unrecognized cache policy: ${JSON.stringify(cachePolicy)}`);
@@ -776,12 +961,14 @@ function makeDurable(environment, { durableStore, instrumentation }) {
     const applyCachePolicy = function (cachePolicy, buildSnapshotContext, buildInMemorySnapshot, buildNetworkSnapshot) {
         validateNotDisposed();
         const cachePolicyImpl = resolveCachePolicy(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,
             });

package/dist/es/es2018/makeDurable/cachepolicies/cache-and-network.d.ts

@@ -0,0 +1,3 @@
+import { CachePolicyImplementationArgs, Snapshot } from '@luvio/engine';
+import { DurableCachePolicyFunctions } from './utils';
+export declare function buildCacheAndNetworkImplementation(funcs: DurableCachePolicyFunctions, staleDurationSeconds?: number): <C, D>(args: CachePolicyImplementationArgs<C, D>) => import("@luvio/engine").ErrorSnapshot | import("@luvio/engine").FulfilledSnapshot<D, unknown> | import("@luvio/engine").UnfulfilledSnapshot<D, unknown> | import("@luvio/engine").StaleSnapshot<D, unknown> | import("@luvio/engine").PendingSnapshot<D, unknown> | Promise<Snapshot<D, unknown>>;

package/dist/es/es2018/makeDurable/cachepolicies/cache-then-network.d.ts

@@ -0,0 +1,3 @@
+import { CachePolicyImplementationArgs, Snapshot } from '@luvio/engine';
+import { DurableCachePolicyFunctions } from './utils';
+export declare function buildCacheThenNetworkImplementation(funcs: DurableCachePolicyFunctions): <C, D>(args: CachePolicyImplementationArgs<C, D>) => import("@luvio/engine").ErrorSnapshot | import("@luvio/engine").FulfilledSnapshot<D, unknown> | import("@luvio/engine").UnfulfilledSnapshot<D, unknown> | import("@luvio/engine").StaleSnapshot<D, unknown> | import("@luvio/engine").PendingSnapshot<D, unknown> | Promise<Snapshot<D, unknown>>;

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

@@ -1 +1,5 @@
+export { buildCacheAndNetworkImplementation } from './cache-and-network';
+export { buildCacheThenNetworkImplementation } from './cache-then-network';
+export { buildNoCacheImplementation } from './no-cache';
+export { buildOnlyIfCachedImplementation } from './only-if-cached';
 export { buildStaleWhileRevalidateImplementation } from './stale-while-revalidate';

package/dist/es/es2018/makeDurable/cachepolicies/no-cache.d.ts

@@ -0,0 +1,3 @@
+import { CachePolicyImplementationArgs, Snapshot } from '@luvio/engine';
+import { DurableCachePolicyFunctions } from './utils';
+export declare function buildNoCacheImplementation(funcs: DurableCachePolicyFunctions): <C, D>(args: CachePolicyImplementationArgs<C, D>) => import("@luvio/engine").ErrorSnapshot | import("@luvio/engine").FulfilledSnapshot<D, unknown> | import("@luvio/engine").UnfulfilledSnapshot<D, unknown> | import("@luvio/engine").StaleSnapshot<D, unknown> | import("@luvio/engine").PendingSnapshot<D, unknown> | Promise<Snapshot<D, unknown>>;

package/dist/es/es2018/makeDurable/cachepolicies/only-if-cached.d.ts

@@ -0,0 +1,3 @@
+import { CachePolicyImplementationArgs, ErrorSnapshot, Snapshot } from '@luvio/engine';
+import { DurableCachePolicyFunctions } from './utils';
+export declare function buildOnlyIfCachedImplementation(funcs: DurableCachePolicyFunctions): <C, D>(args: CachePolicyImplementationArgs<C, D>) => ErrorSnapshot | import("@luvio/engine").FulfilledSnapshot<D, unknown> | import("@luvio/engine").UnfulfilledSnapshot<D, unknown> | import("@luvio/engine").StaleSnapshot<D, unknown> | import("@luvio/engine").PendingSnapshot<D, unknown> | Promise<Snapshot<D, unknown>>;

package/dist/es/es2018/makeDurable/cachepolicies/stale-while-revalidate.d.ts

@@ -1,3 +1,3 @@
 import { CachePolicyImplementationArgs, Snapshot } from '@luvio/engine';
 import { DurableCachePolicyFunctions } from './utils';
-export declare function buildStaleWhileRevalidateImplementation(funcs: DurableCachePolicyFunctions, staleDuration: number): <C, D>(args: CachePolicyImplementationArgs<C, D>) => import("@luvio/engine").ErrorSnapshot | import("@luvio/engine").FulfilledSnapshot<D, unknown> | import("@luvio/engine").UnfulfilledSnapshot<D, unknown> | import("@luvio/engine").StaleSnapshot<D, unknown> | import("@luvio/engine").PendingSnapshot<D, unknown> | Promise<Snapshot<D, unknown>>;
+export declare function buildStaleWhileRevalidateImplementation(funcs: DurableCachePolicyFunctions, staleDurationSeconds: number): <C, D>(args: CachePolicyImplementationArgs<C, D>) => import("@luvio/engine").ErrorSnapshot | import("@luvio/engine").FulfilledSnapshot<D, unknown> | import("@luvio/engine").UnfulfilledSnapshot<D, unknown> | import("@luvio/engine").StaleSnapshot<D, unknown> | import("@luvio/engine").PendingSnapshot<D, unknown> | Promise<Snapshot<D, unknown>>;

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(staleDuration?: 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/es/es2018/makeDurable/cachepolicies/valid-at.d.ts

@@ -0,0 +1,3 @@
+import { CachePolicyImplementation, CachePolicyImplementationArgs, Snapshot } from '@luvio/engine';
+import { DurableCachePolicyFunctions } from './utils';
+export declare function buildValidAtImplementation<C, D>(funcs: DurableCachePolicyFunctions, basePolicyImplementation: CachePolicyImplementation<C, D>, timestamp: number): (args: CachePolicyImplementationArgs<C, D>) => Snapshot<D> | Promise<Snapshot<D>>;

package/dist/umd/es2018/environments.js

@@ -20,12 +20,20 @@
     const { keys, create, assign, freeze } = Object;
     const { isArray } = Array;
 
-    function buildTTLStrategy(staleDuration = 0) {
+    function appendTTLStrategy(storeLookup, ttlStrategy) {
+        return (sel, refresh) => storeLookup(sel, refresh, ttlStrategy);
+    }
+    function buildNetworkSnapshot(args) {
+        const { buildNetworkSnapshot, buildSnapshotContext, dispatchResourceRequest } = args;
+        return buildNetworkSnapshot(buildSnapshotContext, dispatchResourceRequest).then((snapshot) => snapshot.state === 'Pending' ? args.resolvePendingSnapshot(snapshot) : snapshot);
+    }
+    function buildTTLStrategy(staleDurationMilliseconds = 0) {
         return (timestamp, metadata, valueIsError) => {
             if (metadata !== undefined) {
                 const { expirationTimestamp } = metadata;
                 if (timestamp > expirationTimestamp) {
-                    if (timestamp <= expirationTimestamp + staleDuration && valueIsError !== true) {
+                    if (timestamp <= expirationTimestamp + staleDurationMilliseconds &&
+                        valueIsError !== true) {
                         return engine.StoreResolveResultState.Stale;
                     }
                     return engine.StoreResolveResultState.NotPresent;
@@ -36,29 +44,86 @@
             }
             return engine.StoreResolveResultState.Found;
         };
-    }
-    function appendTTLStrategy(storeLookup, ttlStrategy) {
-        return (sel, refresh) => storeLookup(sel, refresh, ttlStrategy);
     }
 
-    function buildStaleWhileRevalidateImplementation(funcs, staleDuration) {
+    function buildCacheAndNetworkImplementation(funcs, staleDurationSeconds) {
         return function (args) {
             funcs.validateNotDisposed();
-            const { buildInMemorySnapshot, buildNetworkSnapshot, buildSnapshotContext, dispatchResourceRequest, storeLookup, } = args;
-            const cachePolicyStoreLookup = appendTTLStrategy(storeLookup, buildTTLStrategy(staleDuration));
+            const { buildInMemorySnapshot, buildNetworkSnapshot: buildNetworkSnapshot$1, buildSnapshotContext, dispatchResourceRequest, storeLookup, } = args;
+            const staleDurationMilliseconds = staleDurationSeconds === undefined ? undefined : staleDurationSeconds * 1000;
+            const cachePolicyStoreLookup = appendTTLStrategy(storeLookup, buildTTLStrategy(staleDurationMilliseconds));
             const snapshot = buildInMemorySnapshot(buildSnapshotContext, cachePolicyStoreLookup);
             if (snapshot !== undefined) {
                 // data found in L1 cache
                 if (snapshot.state === 'Fulfilled' || snapshot.state === 'Error') {
+                    // kick off network request, do not await it
+                    buildNetworkSnapshot$1(buildSnapshotContext, dispatchResourceRequest);
+                    // return the cached snapshot to caller
                     return snapshot;
                 }
-                if (snapshot.state === 'Pending') ;
+                // network request outstanding
+                if (snapshot.state === 'Pending') {
+                    // kick off another network request, do not await it
+                    buildNetworkSnapshot$1(buildSnapshotContext, dispatchResourceRequest);
+                    return args.resolvePendingSnapshot(snapshot);
+                }
                 // stale data found in L1 cache
                 if (snapshot.state === 'Stale') {
+                    // kick off network request, do not await it
                     // offline environment is already doing this; uncomment once we get rid of offline environment
                     // buildNetworkSnapshot(buildSnapshotContext, dispatchResourceRequest);
+                    // return the cached snapshot to caller
                     return snapshot;
                 }
+                // if unfulfilled we have enough info to do an L2 lookup
+                if (snapshot.state === 'Unfulfilled') {
+                    return funcs
+                        .reviveSnapshotWithCachePolicy(snapshot, cachePolicyStoreLookup)
+                        .then((revivedSnapshot) => {
+                        // data found in L2 cache
+                        if (revivedSnapshot.state === 'Fulfilled' ||
+                            revivedSnapshot.state === 'Error') {
+                            // kick off network request, do not await it
+                            buildNetworkSnapshot$1(buildSnapshotContext, dispatchResourceRequest);
+                            // return the L2 cached snapshot to caller
+                            return revivedSnapshot;
+                        }
+                        if (revivedSnapshot.state === 'Pending') {
+                            // kick off network request, do not await it
+                            buildNetworkSnapshot$1(buildSnapshotContext, dispatchResourceRequest);
+                            return args.resolvePendingSnapshot(revivedSnapshot);
+                        }
+                        // stale data found in L2 cache
+                        if (revivedSnapshot.state === 'Stale') {
+                            // kick off network request, do not await it
+                            // offline environment is already doing this; uncomment once we get rid of offline environment
+                            // buildNetworkSnapshot(buildSnapshotContext, dispatchResourceRequest);
+                            // return the L2 cached snapshot to caller
+                            return revivedSnapshot;
+                        }
+                        // data not found in L2 cache, go to the network
+                        return buildNetworkSnapshot(args);
+                    });
+                }
+            }
+            return buildNetworkSnapshot(args);
+        };
+    }
+
+    function buildCacheThenNetworkImplementation(funcs) {
+        return function (args) {
+            funcs.validateNotDisposed();
+            const { buildInMemorySnapshot, buildSnapshotContext, storeLookup } = args;
+            const cachePolicyStoreLookup = appendTTLStrategy(storeLookup, buildTTLStrategy());
+            const snapshot = buildInMemorySnapshot(buildSnapshotContext, cachePolicyStoreLookup);
+            if (snapshot !== undefined) {
+                // data found in L1 cache
+                if (snapshot.state === 'Fulfilled' || snapshot.state === 'Error') {
+                    return snapshot;
+                }
+                if (snapshot.state === 'Pending') {
+                    return args.resolvePendingSnapshot(snapshot);
+                }
                 // data not found in L1 cache, try L2 cache
                 return funcs
                     .reviveSnapshotWithCachePolicy(snapshot, cachePolicyStoreLookup)
@@ -68,19 +133,136 @@
                         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(args);
+                });
+            }
+            // L1 lookup could not find enough information to even construct a snapshot, go to the network
+            return buildNetworkSnapshot(args);
+        };
+    }
+
+    function buildNoCacheImplementation(funcs) {
+        return function (args) {
+            funcs.validateNotDisposed();
+            return buildNetworkSnapshot(args);
+        };
+    }
+
+    function deepFreeze(value) {
+        // No need to freeze primitives
+        if (typeof value !== 'object' || value === null) {
+            return;
+        }
+        if (isArray(value)) {
+            for (let i = 0, len = value.length; i < len; i += 1) {
+                deepFreeze(value[i]);
+            }
+        }
+        else {
+            const keys$1 = keys(value);
+            for (let i = 0, len = keys$1.length; i < len; i += 1) {
+                deepFreeze(value[keys$1[i]]);
+            }
+        }
+        freeze(value);
+    }
+
+    // TODO[@W-10165595]: consolidate this code with the corresponding logic in the default environment's only-if-cached.ts
+    function buildNotCachedErrorSnapshot() {
+        const error = {
+            body: undefined,
+            headers: {},
+            ok: false,
+            status: engine.HttpStatusCode.GatewayTimeout,
+            statusText: 'Gateway Timeout',
+        };
+        deepFreeze(error);
+        return {
+            error,
+            state: 'Error',
+            data: undefined,
+        };
+    }
+    function buildOnlyIfCachedImplementation(funcs) {
+        return function (args) {
+            funcs.validateNotDisposed();
+            const { buildInMemorySnapshot, buildSnapshotContext, storeLookup } = args;
+            const cachePolicyStoreLookup = appendTTLStrategy(storeLookup, buildTTLStrategy());
+            const snapshot = buildInMemorySnapshot(buildSnapshotContext, cachePolicyStoreLookup);
+            if (snapshot !== undefined) {
+                // data found in L1 cache
+                if (snapshot.state === 'Fulfilled' || snapshot.state === 'Error') {
+                    return snapshot;
+                }
+                // network request outstanding, data is not cached
+                if (snapshot.state === 'Pending') {
+                    return buildNotCachedErrorSnapshot();
+                }
+                // data not found in L1 cache, try L2 cache
+                return funcs
+                    .reviveSnapshotWithCachePolicy(snapshot, cachePolicyStoreLookup)
+                    .then((revivedSnapshot) => {
+                    // data found in L2 cache
+                    if (revivedSnapshot.state === 'Fulfilled' ||
+                        revivedSnapshot.state === 'Error') {
+                        return revivedSnapshot;
+                    }
+                    // data is not cached
+                    return buildNotCachedErrorSnapshot();
+                });
+            }
+            return buildNotCachedErrorSnapshot();
+        };
+    }
+
+    function buildStaleWhileRevalidateImplementation(funcs, staleDurationSeconds) {
+        return function (args) {
+            funcs.validateNotDisposed();
+            const { buildInMemorySnapshot, buildSnapshotContext, storeLookup } = args;
+            const cachePolicyStoreLookup = appendTTLStrategy(storeLookup, buildTTLStrategy(staleDurationSeconds * 1000));
+            const snapshot = buildInMemorySnapshot(buildSnapshotContext, cachePolicyStoreLookup);
+            if (snapshot !== undefined) {
+                // data found in L1 cache
+                if (snapshot.state === 'Fulfilled' || snapshot.state === 'Error') {
+                    return snapshot;
+                }
+                if (snapshot.state === 'Pending') {
+                    return args.resolvePendingSnapshot(snapshot);
+                }
+                // stale data found in L1 cache
+                if (snapshot.state === 'Stale') {
+                    // 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
+                return funcs
+                    .reviveSnapshotWithCachePolicy(snapshot, cachePolicyStoreLookup)
+                    .then((revivedSnapshot) => {
+                    // data found in L2 cache
+                    if (revivedSnapshot.state === 'Fulfilled' ||
+                        revivedSnapshot.state === 'Error') {
+                        return revivedSnapshot;
+                    }
+                    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);
         };
     }
 
@@ -108,25 +290,6 @@
         };
     }
 
-    function deepFreeze(value) {
-        // No need to freeze primitives
-        if (typeof value !== 'object' || value === null) {
-            return;
-        }
-        if (isArray(value)) {
-            for (let i = 0, len = value.length; i < len; i += 1) {
-                deepFreeze(value[i]);
-            }
-        }
-        else {
-            const keys$1 = keys(value);
-            for (let i = 0, len = keys$1.length; i < len; i += 1) {
-                deepFreeze(value[keys$1[i]]);
-            }
-        }
-        freeze(value);
-    }
-
     const SELECTOR_PAGINATION_TOKEN = 'tokenDataKey';
     function isFragmentUnionSelection(sel) {
         return sel.union === true;
@@ -275,7 +438,9 @@
      * 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) {
+    function reviveSnapshot(baseEnvironment, durableStore, 
+    // TODO [W-10165787]: We should only allow Unfulfilled snapshot be passed in
+    unavailableSnapshot, durableStoreErrorHandler, buildL1Snapshot) {
         const { recordId, select, 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.
@@ -767,7 +932,27 @@
                     return buildStaleWhileRevalidateImplementation({
                         validateNotDisposed,
                         reviveSnapshotWithCachePolicy,
-                    }, cachePolicy.staleDuration);
+                    }, cachePolicy.staleDurationSeconds);
+                case 'cache-and-network':
+                    return buildCacheAndNetworkImplementation({
+                        validateNotDisposed,
+                        reviveSnapshotWithCachePolicy,
+                    }, cachePolicy.staleDurationSeconds);
+                case 'cache-then-network':
+                    return buildCacheThenNetworkImplementation({
+                        validateNotDisposed,
+                        reviveSnapshotWithCachePolicy,
+                    });
+                case 'no-cache':
+                    return buildNoCacheImplementation({
+                        validateNotDisposed,
+                        reviveSnapshotWithCachePolicy,
+                    });
+                case 'only-if-cached':
+                    return buildOnlyIfCachedImplementation({
+                        validateNotDisposed,
+                        reviveSnapshotWithCachePolicy,
+                    });
                 default: {
                     if (process.env.NODE_ENV !== 'production') {
                         throw new Error(`unrecognized cache policy: ${JSON.stringify(cachePolicy)}`);
@@ -779,12 +964,14 @@
         const applyCachePolicy = function (cachePolicy, buildSnapshotContext, buildInMemorySnapshot, buildNetworkSnapshot) {
             validateNotDisposed();
             const cachePolicyImpl = resolveCachePolicy(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,
                 });

package/dist/umd/es2018/makeDurable/cachepolicies/cache-and-network.d.ts

@@ -0,0 +1,3 @@
+import { CachePolicyImplementationArgs, Snapshot } from '@luvio/engine';
+import { DurableCachePolicyFunctions } from './utils';
+export declare function buildCacheAndNetworkImplementation(funcs: DurableCachePolicyFunctions, staleDurationSeconds?: number): <C, D>(args: CachePolicyImplementationArgs<C, D>) => import("@luvio/engine").ErrorSnapshot | import("@luvio/engine").FulfilledSnapshot<D, unknown> | import("@luvio/engine").UnfulfilledSnapshot<D, unknown> | import("@luvio/engine").StaleSnapshot<D, unknown> | import("@luvio/engine").PendingSnapshot<D, unknown> | Promise<Snapshot<D, unknown>>;

package/dist/umd/es2018/makeDurable/cachepolicies/cache-then-network.d.ts

@@ -0,0 +1,3 @@
+import { CachePolicyImplementationArgs, Snapshot } from '@luvio/engine';
+import { DurableCachePolicyFunctions } from './utils';
+export declare function buildCacheThenNetworkImplementation(funcs: DurableCachePolicyFunctions): <C, D>(args: CachePolicyImplementationArgs<C, D>) => import("@luvio/engine").ErrorSnapshot | import("@luvio/engine").FulfilledSnapshot<D, unknown> | import("@luvio/engine").UnfulfilledSnapshot<D, unknown> | import("@luvio/engine").StaleSnapshot<D, unknown> | import("@luvio/engine").PendingSnapshot<D, unknown> | Promise<Snapshot<D, unknown>>;

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

@@ -1 +1,5 @@
+export { buildCacheAndNetworkImplementation } from './cache-and-network';
+export { buildCacheThenNetworkImplementation } from './cache-then-network';
+export { buildNoCacheImplementation } from './no-cache';
+export { buildOnlyIfCachedImplementation } from './only-if-cached';
 export { buildStaleWhileRevalidateImplementation } from './stale-while-revalidate';

package/dist/umd/es2018/makeDurable/cachepolicies/no-cache.d.ts

@@ -0,0 +1,3 @@
+import { CachePolicyImplementationArgs, Snapshot } from '@luvio/engine';
+import { DurableCachePolicyFunctions } from './utils';
+export declare function buildNoCacheImplementation(funcs: DurableCachePolicyFunctions): <C, D>(args: CachePolicyImplementationArgs<C, D>) => import("@luvio/engine").ErrorSnapshot | import("@luvio/engine").FulfilledSnapshot<D, unknown> | import("@luvio/engine").UnfulfilledSnapshot<D, unknown> | import("@luvio/engine").StaleSnapshot<D, unknown> | import("@luvio/engine").PendingSnapshot<D, unknown> | Promise<Snapshot<D, unknown>>;

package/dist/umd/es2018/makeDurable/cachepolicies/only-if-cached.d.ts

@@ -0,0 +1,3 @@
+import { CachePolicyImplementationArgs, ErrorSnapshot, Snapshot } from '@luvio/engine';
+import { DurableCachePolicyFunctions } from './utils';
+export declare function buildOnlyIfCachedImplementation(funcs: DurableCachePolicyFunctions): <C, D>(args: CachePolicyImplementationArgs<C, D>) => ErrorSnapshot | import("@luvio/engine").FulfilledSnapshot<D, unknown> | import("@luvio/engine").UnfulfilledSnapshot<D, unknown> | import("@luvio/engine").StaleSnapshot<D, unknown> | import("@luvio/engine").PendingSnapshot<D, unknown> | Promise<Snapshot<D, unknown>>;

package/dist/umd/es2018/makeDurable/cachepolicies/stale-while-revalidate.d.ts

@@ -1,3 +1,3 @@
 import { CachePolicyImplementationArgs, Snapshot } from '@luvio/engine';
 import { DurableCachePolicyFunctions } from './utils';
-export declare function buildStaleWhileRevalidateImplementation(funcs: DurableCachePolicyFunctions, staleDuration: number): <C, D>(args: CachePolicyImplementationArgs<C, D>) => import("@luvio/engine").ErrorSnapshot | import("@luvio/engine").FulfilledSnapshot<D, unknown> | import("@luvio/engine").UnfulfilledSnapshot<D, unknown> | import("@luvio/engine").StaleSnapshot<D, unknown> | import("@luvio/engine").PendingSnapshot<D, unknown> | Promise<Snapshot<D, unknown>>;
+export declare function buildStaleWhileRevalidateImplementation(funcs: DurableCachePolicyFunctions, staleDurationSeconds: number): <C, D>(args: CachePolicyImplementationArgs<C, D>) => import("@luvio/engine").ErrorSnapshot | import("@luvio/engine").FulfilledSnapshot<D, unknown> | import("@luvio/engine").UnfulfilledSnapshot<D, unknown> | import("@luvio/engine").StaleSnapshot<D, unknown> | import("@luvio/engine").PendingSnapshot<D, unknown> | Promise<Snapshot<D, unknown>>;

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(staleDuration?: 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/makeDurable/cachepolicies/valid-at.d.ts

@@ -0,0 +1,3 @@
+import { CachePolicyImplementation, CachePolicyImplementationArgs, Snapshot } from '@luvio/engine';
+import { DurableCachePolicyFunctions } from './utils';
+export declare function buildValidAtImplementation<C, D>(funcs: DurableCachePolicyFunctions, basePolicyImplementation: CachePolicyImplementation<C, D>, timestamp: number): (args: CachePolicyImplementationArgs<C, D>) => Snapshot<D> | Promise<Snapshot<D>>;

package/dist/umd/es5/environments.js

@@ -54,13 +54,25 @@
     var keys = Object.keys, create = Object.create, assign = Object.assign, freeze = Object.freeze;
     var isArray = Array.isArray;
 
-    function buildTTLStrategy(staleDuration) {
-        if (staleDuration === void 0) { staleDuration = 0; }
+    function appendTTLStrategy(storeLookup, ttlStrategy) {
+        return function (sel, refresh) {
+            return storeLookup(sel, refresh, ttlStrategy);
+        };
+    }
+    function buildNetworkSnapshot(args) {
+        var buildNetworkSnapshot = args.buildNetworkSnapshot, buildSnapshotContext = args.buildSnapshotContext, dispatchResourceRequest = args.dispatchResourceRequest;
+        return buildNetworkSnapshot(buildSnapshotContext, dispatchResourceRequest).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) {
             if (metadata !== undefined) {
                 var expirationTimestamp = metadata.expirationTimestamp;
                 if (timestamp > expirationTimestamp) {
-                    if (timestamp <= expirationTimestamp + staleDuration && valueIsError !== true) {
+                    if (timestamp <= expirationTimestamp + staleDurationMilliseconds &&
+                        valueIsError !== true) {
                         return engine.StoreResolveResultState.Stale;
                     }
                     return engine.StoreResolveResultState.NotPresent;
@@ -71,29 +83,199 @@
             }
             return engine.StoreResolveResultState.Found;
         };
-    }
-    function appendTTLStrategy(storeLookup, ttlStrategy) {
-        return function (sel, refresh) {
-            return storeLookup(sel, refresh, ttlStrategy);
-        };
     }
 
-    function buildStaleWhileRevalidateImplementation(funcs, staleDuration) {
+    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 cachePolicyStoreLookup = appendTTLStrategy(storeLookup, buildTTLStrategy(staleDuration));
+            var buildInMemorySnapshot = args.buildInMemorySnapshot, buildNetworkSnapshot$1 = args.buildNetworkSnapshot, buildSnapshotContext = args.buildSnapshotContext, dispatchResourceRequest = args.dispatchResourceRequest, storeLookup = args.storeLookup;
+            var staleDurationMilliseconds = staleDurationSeconds === undefined ? undefined : staleDurationSeconds * 1000;
+            var cachePolicyStoreLookup = appendTTLStrategy(storeLookup, buildTTLStrategy(staleDurationMilliseconds));
             var snapshot = buildInMemorySnapshot(buildSnapshotContext, cachePolicyStoreLookup);
             if (snapshot !== undefined) {
                 // data found in L1 cache
                 if (snapshot.state === 'Fulfilled' || snapshot.state === 'Error') {
+                    // kick off network request, do not await it
+                    buildNetworkSnapshot$1(buildSnapshotContext, dispatchResourceRequest);
+                    // return the cached snapshot to caller
                     return snapshot;
                 }
-                if (snapshot.state === 'Pending') ;
+                // network request outstanding
+                if (snapshot.state === 'Pending') {
+                    // kick off another network request, do not await it
+                    buildNetworkSnapshot$1(buildSnapshotContext, dispatchResourceRequest);
+                    return args.resolvePendingSnapshot(snapshot);
+                }
                 // stale data found in L1 cache
                 if (snapshot.state === 'Stale') {
+                    // kick off network request, do not await it
                     // offline environment is already doing this; uncomment once we get rid of offline environment
                     // buildNetworkSnapshot(buildSnapshotContext, dispatchResourceRequest);
+                    // return the cached snapshot to caller
+                    return snapshot;
+                }
+                // if unfulfilled we have enough info to do an L2 lookup
+                if (snapshot.state === 'Unfulfilled') {
+                    return funcs
+                        .reviveSnapshotWithCachePolicy(snapshot, cachePolicyStoreLookup)
+                        .then(function (revivedSnapshot) {
+                        // data found in L2 cache
+                        if (revivedSnapshot.state === 'Fulfilled' ||
+                            revivedSnapshot.state === 'Error') {
+                            // kick off network request, do not await it
+                            buildNetworkSnapshot$1(buildSnapshotContext, dispatchResourceRequest);
+                            // return the L2 cached snapshot to caller
+                            return revivedSnapshot;
+                        }
+                        if (revivedSnapshot.state === 'Pending') {
+                            // kick off network request, do not await it
+                            buildNetworkSnapshot$1(buildSnapshotContext, dispatchResourceRequest);
+                            return args.resolvePendingSnapshot(revivedSnapshot);
+                        }
+                        // stale data found in L2 cache
+                        if (revivedSnapshot.state === 'Stale') {
+                            // kick off network request, do not await it
+                            // offline environment is already doing this; uncomment once we get rid of offline environment
+                            // buildNetworkSnapshot(buildSnapshotContext, dispatchResourceRequest);
+                            // return the L2 cached snapshot to caller
+                            return revivedSnapshot;
+                        }
+                        // data not found in L2 cache, go to the network
+                        return buildNetworkSnapshot(args);
+                    });
+                }
+            }
+            return buildNetworkSnapshot(args);
+        };
+    }
+
+    function buildCacheThenNetworkImplementation(funcs) {
+        return function (args) {
+            funcs.validateNotDisposed();
+            var buildInMemorySnapshot = args.buildInMemorySnapshot, buildSnapshotContext = args.buildSnapshotContext, storeLookup = args.storeLookup;
+            var cachePolicyStoreLookup = appendTTLStrategy(storeLookup, buildTTLStrategy());
+            var snapshot = buildInMemorySnapshot(buildSnapshotContext, cachePolicyStoreLookup);
+            if (snapshot !== undefined) {
+                // data found in L1 cache
+                if (snapshot.state === 'Fulfilled' || snapshot.state === 'Error') {
+                    return snapshot;
+                }
+                if (snapshot.state === 'Pending') {
+                    return args.resolvePendingSnapshot(snapshot);
+                }
+                // data not found in L1 cache, try L2 cache
+                return funcs
+                    .reviveSnapshotWithCachePolicy(snapshot, cachePolicyStoreLookup)
+                    .then(function (revivedSnapshot) {
+                    // data found in L2 cache
+                    if (revivedSnapshot.state === 'Fulfilled' ||
+                        revivedSnapshot.state === 'Error') {
+                        return revivedSnapshot;
+                    }
+                    if (revivedSnapshot.state === 'Pending') {
+                        return args.resolvePendingSnapshot(revivedSnapshot);
+                    }
+                    // data not found in L2 cache, go to the network
+                    return buildNetworkSnapshot(args);
+                });
+            }
+            // L1 lookup could not find enough information to even construct a snapshot, go to the network
+            return buildNetworkSnapshot(args);
+        };
+    }
+
+    function buildNoCacheImplementation(funcs) {
+        return function (args) {
+            funcs.validateNotDisposed();
+            return buildNetworkSnapshot(args);
+        };
+    }
+
+    function deepFreeze(value) {
+        // No need to freeze primitives
+        if (typeof value !== 'object' || value === null) {
+            return;
+        }
+        if (isArray(value)) {
+            for (var i = 0, len = value.length; i < len; i += 1) {
+                deepFreeze(value[i]);
+            }
+        }
+        else {
+            var keys$1 = keys(value);
+            for (var i = 0, len = keys$1.length; i < len; i += 1) {
+                deepFreeze(value[keys$1[i]]);
+            }
+        }
+        freeze(value);
+    }
+
+    // TODO[@W-10165595]: consolidate this code with the corresponding logic in the default environment's only-if-cached.ts
+    function buildNotCachedErrorSnapshot() {
+        var error = {
+            body: undefined,
+            headers: {},
+            ok: false,
+            status: engine.HttpStatusCode.GatewayTimeout,
+            statusText: 'Gateway Timeout',
+        };
+        deepFreeze(error);
+        return {
+            error: error,
+            state: 'Error',
+            data: undefined,
+        };
+    }
+    function buildOnlyIfCachedImplementation(funcs) {
+        return function (args) {
+            funcs.validateNotDisposed();
+            var buildInMemorySnapshot = args.buildInMemorySnapshot, buildSnapshotContext = args.buildSnapshotContext, storeLookup = args.storeLookup;
+            var cachePolicyStoreLookup = appendTTLStrategy(storeLookup, buildTTLStrategy());
+            var snapshot = buildInMemorySnapshot(buildSnapshotContext, cachePolicyStoreLookup);
+            if (snapshot !== undefined) {
+                // data found in L1 cache
+                if (snapshot.state === 'Fulfilled' || snapshot.state === 'Error') {
+                    return snapshot;
+                }
+                // network request outstanding, data is not cached
+                if (snapshot.state === 'Pending') {
+                    return buildNotCachedErrorSnapshot();
+                }
+                // data not found in L1 cache, try L2 cache
+                return funcs
+                    .reviveSnapshotWithCachePolicy(snapshot, cachePolicyStoreLookup)
+                    .then(function (revivedSnapshot) {
+                    // data found in L2 cache
+                    if (revivedSnapshot.state === 'Fulfilled' ||
+                        revivedSnapshot.state === 'Error') {
+                        return revivedSnapshot;
+                    }
+                    // data is not cached
+                    return buildNotCachedErrorSnapshot();
+                });
+            }
+            return buildNotCachedErrorSnapshot();
+        };
+    }
+
+    function buildStaleWhileRevalidateImplementation(funcs, staleDurationSeconds) {
+        return function (args) {
+            funcs.validateNotDisposed();
+            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) {
+                // data found in L1 cache
+                if (snapshot.state === 'Fulfilled' || snapshot.state === 'Error') {
+                    return snapshot;
+                }
+                if (snapshot.state === 'Pending') {
+                    return args.resolvePendingSnapshot(snapshot);
+                }
+                // stale data found in L1 cache
+                if (snapshot.state === 'Stale') {
+                    // 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
@@ -105,19 +287,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);
         };
     }
 
@@ -146,25 +330,6 @@
         };
     }
 
-    function deepFreeze(value) {
-        // No need to freeze primitives
-        if (typeof value !== 'object' || value === null) {
-            return;
-        }
-        if (isArray(value)) {
-            for (var i = 0, len = value.length; i < len; i += 1) {
-                deepFreeze(value[i]);
-            }
-        }
-        else {
-            var keys$1 = keys(value);
-            for (var i = 0, len = keys$1.length; i < len; i += 1) {
-                deepFreeze(value[keys$1[i]]);
-            }
-        }
-        freeze(value);
-    }
-
     var SELECTOR_PAGINATION_TOKEN = 'tokenDataKey';
     function isFragmentUnionSelection(sel) {
         return sel.union === true;
@@ -307,7 +472,9 @@
      * 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) {
+    function reviveSnapshot(baseEnvironment, durableStore, 
+    // TODO [W-10165787]: We should only allow Unfulfilled snapshot be passed in
+    unavailableSnapshot, durableStoreErrorHandler, buildL1Snapshot) {
         var _a;
         var recordId = unavailableSnapshot.recordId, select = unavailableSnapshot.select, seenRecords = unavailableSnapshot.seenRecords, state = unavailableSnapshot.state;
         // L2 can only revive Unfulfilled snapshots that have a selector since they have the
@@ -809,7 +976,27 @@
                     return buildStaleWhileRevalidateImplementation({
                         validateNotDisposed: validateNotDisposed,
                         reviveSnapshotWithCachePolicy: reviveSnapshotWithCachePolicy,
-                    }, cachePolicy.staleDuration);
+                    }, cachePolicy.staleDurationSeconds);
+                case 'cache-and-network':
+                    return buildCacheAndNetworkImplementation({
+                        validateNotDisposed: validateNotDisposed,
+                        reviveSnapshotWithCachePolicy: reviveSnapshotWithCachePolicy,
+                    }, cachePolicy.staleDurationSeconds);
+                case 'cache-then-network':
+                    return buildCacheThenNetworkImplementation({
+                        validateNotDisposed: validateNotDisposed,
+                        reviveSnapshotWithCachePolicy: reviveSnapshotWithCachePolicy,
+                    });
+                case 'no-cache':
+                    return buildNoCacheImplementation({
+                        validateNotDisposed: validateNotDisposed,
+                        reviveSnapshotWithCachePolicy: reviveSnapshotWithCachePolicy,
+                    });
+                case 'only-if-cached':
+                    return buildOnlyIfCachedImplementation({
+                        validateNotDisposed: validateNotDisposed,
+                        reviveSnapshotWithCachePolicy: reviveSnapshotWithCachePolicy,
+                    });
                 default: {
                     if (process.env.NODE_ENV !== 'production') {
                         throw new Error("unrecognized cache policy: " + JSON.stringify(cachePolicy));
@@ -821,12 +1008,16 @@
         var applyCachePolicy = function (cachePolicy, buildSnapshotContext, buildInMemorySnapshot, buildNetworkSnapshot) {
             validateNotDisposed();
             var cachePolicyImpl = resolveCachePolicy(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,
                 });

package/dist/umd/es5/makeDurable/cachepolicies/cache-and-network.d.ts

@@ -0,0 +1,3 @@
+import { CachePolicyImplementationArgs, Snapshot } from '@luvio/engine';
+import { DurableCachePolicyFunctions } from './utils';
+export declare function buildCacheAndNetworkImplementation(funcs: DurableCachePolicyFunctions, staleDurationSeconds?: number): <C, D>(args: CachePolicyImplementationArgs<C, D>) => import("@luvio/engine").ErrorSnapshot | import("@luvio/engine").FulfilledSnapshot<D, unknown> | import("@luvio/engine").UnfulfilledSnapshot<D, unknown> | import("@luvio/engine").StaleSnapshot<D, unknown> | import("@luvio/engine").PendingSnapshot<D, unknown> | Promise<Snapshot<D, unknown>>;

package/dist/umd/es5/makeDurable/cachepolicies/cache-then-network.d.ts

@@ -0,0 +1,3 @@
+import { CachePolicyImplementationArgs, Snapshot } from '@luvio/engine';
+import { DurableCachePolicyFunctions } from './utils';
+export declare function buildCacheThenNetworkImplementation(funcs: DurableCachePolicyFunctions): <C, D>(args: CachePolicyImplementationArgs<C, D>) => import("@luvio/engine").ErrorSnapshot | import("@luvio/engine").FulfilledSnapshot<D, unknown> | import("@luvio/engine").UnfulfilledSnapshot<D, unknown> | import("@luvio/engine").StaleSnapshot<D, unknown> | import("@luvio/engine").PendingSnapshot<D, unknown> | Promise<Snapshot<D, unknown>>;

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

@@ -1 +1,5 @@
+export { buildCacheAndNetworkImplementation } from './cache-and-network';
+export { buildCacheThenNetworkImplementation } from './cache-then-network';
+export { buildNoCacheImplementation } from './no-cache';
+export { buildOnlyIfCachedImplementation } from './only-if-cached';
 export { buildStaleWhileRevalidateImplementation } from './stale-while-revalidate';

package/dist/umd/es5/makeDurable/cachepolicies/no-cache.d.ts

@@ -0,0 +1,3 @@
+import { CachePolicyImplementationArgs, Snapshot } from '@luvio/engine';
+import { DurableCachePolicyFunctions } from './utils';
+export declare function buildNoCacheImplementation(funcs: DurableCachePolicyFunctions): <C, D>(args: CachePolicyImplementationArgs<C, D>) => import("@luvio/engine").ErrorSnapshot | import("@luvio/engine").FulfilledSnapshot<D, unknown> | import("@luvio/engine").UnfulfilledSnapshot<D, unknown> | import("@luvio/engine").StaleSnapshot<D, unknown> | import("@luvio/engine").PendingSnapshot<D, unknown> | Promise<Snapshot<D, unknown>>;

package/dist/umd/es5/makeDurable/cachepolicies/only-if-cached.d.ts

@@ -0,0 +1,3 @@
+import { CachePolicyImplementationArgs, ErrorSnapshot, Snapshot } from '@luvio/engine';
+import { DurableCachePolicyFunctions } from './utils';
+export declare function buildOnlyIfCachedImplementation(funcs: DurableCachePolicyFunctions): <C, D>(args: CachePolicyImplementationArgs<C, D>) => ErrorSnapshot | import("@luvio/engine").FulfilledSnapshot<D, unknown> | import("@luvio/engine").UnfulfilledSnapshot<D, unknown> | import("@luvio/engine").StaleSnapshot<D, unknown> | import("@luvio/engine").PendingSnapshot<D, unknown> | Promise<Snapshot<D, unknown>>;

package/dist/umd/es5/makeDurable/cachepolicies/stale-while-revalidate.d.ts

@@ -1,3 +1,3 @@
 import { CachePolicyImplementationArgs, Snapshot } from '@luvio/engine';
 import { DurableCachePolicyFunctions } from './utils';
-export declare function buildStaleWhileRevalidateImplementation(funcs: DurableCachePolicyFunctions, staleDuration: number): <C, D>(args: CachePolicyImplementationArgs<C, D>) => import("@luvio/engine").ErrorSnapshot | import("@luvio/engine").FulfilledSnapshot<D, unknown> | import("@luvio/engine").UnfulfilledSnapshot<D, unknown> | import("@luvio/engine").StaleSnapshot<D, unknown> | import("@luvio/engine").PendingSnapshot<D, unknown> | Promise<Snapshot<D, unknown>>;
+export declare function buildStaleWhileRevalidateImplementation(funcs: DurableCachePolicyFunctions, staleDurationSeconds: number): <C, D>(args: CachePolicyImplementationArgs<C, D>) => import("@luvio/engine").ErrorSnapshot | import("@luvio/engine").FulfilledSnapshot<D, unknown> | import("@luvio/engine").UnfulfilledSnapshot<D, unknown> | import("@luvio/engine").StaleSnapshot<D, unknown> | import("@luvio/engine").PendingSnapshot<D, unknown> | Promise<Snapshot<D, unknown>>;

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(staleDuration?: 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/makeDurable/cachepolicies/valid-at.d.ts

@@ -0,0 +1,3 @@
+import { CachePolicyImplementation, CachePolicyImplementationArgs, Snapshot } from '@luvio/engine';
+import { DurableCachePolicyFunctions } from './utils';
+export declare function buildValidAtImplementation<C, D>(funcs: DurableCachePolicyFunctions, basePolicyImplementation: CachePolicyImplementation<C, D>, timestamp: number): (args: CachePolicyImplementationArgs<C, D>) => Snapshot<D> | Promise<Snapshot<D>>;

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@luvio/environments",
-    "version": "0.59.0",
+    "version": "0.61.0-236.1",
     "description": "Luvio Environments",
     "main": "dist/umd/es2018/environments.js",
     "module": "dist/es/es2018/environments.js",
@@ -16,6 +16,7 @@
         "dist/"
     ],
     "dependencies": {
-        "@luvio/engine": "0.59.0"
-    }
+        "@luvio/engine": "0.61.0-236.1"
+    },
+    "gitHead": "21ff2ffbe18cd546d4a1f2c0bc35fcd6526a6b75"
 }