@luvio/environments 0.60.0 → 0.62.0

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,13 @@ const DefaultDurableSegment = 'DEFAULT';
 const { keys, create, assign, freeze } = Object;
 const { isArray } = Array;
 
-function buildTTLStrategy(staleDuration = 0) {
+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;
@@ -38,6 +39,61 @@ 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 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(buildSnapshotContext, dispatchResourceRequest);
+                // return the cached snapshot to caller
+                return 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(buildSnapshotContext, dispatchResourceRequest);
+                        // return the L2 cached snapshot to caller
+                        return revivedSnapshot;
+                    }
+                    if (revivedSnapshot.state === 'Pending') ;
+                    // 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(buildSnapshotContext, dispatchResourceRequest);
+                });
+            }
+            if (snapshot.state === 'Pending') ;
+        }
+        return buildNetworkSnapshot(buildSnapshotContext, dispatchResourceRequest);
+    };
+}
+
 function buildCacheThenNetworkImplementation(funcs) {
     return function (args) {
         funcs.validateNotDisposed();
@@ -69,11 +125,89 @@ function buildCacheThenNetworkImplementation(funcs) {
     };
 }
 
-function buildStaleWhileRevalidateImplementation(funcs, staleDuration) {
+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;
+        });
+    };
+}
+
+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, buildNetworkSnapshot, buildSnapshotContext, dispatchResourceRequest, storeLookup, } = args;
-        const cachePolicyStoreLookup = appendTTLStrategy(storeLookup, buildTTLStrategy(staleDuration));
+        const cachePolicyStoreLookup = appendTTLStrategy(storeLookup, buildTTLStrategy(staleDurationSeconds * 1000));
         const snapshot = buildInMemorySnapshot(buildSnapshotContext, cachePolicyStoreLookup);
         if (snapshot !== undefined) {
             // data found in L1 cache
@@ -112,6 +246,28 @@ function buildStaleWhileRevalidateImplementation(funcs, staleDuration) {
     };
 }
 
+function buildValidAtImplementation(funcs, basePolicyImplementation, timestamp) {
+    return function validAtImplementation(args) {
+        funcs.validateNotDisposed();
+        // This somewhat convoluted code is used to force the basePolicyImplementation's
+        // TTLStrategy to use the the valid-at cache policy's timestamp. The flow goes:
+        //
+        // Environment.applyCachePolicy => validAtImplementation (this function) =>
+        //    basePolicyImplementation => adapter's buildInMemorySnapshot =>
+        //    basePolicyImplementation's storeLookup => validAtStoreLookup (below) =>
+        //    Environment.applyCachePolicy's storeLookup => Store/Reader code =>
+        //    valid-at TTLStrategy (below) =>
+        //    basePolicyImplementation's TTLStrategy (with valid-at timestamp)
+        const validAtStoreLookup = (sel, refresh, ttlStrategy) => args.storeLookup(sel, refresh, (_readerTimestamp, metadata, valueIsError) => ttlStrategy(timestamp, metadata, valueIsError));
+        // let basePolicy make all the decisions, but have it use our storeLookup
+        // so we can override the timestamp passed to the basePolicy's TTLStrategy
+        return basePolicyImplementation({
+            ...args,
+            storeLookup: validAtStoreLookup,
+        });
+    };
+}
+
 //Durable store error instrumentation key
 const DURABLE_STORE_ERROR = 'durable-store-error';
 /**
@@ -136,25 +292,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;
@@ -303,7 +440,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.
@@ -795,18 +934,34 @@ function makeDurable(environment, { durableStore, instrumentation }) {
                 return buildStaleWhileRevalidateImplementation({
                     validateNotDisposed,
                     reviveSnapshotWithCachePolicy,
-                }, 
-                // TODO[@W-10077764]: remove staleDuration once Komaci switches to cache-then-network
-                'staleDurationSeconds' in cachePolicy
-                    ? cachePolicy.staleDurationSeconds
-                    : cachePolicy.staleDuration
-                //cachePolicy.staleDurationSeconds
-                );
+                }, 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,
+                });
+            case 'valid-at': {
+                const basePolicy = resolveCachePolicy(cachePolicy.basePolicy);
+                return buildValidAtImplementation({
+                    validateNotDisposed,
+                    reviveSnapshotWithCachePolicy,
+                }, basePolicy, cachePolicy.timestamp);
+            }
             default: {
                 if (process.env.NODE_ENV !== 'production') {
                     throw new Error(`unrecognized cache policy: ${JSON.stringify(cachePolicy)}`);
@@ -815,9 +970,9 @@ function makeDurable(environment, { durableStore, instrumentation }) {
             }
         }
     }
-    const applyCachePolicy = function (cachePolicy, buildSnapshotContext, buildInMemorySnapshot, buildNetworkSnapshot) {
+    const applyCachePolicy = function (adapterRequestContext, buildSnapshotContext, buildInMemorySnapshot, buildNetworkSnapshot) {
         validateNotDisposed();
-        const cachePolicyImpl = resolveCachePolicy(cachePolicy);
+        const cachePolicyImpl = resolveCachePolicy(adapterRequestContext.cachePolicy);
         const storeLookup = (sel, refresh, ttlStrategy) => environment.storeLookup(sel, environment.createSnapshot, refresh, ttlStrategy);
         const applyCachePolicy = () => {
             return cachePolicyImpl({

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/index.d.ts

@@ -1,2 +1,6 @@
+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';
+export { buildValidAtImplementation } from './valid-at';

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,5 @@ 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 buildTTLStrategy(staleDurationMilliseconds?: number): TTLStrategy;
 export declare function appendTTLStrategy<C, D>(storeLookup: CachePolicyImplementationArgs<C, D>['storeLookup'], ttlStrategy: TTLStrategy): Parameters<BuildInMemorySnapshot<C, D>>[1];

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,13 @@
     const { keys, create, assign, freeze } = Object;
     const { isArray } = Array;
 
-    function buildTTLStrategy(staleDuration = 0) {
+    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;
@@ -41,6 +42,61 @@
         return (sel, refresh) => storeLookup(sel, refresh, ttlStrategy);
     }
 
+    function buildCacheAndNetworkImplementation(funcs, staleDurationSeconds) {
+        return function (args) {
+            funcs.validateNotDisposed();
+            const { buildInMemorySnapshot, buildNetworkSnapshot, 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(buildSnapshotContext, dispatchResourceRequest);
+                    // return the cached snapshot to caller
+                    return 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(buildSnapshotContext, dispatchResourceRequest);
+                            // return the L2 cached snapshot to caller
+                            return revivedSnapshot;
+                        }
+                        if (revivedSnapshot.state === 'Pending') ;
+                        // 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(buildSnapshotContext, dispatchResourceRequest);
+                    });
+                }
+                if (snapshot.state === 'Pending') ;
+            }
+            return buildNetworkSnapshot(buildSnapshotContext, dispatchResourceRequest);
+        };
+    }
+
     function buildCacheThenNetworkImplementation(funcs) {
         return function (args) {
             funcs.validateNotDisposed();
@@ -72,11 +128,89 @@
         };
     }
 
-    function buildStaleWhileRevalidateImplementation(funcs, staleDuration) {
+    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;
+            });
+        };
+    }
+
+    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, buildNetworkSnapshot, buildSnapshotContext, dispatchResourceRequest, storeLookup, } = args;
-            const cachePolicyStoreLookup = appendTTLStrategy(storeLookup, buildTTLStrategy(staleDuration));
+            const cachePolicyStoreLookup = appendTTLStrategy(storeLookup, buildTTLStrategy(staleDurationSeconds * 1000));
             const snapshot = buildInMemorySnapshot(buildSnapshotContext, cachePolicyStoreLookup);
             if (snapshot !== undefined) {
                 // data found in L1 cache
@@ -115,6 +249,28 @@
         };
     }
 
+    function buildValidAtImplementation(funcs, basePolicyImplementation, timestamp) {
+        return function validAtImplementation(args) {
+            funcs.validateNotDisposed();
+            // This somewhat convoluted code is used to force the basePolicyImplementation's
+            // TTLStrategy to use the the valid-at cache policy's timestamp. The flow goes:
+            //
+            // Environment.applyCachePolicy => validAtImplementation (this function) =>
+            //    basePolicyImplementation => adapter's buildInMemorySnapshot =>
+            //    basePolicyImplementation's storeLookup => validAtStoreLookup (below) =>
+            //    Environment.applyCachePolicy's storeLookup => Store/Reader code =>
+            //    valid-at TTLStrategy (below) =>
+            //    basePolicyImplementation's TTLStrategy (with valid-at timestamp)
+            const validAtStoreLookup = (sel, refresh, ttlStrategy) => args.storeLookup(sel, refresh, (_readerTimestamp, metadata, valueIsError) => ttlStrategy(timestamp, metadata, valueIsError));
+            // let basePolicy make all the decisions, but have it use our storeLookup
+            // so we can override the timestamp passed to the basePolicy's TTLStrategy
+            return basePolicyImplementation({
+                ...args,
+                storeLookup: validAtStoreLookup,
+            });
+        };
+    }
+
     //Durable store error instrumentation key
     const DURABLE_STORE_ERROR = 'durable-store-error';
     /**
@@ -139,25 +295,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;
@@ -306,7 +443,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.
@@ -798,18 +937,34 @@
                     return buildStaleWhileRevalidateImplementation({
                         validateNotDisposed,
                         reviveSnapshotWithCachePolicy,
-                    }, 
-                    // TODO[@W-10077764]: remove staleDuration once Komaci switches to cache-then-network
-                    'staleDurationSeconds' in cachePolicy
-                        ? cachePolicy.staleDurationSeconds
-                        : cachePolicy.staleDuration
-                    //cachePolicy.staleDurationSeconds
-                    );
+                    }, 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,
+                    });
+                case 'valid-at': {
+                    const basePolicy = resolveCachePolicy(cachePolicy.basePolicy);
+                    return buildValidAtImplementation({
+                        validateNotDisposed,
+                        reviveSnapshotWithCachePolicy,
+                    }, basePolicy, cachePolicy.timestamp);
+                }
                 default: {
                     if (process.env.NODE_ENV !== 'production') {
                         throw new Error(`unrecognized cache policy: ${JSON.stringify(cachePolicy)}`);
@@ -818,9 +973,9 @@
                 }
             }
         }
-        const applyCachePolicy = function (cachePolicy, buildSnapshotContext, buildInMemorySnapshot, buildNetworkSnapshot) {
+        const applyCachePolicy = function (adapterRequestContext, buildSnapshotContext, buildInMemorySnapshot, buildNetworkSnapshot) {
             validateNotDisposed();
-            const cachePolicyImpl = resolveCachePolicy(cachePolicy);
+            const cachePolicyImpl = resolveCachePolicy(adapterRequestContext.cachePolicy);
             const storeLookup = (sel, refresh, ttlStrategy) => environment.storeLookup(sel, environment.createSnapshot, refresh, ttlStrategy);
             const applyCachePolicy = () => {
                 return cachePolicyImpl({

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/index.d.ts

@@ -1,2 +1,6 @@
+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';
+export { buildValidAtImplementation } from './valid-at';

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,5 @@ 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 buildTTLStrategy(staleDurationMilliseconds?: number): TTLStrategy;
 export declare function appendTTLStrategy<C, D>(storeLookup: CachePolicyImplementationArgs<C, D>['storeLookup'], ttlStrategy: TTLStrategy): Parameters<BuildInMemorySnapshot<C, D>>[1];

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,14 @@
     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 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;
@@ -78,6 +79,61 @@
         };
     }
 
+    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 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(buildSnapshotContext, dispatchResourceRequest);
+                    // return the cached snapshot to caller
+                    return 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(buildSnapshotContext, dispatchResourceRequest);
+                            // return the L2 cached snapshot to caller
+                            return revivedSnapshot;
+                        }
+                        if (revivedSnapshot.state === 'Pending') ;
+                        // 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(buildSnapshotContext, dispatchResourceRequest);
+                    });
+                }
+                if (snapshot.state === 'Pending') ;
+            }
+            return buildNetworkSnapshot(buildSnapshotContext, dispatchResourceRequest);
+        };
+    }
+
     function buildCacheThenNetworkImplementation(funcs) {
         return function (args) {
             funcs.validateNotDisposed();
@@ -109,11 +165,89 @@
         };
     }
 
-    function buildStaleWhileRevalidateImplementation(funcs, staleDuration) {
+    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;
+            });
+        };
+    }
+
+    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, buildNetworkSnapshot = args.buildNetworkSnapshot, buildSnapshotContext = args.buildSnapshotContext, dispatchResourceRequest = args.dispatchResourceRequest, storeLookup = args.storeLookup;
-            var cachePolicyStoreLookup = appendTTLStrategy(storeLookup, buildTTLStrategy(staleDuration));
+            var cachePolicyStoreLookup = appendTTLStrategy(storeLookup, buildTTLStrategy(staleDurationSeconds * 1000));
             var snapshot = buildInMemorySnapshot(buildSnapshotContext, cachePolicyStoreLookup);
             if (snapshot !== undefined) {
                 // data found in L1 cache
@@ -152,6 +286,27 @@
         };
     }
 
+    function buildValidAtImplementation(funcs, basePolicyImplementation, timestamp) {
+        return function validAtImplementation(args) {
+            funcs.validateNotDisposed();
+            // This somewhat convoluted code is used to force the basePolicyImplementation's
+            // TTLStrategy to use the the valid-at cache policy's timestamp. The flow goes:
+            //
+            // Environment.applyCachePolicy => validAtImplementation (this function) =>
+            //    basePolicyImplementation => adapter's buildInMemorySnapshot =>
+            //    basePolicyImplementation's storeLookup => validAtStoreLookup (below) =>
+            //    Environment.applyCachePolicy's storeLookup => Store/Reader code =>
+            //    valid-at TTLStrategy (below) =>
+            //    basePolicyImplementation's TTLStrategy (with valid-at timestamp)
+            var validAtStoreLookup = function (sel, refresh, ttlStrategy) {
+                return args.storeLookup(sel, refresh, function (_readerTimestamp, metadata, valueIsError) { return ttlStrategy(timestamp, metadata, valueIsError); });
+            };
+            // let basePolicy make all the decisions, but have it use our storeLookup
+            // so we can override the timestamp passed to the basePolicy's TTLStrategy
+            return basePolicyImplementation(__assign(__assign({}, args), { storeLookup: validAtStoreLookup }));
+        };
+    }
+
     //Durable store error instrumentation key
     var DURABLE_STORE_ERROR = 'durable-store-error';
     /**
@@ -177,25 +332,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;
@@ -338,7 +474,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
@@ -840,18 +978,34 @@
                     return buildStaleWhileRevalidateImplementation({
                         validateNotDisposed: validateNotDisposed,
                         reviveSnapshotWithCachePolicy: reviveSnapshotWithCachePolicy,
-                    }, 
-                    // TODO[@W-10077764]: remove staleDuration once Komaci switches to cache-then-network
-                    'staleDurationSeconds' in cachePolicy
-                        ? cachePolicy.staleDurationSeconds
-                        : cachePolicy.staleDuration
-                    //cachePolicy.staleDurationSeconds
-                    );
+                    }, 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,
+                    });
+                case 'valid-at': {
+                    var basePolicy = resolveCachePolicy(cachePolicy.basePolicy);
+                    return buildValidAtImplementation({
+                        validateNotDisposed: validateNotDisposed,
+                        reviveSnapshotWithCachePolicy: reviveSnapshotWithCachePolicy,
+                    }, basePolicy, cachePolicy.timestamp);
+                }
                 default: {
                     if (process.env.NODE_ENV !== 'production') {
                         throw new Error("unrecognized cache policy: " + JSON.stringify(cachePolicy));
@@ -860,9 +1014,9 @@
                 }
             }
         }
-        var applyCachePolicy = function (cachePolicy, buildSnapshotContext, buildInMemorySnapshot, buildNetworkSnapshot) {
+        var applyCachePolicy = function (adapterRequestContext, buildSnapshotContext, buildInMemorySnapshot, buildNetworkSnapshot) {
             validateNotDisposed();
-            var cachePolicyImpl = resolveCachePolicy(cachePolicy);
+            var cachePolicyImpl = resolveCachePolicy(adapterRequestContext.cachePolicy);
             var storeLookup = function (sel, refresh, ttlStrategy) { return environment.storeLookup(sel, environment.createSnapshot, refresh, ttlStrategy); };
             var applyCachePolicy = function () {
                 return cachePolicyImpl({

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/index.d.ts

@@ -1,2 +1,6 @@
+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';
+export { buildValidAtImplementation } from './valid-at';

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,5 @@ 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 buildTTLStrategy(staleDurationMilliseconds?: number): TTLStrategy;
 export declare function appendTTLStrategy<C, D>(storeLookup: CachePolicyImplementationArgs<C, D>['storeLookup'], ttlStrategy: TTLStrategy): Parameters<BuildInMemorySnapshot<C, D>>[1];

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.60.0",
+    "version": "0.62.0",
     "description": "Luvio Environments",
     "main": "dist/umd/es2018/environments.js",
     "module": "dist/es/es2018/environments.js",
@@ -10,12 +10,13 @@
         "clean": "rm -rf dist",
         "build": "rollup --config rollup.config.js",
         "watch": "yarn build --watch",
-        "test": "jest"
+        "test": "jest",
+        "test:debug": "node --inspect-brk ../../../node_modules/jest/bin/jest.js --config ./jest.config.js --runInBand"
     },
     "files": [
         "dist/"
     ],
     "dependencies": {
-        "@luvio/engine": "0.60.0"
+        "@luvio/engine": "0.62.0"
     }
 }