@luvio/environments 0.72.0 → 0.73.3

package/dist/es/es2018/environments.js

@@ -1,4 +1,4 @@
-import { StoreResolveResultState, HttpStatusCode, Store, coerceAdapterRequestContext } from '@luvio/engine';
+import { buildStaleWhileRevalidateImplementation, Store } from '@luvio/engine';
 
 function isDeprecatedDurableStoreEntry(durableRecord) {
     if (durableRecord.expiration !== undefined) {
@@ -17,292 +17,6 @@ const DefaultDurableSegment = 'DEFAULT';
 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 StoreResolveResultState.Stale;
-                }
-                return StoreResolveResultState.NotPresent;
-            }
-        }
-        if (valueIsError === true) {
-            return StoreResolveResultState.Error;
-        }
-        return 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: 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';
 /**
@@ -327,6 +41,25 @@ function handleDurableStoreRejection(instrument) {
     };
 }
 
+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;
@@ -696,6 +429,15 @@ function reviveOrCreateContext(adapterId, durableStore, durableStoreErrorHandler
         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.
@@ -806,12 +548,9 @@ function makeDurable(environment, { durableStore, instrumentation }) {
     };
     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();
@@ -853,28 +592,6 @@ function makeDurable(environment, { durableStore, instrumentation }) {
         }
         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
@@ -937,73 +654,20 @@ function makeDurable(environment, { durableStore, instrumentation }) {
         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: coerceAdapterRequestContext(adapterRequestContext),
-            });
+            return environment.applyCachePolicy(adapterRequestContext, buildSnapshotContext, wrappedCacheLookup, buildNetworkSnapshot);
         };
         return isRevivingTTLOverrides !== undefined
             ? isRevivingTTLOverrides.then(applyCachePolicy)
@@ -1030,15 +694,26 @@ function makeDurable(environment, { durableStore, instrumentation }) {
             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 = buildStaleWhileRevalidateImplementation(Number.MAX_SAFE_INTEGER);
     return create(environment, {
         publishStoreMetadata: { value: publishStoreMetadata },
         storeIngest: { value: storeIngest },
@@ -1048,7 +723,6 @@ function makeDurable(environment, { durableStore, instrumentation }) {
         storeEvict: { value: storeEvict },
         wrapNormalizedGraphNode: { value: wrapNormalizedGraphNode },
         getNode: { value: getNode },
-        resolveSnapshot: { value: resolveSnapshot },
         rebuildSnapshot: { value: rebuildSnapshot },
         withContext: { value: withContext },
         storeSetTTLOverride: { value: storeSetTTLOverride },
@@ -1058,11 +732,11 @@ function makeDurable(environment, { durableStore, instrumentation }) {
         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 },
     });
 }