@luvio/environments 0.52.0 → 0.55.0

package/dist/umd/es5/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) {
@@ -55,6 +55,53 @@
     var hasOwnProperty = Object.prototype.hasOwnProperty;
     var isArray = Array.isArray;
 
+    // cache policy implementations
+    function buildTTLStrategy(staleDuration) {
+        if (staleDuration === void 0) { staleDuration = 0; }
+        return function (timestamp, metadata, valueIsError) {
+            if (metadata !== undefined) {
+                var expirationTimestamp = metadata.expirationTimestamp;
+                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 function (sel, refresh) {
+            return storeLookup(sel, refresh, ttlStrategy);
+        };
+    }
+    function buildStaleWhileRevalidateImplementation(validateNotDisposed, resolveSnapshot, staleDuration) {
+        return function (args) {
+            validateNotDisposed();
+            var buildInMemorySnapshot = args.buildInMemorySnapshot, buildNetworkSnapshot = args.buildNetworkSnapshot, buildSnapshotContext = args.buildSnapshotContext, dispatchResourceRequest = args.dispatchResourceRequest, storeLookup = args.storeLookup;
+            var 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: function () { return buildNetworkSnapshot(buildSnapshotContext, dispatchResourceRequest); },
+                    config: undefined,
+                });
+            }
+            return buildNetworkSnapshot(buildSnapshotContext, dispatchResourceRequest);
+        };
+    }
+
     //Durable store error instrumentation key
     var DURABLE_STORE_ERROR = 'durable-store-error';
     /**
@@ -244,8 +291,7 @@
                     }
                     promiseResolve(resolvedSnapshot);
                 });
-                var resolve = refresh.resolve, config = refresh.config;
-                resolve(config)
+                refresh()
                     .then(function (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
@@ -287,11 +333,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) {
         var revivedKeys = create(null);
         var hadUnexpectedShape = false;
         if (durableRecords === undefined) {
@@ -319,13 +377,13 @@
             }
             if (metadata !== undefined) {
                 var expirationTimestamp = metadata.expirationTimestamp, staleTimestamp = metadata.staleTimestamp;
-                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
@@ -340,8 +398,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
@@ -351,8 +408,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: revivedKeys, hadUnexpectedShape: hadUnexpectedShape };
@@ -364,14 +420,14 @@
      * 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) {
         var _a;
         var recordId = unavailableSnapshot.recordId, select = unavailableSnapshot.select, seenRecords = unavailableSnapshot.seenRecords, state = unavailableSnapshot.state;
         // on rebuilds return the network snapshot on L2 miss
         var refreshSnapshot = baseSnapshot !== undefined
             ? function () {
                 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
@@ -384,17 +440,17 @@
                 }
                 // track the refresh operation to ensure no other refreshes kick off while in flight
                 snapshotRefreshMap.add(baseSnapshot);
-                return refresh.resolve(refresh.config).finally(function () {
+                return refresh().finally(function () {
                     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
         var keysToReviveSet = assign((_a = {}, _a[recordId] = true, _a), seenRecords);
         var keysToRevive = keys(keysToReviveSet);
@@ -403,10 +459,10 @@
             var paginationKey = paginationKeys[i];
             keysToRevive.push(paginationKey);
         }
-        var canonicalKeys = keysToRevive.map(function (x) { return environment.storeGetCanonicalKey(x); });
+        var canonicalKeys = keysToRevive.map(function (x) { return baseEnvironment.storeGetCanonicalKey(x); });
         return durableStore.getEntries(canonicalKeys, DefaultDurableSegment).then(function (durableRecords) {
             var _a;
-            var _b = reviveDurableEntriesToStore(durableRecords, environment, pendingWriter), revivedKeys = _b.revivedKeys, hadUnexpectedShape = _b.hadUnexpectedShape;
+            var _b = publishDurableStoreEntries(durableRecords, baseEnvironment.storePublish.bind(baseEnvironment), baseEnvironment.publishStoreMetadata.bind(baseEnvironment), pendingWriter), revivedKeys = _b.revivedKeys, hadUnexpectedShape = _b.hadUnexpectedShape;
             // if the data coming back from DS had an unexpected shape then refresh
             // data from network
             if (hadUnexpectedShape === true) {
@@ -419,8 +475,8 @@
             // attempt to lookup (or rebuild if baseSnapshot is provided) the snapshot
             // now that we have revived the missingLinks
             var snapshot = baseSnapshot === undefined
-                ? environment.storeLookup(unavailableSnapshot.select, environment.createSnapshot, unavailableSnapshot.refresh)
-                : environment.rebuildSnapshot(baseSnapshot, environment.getStoreRecords(), environment.getStoreMetadataMap(), environment.getStoreRedirectKeys(), function () { });
+                ? baseEnvironment.storeLookup(unavailableSnapshot.select, baseEnvironment.createSnapshot, unavailableSnapshot.refresh)
+                : baseEnvironment.rebuildSnapshot(baseSnapshot, baseEnvironment.getStoreRecords(), baseEnvironment.getStoreMetadataMap(), baseEnvironment.getStoreRedirectKeys(), function () { });
             // if snapshot is pending then some other in-flight refresh will broadcast
             // later
             if (snapshot.state === 'Pending') {
@@ -440,13 +496,13 @@
                 for (var i = 0, len = newKeys.length; i < len; i++) {
                     var 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
@@ -458,6 +514,86 @@
         });
     }
 
+    var TTL_DURABLE_SEGMENT = 'TTL_DURABLE_SEGMENT';
+    var TTL_DEFAULT_KEY = 'TTL_DEFAULT_KEY';
+    function buildDurableTTLOverrideStoreKey(namespace, representationName) {
+        return namespace + "::" + representationName;
+    }
+    function isEntryDurableTTLOverride(entry) {
+        if (typeof entry === 'object' && entry !== undefined && entry !== null) {
+            var 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
+     */
+    var DurableTTLStore = /** @class */ (function () {
+        function DurableTTLStore(durableStore) {
+            this.durableStore = durableStore;
+        }
+        DurableTTLStore.prototype.setDefaultDurableTTLOverrides = function (ttl) {
+            var _a;
+            return this.durableStore.setEntries((_a = {},
+                _a[buildDurableTTLOverrideStoreKey(TTL_DEFAULT_KEY, TTL_DEFAULT_KEY)] = {
+                    data: {
+                        namespace: TTL_DEFAULT_KEY,
+                        representationName: TTL_DEFAULT_KEY,
+                        ttl: ttl,
+                    },
+                },
+                _a), TTL_DURABLE_SEGMENT);
+        };
+        DurableTTLStore.prototype.setDurableTTLOverride = function (namespace, representationName, ttl) {
+            var _a;
+            return this.durableStore.setEntries((_a = {},
+                _a[buildDurableTTLOverrideStoreKey(namespace, representationName)] = {
+                    data: { namespace: namespace, representationName: representationName, ttl: ttl },
+                },
+                _a), TTL_DURABLE_SEGMENT);
+        };
+        DurableTTLStore.prototype.getDurableTTLOverrides = function () {
+            return this.durableStore
+                .getAllEntries(TTL_DURABLE_SEGMENT)
+                .then(function (entries) {
+                var overrides = [];
+                var defaultTTL = undefined;
+                if (entries === undefined) {
+                    return {
+                        defaultTTL: defaultTTL,
+                        overrides: overrides,
+                    };
+                }
+                var keys$1 = keys(entries);
+                for (var i = 0, len = keys$1.length; i < len; i++) {
+                    var key = keys$1[i];
+                    var entry = entries[key];
+                    if (entry !== undefined && isEntryDurableTTLOverride(entry)) {
+                        if (isDefaultDurableTTLOverride(entry.data)) {
+                            defaultTTL = entry.data;
+                        }
+                        else {
+                            overrides.push(entry.data);
+                        }
+                    }
+                }
+                return {
+                    defaultTTL: defaultTTL,
+                    overrides: overrides,
+                };
+            });
+        };
+        return DurableTTLStore;
+    }());
+
     var AdapterContextSegment = 'ADAPTER-CONTEXT';
     var ADAPTER_CONTEXT_ID_SUFFIX = '__NAMED_CONTEXT';
     function reviveOrCreateContext(adapterId, durableStore, durableStoreErrorHandler, onContextLoaded) {
@@ -505,6 +641,7 @@
      */
     function makeDurable(environment, _a) {
         var durableStore = _a.durableStore, instrumentation = _a.instrumentation, _b = _a.pendingWriter, pendingWriter = _b === void 0 ? buildPendingWriter() : _b;
+        var durableTTLStore = new DurableTTLStore(durableStore);
         //instrumentation for durable store errors
         var durableStoreErrorHandler = handleDurableStoreRejection(instrumentation);
         var disposed = false;
@@ -565,6 +702,19 @@
             pendingWriter.addPendingWrite(recordId);
             environment.publishStoreMetadata(recordId, storeMetadata);
         };
+        var storeIngestError = function (key, errorSnapshot, storeMetadataParams, _storeOverride) {
+            validateNotDisposed();
+            // TODO [W-9680660]: this will get cleaned up in next PR to use staging store
+            var store = {
+                publish: function (key, data) {
+                    storePublish(key, data);
+                },
+                publishMetadata: function (key, storeMetadata) {
+                    publishStoreMetadata(key, storeMetadata);
+                },
+            };
+            environment.storeIngestError(key, errorSnapshot, storeMetadataParams, store);
+        };
         var storeBroadcast = function (_rebuildSnapshot, _snapshotDataAvailable) {
             // don't await the DS write - DS implementation will take care of R/W
             // synchronization
@@ -597,7 +747,9 @@
             if (snapshot.state === 'Pending') {
                 return environment.resolvePendingSnapshot(snapshot);
             }
-            return reviveSnapshot(environment, durableStore, pendingWriter, snapshot, refresh, durableStoreErrorHandler);
+            var resolve = refresh.resolve, config = refresh.config;
+            var refreshFunc = function () { return resolve(config); };
+            return reviveSnapshot(environment, durableStore, pendingWriter, snapshot, refreshFunc, durableStoreErrorHandler);
         };
         var rebuildSnapshot = function (snapshot, records, storeMetadataMap, redirects, onAsyncRebuild) {
             validateNotDisposed();
@@ -613,9 +765,11 @@
             if (refresh === undefined) {
                 return rebuilt;
             }
+            var resolve = refresh.resolve, config = refresh.config;
+            var refreshFunc = function () { return 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(function (revivedSnapshot) {
+            reviveSnapshot(environment, durableStore, pendingWriter, rebuilt, refreshFunc, durableStoreErrorHandler, snapshot).then(function (revivedSnapshot) {
                 if (environment.snapshotAvailable(revivedSnapshot) === true) {
                     onAsyncRebuild(revivedSnapshot);
                 }
@@ -659,19 +813,67 @@
                 return result;
             });
         };
+        var storeSetTTLOverride = function (namespace, representationName, ttl) {
+            validateNotDisposed();
+            durableTTLStore.setDurableTTLOverride(namespace, representationName, ttl);
+            environment.storeSetTTLOverride(namespace, representationName, ttl);
+        };
+        var storeSetDefaultTTLOverride = function (ttl) {
+            validateNotDisposed();
+            durableTTLStore.setDefaultDurableTTLOverrides(ttl);
+            environment.storeSetDefaultTTLOverride(ttl);
+        };
+        var getDurableTTLOverrides = function () {
+            validateNotDisposed();
+            return durableTTLStore.getDurableTTLOverrides();
+        };
+        var 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;
+                }
+            }
+        }
+        var applyCachePolicy = function (cachePolicy, buildSnapshotContext, buildInMemorySnapshot, buildNetworkSnapshot) {
+            validateNotDisposed();
+            var cachePolicyImpl = resolveCachePolicy(cachePolicy, defaultCachePolicy);
+            var storeLookup = function (sel, refresh, ttlStrategy) { return environment.storeLookup(sel, environment.createSnapshot, refresh, ttlStrategy); };
+            return cachePolicyImpl({
+                buildInMemorySnapshot: buildInMemorySnapshot,
+                buildNetworkSnapshot: buildNetworkSnapshot,
+                buildSnapshotContext: buildSnapshotContext,
+                storeLookup: storeLookup,
+                dispatchResourceRequest: 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 },
         });
     }
 
@@ -687,8 +889,8 @@
      * cause a network refresh to happen).
      */
     function makeOffline(environment) {
-        var storeLookup = function (sel, createSnapshot, refresh) {
-            var snapshot = environment.storeLookup(sel, createSnapshot, refresh);
+        var storeLookup = function (sel, createSnapshot, refresh, ttlStrategy) {
+            var 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) {
@@ -708,6 +910,9 @@
             environment.publishStoreMetadata(recordId, __assign(__assign({}, storeMetadata), { staleTimestamp: Number.MAX_SAFE_INTEGER }));
         };
         return create(environment, {
+            defaultCachePolicy: {
+                value: engine.buildStaleWhileRevalidateImplementation(Number.MAX_SAFE_INTEGER),
+            },
             storeLookup: { value: storeLookup },
             snapshotAvailable: {
                 value: snapshotAvailable,
@@ -721,6 +926,7 @@
     exports.DefaultDurableSegment = DefaultDurableSegment;
     exports.makeDurable = makeDurable;
     exports.makeOffline = makeOffline;
+    exports.publishDurableStoreEntries = publishDurableStoreEntries;
 
     Object.defineProperty(exports, '__esModule', { value: true });
 

package/dist/umd/es5/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/es5/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/es5/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/es5/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/es5/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/es5/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/es5/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/package.json

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