@luvio/environments 0.68.0 → 0.72.0

package/dist/umd/es5/environments.js

@@ -58,9 +58,13 @@
     var isArray = Array.isArray;
 
     function appendTTLStrategy(storeLookup, ttlStrategy) {
-        return function (sel, refresh) {
+        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;
@@ -86,102 +90,113 @@
             }
             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 buildInMemorySnapshot = args.buildInMemorySnapshot, buildNetworkSnapshot$1 = args.buildNetworkSnapshot, buildSnapshotContext = args.buildSnapshotContext, storeLookup = args.storeLookup, coercedAdapterRequestContext = args.coercedAdapterRequestContext;
-            var staleDurationMilliseconds = staleDurationSeconds === undefined ? undefined : staleDurationSeconds * 1000;
+            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 snapshot = buildInMemorySnapshot(buildSnapshotContext, cachePolicyStoreLookup);
-            if (snapshot !== undefined) {
-                // data found in L1 cache
-                if (snapshot.state === 'Fulfilled' || snapshot.state === 'Error') {
-                    // kick off network request, do not await it
-                    buildNetworkSnapshot$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);
-                }
-                // stale data found in L1 cache
-                if (snapshot.state === 'Stale') {
-                    // kick off network request, do not await it
-                    buildNetworkSnapshot$1(buildSnapshotContext, coercedAdapterRequestContext);
-                    // return the cached snapshot to caller
-                    return snapshot;
-                }
-                // if unfulfilled we have enough info to do an L2 lookup
-                if (snapshot.state === 'Unfulfilled') {
-                    return funcs
-                        .reviveSnapshotWithCachePolicy(snapshot, cachePolicyStoreLookup)
-                        .then(function (revivedSnapshot) {
-                        // data found in L2 cache
-                        if (revivedSnapshot.state === 'Fulfilled' ||
-                            revivedSnapshot.state === 'Error') {
-                            // kick off network request, do not await it
-                            buildNetworkSnapshot$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);
-                        }
-                        // stale data found in L2 cache
-                        if (revivedSnapshot.state === 'Stale') {
-                            // kick off network request, do not await it
-                            buildNetworkSnapshot$1(buildSnapshotContext, coercedAdapterRequestContext);
-                            // return the L2 cached snapshot to caller
-                            return revivedSnapshot;
-                        }
-                        // data not found in L2 cache, go to the network
-                        return buildNetworkSnapshot(args);
-                    });
+            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);
+                return buildNetworkSnapshot(args);
+            });
         };
     }
 
     function buildCacheThenNetworkImplementation(funcs) {
         return function (args) {
             funcs.validateNotDisposed();
-            var buildInMemorySnapshot = args.buildInMemorySnapshot, buildSnapshotContext = args.buildSnapshotContext, storeLookup = args.storeLookup;
+            var buildCachedSnapshot = args.buildCachedSnapshot, buildSnapshotContext = args.buildSnapshotContext, storeLookup = args.storeLookup;
             var cachePolicyStoreLookup = appendTTLStrategy(storeLookup, buildTTLStrategy());
-            var snapshot = buildInMemorySnapshot(buildSnapshotContext, cachePolicyStoreLookup);
-            if (snapshot !== undefined) {
-                // data found in L1 cache
-                if (snapshot.state === 'Fulfilled' || snapshot.state === 'Error') {
-                    return snapshot;
-                }
-                if (snapshot.state === 'Pending') {
-                    return args.resolvePendingSnapshot(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;
+            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 (revivedSnapshot.state === 'Pending') {
-                        return args.resolvePendingSnapshot(revivedSnapshot);
+                    if (snapshot.state === 'Pending') {
+                        return args.resolvePendingSnapshot(snapshot);
                     }
-                    // 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);
+                    // 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);
+            });
         };
     }
 
@@ -225,84 +240,90 @@
             error: error,
             state: 'Error',
             data: undefined,
-            // TODO[@W-10164067]: copy refresh data from the snapshot returned by buildInMemorySnapshot (if any)
+            // TODO[@W-10164067]: copy refresh data from the snapshot returned by buildCachedSnapshot (if any)
             // refresh: ...
         };
     }
     function buildOnlyIfCachedImplementation(funcs) {
         return function (args) {
             funcs.validateNotDisposed();
-            var buildInMemorySnapshot = args.buildInMemorySnapshot, buildSnapshotContext = args.buildSnapshotContext, storeLookup = args.storeLookup;
+            var buildCachedSnapshot = args.buildCachedSnapshot, buildSnapshotContext = args.buildSnapshotContext, storeLookup = args.storeLookup;
             var cachePolicyStoreLookup = appendTTLStrategy(storeLookup, buildTTLStrategy());
-            var snapshot = buildInMemorySnapshot(buildSnapshotContext, cachePolicyStoreLookup);
-            if (snapshot !== undefined) {
-                // data found in L1 cache
-                if (snapshot.state === 'Fulfilled' || snapshot.state === 'Error') {
-                    return snapshot;
-                }
-                // network request outstanding, data is not cached
-                if (snapshot.state === 'Pending') {
-                    return buildNotCachedErrorSnapshot();
-                }
-                // data not found in L1 cache, try L2 cache
-                return funcs
-                    .reviveSnapshotWithCachePolicy(snapshot, cachePolicyStoreLookup)
-                    .then(function (revivedSnapshot) {
-                    // data found in L2 cache
-                    if (revivedSnapshot.state === 'Fulfilled' ||
-                        revivedSnapshot.state === 'Error') {
-                        return revivedSnapshot;
+            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;
                     }
-                    // data is not cached
-                    return buildNotCachedErrorSnapshot();
-                });
-            }
-            return buildNotCachedErrorSnapshot();
+                    // 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 buildInMemorySnapshot = args.buildInMemorySnapshot, buildSnapshotContext = args.buildSnapshotContext, storeLookup = args.storeLookup;
+            var buildCachedSnapshot = args.buildCachedSnapshot, buildSnapshotContext = args.buildSnapshotContext, storeLookup = args.storeLookup;
             var cachePolicyStoreLookup = appendTTLStrategy(storeLookup, buildTTLStrategy(staleDurationSeconds * 1000));
-            var snapshot = buildInMemorySnapshot(buildSnapshotContext, cachePolicyStoreLookup);
-            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;
+            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 (revivedSnapshot.state === 'Pending') {
-                        return args.resolvePendingSnapshot(revivedSnapshot);
+                    if (snapshot.state === 'Pending') {
+                        return args.resolvePendingSnapshot(snapshot);
                     }
-                    // stale data found in L2 cache
-                    if (revivedSnapshot.state === 'Stale') {
+                    // stale data found in L1 cache
+                    if (snapshot.state === 'Stale') {
                         buildNetworkSnapshot(args);
-                        return revivedSnapshot;
+                        return snapshot;
                     }
-                    // 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);
+                    // 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);
+            });
         };
     }
 
@@ -313,7 +334,7 @@
             // TTLStrategy to use the the valid-at cache policy's timestamp. The flow goes:
             //
             // Environment.applyCachePolicy => validAtImplementation (this function) =>
-            //    basePolicyImplementation => adapter's buildInMemorySnapshot =>
+            //    basePolicyImplementation => adapter's buildCachedSnapshot =>
             //    basePolicyImplementation's storeLookup => validAtStoreLookup (below) =>
             //    Environment.applyCachePolicy's storeLookup => Store/Reader code =>
             //    valid-at TTLStrategy (below) =>
@@ -414,9 +435,6 @@
         return storeRecord.__type === 'error';
     }
 
-    function isStoreEntryExpiredAndError(storeRecord, expirationTimestamp, now) {
-        return isStoreEntryError(storeRecord) && expirationTimestamp < now;
-    }
     /**
      * 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
@@ -439,7 +457,6 @@
             // no records to revive
             return { revivedKeys: revivedKeys, hadUnexpectedShape: hadUnexpectedShape };
         }
-        var now = Date.now();
         for (var i = 0, len = durableKeys.length; i < len; i += 1) {
             var key = durableKeys[i];
             var durableRecord = durableRecords[key];
@@ -455,27 +472,12 @@
                 continue;
             }
             if (metadata !== undefined) {
-                var expirationTimestamp = metadata.expirationTimestamp, staleTimestamp = metadata.staleTimestamp;
+                var expirationTimestamp = metadata.expirationTimestamp;
                 if (expirationTimestamp === undefined) {
                     // if unexpected expiration data skip reviving
                     hadUnexpectedShape = true;
                     continue;
                 }
-                // if past stale TTL then don't revive
-                if (staleTimestamp !== undefined && staleTimestamp < now) {
-                    continue;
-                }
-                // We don't want to revive a cached value if it's an error and it's
-                // expirationTimestamp TTL is expired, otherwise we would never hit the network
-                // during resolveSnapshot or rebuildSnapshot because the way the Reader works.
-                // If a StoreEntry is an error, the Reader will return UnfulfilledSnapshot
-                // if stale TTL is expired.  But it will return ErrorSnapshot (instead of
-                // StaleSnapshot) if expirationTimestamp TTL is expired (but stale TTL isn't).
-                // In our environment the stale TTL is maxed out so Reader will always
-                // return ErrorSnapshot.
-                if (isStoreEntryExpiredAndError(data, expirationTimestamp, now)) {
-                    continue;
-                }
                 publishMetadata(key, metadata);
             }
             if (isStoreEntryError(data)) {
@@ -873,7 +875,7 @@
             if (ingestStagingStore !== null) {
                 return ingestStagingStore.lookup(sel, createSnapshot, refresh, ttlStrategy);
             }
-            // otherwise this is from buildInMemorySnapshot and we should use the luvio
+            // otherwise this is from buildCachedSnapshot and we should use the luvio
             // L1 store
             return environment.storeLookup(sel, createSnapshot, refresh, ttlStrategy);
         };
@@ -1037,7 +1039,7 @@
                 }
             }
         }
-        var applyCachePolicy = function (adapterRequestContext, buildSnapshotContext, buildInMemorySnapshot, buildNetworkSnapshot) {
+        var applyCachePolicy = function (adapterRequestContext, buildSnapshotContext, buildCachedSnapshot, buildNetworkSnapshot) {
             validateNotDisposed();
             var cachePolicy = adapterRequestContext.cachePolicy;
             var cachePolicyImpl = resolveCachePolicy(cachePolicy);
@@ -1047,7 +1049,7 @@
             var storeLookup = function (sel, refresh, ttlStrategy) { return environment.storeLookup(sel, environment.createSnapshot, refresh, ttlStrategy); };
             var applyCachePolicy = function () {
                 return cachePolicyImpl({
-                    buildInMemorySnapshot: buildInMemorySnapshot,
+                    buildCachedSnapshot: buildCachedSnapshot,
                     buildNetworkSnapshot: buildNetworkSnapshot,
                     buildSnapshotContext: buildSnapshotContext,
                     resolvePendingSnapshot: resolvePendingSnapshot,

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

@@ -1,8 +1,9 @@
-import { BuildInMemorySnapshot, CachePolicyImplementationArgs, Snapshot, StoreLookup, TTLStrategy, UnAvailableSnapshot } from '@luvio/engine';
+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<BuildInMemorySnapshot<C, D>>[1];
+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/package.json

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