@luvio/environments 0.142.2 → 0.142.4

package/dist/umd/es2018/environments.js

@@ -1,864 +0,0 @@
-(function (global, factory) {
-    typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports, require('@luvio/engine')) :
-    typeof define === 'function' && define.amd ? define(['exports', '@luvio/engine'], factory) :
-    (global = typeof globalThis !== 'undefined' ? globalThis : global || self, factory(global.luvioEnvironments = {}, global.luvioEngine));
-})(this, (function (exports, engine) { 'use strict';
-
-    // the last version the metadata shape was altered
-    const DURABLE_METADATA_VERSION = '0.111.0';
-    function isDeprecatedDurableStoreEntry(durableRecord) {
-        if (durableRecord.expiration !== undefined) {
-            return true;
-        }
-        const metadata = durableRecord.metadata;
-        if (metadata !== undefined) {
-            const { metadataVersion } = metadata;
-            // eventually we will want to assert that metadataVersion is defined
-            if (metadataVersion !== undefined && metadataVersion !== DURABLE_METADATA_VERSION) {
-                return true;
-            }
-        }
-        // Add more deprecated shape checks here
-        return false;
-    }
-    const DefaultDurableSegment = 'DEFAULT';
-
-    const { keys, create, assign, freeze } = Object;
-
-    //Durable store error instrumentation key
-    const DURABLE_STORE_ERROR = 'durable-store-error';
-    /**
-     * Returns a function that processes errors from durable store promise rejections.
-     * If running in a non-production environment, the error is rethrown.
-     * When running in production the error is sent to instrumentation.
-     * @param instrument Instrumentation function implementation
-     */
-    function handleDurableStoreRejection(instrument) {
-        return (error) => {
-            if (process.env.NODE_ENV !== 'production') {
-                throw error;
-            }
-            if (instrument !== undefined) {
-                instrument(() => {
-                    return {
-                        [DURABLE_STORE_ERROR]: true,
-                        error: error,
-                    };
-                });
-            }
-        };
-    }
-
-    function isStoreEntryError(storeRecord) {
-        return storeRecord.__type === 'error';
-    }
-
-    /**
-     * Takes a set of entries from DurableStore and publishes them via the passed in funcs.
-     * This respects expiration and checks for valid DurableStore data shapes.  This should
-     * be used over manually parsing DurableStoreEntries
-     *
-     * @param durableRecords The DurableStoreEntries to parse
-     * @param publish A function to call with the data of each DurableStoreEntry
-     * @param publishMetadata A function to call with the metadata of each DurableStoreEntry
-     * @param pendingWriter the PendingWriter (this is going away soon)
-     * @returns
-     */
-    function publishDurableStoreEntries(durableRecords, put, publishMetadata) {
-        const revivedKeys = new engine.StoreKeySet();
-        let hadUnexpectedShape = false;
-        if (durableRecords === undefined) {
-            return { revivedKeys, hadUnexpectedShape };
-        }
-        const durableKeys = keys(durableRecords);
-        if (durableKeys.length === 0) {
-            // no records to revive
-            return { revivedKeys, hadUnexpectedShape };
-        }
-        for (let i = 0, len = durableKeys.length; i < len; i += 1) {
-            const key = durableKeys[i];
-            const durableRecord = durableRecords[key];
-            if (isDeprecatedDurableStoreEntry(durableRecord)) {
-                // had the old shape, skip reviving this entry.
-                hadUnexpectedShape = true;
-                continue;
-            }
-            const { metadata, data } = durableRecord;
-            if (data === undefined) {
-                // if unexpected data skip reviving
-                hadUnexpectedShape = true;
-                continue;
-            }
-            if (metadata !== undefined) {
-                const { expirationTimestamp } = metadata;
-                if (expirationTimestamp === undefined) {
-                    // if unexpected expiration data skip reviving
-                    hadUnexpectedShape = true;
-                    continue;
-                }
-                publishMetadata(key, metadata);
-            }
-            if (isStoreEntryError(data)) {
-                // freeze errors on way into L1
-                engine.deepFreeze(data.error);
-            }
-            put(key, data);
-            revivedKeys.add(key);
-        }
-        return { revivedKeys, hadUnexpectedShape };
-    }
-    /**
-     * This method returns a Promise to a snapshot that is revived from L2 cache.  If
-     * L2 does not have the entries necessary to fulfill the snapshot then this method
-     * will refresh the snapshot from network, and then run the results from network
-     * through L2 ingestion, returning the subsequent revived snapshot.
-     */
-    function reviveSnapshot(baseEnvironment, durableStore, unavailableSnapshot, durableStoreErrorHandler, buildL1Snapshot, reviveMetrics = { l2Trips: [] }) {
-        const { recordId, select, missingLinks, seenRecords, state } = unavailableSnapshot;
-        // L2 can only revive Unfulfilled snapshots that have a selector since they have the
-        // info needed to revive (like missingLinks) and rebuild.  Otherwise return L1 snapshot.
-        if (state !== 'Unfulfilled' || select === undefined) {
-            return Promise.resolve({
-                snapshot: unavailableSnapshot,
-                metrics: reviveMetrics,
-            });
-        }
-        // in case L1 store changes/deallocs a record while we are doing the async read
-        // we attempt to read all keys from L2 - so combine recordId with any seenRecords
-        const keysToReviveSet = new engine.StoreKeySet().add(recordId);
-        keysToReviveSet.merge(seenRecords);
-        keysToReviveSet.merge(missingLinks);
-        const keysToRevive = keysToReviveSet.keysAsArray();
-        const canonicalKeys = keysToRevive.map((x) => engine.serializeStructuredKey(baseEnvironment.storeGetCanonicalKey(x)));
-        const start = Date.now();
-        const { l2Trips } = reviveMetrics;
-        return durableStore.getEntries(canonicalKeys, DefaultDurableSegment).then((durableRecords) => {
-            l2Trips.push({
-                duration: Date.now() - start,
-                keysRequestedCount: canonicalKeys.length,
-            });
-            const { revivedKeys, hadUnexpectedShape } = publishDurableStoreEntries(durableRecords, 
-            // TODO [W-10072584]: instead of implicitly using L1 we should take in
-            // publish and publishMetadata funcs, so callers can decide where to
-            // revive to (like they pass in how to do the buildL1Snapshot)
-            baseEnvironment.storePut.bind(baseEnvironment), baseEnvironment.publishStoreMetadata.bind(baseEnvironment));
-            // if the data coming back from DS had an unexpected shape then just
-            // return the L1 snapshot
-            if (hadUnexpectedShape === true) {
-                return { snapshot: unavailableSnapshot, metrics: reviveMetrics };
-            }
-            if (revivedKeys.size() === 0) {
-                // durable store doesn't have what we asked for so return L1 snapshot
-                return { snapshot: unavailableSnapshot, metrics: reviveMetrics };
-            }
-            // try building the snapshot from L1 now that we have revived the missingLinks
-            const snapshot = buildL1Snapshot();
-            // if snapshot is pending then some other in-flight refresh will broadcast
-            // later
-            if (snapshot.state === 'Pending') {
-                return { snapshot, metrics: reviveMetrics };
-            }
-            if (snapshot.state === 'Unfulfilled') {
-                // have to check if the new snapshot has any additional seenRecords
-                // and revive again if so
-                const { seenRecords: newSnapshotSeenRecords, missingLinks: newSnapshotMissingLinks, recordId: newSnapshotRecordId, } = snapshot;
-                const newKeysToReviveSet = new engine.StoreKeySet();
-                newKeysToReviveSet.add(newSnapshotRecordId);
-                newKeysToReviveSet.merge(newSnapshotSeenRecords);
-                newKeysToReviveSet.merge(newSnapshotMissingLinks);
-                const newKeys = newKeysToReviveSet.keysAsArray();
-                // in case DS returned additional entries we combine the requested
-                // and returned keys
-                const alreadyRequestedOrRevivedSet = keysToReviveSet;
-                alreadyRequestedOrRevivedSet.merge(revivedKeys);
-                // if there's any seen keys in the newly rebuilt snapshot that
-                // haven't already been requested or returned then revive again
-                for (let i = 0, len = newKeys.length; i < len; i++) {
-                    const newSnapshotSeenKey = newKeys[i];
-                    if (!alreadyRequestedOrRevivedSet.has(newSnapshotSeenKey)) {
-                        return reviveSnapshot(baseEnvironment, durableStore, snapshot, durableStoreErrorHandler, buildL1Snapshot, reviveMetrics);
-                    }
-                }
-            }
-            return { snapshot, metrics: reviveMetrics };
-        }, (error) => {
-            durableStoreErrorHandler(error);
-            // getEntries failed, return the L1 snapshot
-            return { snapshot: unavailableSnapshot, metrics: reviveMetrics };
-        });
-    }
-
-    const TTL_DURABLE_SEGMENT = 'TTL_DURABLE_SEGMENT';
-    const TTL_DEFAULT_KEY = 'TTL_DEFAULT_KEY';
-    function buildDurableTTLOverrideStoreKey(namespace, representationName) {
-        return `${namespace}::${representationName}`;
-    }
-    function isEntryDurableTTLOverride(entry) {
-        if (typeof entry === 'object' && entry !== undefined && entry !== null) {
-            const data = entry.data;
-            if (data !== undefined) {
-                return (data.namespace !== undefined &&
-                    data.representationName !== undefined &&
-                    data.ttl !== undefined);
-            }
-        }
-        return false;
-    }
-    function isDefaultDurableTTLOverride(override) {
-        return (override.namespace === TTL_DEFAULT_KEY && override.representationName === TTL_DEFAULT_KEY);
-    }
-    /**
-     * Class to set and get the TTL override values in the Durable Store
-     */
-    class DurableTTLStore {
-        constructor(durableStore) {
-            this.durableStore = durableStore;
-        }
-        setDefaultDurableTTLOverrides(ttl) {
-            return this.durableStore.setEntries({
-                [buildDurableTTLOverrideStoreKey(TTL_DEFAULT_KEY, TTL_DEFAULT_KEY)]: {
-                    data: {
-                        namespace: TTL_DEFAULT_KEY,
-                        representationName: TTL_DEFAULT_KEY,
-                        ttl,
-                    },
-                },
-            }, TTL_DURABLE_SEGMENT);
-        }
-        setDurableTTLOverride(namespace, representationName, ttl) {
-            return this.durableStore.setEntries({
-                [buildDurableTTLOverrideStoreKey(namespace, representationName)]: {
-                    data: { namespace, representationName, ttl },
-                },
-            }, TTL_DURABLE_SEGMENT);
-        }
-        getDurableTTLOverrides() {
-            return this.durableStore
-                .getAllEntries(TTL_DURABLE_SEGMENT)
-                .then((entries) => {
-                const overrides = [];
-                let defaultTTL = undefined;
-                if (entries === undefined) {
-                    return {
-                        defaultTTL,
-                        overrides,
-                    };
-                }
-                const keys$1 = keys(entries);
-                for (let i = 0, len = keys$1.length; i < len; i++) {
-                    const key = keys$1[i];
-                    const entry = entries[key];
-                    if (entry !== undefined && isEntryDurableTTLOverride(entry)) {
-                        if (isDefaultDurableTTLOverride(entry.data)) {
-                            defaultTTL = entry.data;
-                        }
-                        else {
-                            overrides.push(entry.data);
-                        }
-                    }
-                }
-                return {
-                    defaultTTL,
-                    overrides,
-                };
-            });
-        }
-    }
-
-    function flushInMemoryStoreValuesToDurableStore(store, durableStore, durableStoreErrorHandler, additionalDurableStoreOperations = []) {
-        const durableRecords = create(null);
-        const evictedRecords = create(null);
-        const { records, metadata: storeMetadata, visitedIds, refreshedIds, } = store.fallbackStringKeyInMemoryStore;
-        // TODO: W-8909393 Once metadata is stored in its own segment we need to
-        // call setEntries for the visitedIds on default segment and call setEntries
-        // on the metadata segment for the refreshedIds
-        const keys$1 = keys({ ...visitedIds, ...refreshedIds });
-        for (let i = 0, len = keys$1.length; i < len; i += 1) {
-            const key = keys$1[i];
-            const record = records[key];
-            // this record has been evicted, evict from DS
-            if (record === undefined) {
-                evictedRecords[key] = true;
-                continue;
-            }
-            const metadata = storeMetadata[key];
-            durableRecords[key] = {
-                data: record,
-            };
-            if (metadata !== undefined) {
-                durableRecords[key].metadata = {
-                    ...metadata,
-                    metadataVersion: DURABLE_METADATA_VERSION,
-                };
-            }
-        }
-        const durableStoreOperations = additionalDurableStoreOperations;
-        // publishes
-        const recordKeys = keys(durableRecords);
-        if (recordKeys.length > 0) {
-            durableStoreOperations.push({
-                type: 'setEntries',
-                entries: durableRecords,
-                segment: DefaultDurableSegment,
-            });
-        }
-        // evicts
-        const evictedKeys = keys(evictedRecords);
-        if (evictedKeys.length > 0) {
-            durableStoreOperations.push({
-                type: 'evictEntries',
-                ids: evictedKeys,
-                segment: DefaultDurableSegment,
-            });
-        }
-        if (durableStoreOperations.length > 0) {
-            return durableStore.batchOperations(durableStoreOperations).catch(durableStoreErrorHandler);
-        }
-        return Promise.resolve();
-    }
-
-    const DurableEnvironmentEventDiscriminator = 'durable';
-    function isDurableEnvironmentEvent(event) {
-        return (event.type === 'environment' && event.environment === DurableEnvironmentEventDiscriminator);
-    }
-    function emitDurableEnvironmentAdapterEvent(eventData, observers) {
-        engine.emitAdapterEvent({
-            type: 'environment',
-            timestamp: Date.now(),
-            environment: DurableEnvironmentEventDiscriminator,
-            data: eventData,
-        }, observers);
-    }
-
-    async function reviveTTLOverrides(ttlStore, environment) {
-        const map = await ttlStore.getDurableTTLOverrides();
-        const { defaultTTL, overrides } = map;
-        if (defaultTTL !== undefined) {
-            environment.storeSetDefaultTTLOverride(defaultTTL.ttl);
-        }
-        for (let i = 0, len = overrides.length; i < len; i++) {
-            const { namespace, representationName, ttl } = overrides[i];
-            environment.storeSetTTLOverride(namespace, representationName, ttl);
-        }
-    }
-
-    /**
-     * Returns an empty InMemoryStore that can be used for ingestion.  Copies over
-     * the TTLOverrides from the given Environment's Store.
-     */
-    function buildIngestStagingStore(environment) {
-        return environment.storeBuildIngestionStagingStore();
-    }
-
-    const AdapterContextSegment = 'ADAPTER-CONTEXT';
-    const ADAPTER_CONTEXT_ID_SUFFIX = '__NAMED_CONTEXT';
-    async function reviveOrCreateContext(adapterId, durableStore, durableStoreErrorHandler, contextStores, pendingContextStoreKeys, onContextLoaded) {
-        // initialize empty context store
-        contextStores[adapterId] = create(null);
-        const context = {
-            set(key, value) {
-                contextStores[adapterId][key] = value;
-                durableStore.setEntries({
-                    [adapterId]: { data: contextStores[adapterId] },
-                }, AdapterContextSegment);
-                pendingContextStoreKeys.add(adapterId);
-            },
-            get(key) {
-                return contextStores[adapterId][key];
-            },
-        };
-        const contextReturn = () => {
-            if (onContextLoaded !== undefined) {
-                return onContextLoaded(context).then(() => {
-                    return context;
-                });
-            }
-            return context;
-        };
-        try {
-            const entries = await durableStore.getEntries([adapterId], AdapterContextSegment);
-            if (entries !== undefined && entries[adapterId] !== undefined) {
-                // if durable store has a saved context then load it in the store
-                contextStores[adapterId] = entries[adapterId].data;
-            }
-        }
-        catch (error) {
-            durableStoreErrorHandler(error);
-        }
-        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.
-     *
-     * @param environment The base environment
-     * @param durableStore A DurableStore implementation
-     * @param instrumentation An instrumentation function implementation
-     */
-    function makeDurable(environment, { durableStore, instrumentation }) {
-        let ingestStagingStore = null;
-        const durableTTLStore = new DurableTTLStore(durableStore);
-        const mergeKeysPromiseMap = new Map();
-        // When a context store is mutated we write it to L2, which causes DS on change
-        // event. If this instance of makeDurable caused that L2 write we can ignore that
-        // on change event. This Set helps us do that.
-        const pendingContextStoreKeys = new Set();
-        const contextStores = create(null);
-        let initializationPromise = new Promise((resolve) => {
-            const finish = () => {
-                resolve();
-                initializationPromise = undefined;
-            };
-            reviveTTLOverrides(durableTTLStore, environment).then(finish);
-        });
-        //instrumentation for durable store errors
-        const durableStoreErrorHandler = handleDurableStoreRejection(instrumentation);
-        let disposed = false;
-        const validateNotDisposed = () => {
-            if (disposed === true) {
-                throw new Error('This makeDurable instance has been disposed');
-            }
-        };
-        const unsubscribe = durableStore.registerOnChangedListener(async (changes) => {
-            const defaultSegmentKeys = [];
-            const adapterContextSegmentKeys = [];
-            for (let i = 0, len = changes.length; i < len; i++) {
-                const change = changes[i];
-                // we only care about changes to the data which is stored in the default
-                // segment or the adapter context
-                if (change.segment === DefaultDurableSegment) {
-                    defaultSegmentKeys.push(...change.ids);
-                }
-                else if (change.segment === AdapterContextSegment) {
-                    adapterContextSegmentKeys.push(...change.ids);
-                }
-            }
-            // process adapter context changes
-            const adapterContextKeysFromDifferentInstance = [];
-            for (const key of adapterContextSegmentKeys) {
-                if (pendingContextStoreKeys.has(key)) {
-                    // if this instance caused the L2 write then remove from the
-                    // "pending" Set and move on
-                    pendingContextStoreKeys.delete(key);
-                }
-                else {
-                    // else it came from another luvio instance and we need to
-                    // read from L2
-                    adapterContextKeysFromDifferentInstance.push(key);
-                }
-            }
-            if (adapterContextKeysFromDifferentInstance.length > 0) {
-                try {
-                    const entries = await durableStore.getEntries(adapterContextKeysFromDifferentInstance, AdapterContextSegment);
-                    if (entries !== undefined) {
-                        const entryKeys = keys(entries);
-                        for (let i = 0, len = entryKeys.length; i < len; i++) {
-                            const entryKey = entryKeys[i];
-                            const entry = entries[entryKey];
-                            contextStores[entryKey] = entry.data;
-                        }
-                    }
-                }
-                catch (error) {
-                    durableStoreErrorHandler(error);
-                }
-            }
-            // process default segment changes
-            const defaultSegmentKeysLength = defaultSegmentKeys.length;
-            if (defaultSegmentKeysLength > 0) {
-                for (let i = 0; i < defaultSegmentKeysLength; i++) {
-                    const key = defaultSegmentKeys[i];
-                    const canonical = environment.storeGetCanonicalKey(key);
-                    if (canonical !== key) {
-                        continue;
-                    }
-                    // TODO: W-8909393 If expiration is the only thing that changed we should not evict the data... so
-                    // if we stored expiration and data at different keys (or same keys in different segments)
-                    // then we could know if only the expiration has changed and we wouldn't need to evict
-                    // and go through an entire broadcast/revive cycle for unchanged data
-                    // call base environment storeEvict so this evict is not tracked for durable deletion
-                    environment.storeEvict(key);
-                }
-                await environment.storeBroadcast(rebuildSnapshot, environment.snapshotAvailable);
-            }
-        });
-        const dispose = function () {
-            validateNotDisposed();
-            disposed = true;
-            return unsubscribe();
-        };
-        const storePublish = function (key, data) {
-            validateNotDisposed();
-            if (ingestStagingStore === null) {
-                ingestStagingStore = buildIngestStagingStore(environment);
-            }
-            ingestStagingStore.publish(key, data);
-            // remove record from main luvio L1 cache while we are on the synchronous path
-            // because we do not want some other code attempting to use the
-            // in-memory values before the durable store onChanged handler
-            // calls back and revives the values to in-memory
-            environment.storeEvict(key);
-        };
-        const publishStoreMetadata = function (recordId, storeMetadata) {
-            validateNotDisposed();
-            if (ingestStagingStore === null) {
-                ingestStagingStore = buildIngestStagingStore(environment);
-            }
-            ingestStagingStore.publishMetadata(recordId, storeMetadata);
-        };
-        const storeIngest = function (key, ingest, response, luvio) {
-            validateNotDisposed();
-            // we don't ingest to the luvio L1 store from network directly, we ingest to
-            // L2 and let DurableStore on change event revive keys into luvio L1 store
-            if (ingestStagingStore === null) {
-                ingestStagingStore = buildIngestStagingStore(environment);
-            }
-            environment.storeIngest(key, ingest, response, luvio, ingestStagingStore);
-        };
-        const storeIngestError = function (key, errorSnapshot, storeMetadataParams, _storeOverride) {
-            validateNotDisposed();
-            if (ingestStagingStore === null) {
-                ingestStagingStore = buildIngestStagingStore(environment);
-            }
-            environment.storeIngestError(key, errorSnapshot, storeMetadataParams, ingestStagingStore);
-        };
-        const storeBroadcast = function (_rebuildSnapshot, _snapshotDataAvailable) {
-            validateNotDisposed();
-            // publishing to L2 is essentially "broadcasting" because the onChanged
-            // handler will fire which will revive records to the main L1 store and
-            // call the base storeBroadcast
-            return publishChangesToDurableStore();
-        };
-        const publishChangesToDurableStore = function (additionalDurableStoreOperations) {
-            validateNotDisposed();
-            if (ingestStagingStore === null) {
-                return Promise.resolve();
-            }
-            const promise = flushInMemoryStoreValuesToDurableStore(ingestStagingStore, durableStore, durableStoreErrorHandler, additionalDurableStoreOperations);
-            ingestStagingStore = null;
-            return promise;
-        };
-        const storeLookup = function (sel, createSnapshot, refresh, ttlStrategy) {
-            validateNotDisposed();
-            // if this lookup is right after an ingest there will be a staging store
-            if (ingestStagingStore !== null) {
-                const reader = new engine.Reader(ingestStagingStore, sel.variables, refresh, undefined, ttlStrategy);
-                return reader.read(sel);
-            }
-            // otherwise this is from buildCachedSnapshot and we should use the luvio
-            // L1 store
-            return environment.storeLookup(sel, createSnapshot, refresh, ttlStrategy);
-        };
-        const storeEvict = function (key) {
-            validateNotDisposed();
-            if (ingestStagingStore === null) {
-                ingestStagingStore = buildIngestStagingStore(environment);
-            }
-            ingestStagingStore.evict(key);
-        };
-        const getNode = function (key) {
-            validateNotDisposed();
-            if (ingestStagingStore === null) {
-                ingestStagingStore = buildIngestStagingStore(environment);
-            }
-            return environment.getNode(key, ingestStagingStore);
-        };
-        const wrapNormalizedGraphNode = function (normalized) {
-            validateNotDisposed();
-            if (ingestStagingStore === null) {
-                ingestStagingStore = buildIngestStagingStore(environment);
-            }
-            return environment.wrapNormalizedGraphNode(normalized, ingestStagingStore);
-        };
-        const rebuildSnapshot = function (snapshot, onRebuild) {
-            validateNotDisposed();
-            // try rebuilding from memory
-            environment.rebuildSnapshot(snapshot, (rebuilt) => {
-                // only try reviving from durable store if snapshot is unfulfilled
-                if (rebuilt.state !== 'Unfulfilled') {
-                    onRebuild(rebuilt);
-                    return;
-                }
-                // Do an L2 revive and emit to subscriber using the callback.
-                reviveSnapshot(environment, durableStore, rebuilt, durableStoreErrorHandler, () => {
-                    // reviveSnapshot will revive into L1, and since "records" is a reference
-                    // (and not a copy) to the L1 records we can use it for rebuild
-                    let rebuiltSnap;
-                    environment.rebuildSnapshot(snapshot, (rebuilt) => {
-                        rebuiltSnap = rebuilt;
-                    });
-                    return rebuiltSnap;
-                }).then((result) => {
-                    onRebuild(result.snapshot);
-                });
-            });
-        };
-        const withContext = function (adapter, options) {
-            validateNotDisposed();
-            const { contextId, contextVersion, onContextLoaded } = options;
-            let context = undefined;
-            let contextKey = `${contextId}`;
-            // if a context version is supplied, key with the version encoded
-            if (contextVersion !== undefined) {
-                contextKey += `::${contextVersion}`;
-            }
-            contextKey += ADAPTER_CONTEXT_ID_SUFFIX;
-            const contextAsPromise = reviveOrCreateContext(contextKey, durableStore, durableStoreErrorHandler, contextStores, pendingContextStoreKeys, onContextLoaded);
-            return (config, requestContext) => {
-                if (context === undefined) {
-                    return contextAsPromise.then((revivedContext) => {
-                        context = revivedContext;
-                        return adapter(config, context, requestContext); // TODO - remove as any cast after https://github.com/salesforce-experience-platform-emu/luvio/pull/230
-                    });
-                }
-                return adapter(config, context, requestContext);
-            };
-        };
-        const storeRedirect = function (existingKey, canonicalKey) {
-            validateNotDisposed();
-            // call redirect on staging store so "old" keys are removed from L2 on
-            // the next publishChangesToDurableStore.  NOTE: we don't need to call
-            // redirect on the base environment store because staging store and base
-            // L1 store share the same redirect and reverseRedirectKeys
-            if (ingestStagingStore === null) {
-                ingestStagingStore = buildIngestStagingStore(environment);
-            }
-            ingestStagingStore.redirect(existingKey, canonicalKey);
-        };
-        const storeSetTTLOverride = function (namespace, representationName, ttl) {
-            validateNotDisposed();
-            return Promise.all([
-                environment.storeSetTTLOverride(namespace, representationName, ttl),
-                durableTTLStore.setDurableTTLOverride(namespace, representationName, ttl),
-            ]).then();
-        };
-        const storeSetDefaultTTLOverride = function (ttl) {
-            validateNotDisposed();
-            return Promise.all([
-                environment.storeSetDefaultTTLOverride(ttl),
-                durableTTLStore.setDefaultDurableTTLOverrides(ttl),
-            ]).then();
-        };
-        const getDurableTTLOverrides = function () {
-            validateNotDisposed();
-            return durableTTLStore.getDurableTTLOverrides();
-        };
-        const dispatchResourceRequest = async function (request, context, eventObservers) {
-            validateNotDisposed();
-            // non-GET adapters call dispatchResourceRequest before any other luvio
-            // function so this is our chance to ensure we're initialized
-            if (initializationPromise !== undefined) {
-                await initializationPromise;
-            }
-            return environment.dispatchResourceRequest(request, context, eventObservers);
-        };
-        // NOTE: we can't use "async" keyword on this function because that would
-        // force it to always be an async response.  The signature is a union
-        // of sync/async so no "awaiting" in this function, just promise-chaining
-        const applyCachePolicy = function (luvio, adapterRequestContext, buildSnapshotContext, buildCachedSnapshot, buildNetworkSnapshot) {
-            validateNotDisposed();
-            const wrappedCacheLookup = (injectedBuildSnapshotContext, injectedStoreLookup) => {
-                const snapshot = buildCachedSnapshot(injectedBuildSnapshotContext, injectedStoreLookup, luvio);
-                // if the adapter attempted to do an L1 lookup and it was unfulfilled
-                // then we can attempt an L2 lookup
-                if (isUnfulfilledSnapshot(snapshot)) {
-                    const start = Date.now();
-                    emitDurableEnvironmentAdapterEvent({ type: 'l2-revive-start' }, adapterRequestContext.eventObservers);
-                    const revivedSnapshot = reviveSnapshot(environment, durableStore, snapshot, durableStoreErrorHandler, () => injectedStoreLookup(snapshot.select, snapshot.refresh)).then((result) => {
-                        emitDurableEnvironmentAdapterEvent({
-                            type: 'l2-revive-end',
-                            snapshot: result.snapshot,
-                            duration: Date.now() - start,
-                            l2Trips: result.metrics.l2Trips,
-                        }, adapterRequestContext.eventObservers);
-                        return result.snapshot;
-                    });
-                    return revivedSnapshot;
-                }
-                // otherwise just return what buildCachedSnapshot gave us
-                return snapshot;
-            };
-            const wrappedApplyCachePolicy = () => {
-                return environment.applyCachePolicy(luvio, adapterRequestContext, buildSnapshotContext, wrappedCacheLookup, buildNetworkSnapshot);
-            };
-            // GET adapters call applyCachePolicy before any other luvio
-            // function so this is our chance to ensure we're initialized
-            return initializationPromise !== undefined
-                ? initializationPromise.then(wrappedApplyCachePolicy)
-                : wrappedApplyCachePolicy();
-        };
-        const getIngestStagingStoreRecords = function () {
-            validateNotDisposed();
-            if (ingestStagingStore !== null) {
-                return ingestStagingStore.fallbackStringKeyInMemoryStore.records;
-            }
-            return {};
-        };
-        const getIngestStagingStoreMetadata = function () {
-            validateNotDisposed();
-            if (ingestStagingStore !== null) {
-                return ingestStagingStore.fallbackStringKeyInMemoryStore.metadata;
-            }
-            return {};
-        };
-        const handleSuccessResponse = async function (ingestAndBroadcastFunc, getResponseCacheKeysFunc) {
-            validateNotDisposed();
-            const cacheKeyMap = getResponseCacheKeysFunc();
-            const cacheKeyMapKeys = cacheKeyMap.keysAsArray();
-            const keysToRevive = new engine.StoreKeySet();
-            for (const cacheKeyMapKey of cacheKeyMapKeys) {
-                const cacheKey = cacheKeyMap.get(cacheKeyMapKey);
-                if (cacheKey.mergeable === true) {
-                    const canonical = environment.storeGetCanonicalKey(cacheKeyMapKey);
-                    keysToRevive.add(canonical);
-                }
-            }
-            let snapshotFromMemoryIngest = undefined;
-            // To-do: Once these are structured keys, will need to support them throughout durable logic W-12356727
-            const keysToReviveAsArray = Array.from(keysToRevive.keysAsStrings());
-            if (keysToReviveAsArray.length > 0) {
-                // if we need to do an L2 read then L2 write then we need to synchronize
-                // our read/merge/ingest/write Promise based on the keys so we don't
-                // stomp over any data
-                const readWritePromise = (async () => {
-                    const pendingPromises = [];
-                    for (const key of keysToReviveAsArray) {
-                        const pendingPromise = mergeKeysPromiseMap.get(key);
-                        if (pendingPromise !== undefined) {
-                            // IMPORTANT: while on the synchronous code path we get a
-                            // handle to pendingPromise and push it onto the array.
-                            // This is important because later in this synchronous code
-                            // path we will upsert readWritePromise into the
-                            // mergeKeysPromiseMap (essentially overwriting pendingPromise
-                            // in the map).
-                            pendingPromises.push(pendingPromise);
-                        }
-                    }
-                    await Promise.all(pendingPromises);
-                    const entries = await durableStore.getEntries(keysToReviveAsArray, DefaultDurableSegment);
-                    ingestStagingStore = buildIngestStagingStore(environment);
-                    publishDurableStoreEntries(entries, (key, record) => {
-                        if (typeof key === 'string') {
-                            ingestStagingStore.fallbackStringKeyInMemoryStore.records[key] =
-                                record;
-                        }
-                        else {
-                            ingestStagingStore.recordsMap.set(key, record);
-                        }
-                    }, (key, metadata) => {
-                        if (typeof key === 'string') {
-                            ingestStagingStore.fallbackStringKeyInMemoryStore.metadata[key] =
-                                metadata;
-                        }
-                        else {
-                            ingestStagingStore.metadataMap.set(key, metadata);
-                        }
-                    });
-                    snapshotFromMemoryIngest = await ingestAndBroadcastFunc();
-                })();
-                for (const key of keysToReviveAsArray) {
-                    // we are overwriting the previous promise at this key, but that
-                    // is ok because we got a handle to it earlier (see the IMPORTANT
-                    // comment about 35 lines up)
-                    mergeKeysPromiseMap.set(key, readWritePromise);
-                }
-                try {
-                    await readWritePromise;
-                }
-                finally {
-                    for (const key of keysToReviveAsArray) {
-                        const pendingPromise = mergeKeysPromiseMap.get(key);
-                        // cleanup the entry from the map if this is the last promise
-                        // for that key
-                        if (pendingPromise === readWritePromise) {
-                            mergeKeysPromiseMap.delete(key);
-                        }
-                    }
-                }
-            }
-            else {
-                // we aren't doing any merging so we don't have to synchronize, the
-                // underlying DurableStore implementation takes care of R/W sync
-                // so all we have to do is ingest then write to L2
-                ingestStagingStore = buildIngestStagingStore(environment);
-                snapshotFromMemoryIngest = await ingestAndBroadcastFunc();
-            }
-            if (snapshotFromMemoryIngest === undefined) {
-                return undefined;
-            }
-            if (snapshotFromMemoryIngest.state !== 'Unfulfilled') {
-                return snapshotFromMemoryIngest;
-            }
-            // if snapshot from staging store lookup is unfulfilled then do an L2 lookup
-            const { select, refresh } = snapshotFromMemoryIngest;
-            const result = await reviveSnapshot(environment, durableStore, snapshotFromMemoryIngest, durableStoreErrorHandler, () => environment.storeLookup(select, environment.createSnapshot, refresh));
-            return result.snapshot;
-        };
-        const handleErrorResponse = async function (ingestAndBroadcastFunc) {
-            validateNotDisposed();
-            ingestStagingStore = buildIngestStagingStore(environment);
-            return ingestAndBroadcastFunc();
-        };
-        const getNotifyChangeStoreEntries = function (keys) {
-            validateNotDisposed();
-            return durableStore
-                .getEntries(keys.map(engine.serializeStructuredKey), DefaultDurableSegment)
-                .then((durableRecords) => {
-                const entries = [];
-                publishDurableStoreEntries(durableRecords, (key, record) => {
-                    entries.push({
-                        key,
-                        record: record,
-                    });
-                }, () => { });
-                return entries;
-            });
-        };
-        environment.defaultCachePolicy = {
-            type: 'stale-while-revalidate',
-            implementation: engine.buildStaleWhileRevalidateImplementation(Number.MAX_SAFE_INTEGER),
-        };
-        return create(environment, {
-            publishStoreMetadata: { value: publishStoreMetadata },
-            storeIngest: { value: storeIngest },
-            storeIngestError: { value: storeIngestError },
-            storeBroadcast: { value: storeBroadcast },
-            storeLookup: { value: storeLookup },
-            storeEvict: { value: storeEvict },
-            wrapNormalizedGraphNode: { value: wrapNormalizedGraphNode },
-            getNode: { value: getNode },
-            rebuildSnapshot: { value: rebuildSnapshot },
-            withContext: { value: withContext },
-            storeSetTTLOverride: { value: storeSetTTLOverride },
-            storeSetDefaultTTLOverride: { value: storeSetDefaultTTLOverride },
-            storePublish: { value: storePublish },
-            storeRedirect: { value: storeRedirect },
-            dispose: { value: dispose },
-            publishChangesToDurableStore: { value: publishChangesToDurableStore },
-            getDurableTTLOverrides: { value: getDurableTTLOverrides },
-            dispatchResourceRequest: { value: dispatchResourceRequest },
-            applyCachePolicy: { value: applyCachePolicy },
-            getIngestStagingStoreRecords: { value: getIngestStagingStoreRecords },
-            getIngestStagingStoreMetadata: { value: getIngestStagingStoreMetadata },
-            handleSuccessResponse: { value: handleSuccessResponse },
-            handleErrorResponse: { value: handleErrorResponse },
-            getNotifyChangeStoreEntries: { value: getNotifyChangeStoreEntries },
-        });
-    }
-
-    exports.DURABLE_METADATA_VERSION = DURABLE_METADATA_VERSION;
-    exports.DefaultDurableSegment = DefaultDurableSegment;
-    exports.isDurableEnvironmentEvent = isDurableEnvironmentEvent;
-    exports.makeDurable = makeDurable;
-    exports.publishDurableStoreEntries = publishDurableStoreEntries;
-
-}));