@luvio/environments 0.52.0 → 0.55.0

package/dist/umd/es2018/environments.js

@@ -1,8 +1,8 @@
 (function (global, factory) {
-    typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports) :
-    typeof define === 'function' && define.amd ? define(['exports'], factory) :
-    (global = global || self, factory(global.luvioEnvironments = {}));
-}(this, (function (exports) { 'use strict';
+    typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports, require('@luvio/engine')) :
+    typeof define === 'function' && define.amd ? define(['exports', '@luvio/engine'], factory) :
+    (global = global || self, factory(global.luvioEnvironments = {}, global.luvioEngine));
+}(this, (function (exports, engine) { 'use strict';
 
     function isDeprecatedDurableStoreEntry(durableRecord) {
         if (durableRecord.expiration !== undefined) {
@@ -21,6 +21,50 @@
     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 engine.StoreResolveResultState.Stale;
+                    }
+                    return engine.StoreResolveResultState.NotPresent;
+                }
+            }
+            if (valueIsError === true) {
+                return engine.StoreResolveResultState.Error;
+            }
+            return engine.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';
     /**
@@ -218,8 +262,7 @@
                     }
                     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
@@ -261,11 +304,23 @@
 
     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) {
@@ -293,13 +348,13 @@
             }
             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
@@ -314,8 +369,7 @@
                 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
@@ -325,8 +379,7 @@
             // 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 };
@@ -338,13 +391,13 @@
      * 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
@@ -357,17 +410,17 @@
                 }
                 // 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);
@@ -376,9 +429,9 @@
             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) {
@@ -391,8 +444,8 @@
             // 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') {
@@ -412,13 +465,13 @@
                 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
@@ -430,6 +483,83 @@
         });
     }
 
+    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) {
@@ -475,6 +605,7 @@
      * @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;
@@ -535,6 +666,19 @@
             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
@@ -567,7 +711,9 @@
             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();
@@ -583,9 +729,11 @@
             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);
                 }
@@ -631,19 +779,67 @@
                 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 },
         });
     }
 
@@ -659,8 +855,8 @@
      * 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) {
@@ -683,6 +879,9 @@
             });
         };
         return create(environment, {
+            defaultCachePolicy: {
+                value: engine.buildStaleWhileRevalidateImplementation(Number.MAX_SAFE_INTEGER),
+            },
             storeLookup: { value: storeLookup },
             snapshotAvailable: {
                 value: snapshotAvailable,
@@ -696,6 +895,7 @@
     exports.DefaultDurableSegment = DefaultDurableSegment;
     exports.makeDurable = makeDurable;
     exports.makeOffline = makeOffline;
+    exports.publishDurableStoreEntries = publishDurableStoreEntries;
 
     Object.defineProperty(exports, '__esModule', { value: true });
 

package/dist/umd/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/umd/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/umd/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/umd/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/umd/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/umd/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/umd/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/es5/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>;
+}