@luvio/environments 0.52.0 → 0.55.0

package/dist/es/es2018/DurableTTLStore.d.ts

@@ -0,0 +1,25 @@
+import { DurableStore } from './DurableStore';
+export declare const TTL_DURABLE_SEGMENT = "TTL_DURABLE_SEGMENT";
+export interface DefaultDurableTTLOverride extends DurableTTLOverride {
+    namespace: 'TTL_DEFAULT_KEY';
+    representationName: 'TTL_DEFAULT_KEY';
+}
+export interface DurableTTLOverride {
+    namespace: string;
+    representationName: string;
+    ttl: number;
+}
+export interface TTLOverridesMap {
+    defaultTTL: DefaultDurableTTLOverride | undefined;
+    overrides: DurableTTLOverride[];
+}
+/**
+ * Class to set and get the TTL override values in the Durable Store
+ */
+export declare class DurableTTLStore {
+    private durableStore;
+    constructor(durableStore: DurableStore);
+    setDefaultDurableTTLOverrides(ttl: number): Promise<void>;
+    setDurableTTLOverride(namespace: string, representationName: string, ttl: number): Promise<void>;
+    getDurableTTLOverrides(): Promise<TTLOverridesMap>;
+}

package/dist/es/es2018/environments.js

@@ -1,3 +1,5 @@
+import { StoreResolveResultState, buildStaleWhileRevalidateImplementation as buildStaleWhileRevalidateImplementation$1 } from '@luvio/engine';
+
 function isDeprecatedDurableStoreEntry(durableRecord) {
     if (durableRecord.expiration !== undefined) {
         return true;
@@ -16,6 +18,50 @@ const { keys, create, assign, freeze } = Object;
 const { hasOwnProperty } = Object.prototype;
 const { isArray } = Array;
 
+// cache policy implementations
+function buildTTLStrategy(staleDuration = 0) {
+    return (timestamp, metadata, valueIsError) => {
+        if (metadata !== undefined) {
+            const { expirationTimestamp } = metadata;
+            if (timestamp > expirationTimestamp) {
+                if (timestamp <= expirationTimestamp + staleDuration && valueIsError !== true) {
+                    return StoreResolveResultState.Stale;
+                }
+                return StoreResolveResultState.NotPresent;
+            }
+        }
+        if (valueIsError === true) {
+            return StoreResolveResultState.Error;
+        }
+        return StoreResolveResultState.Found;
+    };
+}
+function appendTTLStrategy(storeLookup, ttlStrategy) {
+    return (sel, refresh) => storeLookup(sel, refresh, ttlStrategy);
+}
+function buildStaleWhileRevalidateImplementation(validateNotDisposed, resolveSnapshot, staleDuration) {
+    return function (args) {
+        validateNotDisposed();
+        const { buildInMemorySnapshot, buildNetworkSnapshot, buildSnapshotContext, dispatchResourceRequest, storeLookup, } = args;
+        const snapshot = buildInMemorySnapshot(buildSnapshotContext, appendTTLStrategy(storeLookup, buildTTLStrategy(staleDuration)));
+        if (snapshot !== undefined) {
+            if (snapshot.state === 'Fulfilled' || snapshot.state === 'Error') {
+                return snapshot;
+            }
+            if (snapshot.state === 'Stale') {
+                // offline environment is already doing this; uncomment once we get rid of offline environment
+                // buildNetworkSnapshot(buildSnapshotContext, dispatchResourceRequest);
+                return snapshot;
+            }
+            return resolveSnapshot(snapshot, {
+                resolve: () => buildNetworkSnapshot(buildSnapshotContext, dispatchResourceRequest),
+                config: undefined,
+            });
+        }
+        return buildNetworkSnapshot(buildSnapshotContext, dispatchResourceRequest);
+    };
+}
+
 //Durable store error instrumentation key
 const DURABLE_STORE_ERROR = 'durable-store-error';
 /**
@@ -213,8 +259,7 @@ function buildDurableStoreAwareRefresh(refresh, snapshot, environment, pendingWr
                 }
                 promiseResolve(resolvedSnapshot);
             });
-            const { resolve, config } = refresh;
-            resolve(config)
+            refresh()
                 .then((refreshedSnapshot) => {
                 // if error, just return it, because there won't be a L2 flush/broadcast/rebuild
                 // (non-cached errors don't broadcast, and subscribing to an error snapshot
@@ -256,11 +301,23 @@ function buildDurableStoreAwareRefresh(refresh, snapshot, environment, pendingWr
 
 function isStoreEntryError(storeRecord) {
     return storeRecord.__type === 'error';
-}
+}
+
 function isStoreEntryExpiredAndError(storeRecord, expirationTimestamp, now) {
     return isStoreEntryError(storeRecord) && expirationTimestamp < now;
 }
-function reviveDurableEntriesToStore(durableRecords, environment, pendingWriter) {
+/**
+ * Takes a set of entries from DurableStore and publishes them via the passed in funcs.
+ * This respects expiration and checks for valid DurableStore data shapes.  This should
+ * be used over manually parsing DurableStoreEntries
+ *
+ * @param durableRecords The DurableStoreEntries to parse
+ * @param publish A function to call with the data of each DurableStoreEntry
+ * @param publishMetadata A function to call with the metadata of each DurableStoreEntry
+ * @param pendingWriter the PendingWriter (this is going away soon)
+ * @returns
+ */
+function publishDurableStoreEntries(durableRecords, publish, publishMetadata, pendingWriter) {
     const revivedKeys = create(null);
     let hadUnexpectedShape = false;
     if (durableRecords === undefined) {
@@ -288,13 +345,13 @@ function reviveDurableEntriesToStore(durableRecords, environment, pendingWriter)
         }
         if (metadata !== undefined) {
             const { expirationTimestamp, staleTimestamp } = metadata;
-            if (expirationTimestamp === undefined || staleTimestamp === undefined) {
+            if (expirationTimestamp === undefined) {
                 // if unexpected expiration data skip reviving
                 hadUnexpectedShape = true;
                 continue;
             }
             // if past stale TTL then don't revive
-            if (staleTimestamp < now) {
+            if (staleTimestamp !== undefined && staleTimestamp < now) {
                 continue;
             }
             // We don't want to revive a cached value if it's an error and it's
@@ -309,8 +366,7 @@ function reviveDurableEntriesToStore(durableRecords, environment, pendingWriter)
             if (isStoreEntryExpiredAndError(data, expirationTimestamp, now)) {
                 continue;
             }
-            // call base publishStoreMetadata so we don't add the key to pendingWriters
-            environment.publishStoreMetadata(key, metadata);
+            publishMetadata(key, metadata);
         }
         if (isStoreEntryError(data)) {
             // freeze errors on way into L1
@@ -320,8 +376,7 @@ function reviveDurableEntriesToStore(durableRecords, environment, pendingWriter)
         // Note: this won't affect ingest (which ingests to L1 temporarily then
         // flushes to L2) because that path is synchronous and atomic.
         pendingWriter.removePendingWrite(key);
-        // call base storePublish so we don't add the key to pendingWriters
-        environment.storePublish(key, data);
+        publish(key, data);
         revivedKeys[key] = true;
     }
     return { revivedKeys, hadUnexpectedShape };
@@ -333,13 +388,13 @@ const snapshotRefreshMap = new WeakSet();
  * will refresh the snapshot from network, and then run the results from network
  * through L2 ingestion, returning the subsequent revived snapshot.
  */
-function reviveSnapshot(environment, durableStore, pendingWriter, unavailableSnapshot, refresh, durableStoreErrorHandler, baseSnapshot) {
+function reviveSnapshot(baseEnvironment, durableStore, pendingWriter, unavailableSnapshot, refresh, durableStoreErrorHandler, baseSnapshot) {
     const { recordId, select, seenRecords, state } = unavailableSnapshot;
     // on rebuilds return the network snapshot on L2 miss
     const refreshSnapshot = baseSnapshot !== undefined
         ? () => {
             if (baseSnapshot.state !== 'Pending') {
-                return refresh.resolve(refresh.config);
+                return refresh();
             }
             // A Pending snapshot could be in the store awaiting either a result
             // from the network or L2. If another ingest brings in an overlapping key
@@ -352,17 +407,17 @@ function reviveSnapshot(environment, durableStore, pendingWriter, unavailableSna
             }
             // track the refresh operation to ensure no other refreshes kick off while in flight
             snapshotRefreshMap.add(baseSnapshot);
-            return refresh.resolve(refresh.config).finally(() => {
+            return refresh().finally(() => {
                 snapshotRefreshMap.delete(baseSnapshot);
             });
         }
-        : buildDurableStoreAwareRefresh(refresh, unavailableSnapshot, environment, pendingWriter);
+        : buildDurableStoreAwareRefresh(refresh, unavailableSnapshot, baseEnvironment, pendingWriter);
     // L2 can only revive Unfulfilled snapshots that have a selector since they have the
     // info needed to revive (like missingLinks) and rebuild.  Otherwise refresh.
     if (state !== 'Unfulfilled' || select === undefined) {
         return refreshSnapshot();
     }
-    // in case L1 cache changes/deallocs a record while we are doing the async read
+    // in case L1 store changes/deallocs a record while we are doing the async read
     // we attempt to read all keys from L2 - so combine recordId with any seenRecords
     const keysToReviveSet = assign({ [recordId]: true }, seenRecords);
     const keysToRevive = keys(keysToReviveSet);
@@ -371,9 +426,9 @@ function reviveSnapshot(environment, durableStore, pendingWriter, unavailableSna
         const paginationKey = paginationKeys[i];
         keysToRevive.push(paginationKey);
     }
-    const canonicalKeys = keysToRevive.map((x) => environment.storeGetCanonicalKey(x));
+    const canonicalKeys = keysToRevive.map((x) => baseEnvironment.storeGetCanonicalKey(x));
     return durableStore.getEntries(canonicalKeys, DefaultDurableSegment).then((durableRecords) => {
-        const { revivedKeys, hadUnexpectedShape } = reviveDurableEntriesToStore(durableRecords, environment, pendingWriter);
+        const { revivedKeys, hadUnexpectedShape } = publishDurableStoreEntries(durableRecords, baseEnvironment.storePublish.bind(baseEnvironment), baseEnvironment.publishStoreMetadata.bind(baseEnvironment), pendingWriter);
         // if the data coming back from DS had an unexpected shape then refresh
         // data from network
         if (hadUnexpectedShape === true) {
@@ -386,8 +441,8 @@ function reviveSnapshot(environment, durableStore, pendingWriter, unavailableSna
         // attempt to lookup (or rebuild if baseSnapshot is provided) the snapshot
         // now that we have revived the missingLinks
         const snapshot = baseSnapshot === undefined
-            ? environment.storeLookup(unavailableSnapshot.select, environment.createSnapshot, unavailableSnapshot.refresh)
-            : environment.rebuildSnapshot(baseSnapshot, environment.getStoreRecords(), environment.getStoreMetadataMap(), environment.getStoreRedirectKeys(), () => { });
+            ? baseEnvironment.storeLookup(unavailableSnapshot.select, baseEnvironment.createSnapshot, unavailableSnapshot.refresh)
+            : baseEnvironment.rebuildSnapshot(baseSnapshot, baseEnvironment.getStoreRecords(), baseEnvironment.getStoreMetadataMap(), baseEnvironment.getStoreRedirectKeys(), () => { });
         // if snapshot is pending then some other in-flight refresh will broadcast
         // later
         if (snapshot.state === 'Pending') {
@@ -407,13 +462,13 @@ function reviveSnapshot(environment, durableStore, pendingWriter, unavailableSna
             for (let i = 0, len = newKeys.length; i < len; i++) {
                 const newSnapshotSeenKey = newKeys[i];
                 if (alreadyRequestedOrRevivedSet[newSnapshotSeenKey] !== true) {
-                    return reviveSnapshot(environment, durableStore, pendingWriter, snapshot, refresh, durableStoreErrorHandler, baseSnapshot);
+                    return reviveSnapshot(baseEnvironment, durableStore, pendingWriter, snapshot, refresh, durableStoreErrorHandler, baseSnapshot);
                 }
             }
             // otherwise it's an L2 cache miss, so refresh
             return refreshSnapshot();
         }
-        if (environment.snapshotAvailable(snapshot)) {
+        if (baseEnvironment.snapshotAvailable(snapshot)) {
             return snapshot;
         }
         // all other scenarios we just refresh
@@ -425,6 +480,83 @@ function reviveSnapshot(environment, durableStore, pendingWriter, unavailableSna
     });
 }
 
+const TTL_DURABLE_SEGMENT = 'TTL_DURABLE_SEGMENT';
+const TTL_DEFAULT_KEY = 'TTL_DEFAULT_KEY';
+function buildDurableTTLOverrideStoreKey(namespace, representationName) {
+    return `${namespace}::${representationName}`;
+}
+function isEntryDurableTTLOverride(entry) {
+    if (typeof entry === 'object' && entry !== undefined && entry !== null) {
+        const data = entry.data;
+        if (data !== undefined) {
+            return (data.namespace !== undefined &&
+                data.representationName !== undefined &&
+                data.ttl !== undefined);
+        }
+    }
+    return false;
+}
+function isDefaultDurableTTLOverride(override) {
+    return (override.namespace === TTL_DEFAULT_KEY && override.representationName === TTL_DEFAULT_KEY);
+}
+/**
+ * Class to set and get the TTL override values in the Durable Store
+ */
+class DurableTTLStore {
+    constructor(durableStore) {
+        this.durableStore = durableStore;
+    }
+    setDefaultDurableTTLOverrides(ttl) {
+        return this.durableStore.setEntries({
+            [buildDurableTTLOverrideStoreKey(TTL_DEFAULT_KEY, TTL_DEFAULT_KEY)]: {
+                data: {
+                    namespace: TTL_DEFAULT_KEY,
+                    representationName: TTL_DEFAULT_KEY,
+                    ttl,
+                },
+            },
+        }, TTL_DURABLE_SEGMENT);
+    }
+    setDurableTTLOverride(namespace, representationName, ttl) {
+        return this.durableStore.setEntries({
+            [buildDurableTTLOverrideStoreKey(namespace, representationName)]: {
+                data: { namespace, representationName, ttl },
+            },
+        }, TTL_DURABLE_SEGMENT);
+    }
+    getDurableTTLOverrides() {
+        return this.durableStore
+            .getAllEntries(TTL_DURABLE_SEGMENT)
+            .then((entries) => {
+            const overrides = [];
+            let defaultTTL = undefined;
+            if (entries === undefined) {
+                return {
+                    defaultTTL,
+                    overrides,
+                };
+            }
+            const keys$1 = keys(entries);
+            for (let i = 0, len = keys$1.length; i < len; i++) {
+                const key = keys$1[i];
+                const entry = entries[key];
+                if (entry !== undefined && isEntryDurableTTLOverride(entry)) {
+                    if (isDefaultDurableTTLOverride(entry.data)) {
+                        defaultTTL = entry.data;
+                    }
+                    else {
+                        overrides.push(entry.data);
+                    }
+                }
+            }
+            return {
+                defaultTTL,
+                overrides,
+            };
+        });
+    }
+}
+
 const AdapterContextSegment = 'ADAPTER-CONTEXT';
 const ADAPTER_CONTEXT_ID_SUFFIX = '__NAMED_CONTEXT';
 function reviveOrCreateContext(adapterId, durableStore, durableStoreErrorHandler, onContextLoaded) {
@@ -470,6 +602,7 @@ function reviveOrCreateContext(adapterId, durableStore, durableStoreErrorHandler
  * @param instrumentation An instrumentation function implementation
  */
 function makeDurable(environment, { durableStore, instrumentation, pendingWriter = buildPendingWriter() }) {
+    const durableTTLStore = new DurableTTLStore(durableStore);
     //instrumentation for durable store errors
     const durableStoreErrorHandler = handleDurableStoreRejection(instrumentation);
     let disposed = false;
@@ -530,6 +663,19 @@ function makeDurable(environment, { durableStore, instrumentation, pendingWriter
         pendingWriter.addPendingWrite(recordId);
         environment.publishStoreMetadata(recordId, storeMetadata);
     };
+    const storeIngestError = function (key, errorSnapshot, storeMetadataParams, _storeOverride) {
+        validateNotDisposed();
+        // TODO [W-9680660]: this will get cleaned up in next PR to use staging store
+        const store = {
+            publish: function (key, data) {
+                storePublish(key, data);
+            },
+            publishMetadata: function (key, storeMetadata) {
+                publishStoreMetadata(key, storeMetadata);
+            },
+        };
+        environment.storeIngestError(key, errorSnapshot, storeMetadataParams, store);
+    };
     const storeBroadcast = function (_rebuildSnapshot, _snapshotDataAvailable) {
         // don't await the DS write - DS implementation will take care of R/W
         // synchronization
@@ -562,7 +708,9 @@ function makeDurable(environment, { durableStore, instrumentation, pendingWriter
         if (snapshot.state === 'Pending') {
             return environment.resolvePendingSnapshot(snapshot);
         }
-        return reviveSnapshot(environment, durableStore, pendingWriter, snapshot, refresh, durableStoreErrorHandler);
+        const { resolve, config } = refresh;
+        const refreshFunc = () => resolve(config);
+        return reviveSnapshot(environment, durableStore, pendingWriter, snapshot, refreshFunc, durableStoreErrorHandler);
     };
     const rebuildSnapshot = function (snapshot, records, storeMetadataMap, redirects, onAsyncRebuild) {
         validateNotDisposed();
@@ -578,9 +726,11 @@ function makeDurable(environment, { durableStore, instrumentation, pendingWriter
         if (refresh === undefined) {
             return rebuilt;
         }
+        const { resolve, config } = refresh;
+        const refreshFunc = () => resolve(config);
         // Do an L2 revive (which will refresh from network on L2 miss) and if
         // it results in an available snapshot emit to subscriber using the callback.
-        reviveSnapshot(environment, durableStore, pendingWriter, rebuilt, refresh, durableStoreErrorHandler, snapshot).then((revivedSnapshot) => {
+        reviveSnapshot(environment, durableStore, pendingWriter, rebuilt, refreshFunc, durableStoreErrorHandler, snapshot).then((revivedSnapshot) => {
             if (environment.snapshotAvailable(revivedSnapshot) === true) {
                 onAsyncRebuild(revivedSnapshot);
             }
@@ -626,19 +776,67 @@ function makeDurable(environment, { durableStore, instrumentation, pendingWriter
             return result;
         });
     };
+    const storeSetTTLOverride = function (namespace, representationName, ttl) {
+        validateNotDisposed();
+        durableTTLStore.setDurableTTLOverride(namespace, representationName, ttl);
+        environment.storeSetTTLOverride(namespace, representationName, ttl);
+    };
+    const storeSetDefaultTTLOverride = function (ttl) {
+        validateNotDisposed();
+        durableTTLStore.setDefaultDurableTTLOverrides(ttl);
+        environment.storeSetDefaultTTLOverride(ttl);
+    };
+    const getDurableTTLOverrides = function () {
+        validateNotDisposed();
+        return durableTTLStore.getDurableTTLOverrides();
+    };
+    const defaultCachePolicy = buildStaleWhileRevalidateImplementation(validateNotDisposed, resolveSnapshot, Number.MAX_SAFE_INTEGER);
+    function resolveCachePolicy(cachePolicy, defaultCachePolicy) {
+        if (cachePolicy === undefined) {
+            return defaultCachePolicy;
+        }
+        switch (cachePolicy.type) {
+            case 'stale-while-revalidate':
+                return buildStaleWhileRevalidateImplementation(validateNotDisposed, resolveSnapshot, cachePolicy.staleDuration);
+            default: {
+                if (process.env.NODE_ENV !== 'production') {
+                    throw new Error(`unrecognized cache policy: ${JSON.stringify(cachePolicy)}`);
+                }
+                return defaultCachePolicy;
+            }
+        }
+    }
+    const applyCachePolicy = function (cachePolicy, buildSnapshotContext, buildInMemorySnapshot, buildNetworkSnapshot) {
+        validateNotDisposed();
+        const cachePolicyImpl = resolveCachePolicy(cachePolicy, defaultCachePolicy);
+        const storeLookup = (sel, refresh, ttlStrategy) => environment.storeLookup(sel, environment.createSnapshot, refresh, ttlStrategy);
+        return cachePolicyImpl({
+            buildInMemorySnapshot,
+            buildNetworkSnapshot,
+            buildSnapshotContext,
+            storeLookup,
+            dispatchResourceRequest,
+        });
+    };
     return create(environment, {
         publishStoreMetadata: { value: publishStoreMetadata },
+        storeIngestError: { value: storeIngestError },
         storeBroadcast: { value: storeBroadcast },
         storeReset: { value: storeReset },
         resolveSnapshot: { value: resolveSnapshot },
         storeEvict: { value: storeEvict },
         withContext: { value: withContext },
         rebuildSnapshot: { value: rebuildSnapshot },
+        storeSetTTLOverride: { value: storeSetTTLOverride },
+        storeSetDefaultTTLOverride: { value: storeSetDefaultTTLOverride },
         storePublish: { value: storePublish },
         storeRedirect: { value: storeRedirect },
         dispatchResourceRequest: { value: dispatchResourceRequest },
         dispose: { value: dispose },
         publishChangesToDurableStore: { value: publishChangesToDurableStore },
+        getDurableTTLOverrides: { value: getDurableTTLOverrides },
+        defaultCachePolicy: { value: defaultCachePolicy },
+        applyCachePolicy: { value: applyCachePolicy },
     });
 }
 
@@ -654,8 +852,8 @@ function makeDurable(environment, { durableStore, instrumentation, pendingWriter
  * cause a network refresh to happen).
  */
 function makeOffline(environment) {
-    const storeLookup = function (sel, createSnapshot, refresh) {
-        const snapshot = environment.storeLookup(sel, createSnapshot, refresh);
+    const storeLookup = function (sel, createSnapshot, refresh, ttlStrategy) {
+        const snapshot = environment.storeLookup(sel, createSnapshot, refresh, ttlStrategy);
         // if the snapshot is stale we want to kick off a refresh
         if (snapshot.state === 'Stale') {
             if (refresh !== undefined) {
@@ -678,6 +876,9 @@ function makeOffline(environment) {
         });
     };
     return create(environment, {
+        defaultCachePolicy: {
+            value: buildStaleWhileRevalidateImplementation$1(Number.MAX_SAFE_INTEGER),
+        },
         storeLookup: { value: storeLookup },
         snapshotAvailable: {
             value: snapshotAvailable,
@@ -688,4 +889,4 @@ function makeOffline(environment) {
     });
 }
 
-export { DefaultDurableSegment, DurableStoreOperationType, makeDurable, makeOffline };
+export { DefaultDurableSegment, DurableStoreOperationType, makeDurable, makeOffline, publishDurableStoreEntries };

package/dist/es/es2018/main.d.ts

@@ -1,3 +1,5 @@
 export { DurableStore, DurableStoreEntries, DurableStoreEntry, DurableStoreChange, OnDurableStoreChangedListener, DefaultDurableSegment, DurableStoreOperation, DurableStoreOperationType, } from './DurableStore';
+export { DurableTTLOverride, DefaultDurableTTLOverride } from './DurableTTLStore';
 export { makeDurable, DurableEnvironment } from './makeDurable';
+export { publishDurableStoreEntries } from './makeDurable/revive';
 export { makeOffline } from './makeOffline';

package/dist/es/es2018/makeDurable/cachepolicy.d.ts

@@ -0,0 +1,2 @@
+import { CachePolicyImplementationArgs, Environment, Snapshot } from '@luvio/engine';
+export declare function buildStaleWhileRevalidateImplementation(validateNotDisposed: () => void, resolveSnapshot: Environment['resolveSnapshot'], 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>>;

package/dist/es/es2018/makeDurable/flush.d.ts

@@ -0,0 +1,4 @@
+import { Store } from '@luvio/engine';
+import { DurableStore } from '../DurableStore';
+import { DurableStoreRejectionHandler } from './error';
+export declare function flushStoreValuesToDurableStore(store: Store, durableStore: DurableStore, durableStoreErrorHandler: DurableStoreRejectionHandler): Promise<void>;

package/dist/es/es2018/makeDurable/refresh.d.ts

@@ -1,3 +1,3 @@
-import { Environment, Snapshot, SnapshotRefresh, UnAvailableSnapshot } from '@luvio/engine';
+import { Environment, Snapshot, UnAvailableSnapshot } from '@luvio/engine';
 import { PendingWriter } from './pendingWriter';
-export declare function buildDurableStoreAwareRefresh<ResponseType>(refresh: SnapshotRefresh<ResponseType>, snapshot: UnAvailableSnapshot<ResponseType>, environment: Environment, pendingWriter: PendingWriter): () => Promise<Snapshot<ResponseType>>;
+export declare function buildDurableStoreAwareRefresh<ResponseType, V = unknown>(refresh: () => Promise<Snapshot<ResponseType, V>>, snapshot: UnAvailableSnapshot<ResponseType, V>, environment: Environment, pendingWriter: PendingWriter): () => Promise<Snapshot<ResponseType, V>>;

package/dist/es/es2018/makeDurable/revive.d.ts

@@ -1,4 +1,4 @@
-import { Environment, SnapshotRefresh, Snapshot, UnAvailableSnapshot, DataSnapshot } from '@luvio/engine';
+import { Environment, Snapshot, UnAvailableSnapshot, DataSnapshot, StoreMetadata } from '@luvio/engine';
 import { DurableStore, DurableStoreEntries } from '../DurableStore';
 import { DurableStoreRejectionHandler } from './error';
 import { PendingWriter } from './pendingWriter';
@@ -9,12 +9,23 @@ declare type ReviveResponse = {
     revivedKeys: ObjectAsSet;
     hadUnexpectedShape: boolean;
 };
-export declare function reviveDurableEntriesToStore(durableRecords: DurableStoreEntries<unknown> | undefined, environment: Environment, pendingWriter: PendingWriter): ReviveResponse;
+/**
+ * Takes a set of entries from DurableStore and publishes them via the passed in funcs.
+ * This respects expiration and checks for valid DurableStore data shapes.  This should
+ * be used over manually parsing DurableStoreEntries
+ *
+ * @param durableRecords The DurableStoreEntries to parse
+ * @param publish A function to call with the data of each DurableStoreEntry
+ * @param publishMetadata A function to call with the metadata of each DurableStoreEntry
+ * @param pendingWriter the PendingWriter (this is going away soon)
+ * @returns
+ */
+export declare function publishDurableStoreEntries(durableRecords: DurableStoreEntries<unknown> | undefined, publish: (key: string, record: unknown) => void, publishMetadata: (key: string, metadata: StoreMetadata) => void, pendingWriter: PendingWriter): ReviveResponse;
 /**
  * This method returns a Promise to a snapshot that is revived from L2 cache.  If
  * L2 does not have the entries necessary to fulfill the snapshot then this method
  * will refresh the snapshot from network, and then run the results from network
  * through L2 ingestion, returning the subsequent revived snapshot.
  */
-export declare function reviveSnapshot<D>(environment: Environment, durableStore: DurableStore, pendingWriter: PendingWriter, unavailableSnapshot: UnAvailableSnapshot<D>, refresh: SnapshotRefresh<D>, durableStoreErrorHandler: DurableStoreRejectionHandler, baseSnapshot?: DataSnapshot<D>): Promise<Snapshot<D>>;
+export declare function reviveSnapshot<D, V = unknown>(baseEnvironment: Environment, durableStore: DurableStore, pendingWriter: PendingWriter, unavailableSnapshot: UnAvailableSnapshot<D, V>, refresh: () => Promise<Snapshot<D, V>>, durableStoreErrorHandler: DurableStoreRejectionHandler, baseSnapshot?: DataSnapshot<D, V>): Promise<Snapshot<D, V>>;
 export {};

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

@@ -0,0 +1,2 @@
+import { StoreRecordError } from '@luvio/engine';
+export declare function isStoreEntryError(storeRecord: unknown): storeRecord is StoreRecordError;

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

@@ -2,6 +2,7 @@ import { Environment } from '@luvio/engine';
 import { DurableStore } from './DurableStore';
 import { InstrumentationFunction } from './makeDurable/error';
 import { PendingWriter } from './makeDurable/pendingWriter';
+import { TTLOverridesMap } from './DurableTTLStore';
 export interface DurableEnvironment extends Environment {
     /**
      * Disposes the environment and detaches the durable store listener
@@ -11,6 +12,10 @@ export interface DurableEnvironment extends Environment {
      * publishes the pending changes to the durable store
      */
     publishChangesToDurableStore(): Promise<void>;
+    /**
+     * gets all the stored ttl overrides stored in the durable store
+     */
+    getDurableTTLOverrides(): Promise<TTLOverridesMap>;
 }
 export declare const AdapterContextSegment = "ADAPTER-CONTEXT";
 export declare const ADAPTER_CONTEXT_ID_SUFFIX = "__NAMED_CONTEXT";

package/dist/umd/es2018/DurableTTLStore.d.ts

@@ -0,0 +1,25 @@
+import { DurableStore } from './DurableStore';
+export declare const TTL_DURABLE_SEGMENT = "TTL_DURABLE_SEGMENT";
+export interface DefaultDurableTTLOverride extends DurableTTLOverride {
+    namespace: 'TTL_DEFAULT_KEY';
+    representationName: 'TTL_DEFAULT_KEY';
+}
+export interface DurableTTLOverride {
+    namespace: string;
+    representationName: string;
+    ttl: number;
+}
+export interface TTLOverridesMap {
+    defaultTTL: DefaultDurableTTLOverride | undefined;
+    overrides: DurableTTLOverride[];
+}
+/**
+ * Class to set and get the TTL override values in the Durable Store
+ */
+export declare class DurableTTLStore {
+    private durableStore;
+    constructor(durableStore: DurableStore);
+    setDefaultDurableTTLOverrides(ttl: number): Promise<void>;
+    setDurableTTLOverride(namespace: string, representationName: string, ttl: number): Promise<void>;
+    getDurableTTLOverrides(): Promise<TTLOverridesMap>;
+}