@luvio/environments 0.70.0 → 0.73.1

package/dist/umd/es2018/environments.js

@@ -22,7 +22,11 @@
     const { isArray } = Array;
 
     function appendTTLStrategy(storeLookup, ttlStrategy) {
-        return (sel, refresh) => storeLookup(sel, refresh, ttlStrategy);
+        const returnStoreLookup = (sel, refresh) => 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) {
         const { buildNetworkSnapshot, buildSnapshotContext, coercedAdapterRequestContext } = args;
@@ -45,102 +49,112 @@
             }
             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) {
+    function buildCacheAndNetworkImplementation(funcs, staleDurationSeconds = 0) {
         return function (args) {
             funcs.validateNotDisposed();
-            const { buildInMemorySnapshot, buildNetworkSnapshot: buildNetworkSnapshot$1, buildSnapshotContext, storeLookup, coercedAdapterRequestContext, } = args;
-            const staleDurationMilliseconds = staleDurationSeconds === undefined ? undefined : staleDurationSeconds * 1000;
+            const { buildCachedSnapshot, buildNetworkSnapshot: buildNetworkSnapshot$1, buildSnapshotContext, storeLookup, coercedAdapterRequestContext, } = args;
+            const staleDurationMilliseconds = staleDurationSeconds * 1000;
             const cachePolicyStoreLookup = appendTTLStrategy(storeLookup, buildTTLStrategy(staleDurationMilliseconds));
-            const 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((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);
-                    });
+            const cachedSnapshot = buildCachedSnapshot(buildSnapshotContext, cachePolicyStoreLookup);
+            return buildAvailableSnapshotFromCachedSnapshotResponse(cachedSnapshot, (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((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();
-            const { buildInMemorySnapshot, buildSnapshotContext, storeLookup } = args;
+            const { buildCachedSnapshot, buildSnapshotContext, storeLookup } = args;
             const cachePolicyStoreLookup = appendTTLStrategy(storeLookup, buildTTLStrategy());
-            const 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((revivedSnapshot) => {
-                    // data found in L2 cache
-                    if (revivedSnapshot.state === 'Fulfilled' ||
-                        revivedSnapshot.state === 'Error') {
-                        return revivedSnapshot;
+            const cachedSnapshot = buildCachedSnapshot(buildSnapshotContext, cachePolicyStoreLookup);
+            return buildAvailableSnapshotFromCachedSnapshotResponse(cachedSnapshot, (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((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);
+            });
         };
     }
 
@@ -184,84 +198,90 @@
             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();
-            const { buildInMemorySnapshot, buildSnapshotContext, storeLookup } = args;
+            const { buildCachedSnapshot, buildSnapshotContext, storeLookup } = args;
             const cachePolicyStoreLookup = appendTTLStrategy(storeLookup, buildTTLStrategy());
-            const 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((revivedSnapshot) => {
-                    // data found in L2 cache
-                    if (revivedSnapshot.state === 'Fulfilled' ||
-                        revivedSnapshot.state === 'Error') {
-                        return revivedSnapshot;
+            const cachedSnapshot = buildCachedSnapshot(buildSnapshotContext, cachePolicyStoreLookup);
+            return buildAvailableSnapshotFromCachedSnapshotResponse(cachedSnapshot, (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((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();
-            const { buildInMemorySnapshot, buildSnapshotContext, storeLookup } = args;
+            const { buildCachedSnapshot, buildSnapshotContext, storeLookup } = args;
             const cachePolicyStoreLookup = appendTTLStrategy(storeLookup, buildTTLStrategy(staleDurationSeconds * 1000));
-            const 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((revivedSnapshot) => {
-                    // data found in L2 cache
-                    if (revivedSnapshot.state === 'Fulfilled' ||
-                        revivedSnapshot.state === 'Error') {
-                        return revivedSnapshot;
+            const cachedSnapshot = buildCachedSnapshot(buildSnapshotContext, cachePolicyStoreLookup);
+            return buildAvailableSnapshotFromCachedSnapshotResponse(cachedSnapshot, (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((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);
+            });
         };
     }
 
@@ -272,7 +292,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) =>
@@ -812,7 +832,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);
         };
@@ -837,28 +857,6 @@
             }
             return environment.wrapNormalizedGraphNode(normalized, ingestStagingStore);
         };
-        const 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);
-            }
-            const { resolve, config } = refresh;
-            const refreshFunc = () => resolve(config);
-            // if the snapshot is unfulfilled we can do an L2 lookup
-            if (snapshot.state === 'Unfulfilled') {
-                return reviveSnapshot(environment, durableStore, snapshot, durableStoreErrorHandler, () => environment.storeLookup(snapshot.select, environment.createSnapshot, snapshot.refresh)).then((durableSnapshot) => {
-                    if (environment.snapshotAvailable(durableSnapshot)) {
-                        // L2 cache hit
-                        return durableSnapshot;
-                    }
-                    // else have to hit network
-                    return refreshFunc();
-                });
-            }
-            return refreshFunc();
-        };
         const rebuildSnapshot = function (snapshot, records, storeMetadataMap, redirects, onAsyncRebuild) {
             validateNotDisposed();
             // try rebuilding from memory
@@ -973,7 +971,7 @@
                 }
             }
         }
-        const applyCachePolicy = function (adapterRequestContext, buildSnapshotContext, buildInMemorySnapshot, buildNetworkSnapshot) {
+        const applyCachePolicy = function (adapterRequestContext, buildSnapshotContext, buildCachedSnapshot, buildNetworkSnapshot) {
             validateNotDisposed();
             const { cachePolicy } = adapterRequestContext;
             const cachePolicyImpl = resolveCachePolicy(cachePolicy);
@@ -981,7 +979,7 @@
             const storeLookup = (sel, refresh, ttlStrategy) => environment.storeLookup(sel, environment.createSnapshot, refresh, ttlStrategy);
             const applyCachePolicy = () => {
                 return cachePolicyImpl({
-                    buildInMemorySnapshot,
+                    buildCachedSnapshot,
                     buildNetworkSnapshot,
                     buildSnapshotContext,
                     resolvePendingSnapshot,
@@ -1032,7 +1030,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/es2018/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/dist/umd/es5/DurableStore.d.ts

@@ -12,7 +12,6 @@ export interface DurableStoreEntry<T = unknown> {
     metadata?: {
         ingestionTimestamp: number;
         expirationTimestamp: number;
-        staleTimestamp?: number;
         namespace: string;
         representationName: string;
     };