@luvio/environments 0.70.0 → 0.73.1

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) =>
@@ -854,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);
         };
@@ -879,30 +900,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
@@ -1018,7 +1015,7 @@
                 }
             }
         }
-        var applyCachePolicy = function (adapterRequestContext, buildSnapshotContext, buildInMemorySnapshot, buildNetworkSnapshot) {
+        var applyCachePolicy = function (adapterRequestContext, buildSnapshotContext, buildCachedSnapshot, buildNetworkSnapshot) {
             validateNotDisposed();
             var cachePolicy = adapterRequestContext.cachePolicy;
             var cachePolicyImpl = resolveCachePolicy(cachePolicy);
@@ -1028,7 +1025,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,
@@ -1081,7 +1078,6 @@
             storeEvict: { value: storeEvict },
             wrapNormalizedGraphNode: { value: wrapNormalizedGraphNode },
             getNode: { value: getNode },
-            resolveSnapshot: { value: resolveSnapshot },
             rebuildSnapshot: { value: rebuildSnapshot },
             withContext: { value: withContext },
             storeSetTTLOverride: { value: storeSetTTLOverride },

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.70.0",
+    "version": "0.73.1",
     "description": "Luvio Environments",
     "main": "dist/umd/es2018/environments.js",
     "module": "dist/es/es2018/environments.js",
@@ -26,6 +26,6 @@
         "dist/"
     ],
     "dependencies": {
-        "@luvio/engine": "0.70.0"
+        "@luvio/engine": "0.73.1"
     }
 }