@luvio/environments 0.145.4 → 0.146.0

package/dist/environments.js

@@ -1,4 +1,4 @@
-import { StoreKeySet, deepFreeze, serializeStructuredKey, emitAdapterEvent, Reader } from '@luvio/engine';
+import { StoreKeySet, deepFreeze, serializeStructuredKey, emitAdapterEvent, StringKeyInMemoryStore, Reader } from '@luvio/engine';
 
 // the last version the metadata shape was altered
 const DURABLE_METADATA_VERSION = '0.111.0';
@@ -112,7 +112,7 @@ function publishDurableStoreEntries(durableRecords, put, publishMetadata) {
  * 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: [] }) {
+function reviveSnapshot(baseEnvironment, durableStore, unavailableSnapshot, durableStoreErrorHandler, buildL1Snapshot, revivingStore, 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.
@@ -122,10 +122,21 @@ function reviveSnapshot(baseEnvironment, durableStore, unavailableSnapshot, dura
             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 StoreKeySet().add(recordId);
-    keysToReviveSet.merge(seenRecords);
+    const keysToReviveSet = new StoreKeySet();
+    if (revivingStore) {
+        // Any stale keys since the last l2 read should be cleared and fetched again
+        for (const staleKey of revivingStore.staleEntries) {
+            keysToReviveSet.add(staleKey);
+        }
+        revivingStore.clearStale();
+    }
+    else {
+        // when not using a reviving store:
+        // 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
+        keysToReviveSet.add(recordId);
+        keysToReviveSet.merge(seenRecords);
+    }
     keysToReviveSet.merge(missingLinks);
     const keysToRevive = keysToReviveSet.keysAsArray();
     const canonicalKeys = keysToRevive.map((x) => serializeStructuredKey(baseEnvironment.storeGetCanonicalKey(x)));
@@ -175,7 +186,7 @@ function reviveSnapshot(baseEnvironment, durableStore, unavailableSnapshot, dura
             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 reviveSnapshot(baseEnvironment, durableStore, snapshot, durableStoreErrorHandler, buildL1Snapshot, revivingStore, reviveMetrics);
                 }
             }
         }
@@ -374,6 +385,50 @@ async function reviveRedirects(durableStore, env) {
     }
 }
 
+function buildRevivingStagingStore(upstreamStore) {
+    const localStore = new StringKeyInMemoryStore();
+    const staleEntries = new Set();
+    function readEntry(key) {
+        if (typeof key !== 'string') {
+            return upstreamStore.readEntry(key);
+        }
+        let storeEntry = localStore.readEntry(key);
+        if (!storeEntry) {
+            // read from upstream store...
+            storeEntry = upstreamStore.readEntry(key);
+            // put it in our store to avoid it getting evicted prior to the next durable store read
+            localStore.put(key, storeEntry);
+        }
+        return storeEntry;
+    }
+    // Entries are marked stale by the durable store change listener. They are not
+    // immediately evicted so as to not result in a cache miss during a rebuild.
+    // The revive process will clear stale entries and read them from the durable store
+    // on the next revive loop.
+    function markStale(key) {
+        staleEntries.add(key);
+    }
+    // The revive loop clears stale entries right before reading from the durable store.
+    // Any stale entries will be revived to ensure they are present in L1 and match the
+    // latest data.
+    function clearStale() {
+        for (const key of staleEntries) {
+            localStore.dealloc(key);
+        }
+        staleEntries.clear();
+    }
+    // All functions other than `readEntry` pass through to the upstream store.
+    // A reviving store is only "active" during a call to `environment.storeLookup`, and will
+    // be used by the reader attempting to build an L1 snapshot. Immediately after the L1 rebuild
+    // the reviving store becomes inactive other than receiving change notifications.
+    return create(upstreamStore, {
+        readEntry: { value: readEntry },
+        markStale: { value: markStale },
+        clearStale: { value: clearStale },
+        staleEntries: { value: staleEntries },
+    });
+}
+
 const AdapterContextSegment = 'ADAPTER-CONTEXT';
 const ADAPTER_CONTEXT_ID_SUFFIX = '__NAMED_CONTEXT';
 async function reviveOrCreateContext(adapterId, durableStore, durableStoreErrorHandler, contextStores, pendingContextStoreKeys, onContextLoaded) {
@@ -429,14 +484,16 @@ function isUnfulfilledSnapshot(cachedSnapshotResult) {
  * @param durableStore A DurableStore implementation
  * @param instrumentation An instrumentation function implementation
  */
-function makeDurable(environment, { durableStore, instrumentation }) {
-    let ingestStagingStore = null;
+function makeDurable(environment, { durableStore, instrumentation, useRevivingStore }) {
+    let stagingStore = 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();
+    // Reviving stores are tracked so that they can be notified of durable store change notifications.
+    const revivingStores = new Set();
     // redirects that need to be flushed to the durable store
     const pendingStoreRedirects = new Map();
     const contextStores = create(null);
@@ -533,6 +590,9 @@ function makeDurable(environment, { durableStore, instrumentation }) {
                 // 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);
+                for (const revivingStore of revivingStores) {
+                    revivingStore.markStale(key);
+                }
             }
             shouldBroadcast = true;
         }
@@ -561,10 +621,10 @@ function makeDurable(environment, { durableStore, instrumentation }) {
     };
     const storePublish = function (key, data) {
         validateNotDisposed();
-        if (ingestStagingStore === null) {
-            ingestStagingStore = buildIngestStagingStore(environment);
+        if (stagingStore === null) {
+            stagingStore = buildIngestStagingStore(environment);
         }
-        ingestStagingStore.publish(key, data);
+        stagingStore.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
@@ -573,26 +633,26 @@ function makeDurable(environment, { durableStore, instrumentation }) {
     };
     const publishStoreMetadata = function (recordId, storeMetadata) {
         validateNotDisposed();
-        if (ingestStagingStore === null) {
-            ingestStagingStore = buildIngestStagingStore(environment);
+        if (stagingStore === null) {
+            stagingStore = buildIngestStagingStore(environment);
         }
-        ingestStagingStore.publishMetadata(recordId, storeMetadata);
+        stagingStore.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);
+        if (stagingStore === null) {
+            stagingStore = buildIngestStagingStore(environment);
         }
-        environment.storeIngest(key, ingest, response, luvio, ingestStagingStore);
+        environment.storeIngest(key, ingest, response, luvio, stagingStore);
     };
     const storeIngestError = function (key, errorSnapshot, storeMetadataParams, _storeOverride) {
         validateNotDisposed();
-        if (ingestStagingStore === null) {
-            ingestStagingStore = buildIngestStagingStore(environment);
+        if (stagingStore === null) {
+            stagingStore = buildIngestStagingStore(environment);
         }
-        environment.storeIngestError(key, errorSnapshot, storeMetadataParams, ingestStagingStore);
+        environment.storeIngestError(key, errorSnapshot, storeMetadataParams, stagingStore);
     };
     const storeBroadcast = function (_rebuildSnapshot, _snapshotDataAvailable) {
         validateNotDisposed();
@@ -603,19 +663,19 @@ function makeDurable(environment, { durableStore, instrumentation }) {
     };
     const publishChangesToDurableStore = function (additionalDurableStoreOperations) {
         validateNotDisposed();
-        if (ingestStagingStore === null) {
+        if (stagingStore === null) {
             return Promise.resolve();
         }
-        const promise = flushInMemoryStoreValuesToDurableStore(ingestStagingStore, durableStore, durableStoreErrorHandler, new Map(pendingStoreRedirects), additionalDurableStoreOperations);
+        const promise = flushInMemoryStoreValuesToDurableStore(stagingStore, durableStore, durableStoreErrorHandler, new Map(pendingStoreRedirects), additionalDurableStoreOperations);
         pendingStoreRedirects.clear();
-        ingestStagingStore = null;
+        stagingStore = 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 Reader(ingestStagingStore, sel.variables, refresh, undefined, ttlStrategy);
+        // if this lookup is right after an ingest or during a revive there will be a staging store
+        if (stagingStore !== null) {
+            const reader = new Reader(stagingStore, sel.variables, refresh, undefined, ttlStrategy);
             return reader.read(sel);
         }
         // otherwise this is from buildCachedSnapshot and we should use the luvio
@@ -624,24 +684,24 @@ function makeDurable(environment, { durableStore, instrumentation }) {
     };
     const storeEvict = function (key) {
         validateNotDisposed();
-        if (ingestStagingStore === null) {
-            ingestStagingStore = buildIngestStagingStore(environment);
+        if (stagingStore === null) {
+            stagingStore = buildIngestStagingStore(environment);
         }
-        ingestStagingStore.evict(key);
+        stagingStore.evict(key);
     };
     const getNode = function (key) {
         validateNotDisposed();
-        if (ingestStagingStore === null) {
-            ingestStagingStore = buildIngestStagingStore(environment);
+        if (stagingStore === null) {
+            stagingStore = buildIngestStagingStore(environment);
         }
-        return environment.getNode(key, ingestStagingStore);
+        return environment.getNode(key, stagingStore);
     };
     const wrapNormalizedGraphNode = function (normalized) {
         validateNotDisposed();
-        if (ingestStagingStore === null) {
-            ingestStagingStore = buildIngestStagingStore(environment);
+        if (stagingStore === null) {
+            stagingStore = buildIngestStagingStore(environment);
         }
-        return environment.wrapNormalizedGraphNode(normalized, ingestStagingStore);
+        return environment.wrapNormalizedGraphNode(normalized, stagingStore);
     };
     const rebuildSnapshot = function (snapshot, onRebuild) {
         validateNotDisposed();
@@ -653,7 +713,7 @@ function makeDurable(environment, { durableStore, instrumentation }) {
                 return;
             }
             // Do an L2 revive and emit to subscriber using the callback.
-            reviveSnapshot(environment, durableStore, rebuilt, durableStoreErrorHandler, () => {
+            reviveSnapshotWrapper(rebuilt, () => {
                 // 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;
@@ -694,10 +754,10 @@ function makeDurable(environment, { durableStore, instrumentation }) {
         // 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);
+        if (stagingStore === null) {
+            stagingStore = buildIngestStagingStore(environment);
         }
-        ingestStagingStore.redirect(existingKey, canonicalKey);
+        stagingStore.redirect(existingKey, canonicalKey);
     };
     const storeSetTTLOverride = function (namespace, representationName, ttl) {
         validateNotDisposed();
@@ -738,7 +798,7 @@ function makeDurable(environment, { durableStore, instrumentation }) {
             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) => {
+                const revivedSnapshot = reviveSnapshotWrapper(snapshot, () => injectedStoreLookup(snapshot.select, snapshot.refresh)).then((result) => {
                     emitDurableEnvironmentAdapterEvent({
                         type: 'l2-revive-end',
                         snapshot: result.snapshot,
@@ -763,15 +823,15 @@ function makeDurable(environment, { durableStore, instrumentation }) {
     };
     const getIngestStagingStoreRecords = function () {
         validateNotDisposed();
-        if (ingestStagingStore !== null) {
-            return ingestStagingStore.fallbackStringKeyInMemoryStore.records;
+        if (stagingStore !== null) {
+            return stagingStore.fallbackStringKeyInMemoryStore.records;
         }
         return {};
     };
     const getIngestStagingStoreMetadata = function () {
         validateNotDisposed();
-        if (ingestStagingStore !== null) {
-            return ingestStagingStore.fallbackStringKeyInMemoryStore.metadata;
+        if (stagingStore !== null) {
+            return stagingStore.fallbackStringKeyInMemoryStore.metadata;
         }
         return {};
     };
@@ -810,22 +870,20 @@ function makeDurable(environment, { durableStore, instrumentation }) {
                 }
                 await Promise.all(pendingPromises);
                 const entries = await durableStore.getEntries(keysToReviveAsArray, DefaultDurableSegment);
-                ingestStagingStore = buildIngestStagingStore(environment);
+                stagingStore = buildIngestStagingStore(environment);
                 publishDurableStoreEntries(entries, (key, record) => {
                     if (typeof key === 'string') {
-                        ingestStagingStore.fallbackStringKeyInMemoryStore.records[key] =
-                            record;
+                        stagingStore.fallbackStringKeyInMemoryStore.records[key] = record;
                     }
                     else {
-                        ingestStagingStore.recordsMap.set(key, record);
+                        stagingStore.recordsMap.set(key, record);
                     }
                 }, (key, metadata) => {
                     if (typeof key === 'string') {
-                        ingestStagingStore.fallbackStringKeyInMemoryStore.metadata[key] =
-                            metadata;
+                        stagingStore.fallbackStringKeyInMemoryStore.metadata[key] = metadata;
                     }
                     else {
-                        ingestStagingStore.metadataMap.set(key, metadata);
+                        stagingStore.metadataMap.set(key, metadata);
                     }
                 });
                 snapshotFromMemoryIngest = await ingestAndBroadcastFunc();
@@ -854,7 +912,7 @@ function makeDurable(environment, { durableStore, instrumentation }) {
             // 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);
+            stagingStore = buildIngestStagingStore(environment);
             snapshotFromMemoryIngest = await ingestAndBroadcastFunc();
         }
         if (snapshotFromMemoryIngest === undefined) {
@@ -865,12 +923,12 @@ function makeDurable(environment, { durableStore, instrumentation }) {
         }
         // 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));
+        const result = await reviveSnapshotWrapper(snapshotFromMemoryIngest, () => environment.storeLookup(select, environment.createSnapshot, refresh));
         return result.snapshot;
     };
     const handleErrorResponse = async function (ingestAndBroadcastFunc) {
         validateNotDisposed();
-        ingestStagingStore = buildIngestStagingStore(environment);
+        stagingStore = buildIngestStagingStore(environment);
         return ingestAndBroadcastFunc();
     };
     const getNotifyChangeStoreEntries = function (keys) {
@@ -921,6 +979,27 @@ function makeDurable(environment, { durableStore, instrumentation }) {
         await durableStore.setEntries({ notifyStoreUpdateAvailable: { data: entryKeys } }, MessagingDurableSegment);
         return Promise.resolve(undefined);
     };
+    const reviveSnapshotWrapper = function (unavailableSnapshot, buildL1Snapshot) {
+        let revivingStore = undefined;
+        if (useRevivingStore) {
+            // NOTE: `store` is private, there doesn't seem to be a better,
+            // cleaner way of accessing it from a derived environment.
+            let baseStore = environment.store;
+            // If we're rebuilding during an ingest, the existing staging store should be the base store.
+            if (stagingStore) {
+                baseStore = stagingStore;
+            }
+            let revivingStore = buildRevivingStagingStore(baseStore);
+            revivingStores.add(revivingStore);
+        }
+        return reviveSnapshot(environment, durableStore, unavailableSnapshot, durableStoreErrorHandler, () => {
+            const tempStore = stagingStore;
+            const result = buildL1Snapshot();
+            stagingStore = tempStore;
+            return result;
+        }, revivingStore).finally(() => {
+        });
+    };
     // set the default cache policy of the base environment
     environment.setDefaultCachePolicy({
         type: 'stale-while-revalidate',

package/dist/types/makeDurable/RevivingStore.d.ts

@@ -0,0 +1,7 @@
+import type { InMemoryStore } from '@luvio/engine';
+export interface RevivingStore extends InMemoryStore {
+    staleEntries: Set<string>;
+    markStale(key: string): void;
+    clearStale(): void;
+}
+export declare function buildRevivingStagingStore(upstreamStore: InMemoryStore): RevivingStore;

package/dist/types/makeDurable/revive.d.ts

@@ -2,6 +2,7 @@ import type { Environment, Snapshot, StoreMetadata, NormalizedKeyMetadata, Unful
 import type { DurableStore, DurableStoreEntries } from '../DurableStore';
 import type { DurableStoreRejectionHandler } from './error';
 import { StoreKeySet } from '@luvio/engine';
+import type { RevivingStore } from './RevivingStore';
 type ReviveResponse = {
     revivedKeys: StoreKeySet<string | NormalizedKeyMetadata>;
     hadUnexpectedShape: boolean;
@@ -18,13 +19,13 @@ type ReviveResponse = {
  * @returns
  */
 export declare function publishDurableStoreEntries(durableRecords: DurableStoreEntries<unknown> | undefined, put: (key: string | NormalizedKeyMetadata, record: unknown) => void, publishMetadata: (key: string, metadata: StoreMetadata) => void): ReviveResponse;
-interface ReviveMetrics {
+export interface ReviveMetrics {
     l2Trips: {
         keysRequestedCount: number;
         duration: number;
     }[];
 }
-interface ReviveResult<D, V> {
+export interface ReviveResult<D, V> {
     snapshot: Snapshot<D, V>;
     metrics: ReviveMetrics;
 }
@@ -34,5 +35,5 @@ interface ReviveResult<D, V> {
  * will refresh the snapshot from network, and then run the results from network
  * through L2 ingestion, returning the subsequent revived snapshot.
  */
-export declare function reviveSnapshot<D, V = unknown>(baseEnvironment: Environment, durableStore: DurableStore, unavailableSnapshot: UnfulfilledSnapshot<D, V>, durableStoreErrorHandler: DurableStoreRejectionHandler, buildL1Snapshot: () => Snapshot<D, V>, reviveMetrics?: ReviveMetrics): Promise<ReviveResult<D, V>>;
+export declare function reviveSnapshot<D, V = unknown>(baseEnvironment: Environment, durableStore: DurableStore, unavailableSnapshot: UnfulfilledSnapshot<D, V>, durableStoreErrorHandler: DurableStoreRejectionHandler, buildL1Snapshot: () => Snapshot<D, V>, revivingStore: RevivingStore | undefined, reviveMetrics?: ReviveMetrics): Promise<ReviveResult<D, V>>;
 export {};

package/dist/types/makeDurable.d.ts

@@ -34,6 +34,7 @@ export declare const ADAPTER_CONTEXT_ID_SUFFIX = "__NAMED_CONTEXT";
 interface MakeDurableOptions {
     durableStore: DurableStore;
     instrumentation?: InstrumentationFunction;
+    useRevivingStore?: boolean;
 }
 /**
  * Configures the environment to persist data into a durable store and attempt to resolve
@@ -44,5 +45,5 @@ interface MakeDurableOptions {
  * @param durableStore A DurableStore implementation
  * @param instrumentation An instrumentation function implementation
  */
-export declare function makeDurable(environment: Environment, { durableStore, instrumentation }: MakeDurableOptions): DurableEnvironment;
+export declare function makeDurable(environment: Environment, { durableStore, instrumentation, useRevivingStore }: MakeDurableOptions): DurableEnvironment;
 export {};

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@luvio/environments",
-    "version": "0.145.4",
+    "version": "0.146.0",
     "description": "Luvio Environments",
     "repository": {
         "type": "git",
@@ -27,7 +27,7 @@
         "watch": "yarn build --watch"
     },
     "dependencies": {
-        "@luvio/engine": "^0.145.4"
+        "@luvio/engine": "^0.146.0"
     },
     "volta": {
         "extends": "../../../package.json"
@@ -36,9 +36,9 @@
         {
             "path": "./dist/environments.js",
             "maxSize": {
-                "none": "42.2 kB",
-                "min": "12.3 kB",
-                "compressed": "8.1 kB"
+                "none": "45.5 kB",
+                "min": "13.0 kB",
+                "compressed": "8.8 kB"
             }
         }
     ],