@luvio/environments 0.72.0 → 0.73.3

package/dist/umd/es2018/environments.js

@@ -21,292 +21,6 @@
     const { keys, create, assign, freeze } = Object;
     const { isArray } = Array;
 
-    function appendTTLStrategy(storeLookup, 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;
-        return buildNetworkSnapshot(buildSnapshotContext, coercedAdapterRequestContext).then((snapshot) => snapshot.state === 'Pending' ? args.resolvePendingSnapshot(snapshot) : snapshot);
-    }
-    function buildTTLStrategy(staleDurationMilliseconds = 0) {
-        return (timestamp, metadata, valueIsError) => {
-            if (metadata !== undefined) {
-                const { expirationTimestamp } = metadata;
-                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 = 0) {
-        return function (args) {
-            funcs.validateNotDisposed();
-            const { buildCachedSnapshot, buildNetworkSnapshot: buildNetworkSnapshot$1, buildSnapshotContext, storeLookup, coercedAdapterRequestContext, } = args;
-            const staleDurationMilliseconds = staleDurationSeconds * 1000;
-            const cachePolicyStoreLookup = appendTTLStrategy(storeLookup, buildTTLStrategy(staleDurationMilliseconds));
-            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);
-            });
-        };
-    }
-
-    function buildCacheThenNetworkImplementation(funcs) {
-        return function (args) {
-            funcs.validateNotDisposed();
-            const { buildCachedSnapshot, buildSnapshotContext, storeLookup } = args;
-            const cachePolicyStoreLookup = appendTTLStrategy(storeLookup, buildTTLStrategy());
-            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 (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((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 (let i = 0, len = value.length; i < len; i += 1) {
-                deepFreeze(value[i]);
-            }
-        }
-        else {
-            const keys$1 = keys(value);
-            for (let 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() {
-        const error = {
-            body: undefined,
-            headers: {},
-            ok: false,
-            status: engine.HttpStatusCode.GatewayTimeout,
-            statusText: 'Gateway Timeout',
-        };
-        deepFreeze(error);
-        return {
-            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();
-            const { buildCachedSnapshot, buildSnapshotContext, storeLookup } = args;
-            const cachePolicyStoreLookup = appendTTLStrategy(storeLookup, buildTTLStrategy());
-            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;
-                    }
-                    // 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 { buildCachedSnapshot, buildSnapshotContext, storeLookup } = args;
-            const cachePolicyStoreLookup = appendTTLStrategy(storeLookup, buildTTLStrategy(staleDurationSeconds * 1000));
-            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 (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;
-                        }
-                        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)
-            const validAtStoreLookup = (sel, refresh, ttlStrategy) => args.storeLookup(sel, refresh, (_readerTimestamp, metadata, valueIsError) => 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({
-                ...args,
-                storeLookup: validAtStoreLookup,
-            });
-        };
-    }
-
     //Durable store error instrumentation key
     const DURABLE_STORE_ERROR = 'durable-store-error';
     /**
@@ -331,6 +45,25 @@
         };
     }
 
+    function deepFreeze(value) {
+        // No need to freeze primitives
+        if (typeof value !== 'object' || value === null) {
+            return;
+        }
+        if (isArray(value)) {
+            for (let i = 0, len = value.length; i < len; i += 1) {
+                deepFreeze(value[i]);
+            }
+        }
+        else {
+            const keys$1 = keys(value);
+            for (let i = 0, len = keys$1.length; i < len; i += 1) {
+                deepFreeze(value[keys$1[i]]);
+            }
+        }
+        freeze(value);
+    }
+
     const SELECTOR_PAGINATION_TOKEN = 'tokenDataKey';
     function isFragmentUnionSelection(sel) {
         return sel.union === true;
@@ -700,6 +433,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.
@@ -810,12 +552,9 @@
         };
         const 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
         };
         const publishChangesToDurableStore = function () {
             validateNotDisposed();
@@ -857,28 +596,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
@@ -941,73 +658,20 @@
             validateNotDisposed();
             return durableTTLStore.getDurableTTLOverrides();
         };
-        // reviveSnapshot wrapper to let cache policies revive data from L2 and
-        // access the revived data via their own storeLookups
-        const reviveSnapshotWithCachePolicy = (unavailableSnapshot, storeLookup) => reviveSnapshot(environment, durableStore, unavailableSnapshot, durableStoreErrorHandler, () => storeLookup(unavailableSnapshot.select, unavailableSnapshot.refresh));
-        const defaultCachePolicy = buildStaleWhileRevalidateImplementation({
-            validateNotDisposed,
-            reviveSnapshotWithCachePolicy,
-        }, Number.MAX_SAFE_INTEGER);
-        function resolveCachePolicy(cachePolicy) {
-            if (cachePolicy === undefined) {
-                return defaultCachePolicy;
-            }
-            switch (cachePolicy.type) {
-                case 'stale-while-revalidate':
-                    return buildStaleWhileRevalidateImplementation({
-                        validateNotDisposed,
-                        reviveSnapshotWithCachePolicy,
-                    }, cachePolicy.staleDurationSeconds);
-                case 'cache-and-network':
-                    return buildCacheAndNetworkImplementation({
-                        validateNotDisposed,
-                        reviveSnapshotWithCachePolicy,
-                    }, cachePolicy.staleDurationSeconds);
-                case 'cache-then-network':
-                    return buildCacheThenNetworkImplementation({
-                        validateNotDisposed,
-                        reviveSnapshotWithCachePolicy,
-                    });
-                case 'no-cache':
-                    return buildNoCacheImplementation({
-                        validateNotDisposed,
-                        reviveSnapshotWithCachePolicy,
-                    });
-                case 'only-if-cached':
-                    return buildOnlyIfCachedImplementation({
-                        validateNotDisposed,
-                        reviveSnapshotWithCachePolicy,
-                    });
-                case 'valid-at': {
-                    const basePolicy = resolveCachePolicy(cachePolicy.basePolicy);
-                    return buildValidAtImplementation({
-                        validateNotDisposed,
-                        reviveSnapshotWithCachePolicy,
-                    }, basePolicy, cachePolicy.timestamp);
-                }
-                default: {
-                    if (process.env.NODE_ENV !== 'production') {
-                        throw new Error(`unrecognized cache policy: ${JSON.stringify(cachePolicy)}`);
-                    }
-                    return defaultCachePolicy;
-                }
-            }
-        }
         const applyCachePolicy = function (adapterRequestContext, buildSnapshotContext, buildCachedSnapshot, buildNetworkSnapshot) {
             validateNotDisposed();
-            const { cachePolicy } = adapterRequestContext;
-            const cachePolicyImpl = resolveCachePolicy(cachePolicy);
-            const resolvePendingSnapshot = (snapshot) => environment.resolvePendingSnapshot(snapshot);
-            const storeLookup = (sel, refresh, ttlStrategy) => environment.storeLookup(sel, environment.createSnapshot, refresh, ttlStrategy);
+            const wrappedCacheLookup = (buildSnapshotContext, storeLookup) => {
+                const 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, () => storeLookup(snapshot.select, snapshot.refresh));
+                }
+                // otherwise just return what buildCachedSnapshot gave us
+                return snapshot;
+            };
             const applyCachePolicy = () => {
-                return cachePolicyImpl({
-                    buildCachedSnapshot,
-                    buildNetworkSnapshot,
-                    buildSnapshotContext,
-                    resolvePendingSnapshot,
-                    storeLookup,
-                    coercedAdapterRequestContext: engine.coerceAdapterRequestContext(adapterRequestContext),
-                });
+                return environment.applyCachePolicy(adapterRequestContext, buildSnapshotContext, wrappedCacheLookup, buildNetworkSnapshot);
             };
             return isRevivingTTLOverrides !== undefined
                 ? isRevivingTTLOverrides.then(applyCachePolicy)
@@ -1034,15 +698,26 @@
                 ingestStagingStore.records = existingRecords;
             }
             const 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(() => {
+                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, () => environment.storeLookup(snapshotFromMemoryIngest.select, environment.createSnapshot, snapshotFromMemoryIngest.refresh));
+            });
+        };
+        const handleErrorResponse = function (ingestAndBroadcastFunc) {
+            validateNotDisposed();
+            const snapshotFromMemoryIngest = ingestAndBroadcastFunc();
+            return publishChangesToDurableStore().then(() => {
                 return snapshotFromMemoryIngest;
-            }
-            // if snapshot from staging store lookup is unfulfilled then do an L2 lookup
-            return reviveSnapshot(environment, durableStore, snapshotFromMemoryIngest, durableStoreErrorHandler, () => 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 },
@@ -1052,7 +727,6 @@
             storeEvict: { value: storeEvict },
             wrapNormalizedGraphNode: { value: wrapNormalizedGraphNode },
             getNode: { value: getNode },
-            resolveSnapshot: { value: resolveSnapshot },
             rebuildSnapshot: { value: rebuildSnapshot },
             withContext: { value: withContext },
             storeSetTTLOverride: { value: storeSetTTLOverride },
@@ -1062,11 +736,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 },
         });
     }