@luvio/environments 0.72.0 → 0.73.3

package/dist/umd/es5/environments.js

@@ -57,297 +57,6 @@
     var keys = Object.keys, create = Object.create, assign = Object.assign, freeze = Object.freeze;
     var isArray = Array.isArray;
 
-    function appendTTLStrategy(storeLookup, ttlStrategy) {
-        var returnStoreLookup = function (sel, refresh) {
-            return storeLookup(sel, refresh, ttlStrategy);
-        };
-        // append ttlStrategy to storeLookup function (in cases where custom adapter
-        // wants to perform it's own lookup)
-        returnStoreLookup.ttlStrategy = ttlStrategy;
-        return returnStoreLookup;
-    }
-    function buildNetworkSnapshot(args) {
-        var buildNetworkSnapshot = args.buildNetworkSnapshot, buildSnapshotContext = args.buildSnapshotContext, coercedAdapterRequestContext = args.coercedAdapterRequestContext;
-        return buildNetworkSnapshot(buildSnapshotContext, coercedAdapterRequestContext).then(function (snapshot) {
-            return snapshot.state === 'Pending' ? args.resolvePendingSnapshot(snapshot) : snapshot;
-        });
-    }
-    function buildTTLStrategy(staleDurationMilliseconds) {
-        if (staleDurationMilliseconds === void 0) { staleDurationMilliseconds = 0; }
-        return function (timestamp, metadata, valueIsError) {
-            if (metadata !== undefined) {
-                var expirationTimestamp = metadata.expirationTimestamp;
-                if (timestamp > expirationTimestamp) {
-                    if (timestamp <= expirationTimestamp + staleDurationMilliseconds &&
-                        valueIsError !== true) {
-                        return engine.StoreResolveResultState.Stale;
-                    }
-                    return engine.StoreResolveResultState.NotPresent;
-                }
-            }
-            if (valueIsError === true) {
-                return engine.StoreResolveResultState.Error;
-            }
-            return engine.StoreResolveResultState.Found;
-        };
-    }
-    // TODO - update userland-facing APIs to return `AvailableSnapshot` instead of `Snapshot`
-    // and then the signatures here can be updated as well
-    function buildAvailableSnapshotFromCachedSnapshotResponse(cachedSnapshot, availableSnapshotFunc) {
-        if (isPromise(cachedSnapshot)) {
-            return cachedSnapshot.then(availableSnapshotFunc);
-        }
-        return availableSnapshotFunc(cachedSnapshot);
-    }
-    function isPromise(value) {
-        if (value === undefined) {
-            return false;
-        }
-        // check for Thenable due to test frameworks using custom Promise impls
-        return value.then !== undefined;
-    }
-
-    function buildCacheAndNetworkImplementation(funcs, staleDurationSeconds) {
-        if (staleDurationSeconds === void 0) { staleDurationSeconds = 0; }
-        return function (args) {
-            funcs.validateNotDisposed();
-            var buildCachedSnapshot = args.buildCachedSnapshot, buildNetworkSnapshot$1 = args.buildNetworkSnapshot, buildSnapshotContext = args.buildSnapshotContext, storeLookup = args.storeLookup, coercedAdapterRequestContext = args.coercedAdapterRequestContext;
-            var staleDurationMilliseconds = staleDurationSeconds * 1000;
-            var cachePolicyStoreLookup = appendTTLStrategy(storeLookup, buildTTLStrategy(staleDurationMilliseconds));
-            var cachedSnapshot = buildCachedSnapshot(buildSnapshotContext, cachePolicyStoreLookup);
-            return buildAvailableSnapshotFromCachedSnapshotResponse(cachedSnapshot, function (snapshot) {
-                if (snapshot !== undefined) {
-                    // data found in L1 cache
-                    if (snapshot.state === 'Fulfilled' ||
-                        snapshot.state === 'Error' ||
-                        snapshot.state === 'Stale') {
-                        // kick off network request, do not await it
-                        buildNetworkSnapshot$1(buildSnapshotContext, coercedAdapterRequestContext);
-                        // return the cached snapshot to caller
-                        return snapshot;
-                    }
-                    // network request outstanding
-                    if (snapshot.state === 'Pending') {
-                        // kick off another network request, do not await it
-                        buildNetworkSnapshot$1(buildSnapshotContext, coercedAdapterRequestContext);
-                        return args.resolvePendingSnapshot(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' ||
-                                revivedSnapshot.state === 'Stale') {
-                                // kick off network request, do not await it
-                                buildNetworkSnapshot$1(buildSnapshotContext, coercedAdapterRequestContext);
-                                // return the L2 cached snapshot to caller
-                                return revivedSnapshot;
-                            }
-                            if (revivedSnapshot.state === 'Pending') {
-                                // kick off network request, do not await it
-                                buildNetworkSnapshot$1(buildSnapshotContext, coercedAdapterRequestContext);
-                                return args.resolvePendingSnapshot(revivedSnapshot);
-                            }
-                            // data not found in L2 cache, go to the network
-                            return buildNetworkSnapshot(args);
-                        });
-                    }
-                }
-                return buildNetworkSnapshot(args);
-            });
-        };
-    }
-
-    function buildCacheThenNetworkImplementation(funcs) {
-        return function (args) {
-            funcs.validateNotDisposed();
-            var buildCachedSnapshot = args.buildCachedSnapshot, buildSnapshotContext = args.buildSnapshotContext, storeLookup = args.storeLookup;
-            var cachePolicyStoreLookup = appendTTLStrategy(storeLookup, buildTTLStrategy());
-            var cachedSnapshot = buildCachedSnapshot(buildSnapshotContext, cachePolicyStoreLookup);
-            return buildAvailableSnapshotFromCachedSnapshotResponse(cachedSnapshot, function (snapshot) {
-                if (snapshot !== undefined) {
-                    // data found in L1 cache
-                    if (snapshot.state === 'Fulfilled' || snapshot.state === 'Error') {
-                        return snapshot;
-                    }
-                    if (snapshot.state === 'Pending') {
-                        return args.resolvePendingSnapshot(snapshot);
-                    }
-                    // 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') {
-                                return revivedSnapshot;
-                            }
-                            if (revivedSnapshot.state === 'Pending') {
-                                return args.resolvePendingSnapshot(revivedSnapshot);
-                            }
-                            // data not found in L2 cache, go to the network
-                            return buildNetworkSnapshot(args);
-                        });
-                    }
-                }
-                // L1 lookup could not find enough information to even construct a snapshot, go to the network
-                return buildNetworkSnapshot(args);
-            });
-        };
-    }
-
-    function buildNoCacheImplementation(funcs) {
-        return function (args) {
-            funcs.validateNotDisposed();
-            return buildNetworkSnapshot(args);
-        };
-    }
-
-    function deepFreeze(value) {
-        // No need to freeze primitives
-        if (typeof value !== 'object' || value === null) {
-            return;
-        }
-        if (isArray(value)) {
-            for (var i = 0, len = value.length; i < len; i += 1) {
-                deepFreeze(value[i]);
-            }
-        }
-        else {
-            var keys$1 = keys(value);
-            for (var i = 0, len = keys$1.length; i < len; i += 1) {
-                deepFreeze(value[keys$1[i]]);
-            }
-        }
-        freeze(value);
-    }
-
-    // TODO[@W-10165595]: consolidate this code with the corresponding logic in the default environment's only-if-cached.ts
-    function buildNotCachedErrorSnapshot() {
-        var error = {
-            body: undefined,
-            headers: {},
-            ok: false,
-            status: engine.HttpStatusCode.GatewayTimeout,
-            statusText: 'Gateway Timeout',
-        };
-        deepFreeze(error);
-        return {
-            error: error,
-            state: 'Error',
-            data: undefined,
-            // TODO[@W-10164067]: copy refresh data from the snapshot returned by buildCachedSnapshot (if any)
-            // refresh: ...
-        };
-    }
-    function buildOnlyIfCachedImplementation(funcs) {
-        return function (args) {
-            funcs.validateNotDisposed();
-            var buildCachedSnapshot = args.buildCachedSnapshot, buildSnapshotContext = args.buildSnapshotContext, storeLookup = args.storeLookup;
-            var cachePolicyStoreLookup = appendTTLStrategy(storeLookup, buildTTLStrategy());
-            var cachedSnapshot = buildCachedSnapshot(buildSnapshotContext, cachePolicyStoreLookup);
-            return buildAvailableSnapshotFromCachedSnapshotResponse(cachedSnapshot, function (snapshot) {
-                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();
-                    }
-                    // 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') {
-                                return revivedSnapshot;
-                            }
-                            // data is not cached
-                            return buildNotCachedErrorSnapshot();
-                        });
-                    }
-                }
-                return buildNotCachedErrorSnapshot();
-            });
-        };
-    }
-
-    function buildStaleWhileRevalidateImplementation(funcs, staleDurationSeconds) {
-        return function (args) {
-            funcs.validateNotDisposed();
-            var buildCachedSnapshot = args.buildCachedSnapshot, buildSnapshotContext = args.buildSnapshotContext, storeLookup = args.storeLookup;
-            var cachePolicyStoreLookup = appendTTLStrategy(storeLookup, buildTTLStrategy(staleDurationSeconds * 1000));
-            var cachedSnapshot = buildCachedSnapshot(buildSnapshotContext, cachePolicyStoreLookup);
-            return buildAvailableSnapshotFromCachedSnapshotResponse(cachedSnapshot, function (snapshot) {
-                if (snapshot !== undefined) {
-                    // data found in L1 cache
-                    if (snapshot.state === 'Fulfilled' || snapshot.state === 'Error') {
-                        return snapshot;
-                    }
-                    if (snapshot.state === 'Pending') {
-                        return args.resolvePendingSnapshot(snapshot);
-                    }
-                    // stale data found in L1 cache
-                    if (snapshot.state === 'Stale') {
-                        buildNetworkSnapshot(args);
-                        return snapshot;
-                    }
-                    // data not found in L1 cache, try L2 cache
-                    return funcs
-                        .reviveSnapshotWithCachePolicy(snapshot, cachePolicyStoreLookup)
-                        .then(function (revivedSnapshot) {
-                        // data found in L2 cache
-                        if (revivedSnapshot.state === 'Fulfilled' ||
-                            revivedSnapshot.state === 'Error') {
-                            return revivedSnapshot;
-                        }
-                        if (revivedSnapshot.state === 'Pending') {
-                            return args.resolvePendingSnapshot(revivedSnapshot);
-                        }
-                        // stale data found in L2 cache
-                        if (revivedSnapshot.state === 'Stale') {
-                            buildNetworkSnapshot(args);
-                            return revivedSnapshot;
-                        }
-                        // data not found in L2 cache, go to the network
-                        return buildNetworkSnapshot(args);
-                    });
-                }
-                // L1 lookup could not find enough information to even construct a snapshot, go to the network
-                return buildNetworkSnapshot(args);
-            });
-        };
-    }
-
-    function 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 buildCachedSnapshot =>
-            //    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';
     /**
@@ -373,6 +82,25 @@
         };
     }
 
+    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;
@@ -742,6 +470,15 @@
             return contextReturn();
         });
     }
+    function isUnfulfilledSnapshot(cachedSnapshotResult) {
+        if (cachedSnapshotResult === undefined) {
+            return false;
+        }
+        if ('then' in cachedSnapshotResult) {
+            return false;
+        }
+        return cachedSnapshotResult.state === 'Unfulfilled';
+    }
     /**
      * Configures the environment to persist data into a durable store and attempt to resolve
      * data from the persistent store before hitting the network.
@@ -853,12 +590,9 @@
         };
         var storeBroadcast = function (_rebuildSnapshot, _snapshotDataAvailable) {
             validateNotDisposed();
-            // for our environment we basically want a broadcast to be a "durable store broadcast",
-            // so we flush staging store to L2, which will cause the onChanged handler to fire
-            // which will revive records to the main L1 store and call the base storeBroadcast
-            // don't await the DS write - DS implementation will take care of R/W
-            // synchronization
-            publishChangesToDurableStore();
+            // no-op here and wait for the L2 flush to happen in handleSuccessResponse,
+            // that flush will cause the onChanged handler to fire which will revive
+            // records to the main L1 store and call the base storeBroadcast
         };
         var publishChangesToDurableStore = function () {
             validateNotDisposed();
@@ -900,30 +634,6 @@
             }
             return environment.wrapNormalizedGraphNode(normalized, ingestStagingStore);
         };
-        var resolveSnapshot = function (snapshot, refresh) {
-            validateNotDisposed();
-            // if the snapshot is already pending then no need to kick off another
-            // revive, just wait for the pending refresh to broadcast
-            if (snapshot.state === 'Pending') {
-                return environment.resolvePendingSnapshot(snapshot);
-            }
-            var resolve = refresh.resolve, config = refresh.config;
-            var refreshFunc = function () { return resolve(config); };
-            // if the snapshot is unfulfilled we can do an L2 lookup
-            if (snapshot.state === 'Unfulfilled') {
-                return reviveSnapshot(environment, durableStore, snapshot, durableStoreErrorHandler, function () {
-                    return environment.storeLookup(snapshot.select, environment.createSnapshot, snapshot.refresh);
-                }).then(function (durableSnapshot) {
-                    if (environment.snapshotAvailable(durableSnapshot)) {
-                        // L2 cache hit
-                        return durableSnapshot;
-                    }
-                    // else have to hit network
-                    return refreshFunc();
-                });
-            }
-            return refreshFunc();
-        };
         var rebuildSnapshot = function (snapshot, records, storeMetadataMap, redirects, onAsyncRebuild) {
             validateNotDisposed();
             // try rebuilding from memory
@@ -985,77 +695,20 @@
             validateNotDisposed();
             return durableTTLStore.getDurableTTLOverrides();
         };
-        // reviveSnapshot wrapper to let cache policies revive data from L2 and
-        // access the revived data via their own storeLookups
-        var reviveSnapshotWithCachePolicy = function (unavailableSnapshot, storeLookup) {
-            return reviveSnapshot(environment, durableStore, unavailableSnapshot, durableStoreErrorHandler, function () { return storeLookup(unavailableSnapshot.select, unavailableSnapshot.refresh); });
-        };
-        var defaultCachePolicy = buildStaleWhileRevalidateImplementation({
-            validateNotDisposed: validateNotDisposed,
-            reviveSnapshotWithCachePolicy: reviveSnapshotWithCachePolicy,
-        }, Number.MAX_SAFE_INTEGER);
-        function resolveCachePolicy(cachePolicy) {
-            if (cachePolicy === undefined) {
-                return defaultCachePolicy;
-            }
-            switch (cachePolicy.type) {
-                case 'stale-while-revalidate':
-                    return buildStaleWhileRevalidateImplementation({
-                        validateNotDisposed: validateNotDisposed,
-                        reviveSnapshotWithCachePolicy: reviveSnapshotWithCachePolicy,
-                    }, 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: ".concat(JSON.stringify(cachePolicy)));
-                    }
-                    return defaultCachePolicy;
-                }
-            }
-        }
         var applyCachePolicy = function (adapterRequestContext, buildSnapshotContext, buildCachedSnapshot, buildNetworkSnapshot) {
             validateNotDisposed();
-            var cachePolicy = adapterRequestContext.cachePolicy;
-            var cachePolicyImpl = resolveCachePolicy(cachePolicy);
-            var resolvePendingSnapshot = function (snapshot) {
-                return environment.resolvePendingSnapshot(snapshot);
+            var wrappedCacheLookup = function (buildSnapshotContext, storeLookup) {
+                var snapshot = buildCachedSnapshot(buildSnapshotContext, storeLookup);
+                // if the adapter attempted to do an L1 lookup and it was unfulfilled
+                // then we can attempt an L2 lookup
+                if (isUnfulfilledSnapshot(snapshot)) {
+                    return reviveSnapshot(environment, durableStore, snapshot, durableStoreErrorHandler, function () { return storeLookup(snapshot.select, snapshot.refresh); });
+                }
+                // otherwise just return what buildCachedSnapshot gave us
+                return snapshot;
             };
-            var storeLookup = function (sel, refresh, ttlStrategy) { return environment.storeLookup(sel, environment.createSnapshot, refresh, ttlStrategy); };
             var applyCachePolicy = function () {
-                return cachePolicyImpl({
-                    buildCachedSnapshot: buildCachedSnapshot,
-                    buildNetworkSnapshot: buildNetworkSnapshot,
-                    buildSnapshotContext: buildSnapshotContext,
-                    resolvePendingSnapshot: resolvePendingSnapshot,
-                    storeLookup: storeLookup,
-                    coercedAdapterRequestContext: engine.coerceAdapterRequestContext(adapterRequestContext),
-                });
+                return environment.applyCachePolicy(adapterRequestContext, buildSnapshotContext, wrappedCacheLookup, buildNetworkSnapshot);
             };
             return isRevivingTTLOverrides !== undefined
                 ? isRevivingTTLOverrides.then(applyCachePolicy)
@@ -1082,17 +735,28 @@
                 ingestStagingStore.records = existingRecords;
             }
             var snapshotFromMemoryIngest = ingestAndBroadcastFunc();
-            if (snapshotFromMemoryIngest === undefined) {
-                return undefined;
-            }
-            if (snapshotFromMemoryIngest.state !== 'Unfulfilled') {
+            // now that ingestion is done flush staging store values to L2
+            return publishChangesToDurableStore().then(function () {
+                if (snapshotFromMemoryIngest === undefined) {
+                    return undefined;
+                }
+                if (snapshotFromMemoryIngest.state !== 'Unfulfilled') {
+                    return snapshotFromMemoryIngest;
+                }
+                // if snapshot from staging store lookup is unfulfilled then do an L2 lookup
+                return reviveSnapshot(environment, durableStore, snapshotFromMemoryIngest, durableStoreErrorHandler, function () {
+                    return environment.storeLookup(snapshotFromMemoryIngest.select, environment.createSnapshot, snapshotFromMemoryIngest.refresh);
+                });
+            });
+        };
+        var handleErrorResponse = function (ingestAndBroadcastFunc) {
+            validateNotDisposed();
+            var snapshotFromMemoryIngest = ingestAndBroadcastFunc();
+            return publishChangesToDurableStore().then(function () {
                 return snapshotFromMemoryIngest;
-            }
-            // if snapshot from staging store lookup is unfulfilled then do an L2 lookup
-            return reviveSnapshot(environment, durableStore, snapshotFromMemoryIngest, durableStoreErrorHandler, function () {
-                return environment.storeLookup(snapshotFromMemoryIngest.select, environment.createSnapshot, snapshotFromMemoryIngest.refresh);
             });
         };
+        environment.defaultCachePolicy = engine.buildStaleWhileRevalidateImplementation(Number.MAX_SAFE_INTEGER);
         return create(environment, {
             publishStoreMetadata: { value: publishStoreMetadata },
             storeIngest: { value: storeIngest },
@@ -1102,7 +766,6 @@
             storeEvict: { value: storeEvict },
             wrapNormalizedGraphNode: { value: wrapNormalizedGraphNode },
             getNode: { value: getNode },
-            resolveSnapshot: { value: resolveSnapshot },
             rebuildSnapshot: { value: rebuildSnapshot },
             withContext: { value: withContext },
             storeSetTTLOverride: { value: storeSetTTLOverride },
@@ -1112,11 +775,11 @@
             dispose: { value: dispose },
             publishChangesToDurableStore: { value: publishChangesToDurableStore },
             getDurableTTLOverrides: { value: getDurableTTLOverrides },
-            defaultCachePolicy: { value: defaultCachePolicy },
             applyCachePolicy: { value: applyCachePolicy },
             getIngestStagingStoreRecords: { value: getIngestStagingStoreRecords },
             getIngestStagingStoreMetadata: { value: getIngestStagingStoreMetadata },
             handleSuccessResponse: { value: handleSuccessResponse },
+            handleErrorResponse: { value: handleErrorResponse },
         });
     }
 

package/package.json

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

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

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

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

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

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

@@ -1,6 +0,0 @@
-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

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

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

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

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

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

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

@@ -1,9 +0,0 @@
-import { BuildCachedSnapshot, CachePolicyImplementationArgs, Snapshot, StoreLookup, TTLStrategy, UnAvailableSnapshot } from '@luvio/engine';
-export declare type DurableCachePolicyFunctions = {
-    validateNotDisposed: () => void;
-    reviveSnapshotWithCachePolicy: <D, V>(unavailableSnapshot: UnAvailableSnapshot<D, V>, storeLookup: StoreLookup<D, V>) => Promise<Snapshot<D, V>>;
-};
-export declare function appendTTLStrategy<C, D>(storeLookup: CachePolicyImplementationArgs<C, D>['storeLookup'], ttlStrategy: TTLStrategy): Parameters<BuildCachedSnapshot<C, D>>[1];
-export declare function buildNetworkSnapshot<C, D>(args: CachePolicyImplementationArgs<C, D>): Promise<Snapshot<D, unknown>>;
-export declare function buildTTLStrategy(staleDurationMilliseconds?: number): TTLStrategy;
-export declare function buildAvailableSnapshotFromCachedSnapshotResponse<C, D>(cachedSnapshot: ReturnType<BuildCachedSnapshot<C, D>>, availableSnapshotFunc: (snapshot: Snapshot<D> | undefined) => Snapshot<D> | Promise<Snapshot<D>>): Snapshot<D> | Promise<Snapshot<D>>;

package/dist/es/es2018/makeDurable/cachepolicies/valid-at.d.ts

@@ -1,3 +0,0 @@
-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/makeDurable/cachepolicies/cache-and-network.d.ts

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

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

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

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

@@ -1,6 +0,0 @@
-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

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

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

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

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

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

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

@@ -1,9 +0,0 @@
-import { BuildCachedSnapshot, CachePolicyImplementationArgs, Snapshot, StoreLookup, TTLStrategy, UnAvailableSnapshot } from '@luvio/engine';
-export declare type DurableCachePolicyFunctions = {
-    validateNotDisposed: () => void;
-    reviveSnapshotWithCachePolicy: <D, V>(unavailableSnapshot: UnAvailableSnapshot<D, V>, storeLookup: StoreLookup<D, V>) => Promise<Snapshot<D, V>>;
-};
-export declare function appendTTLStrategy<C, D>(storeLookup: CachePolicyImplementationArgs<C, D>['storeLookup'], ttlStrategy: TTLStrategy): Parameters<BuildCachedSnapshot<C, D>>[1];
-export declare function buildNetworkSnapshot<C, D>(args: CachePolicyImplementationArgs<C, D>): Promise<Snapshot<D, unknown>>;
-export declare function buildTTLStrategy(staleDurationMilliseconds?: number): TTLStrategy;
-export declare function buildAvailableSnapshotFromCachedSnapshotResponse<C, D>(cachedSnapshot: ReturnType<BuildCachedSnapshot<C, D>>, availableSnapshotFunc: (snapshot: Snapshot<D> | undefined) => Snapshot<D> | Promise<Snapshot<D>>): Snapshot<D> | Promise<Snapshot<D>>;

package/dist/umd/es2018/makeDurable/cachepolicies/valid-at.d.ts

@@ -1,3 +0,0 @@
-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>>;