@luvio/environments 0.99.2 → 0.102.1

package/dist/es/es2018/environments.js

@@ -1,4 +1,4 @@
-import { emitAdapterEvent, buildStaleWhileRevalidateImplementation, InMemoryStore } from '@luvio/engine';
+import { emitAdapterEvent, InMemoryStore, buildStaleWhileRevalidateImplementation, Reader } from '@luvio/engine';
 
 function isDeprecatedDurableStoreEntry(durableRecord) {
     if (durableRecord.expiration !== undefined) {
@@ -343,6 +343,31 @@ function emitDurableEnvironmentAdapterEvent(eventData, observers) {
     }, 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) {
+    const store = new InMemoryStore();
+    // need to make sure any TTL overrides are brought over from real L1
+    // because storePublishMetadata uses those overrides
+    store.ttlOverrides = environment.storeGetTTLOverrides();
+    store.defaultTTLOverride = environment.storeGetDefaultTTLOverride();
+    return store;
+}
+
 const AdapterContextSegment = 'ADAPTER-CONTEXT';
 const ADAPTER_CONTEXT_ID_SUFFIX = '__NAMED_CONTEXT';
 function reviveOrCreateContext(adapterId, durableStore, durableStoreErrorHandler, onContextLoaded) {
@@ -399,20 +424,12 @@ function isUnfulfilledSnapshot(cachedSnapshotResult) {
 function makeDurable(environment, { durableStore, instrumentation }) {
     let ingestStagingStore = null;
     const durableTTLStore = new DurableTTLStore(durableStore);
-    let isRevivingTTLOverrides;
-    isRevivingTTLOverrides = new Promise((resolve) => {
-        durableTTLStore.getDurableTTLOverrides().then((map) => {
-            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);
-            }
+    let initializationPromise = new Promise((resolve) => {
+        const finish = () => {
             resolve();
-            isRevivingTTLOverrides = undefined;
-        });
+            initializationPromise = undefined;
+        };
+        reviveTTLOverrides(durableTTLStore, environment).then(finish);
     });
     //instrumentation for durable store errors
     const durableStoreErrorHandler = handleDurableStoreRejection(instrumentation);
@@ -464,7 +481,7 @@ function makeDurable(environment, { durableStore, instrumentation }) {
     const storePublish = function (key, data) {
         validateNotDisposed();
         if (ingestStagingStore === null) {
-            ingestStagingStore = new InMemoryStore();
+            ingestStagingStore = buildIngestStagingStore(environment);
         }
         ingestStagingStore.publish(key, data);
         // remove record from main luvio L1 cache while we are on the synchronous path
@@ -476,7 +493,7 @@ function makeDurable(environment, { durableStore, instrumentation }) {
     const publishStoreMetadata = function (recordId, storeMetadata) {
         validateNotDisposed();
         if (ingestStagingStore === null) {
-            ingestStagingStore = new InMemoryStore();
+            ingestStagingStore = buildIngestStagingStore(environment);
         }
         ingestStagingStore.publishMetadata(recordId, storeMetadata);
     };
@@ -485,14 +502,14 @@ function makeDurable(environment, { durableStore, instrumentation }) {
         // 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 = new InMemoryStore();
+            ingestStagingStore = buildIngestStagingStore(environment);
         }
         environment.storeIngest(key, ingest, response, luvio, ingestStagingStore);
     };
     const storeIngestError = function (key, errorSnapshot, storeMetadataParams, _storeOverride) {
         validateNotDisposed();
         if (ingestStagingStore === null) {
-            ingestStagingStore = new InMemoryStore();
+            ingestStagingStore = buildIngestStagingStore(environment);
         }
         environment.storeIngestError(key, errorSnapshot, storeMetadataParams, ingestStagingStore);
     };
@@ -515,7 +532,8 @@ function makeDurable(environment, { durableStore, instrumentation }) {
         validateNotDisposed();
         // if this lookup is right after an ingest there will be a staging store
         if (ingestStagingStore !== null) {
-            return ingestStagingStore.lookup(sel, createSnapshot, refresh, ttlStrategy);
+            const reader = new Reader(ingestStagingStore, sel.variables, refresh, undefined, ttlStrategy);
+            return reader.read(sel);
         }
         // otherwise this is from buildCachedSnapshot and we should use the luvio
         // L1 store
@@ -524,28 +542,28 @@ function makeDurable(environment, { durableStore, instrumentation }) {
     const storeEvict = function (key) {
         validateNotDisposed();
         if (ingestStagingStore === null) {
-            ingestStagingStore = new InMemoryStore();
+            ingestStagingStore = buildIngestStagingStore(environment);
         }
         ingestStagingStore.evict(key);
     };
     const getNode = function (key) {
         validateNotDisposed();
         if (ingestStagingStore === null) {
-            ingestStagingStore = new InMemoryStore();
+            ingestStagingStore = buildIngestStagingStore(environment);
         }
         return environment.getNode(key, ingestStagingStore);
     };
     const wrapNormalizedGraphNode = function (normalized) {
         validateNotDisposed();
         if (ingestStagingStore === null) {
-            ingestStagingStore = new InMemoryStore();
+            ingestStagingStore = buildIngestStagingStore(environment);
         }
         return environment.wrapNormalizedGraphNode(normalized, ingestStagingStore);
     };
-    const rebuildSnapshot = function (snapshot, records, storeMetadataMap, redirects, onAsyncRebuild) {
+    const rebuildSnapshot = function (snapshot, onAsyncRebuild) {
         validateNotDisposed();
         // try rebuilding from memory
-        const rebuilt = environment.rebuildSnapshot(snapshot, records, storeMetadataMap, redirects, onAsyncRebuild);
+        const rebuilt = environment.rebuildSnapshot(snapshot, onAsyncRebuild);
         // only try reviving from durable store if snapshot is unfulfilled
         if (rebuilt.state !== 'Unfulfilled') {
             return rebuilt;
@@ -554,7 +572,7 @@ function makeDurable(environment, { durableStore, instrumentation }) {
         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
-        environment.rebuildSnapshot(snapshot, records, storeMetadataMap, redirects, () => { })).then((result) => {
+        environment.rebuildSnapshot(snapshot, () => { })).then((result) => {
             onAsyncRebuild(result.snapshot);
         });
         // synchronously return the base snapshot as Pending if not already
@@ -606,16 +624,28 @@ function makeDurable(environment, { durableStore, instrumentation }) {
         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 = (buildSnapshotContext, storeLookup) => {
-            const snapshot = buildCachedSnapshot(buildSnapshotContext, storeLookup, luvio);
+        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, () => storeLookup(snapshot.select, snapshot.refresh)).then((result) => {
+                const revivedSnapshot = reviveSnapshot(environment, durableStore, snapshot, durableStoreErrorHandler, () => injectedStoreLookup(snapshot.select, snapshot.refresh)).then((result) => {
                     emitDurableEnvironmentAdapterEvent({
                         type: 'l2-revive-end',
                         duration: Date.now() - start,
@@ -629,12 +659,14 @@ function makeDurable(environment, { durableStore, instrumentation }) {
             // otherwise just return what buildCachedSnapshot gave us
             return snapshot;
         };
-        const applyCachePolicy = () => {
+        const wrappedApplyCachePolicy = () => {
             return environment.applyCachePolicy(luvio, adapterRequestContext, buildSnapshotContext, wrappedCacheLookup, buildNetworkSnapshot);
         };
-        return isRevivingTTLOverrides !== undefined
-            ? isRevivingTTLOverrides.then(applyCachePolicy)
-            : applyCachePolicy();
+        // 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();
@@ -666,7 +698,7 @@ function makeDurable(environment, { durableStore, instrumentation }) {
             const toPrime = existingRecords !== undefined
                 ? { ...revivedRecords, ...existingRecords }
                 : revivedRecords;
-            ingestStagingStore = new InMemoryStore();
+            ingestStagingStore = buildIngestStagingStore(environment);
             ingestStagingStore.records = toPrime;
             const snapshotFromMemoryIngest = ingestAndBroadcastFunc();
             return publishChangesToDurableStore().then(() => {
@@ -736,6 +768,7 @@ function makeDurable(environment, { durableStore, instrumentation }) {
         dispose: { value: dispose },
         publishChangesToDurableStore: { value: publishChangesToDurableStore },
         getDurableTTLOverrides: { value: getDurableTTLOverrides },
+        dispatchResourceRequest: { value: dispatchResourceRequest },
         applyCachePolicy: { value: applyCachePolicy },
         getIngestStagingStoreRecords: { value: getIngestStagingStoreRecords },
         getIngestStagingStoreMetadata: { value: getIngestStagingStoreMetadata },

package/dist/es/es2018/makeDurable/stagingStore.d.ts

@@ -0,0 +1,7 @@
+import { InMemoryStore } from '@luvio/engine';
+import type { Environment } from '@luvio/engine';
+/**
+ * Returns an empty InMemoryStore that can be used for ingestion.  Copies over
+ * the TTLOverrides from the given Environment's Store.
+ */
+export declare function buildIngestStagingStore(environment: Environment): InMemoryStore;

package/dist/es/es2018/makeDurable/ttl.d.ts

@@ -0,0 +1,3 @@
+import type { Environment } from '@luvio/engine';
+import type { DurableTTLStore } from '../DurableTTLStore';
+export declare function reviveTTLOverrides(ttlStore: DurableTTLStore, environment: Environment): Promise<void>;

package/dist/es/es2018/makeDurable.d.ts

@@ -1,5 +1,4 @@
-import type { CacheKeySet, Environment, RecordSource, Snapshot } from '@luvio/engine';
-import { InMemoryStore } from '@luvio/engine';
+import type { CacheKeySet, Environment, RecordSource, Snapshot, InMemoryStore } from '@luvio/engine';
 import type { DurableStore } from './DurableStore';
 import type { InstrumentationFunction } from './makeDurable/error';
 import type { TTLOverridesMap } from './DurableTTLStore';

package/dist/umd/es2018/environments.js

@@ -347,6 +347,31 @@
         }, 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) {
+        const store = new engine.InMemoryStore();
+        // need to make sure any TTL overrides are brought over from real L1
+        // because storePublishMetadata uses those overrides
+        store.ttlOverrides = environment.storeGetTTLOverrides();
+        store.defaultTTLOverride = environment.storeGetDefaultTTLOverride();
+        return store;
+    }
+
     const AdapterContextSegment = 'ADAPTER-CONTEXT';
     const ADAPTER_CONTEXT_ID_SUFFIX = '__NAMED_CONTEXT';
     function reviveOrCreateContext(adapterId, durableStore, durableStoreErrorHandler, onContextLoaded) {
@@ -403,20 +428,12 @@
     function makeDurable(environment, { durableStore, instrumentation }) {
         let ingestStagingStore = null;
         const durableTTLStore = new DurableTTLStore(durableStore);
-        let isRevivingTTLOverrides;
-        isRevivingTTLOverrides = new Promise((resolve) => {
-            durableTTLStore.getDurableTTLOverrides().then((map) => {
-                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);
-                }
+        let initializationPromise = new Promise((resolve) => {
+            const finish = () => {
                 resolve();
-                isRevivingTTLOverrides = undefined;
-            });
+                initializationPromise = undefined;
+            };
+            reviveTTLOverrides(durableTTLStore, environment).then(finish);
         });
         //instrumentation for durable store errors
         const durableStoreErrorHandler = handleDurableStoreRejection(instrumentation);
@@ -468,7 +485,7 @@
         const storePublish = function (key, data) {
             validateNotDisposed();
             if (ingestStagingStore === null) {
-                ingestStagingStore = new engine.InMemoryStore();
+                ingestStagingStore = buildIngestStagingStore(environment);
             }
             ingestStagingStore.publish(key, data);
             // remove record from main luvio L1 cache while we are on the synchronous path
@@ -480,7 +497,7 @@
         const publishStoreMetadata = function (recordId, storeMetadata) {
             validateNotDisposed();
             if (ingestStagingStore === null) {
-                ingestStagingStore = new engine.InMemoryStore();
+                ingestStagingStore = buildIngestStagingStore(environment);
             }
             ingestStagingStore.publishMetadata(recordId, storeMetadata);
         };
@@ -489,14 +506,14 @@
             // 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 = new engine.InMemoryStore();
+                ingestStagingStore = buildIngestStagingStore(environment);
             }
             environment.storeIngest(key, ingest, response, luvio, ingestStagingStore);
         };
         const storeIngestError = function (key, errorSnapshot, storeMetadataParams, _storeOverride) {
             validateNotDisposed();
             if (ingestStagingStore === null) {
-                ingestStagingStore = new engine.InMemoryStore();
+                ingestStagingStore = buildIngestStagingStore(environment);
             }
             environment.storeIngestError(key, errorSnapshot, storeMetadataParams, ingestStagingStore);
         };
@@ -519,7 +536,8 @@
             validateNotDisposed();
             // if this lookup is right after an ingest there will be a staging store
             if (ingestStagingStore !== null) {
-                return ingestStagingStore.lookup(sel, createSnapshot, refresh, ttlStrategy);
+                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
@@ -528,28 +546,28 @@
         const storeEvict = function (key) {
             validateNotDisposed();
             if (ingestStagingStore === null) {
-                ingestStagingStore = new engine.InMemoryStore();
+                ingestStagingStore = buildIngestStagingStore(environment);
             }
             ingestStagingStore.evict(key);
         };
         const getNode = function (key) {
             validateNotDisposed();
             if (ingestStagingStore === null) {
-                ingestStagingStore = new engine.InMemoryStore();
+                ingestStagingStore = buildIngestStagingStore(environment);
             }
             return environment.getNode(key, ingestStagingStore);
         };
         const wrapNormalizedGraphNode = function (normalized) {
             validateNotDisposed();
             if (ingestStagingStore === null) {
-                ingestStagingStore = new engine.InMemoryStore();
+                ingestStagingStore = buildIngestStagingStore(environment);
             }
             return environment.wrapNormalizedGraphNode(normalized, ingestStagingStore);
         };
-        const rebuildSnapshot = function (snapshot, records, storeMetadataMap, redirects, onAsyncRebuild) {
+        const rebuildSnapshot = function (snapshot, onAsyncRebuild) {
             validateNotDisposed();
             // try rebuilding from memory
-            const rebuilt = environment.rebuildSnapshot(snapshot, records, storeMetadataMap, redirects, onAsyncRebuild);
+            const rebuilt = environment.rebuildSnapshot(snapshot, onAsyncRebuild);
             // only try reviving from durable store if snapshot is unfulfilled
             if (rebuilt.state !== 'Unfulfilled') {
                 return rebuilt;
@@ -558,7 +576,7 @@
             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
-            environment.rebuildSnapshot(snapshot, records, storeMetadataMap, redirects, () => { })).then((result) => {
+            environment.rebuildSnapshot(snapshot, () => { })).then((result) => {
                 onAsyncRebuild(result.snapshot);
             });
             // synchronously return the base snapshot as Pending if not already
@@ -610,16 +628,28 @@
             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 = (buildSnapshotContext, storeLookup) => {
-                const snapshot = buildCachedSnapshot(buildSnapshotContext, storeLookup, luvio);
+            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, () => storeLookup(snapshot.select, snapshot.refresh)).then((result) => {
+                    const revivedSnapshot = reviveSnapshot(environment, durableStore, snapshot, durableStoreErrorHandler, () => injectedStoreLookup(snapshot.select, snapshot.refresh)).then((result) => {
                         emitDurableEnvironmentAdapterEvent({
                             type: 'l2-revive-end',
                             duration: Date.now() - start,
@@ -633,12 +663,14 @@
                 // otherwise just return what buildCachedSnapshot gave us
                 return snapshot;
             };
-            const applyCachePolicy = () => {
+            const wrappedApplyCachePolicy = () => {
                 return environment.applyCachePolicy(luvio, adapterRequestContext, buildSnapshotContext, wrappedCacheLookup, buildNetworkSnapshot);
             };
-            return isRevivingTTLOverrides !== undefined
-                ? isRevivingTTLOverrides.then(applyCachePolicy)
-                : applyCachePolicy();
+            // 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();
@@ -670,7 +702,7 @@
                 const toPrime = existingRecords !== undefined
                     ? { ...revivedRecords, ...existingRecords }
                     : revivedRecords;
-                ingestStagingStore = new engine.InMemoryStore();
+                ingestStagingStore = buildIngestStagingStore(environment);
                 ingestStagingStore.records = toPrime;
                 const snapshotFromMemoryIngest = ingestAndBroadcastFunc();
                 return publishChangesToDurableStore().then(() => {
@@ -740,6 +772,7 @@
             dispose: { value: dispose },
             publishChangesToDurableStore: { value: publishChangesToDurableStore },
             getDurableTTLOverrides: { value: getDurableTTLOverrides },
+            dispatchResourceRequest: { value: dispatchResourceRequest },
             applyCachePolicy: { value: applyCachePolicy },
             getIngestStagingStoreRecords: { value: getIngestStagingStoreRecords },
             getIngestStagingStoreMetadata: { value: getIngestStagingStoreMetadata },

package/dist/umd/es2018/makeDurable/stagingStore.d.ts

@@ -0,0 +1,7 @@
+import { InMemoryStore } from '@luvio/engine';
+import type { Environment } from '@luvio/engine';
+/**
+ * Returns an empty InMemoryStore that can be used for ingestion.  Copies over
+ * the TTLOverrides from the given Environment's Store.
+ */
+export declare function buildIngestStagingStore(environment: Environment): InMemoryStore;

package/dist/umd/es2018/makeDurable/ttl.d.ts

@@ -0,0 +1,3 @@
+import type { Environment } from '@luvio/engine';
+import type { DurableTTLStore } from '../DurableTTLStore';
+export declare function reviveTTLOverrides(ttlStore: DurableTTLStore, environment: Environment): Promise<void>;

package/dist/umd/es2018/makeDurable.d.ts

@@ -1,5 +1,4 @@
-import type { CacheKeySet, Environment, RecordSource, Snapshot } from '@luvio/engine';
-import { InMemoryStore } from '@luvio/engine';
+import type { CacheKeySet, Environment, RecordSource, Snapshot, InMemoryStore } from '@luvio/engine';
 import type { DurableStore } from './DurableStore';
 import type { InstrumentationFunction } from './makeDurable/error';
 import type { TTLOverridesMap } from './DurableTTLStore';

package/dist/umd/es5/environments.js

@@ -44,6 +44,44 @@
         return __assign.apply(this, arguments);
     };
 
+    function __awaiter(thisArg, _arguments, P, generator) {
+        function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+        return new (P || (P = Promise))(function (resolve, reject) {
+            function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+            function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+            function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+            step((generator = generator.apply(thisArg, _arguments || [])).next());
+        });
+    }
+
+    function __generator(thisArg, body) {
+        var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
+        return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
+        function verb(n) { return function (v) { return step([n, v]); }; }
+        function step(op) {
+            if (f) throw new TypeError("Generator is already executing.");
+            while (_) try {
+                if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+                if (y = 0, t) op = [op[0] & 2, t.value];
+                switch (op[0]) {
+                    case 0: case 1: t = op; break;
+                    case 4: _.label++; return { value: op[1], done: false };
+                    case 5: _.label++; y = op[1]; op = [0]; continue;
+                    case 7: op = _.ops.pop(); _.trys.pop(); continue;
+                    default:
+                        if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
+                        if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
+                        if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
+                        if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
+                        if (t[2]) _.ops.pop();
+                        _.trys.pop(); continue;
+                }
+                op = body.call(thisArg, _);
+            } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
+            if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
+        }
+    }
+
     function __spreadArray(to, from, pack) {
         if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {
             if (ar || !(i in from)) {
@@ -390,6 +428,41 @@
         }, observers);
     }
 
+    function reviveTTLOverrides(ttlStore, environment) {
+        return __awaiter(this, void 0, void 0, function () {
+            var map, defaultTTL, overrides, i, len, _a, namespace, representationName, ttl;
+            return __generator(this, function (_b) {
+                switch (_b.label) {
+                    case 0: return [4 /*yield*/, ttlStore.getDurableTTLOverrides()];
+                    case 1:
+                        map = _b.sent();
+                        defaultTTL = map.defaultTTL, overrides = map.overrides;
+                        if (defaultTTL !== undefined) {
+                            environment.storeSetDefaultTTLOverride(defaultTTL.ttl);
+                        }
+                        for (i = 0, len = overrides.length; i < len; i++) {
+                            _a = overrides[i], namespace = _a.namespace, representationName = _a.representationName, ttl = _a.ttl;
+                            environment.storeSetTTLOverride(namespace, representationName, ttl);
+                        }
+                        return [2 /*return*/];
+                }
+            });
+        });
+    }
+
+    /**
+     * Returns an empty InMemoryStore that can be used for ingestion.  Copies over
+     * the TTLOverrides from the given Environment's Store.
+     */
+    function buildIngestStagingStore(environment) {
+        var store = new engine.InMemoryStore();
+        // need to make sure any TTL overrides are brought over from real L1
+        // because storePublishMetadata uses those overrides
+        store.ttlOverrides = environment.storeGetTTLOverrides();
+        store.defaultTTLOverride = environment.storeGetDefaultTTLOverride();
+        return store;
+    }
+
     var AdapterContextSegment = 'ADAPTER-CONTEXT';
     var ADAPTER_CONTEXT_ID_SUFFIX = '__NAMED_CONTEXT';
     function reviveOrCreateContext(adapterId, durableStore, durableStoreErrorHandler, onContextLoaded) {
@@ -448,20 +521,12 @@
         var durableStore = _a.durableStore, instrumentation = _a.instrumentation;
         var ingestStagingStore = null;
         var durableTTLStore = new DurableTTLStore(durableStore);
-        var isRevivingTTLOverrides;
-        isRevivingTTLOverrides = new Promise(function (resolve) {
-            durableTTLStore.getDurableTTLOverrides().then(function (map) {
-                var defaultTTL = map.defaultTTL, overrides = map.overrides;
-                if (defaultTTL !== undefined) {
-                    environment.storeSetDefaultTTLOverride(defaultTTL.ttl);
-                }
-                for (var i = 0, len = overrides.length; i < len; i++) {
-                    var _a = overrides[i], namespace = _a.namespace, representationName = _a.representationName, ttl = _a.ttl;
-                    environment.storeSetTTLOverride(namespace, representationName, ttl);
-                }
+        var initializationPromise = new Promise(function (resolve) {
+            var finish = function () {
                 resolve();
-                isRevivingTTLOverrides = undefined;
-            });
+                initializationPromise = undefined;
+            };
+            reviveTTLOverrides(durableTTLStore, environment).then(finish);
         });
         //instrumentation for durable store errors
         var durableStoreErrorHandler = handleDurableStoreRejection(instrumentation);
@@ -513,7 +578,7 @@
         var storePublish = function (key, data) {
             validateNotDisposed();
             if (ingestStagingStore === null) {
-                ingestStagingStore = new engine.InMemoryStore();
+                ingestStagingStore = buildIngestStagingStore(environment);
             }
             ingestStagingStore.publish(key, data);
             // remove record from main luvio L1 cache while we are on the synchronous path
@@ -525,7 +590,7 @@
         var publishStoreMetadata = function (recordId, storeMetadata) {
             validateNotDisposed();
             if (ingestStagingStore === null) {
-                ingestStagingStore = new engine.InMemoryStore();
+                ingestStagingStore = buildIngestStagingStore(environment);
             }
             ingestStagingStore.publishMetadata(recordId, storeMetadata);
         };
@@ -534,14 +599,14 @@
             // 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 = new engine.InMemoryStore();
+                ingestStagingStore = buildIngestStagingStore(environment);
             }
             environment.storeIngest(key, ingest, response, luvio, ingestStagingStore);
         };
         var storeIngestError = function (key, errorSnapshot, storeMetadataParams, _storeOverride) {
             validateNotDisposed();
             if (ingestStagingStore === null) {
-                ingestStagingStore = new engine.InMemoryStore();
+                ingestStagingStore = buildIngestStagingStore(environment);
             }
             environment.storeIngestError(key, errorSnapshot, storeMetadataParams, ingestStagingStore);
         };
@@ -564,7 +629,8 @@
             validateNotDisposed();
             // if this lookup is right after an ingest there will be a staging store
             if (ingestStagingStore !== null) {
-                return ingestStagingStore.lookup(sel, createSnapshot, refresh, ttlStrategy);
+                var 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
@@ -573,28 +639,28 @@
         var storeEvict = function (key) {
             validateNotDisposed();
             if (ingestStagingStore === null) {
-                ingestStagingStore = new engine.InMemoryStore();
+                ingestStagingStore = buildIngestStagingStore(environment);
             }
             ingestStagingStore.evict(key);
         };
         var getNode = function (key) {
             validateNotDisposed();
             if (ingestStagingStore === null) {
-                ingestStagingStore = new engine.InMemoryStore();
+                ingestStagingStore = buildIngestStagingStore(environment);
             }
             return environment.getNode(key, ingestStagingStore);
         };
         var wrapNormalizedGraphNode = function (normalized) {
             validateNotDisposed();
             if (ingestStagingStore === null) {
-                ingestStagingStore = new engine.InMemoryStore();
+                ingestStagingStore = buildIngestStagingStore(environment);
             }
             return environment.wrapNormalizedGraphNode(normalized, ingestStagingStore);
         };
-        var rebuildSnapshot = function (snapshot, records, storeMetadataMap, redirects, onAsyncRebuild) {
+        var rebuildSnapshot = function (snapshot, onAsyncRebuild) {
             validateNotDisposed();
             // try rebuilding from memory
-            var rebuilt = environment.rebuildSnapshot(snapshot, records, storeMetadataMap, redirects, onAsyncRebuild);
+            var rebuilt = environment.rebuildSnapshot(snapshot, onAsyncRebuild);
             // only try reviving from durable store if snapshot is unfulfilled
             if (rebuilt.state !== 'Unfulfilled') {
                 return rebuilt;
@@ -603,7 +669,7 @@
             reviveSnapshot(environment, durableStore, rebuilt, durableStoreErrorHandler, function () {
                 // 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
-                return environment.rebuildSnapshot(snapshot, records, storeMetadataMap, redirects, function () { });
+                return environment.rebuildSnapshot(snapshot, function () { });
             }).then(function (result) {
                 onAsyncRebuild(result.snapshot);
             });
@@ -653,16 +719,35 @@
             validateNotDisposed();
             return durableTTLStore.getDurableTTLOverrides();
         };
+        var dispatchResourceRequest = function (request, context, eventObservers) {
+            return __awaiter(this, void 0, void 0, function () {
+                return __generator(this, function (_a) {
+                    switch (_a.label) {
+                        case 0:
+                            validateNotDisposed();
+                            if (!(initializationPromise !== undefined)) return [3 /*break*/, 2];
+                            return [4 /*yield*/, initializationPromise];
+                        case 1:
+                            _a.sent();
+                            _a.label = 2;
+                        case 2: return [2 /*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
         var applyCachePolicy = function (luvio, adapterRequestContext, buildSnapshotContext, buildCachedSnapshot, buildNetworkSnapshot) {
             validateNotDisposed();
-            var wrappedCacheLookup = function (buildSnapshotContext, storeLookup) {
-                var snapshot = buildCachedSnapshot(buildSnapshotContext, storeLookup, luvio);
+            var wrappedCacheLookup = function (injectedBuildSnapshotContext, injectedStoreLookup) {
+                var 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)) {
                     var start_1 = Date.now();
                     emitDurableEnvironmentAdapterEvent({ type: 'l2-revive-start' }, adapterRequestContext.eventObservers);
-                    var revivedSnapshot = reviveSnapshot(environment, durableStore, snapshot, durableStoreErrorHandler, function () { return storeLookup(snapshot.select, snapshot.refresh); }).then(function (result) {
+                    var revivedSnapshot = reviveSnapshot(environment, durableStore, snapshot, durableStoreErrorHandler, function () { return injectedStoreLookup(snapshot.select, snapshot.refresh); }).then(function (result) {
                         emitDurableEnvironmentAdapterEvent({
                             type: 'l2-revive-end',
                             duration: Date.now() - start_1,
@@ -676,12 +761,14 @@
                 // otherwise just return what buildCachedSnapshot gave us
                 return snapshot;
             };
-            var applyCachePolicy = function () {
+            var wrappedApplyCachePolicy = function () {
                 return environment.applyCachePolicy(luvio, adapterRequestContext, buildSnapshotContext, wrappedCacheLookup, buildNetworkSnapshot);
             };
-            return isRevivingTTLOverrides !== undefined
-                ? isRevivingTTLOverrides.then(applyCachePolicy)
-                : applyCachePolicy();
+            // 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();
         };
         var getIngestStagingStoreRecords = function () {
             validateNotDisposed();
@@ -712,7 +799,7 @@
             var ingestAndPublish = function (revivedRecords) {
                 var toPrime = existingRecords !== undefined
                     ? __assign(__assign({}, revivedRecords), existingRecords) : revivedRecords;
-                ingestStagingStore = new engine.InMemoryStore();
+                ingestStagingStore = buildIngestStagingStore(environment);
                 ingestStagingStore.records = toPrime;
                 var snapshotFromMemoryIngest = ingestAndBroadcastFunc();
                 return publishChangesToDurableStore().then(function () {
@@ -784,6 +871,7 @@
             dispose: { value: dispose },
             publishChangesToDurableStore: { value: publishChangesToDurableStore },
             getDurableTTLOverrides: { value: getDurableTTLOverrides },
+            dispatchResourceRequest: { value: dispatchResourceRequest },
             applyCachePolicy: { value: applyCachePolicy },
             getIngestStagingStoreRecords: { value: getIngestStagingStoreRecords },
             getIngestStagingStoreMetadata: { value: getIngestStagingStoreMetadata },

package/dist/umd/es5/makeDurable/stagingStore.d.ts

@@ -0,0 +1,7 @@
+import { InMemoryStore } from '@luvio/engine';
+import type { Environment } from '@luvio/engine';
+/**
+ * Returns an empty InMemoryStore that can be used for ingestion.  Copies over
+ * the TTLOverrides from the given Environment's Store.
+ */
+export declare function buildIngestStagingStore(environment: Environment): InMemoryStore;

package/dist/umd/es5/makeDurable/ttl.d.ts

@@ -0,0 +1,3 @@
+import type { Environment } from '@luvio/engine';
+import type { DurableTTLStore } from '../DurableTTLStore';
+export declare function reviveTTLOverrides(ttlStore: DurableTTLStore, environment: Environment): Promise<void>;

package/dist/umd/es5/makeDurable.d.ts

@@ -1,5 +1,4 @@
-import type { CacheKeySet, Environment, RecordSource, Snapshot } from '@luvio/engine';
-import { InMemoryStore } from '@luvio/engine';
+import type { CacheKeySet, Environment, RecordSource, Snapshot, InMemoryStore } from '@luvio/engine';
 import type { DurableStore } from './DurableStore';
 import type { InstrumentationFunction } from './makeDurable/error';
 import type { TTLOverridesMap } from './DurableTTLStore';

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@luvio/environments",
-    "version": "0.99.2",
+    "version": "0.102.1",
     "description": "Luvio Environments",
     "repository": {
         "type": "git",
@@ -23,7 +23,7 @@
         "watch": "yarn build --watch"
     },
     "dependencies": {
-        "@luvio/engine": "0.99.2"
+        "@luvio/engine": "0.102.1"
     },
     "bundlesize": [
         {