@luvio/environments 0.126.2 → 0.127.1

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

@@ -58,7 +58,7 @@ export interface DurableStoreChange {
      */
     isExternalChange?: boolean;
 }
-export declare type OnDurableStoreChangedListener = (changes: DurableStoreChange[]) => void;
+export declare type OnDurableStoreChangedListener = (changes: DurableStoreChange[]) => Promise<void>;
 /**
  * The DurableStore implementation must have the following behaviors:
  * - It must handle read/write synchronization (ie: reads should wait for any

package/dist/es/es2018/environments.js

@@ -513,8 +513,9 @@ function makeDurable(environment, { durableStore, instrumentation }) {
                 // call base environment storeEvict so this evict is not tracked for durable deletion
                 environment.storeEvict(key);
             }
-            environment.storeBroadcast(rebuildSnapshot, environment.snapshotAvailable);
+            return environment.storeBroadcast(rebuildSnapshot, environment.snapshotAvailable);
         }
+        return Promise.resolve();
     });
     const dispose = function () {
         validateNotDisposed();
@@ -558,9 +559,10 @@ function makeDurable(environment, { durableStore, instrumentation }) {
     };
     const storeBroadcast = function (_rebuildSnapshot, _snapshotDataAvailable) {
         validateNotDisposed();
-        // no-op here and wait for the L2 flush to happen in handleSuccessResponse,
+        // return resolved promise here and wait for the L2 flush to happen in handleSuccessResponse,
         // that flush will cause the onChanged handler to fire which will revive
         // records to the main L1 store and call the base storeBroadcast
+        return Promise.resolve();
     };
     const publishChangesToDurableStore = function () {
         validateNotDisposed();
@@ -603,28 +605,28 @@ function makeDurable(environment, { durableStore, instrumentation }) {
         }
         return environment.wrapNormalizedGraphNode(normalized, ingestStagingStore);
     };
-    const rebuildSnapshot = function (snapshot, onAsyncRebuild) {
+    const rebuildSnapshot = function (snapshot, onRebuild) {
         validateNotDisposed();
         // try rebuilding from memory
-        const rebuilt = environment.rebuildSnapshot(snapshot, onAsyncRebuild);
-        // only try reviving from durable store if snapshot is unfulfilled
-        if (rebuilt.state !== 'Unfulfilled') {
-            return rebuilt;
-        }
-        // 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
-        environment.rebuildSnapshot(snapshot, () => { })).then((result) => {
-            onAsyncRebuild(result.snapshot);
+        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);
+            });
         });
-        // synchronously return the base snapshot as Pending if not already
-        return snapshot.state === 'Pending'
-            ? snapshot
-            : {
-                ...snapshot,
-                state: 'Pending',
-            };
     };
     const withContext = function (adapter, options) {
         validateNotDisposed();
@@ -773,7 +775,7 @@ function makeDurable(environment, { durableStore, instrumentation }) {
                 }, 
                 // we don't need to prime metadata
                 () => { });
-                snapshotFromMemoryIngest = ingestAndBroadcastFunc();
+                snapshotFromMemoryIngest = await ingestAndBroadcastFunc();
                 await publishChangesToDurableStore();
             })();
             for (const key of keysAsArray) {
@@ -801,7 +803,7 @@ function makeDurable(environment, { durableStore, instrumentation }) {
             // 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 = ingestAndBroadcastFunc();
+            snapshotFromMemoryIngest = await ingestAndBroadcastFunc();
             await publishChangesToDurableStore();
         }
         if (snapshotFromMemoryIngest === undefined) {

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

@@ -58,7 +58,7 @@ export interface DurableStoreChange {
      */
     isExternalChange?: boolean;
 }
-export declare type OnDurableStoreChangedListener = (changes: DurableStoreChange[]) => void;
+export declare type OnDurableStoreChangedListener = (changes: DurableStoreChange[]) => Promise<void>;
 /**
  * The DurableStore implementation must have the following behaviors:
  * - It must handle read/write synchronization (ie: reads should wait for any

package/dist/umd/es2018/environments.js

@@ -517,8 +517,9 @@
                     // call base environment storeEvict so this evict is not tracked for durable deletion
                     environment.storeEvict(key);
                 }
-                environment.storeBroadcast(rebuildSnapshot, environment.snapshotAvailable);
+                return environment.storeBroadcast(rebuildSnapshot, environment.snapshotAvailable);
             }
+            return Promise.resolve();
         });
         const dispose = function () {
             validateNotDisposed();
@@ -562,9 +563,10 @@
         };
         const storeBroadcast = function (_rebuildSnapshot, _snapshotDataAvailable) {
             validateNotDisposed();
-            // no-op here and wait for the L2 flush to happen in handleSuccessResponse,
+            // return resolved promise here and wait for the L2 flush to happen in handleSuccessResponse,
             // that flush will cause the onChanged handler to fire which will revive
             // records to the main L1 store and call the base storeBroadcast
+            return Promise.resolve();
         };
         const publishChangesToDurableStore = function () {
             validateNotDisposed();
@@ -607,28 +609,28 @@
             }
             return environment.wrapNormalizedGraphNode(normalized, ingestStagingStore);
         };
-        const rebuildSnapshot = function (snapshot, onAsyncRebuild) {
+        const rebuildSnapshot = function (snapshot, onRebuild) {
             validateNotDisposed();
             // try rebuilding from memory
-            const rebuilt = environment.rebuildSnapshot(snapshot, onAsyncRebuild);
-            // only try reviving from durable store if snapshot is unfulfilled
-            if (rebuilt.state !== 'Unfulfilled') {
-                return rebuilt;
-            }
-            // 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
-            environment.rebuildSnapshot(snapshot, () => { })).then((result) => {
-                onAsyncRebuild(result.snapshot);
+            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);
+                });
             });
-            // synchronously return the base snapshot as Pending if not already
-            return snapshot.state === 'Pending'
-                ? snapshot
-                : {
-                    ...snapshot,
-                    state: 'Pending',
-                };
         };
         const withContext = function (adapter, options) {
             validateNotDisposed();
@@ -777,7 +779,7 @@
                     }, 
                     // we don't need to prime metadata
                     () => { });
-                    snapshotFromMemoryIngest = ingestAndBroadcastFunc();
+                    snapshotFromMemoryIngest = await ingestAndBroadcastFunc();
                     await publishChangesToDurableStore();
                 })();
                 for (const key of keysAsArray) {
@@ -805,7 +807,7 @@
                 // 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 = ingestAndBroadcastFunc();
+                snapshotFromMemoryIngest = await ingestAndBroadcastFunc();
                 await publishChangesToDurableStore();
             }
             if (snapshotFromMemoryIngest === undefined) {

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

@@ -58,7 +58,7 @@ export interface DurableStoreChange {
      */
     isExternalChange?: boolean;
 }
-export declare type OnDurableStoreChangedListener = (changes: DurableStoreChange[]) => void;
+export declare type OnDurableStoreChangedListener = (changes: DurableStoreChange[]) => Promise<void>;
 /**
  * The DurableStore implementation must have the following behaviors:
  * - It must handle read/write synchronization (ie: reads should wait for any

package/dist/umd/es5/environments.js

@@ -621,8 +621,9 @@
                     // call base environment storeEvict so this evict is not tracked for durable deletion
                     environment.storeEvict(key);
                 }
-                environment.storeBroadcast(rebuildSnapshot, environment.snapshotAvailable);
+                return environment.storeBroadcast(rebuildSnapshot, environment.snapshotAvailable);
             }
+            return Promise.resolve();
         });
         var dispose = function () {
             validateNotDisposed();
@@ -666,9 +667,10 @@
         };
         var storeBroadcast = function (_rebuildSnapshot, _snapshotDataAvailable) {
             validateNotDisposed();
-            // no-op here and wait for the L2 flush to happen in handleSuccessResponse,
+            // return resolved promise here and wait for the L2 flush to happen in handleSuccessResponse,
             // that flush will cause the onChanged handler to fire which will revive
             // records to the main L1 store and call the base storeBroadcast
+            return Promise.resolve();
         };
         var publishChangesToDurableStore = function () {
             validateNotDisposed();
@@ -711,26 +713,28 @@
             }
             return environment.wrapNormalizedGraphNode(normalized, ingestStagingStore);
         };
-        var rebuildSnapshot = function (snapshot, onAsyncRebuild) {
+        var rebuildSnapshot = function (snapshot, onRebuild) {
             validateNotDisposed();
             // try rebuilding from memory
-            var rebuilt = environment.rebuildSnapshot(snapshot, onAsyncRebuild);
-            // only try reviving from durable store if snapshot is unfulfilled
-            if (rebuilt.state !== 'Unfulfilled') {
-                return rebuilt;
-            }
-            // Do an L2 revive and emit to subscriber using the callback.
-            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, function () { });
-            }).then(function (result) {
-                onAsyncRebuild(result.snapshot);
+            environment.rebuildSnapshot(snapshot, function (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, 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
+                    var rebuiltSnap;
+                    environment.rebuildSnapshot(snapshot, function (rebuilt) {
+                        rebuiltSnap = rebuilt;
+                    });
+                    return rebuiltSnap;
+                }).then(function (result) {
+                    onRebuild(result.snapshot);
+                });
             });
-            // synchronously return the base snapshot as Pending if not already
-            return snapshot.state === 'Pending'
-                ? snapshot
-                : __assign(__assign({}, snapshot), { state: 'Pending' });
         };
         var withContext = function (adapter, options) {
             validateNotDisposed();
@@ -899,9 +903,11 @@
                                             }, 
                                             // we don't need to prime metadata
                                             function () { });
-                                            snapshotFromMemoryIngest = ingestAndBroadcastFunc();
-                                            return [4 /*yield*/, publishChangesToDurableStore()];
+                                            return [4 /*yield*/, ingestAndBroadcastFunc()];
                                         case 3:
+                                            snapshotFromMemoryIngest = _a.sent();
+                                            return [4 /*yield*/, publishChangesToDurableStore()];
+                                        case 4:
                                             _a.sent();
                                             return [2 /*return*/];
                                     }
@@ -932,18 +938,20 @@
                                 }
                             }
                             return [7 /*endfinally*/];
-                        case 4: return [3 /*break*/, 7];
+                        case 4: return [3 /*break*/, 8];
                         case 5:
                             // 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 = ingestAndBroadcastFunc();
-                            return [4 /*yield*/, publishChangesToDurableStore()];
+                            return [4 /*yield*/, ingestAndBroadcastFunc()];
                         case 6:
-                            _d.sent();
-                            _d.label = 7;
+                            snapshotFromMemoryIngest = _d.sent();
+                            return [4 /*yield*/, publishChangesToDurableStore()];
                         case 7:
+                            _d.sent();
+                            _d.label = 8;
+                        case 8:
                             if (snapshotFromMemoryIngest === undefined) {
                                 return [2 /*return*/, undefined];
                             }
@@ -952,7 +960,7 @@
                             }
                             _c = snapshotFromMemoryIngest, select = _c.select, refresh = _c.refresh;
                             return [4 /*yield*/, reviveSnapshot(environment, durableStore, snapshotFromMemoryIngest, durableStoreErrorHandler, function () { return environment.storeLookup(select, environment.createSnapshot, refresh); })];
-                        case 8:
+                        case 9:
                             result = _d.sent();
                             return [2 /*return*/, result.snapshot];
                     }

package/package.json

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