@luvio/environments 0.77.1 → 0.81.0

package/dist/es/es2018/environments.js

@@ -618,23 +618,49 @@ function makeDurable(environment, { durableStore, instrumentation }) {
         }
         return {};
     };
-    const handleSuccessResponse = function (ingestAndBroadcastFunc, _getResponseCacheKeysFunc, existingRecords) {
+    const handleSuccessResponse = function (ingestAndBroadcastFunc, getResponseCacheKeysFunc, existingRecords) {
         validateNotDisposed();
-        ingestStagingStore = new Store();
-        if (existingRecords !== undefined) {
-            ingestStagingStore.records = existingRecords;
-        }
-        const snapshotFromMemoryIngest = ingestAndBroadcastFunc();
-        // now that ingestion is done flush staging store values to L2
-        return publishChangesToDurableStore().then(() => {
-            if (snapshotFromMemoryIngest === undefined) {
-                return undefined;
+        const cacheKeySet = getResponseCacheKeysFunc();
+        const cacheKeys = new Set(keys(cacheKeySet));
+        const keysToRevive = {};
+        cacheKeys.forEach((cacheKey) => {
+            const key = cacheKeySet[cacheKey];
+            if (key.mergeable === true &&
+                (existingRecords === undefined || existingRecords[cacheKey] === undefined)) {
+                keysToRevive[cacheKey] = true;
             }
-            if (snapshotFromMemoryIngest.state !== 'Unfulfilled') {
-                return snapshotFromMemoryIngest;
-            }
-            // if snapshot from staging store lookup is unfulfilled then do an L2 lookup
-            return reviveSnapshot(environment, durableStore, snapshotFromMemoryIngest, durableStoreErrorHandler, () => environment.storeLookup(snapshotFromMemoryIngest.select, environment.createSnapshot, snapshotFromMemoryIngest.refresh));
+        });
+        const ingestAndPublish = (revivedRecords) => {
+            const toPrime = existingRecords !== undefined
+                ? { ...revivedRecords, ...existingRecords }
+                : revivedRecords;
+            ingestStagingStore = new Store();
+            ingestStagingStore.records = toPrime;
+            const snapshotFromMemoryIngest = ingestAndBroadcastFunc();
+            return publishChangesToDurableStore().then(() => {
+                if (snapshotFromMemoryIngest === undefined) {
+                    return undefined;
+                }
+                if (snapshotFromMemoryIngest.state !== 'Unfulfilled') {
+                    return snapshotFromMemoryIngest;
+                }
+                // if snapshot from staging store lookup is unfulfilled then do an L2 lookup
+                return reviveSnapshot(environment, durableStore, snapshotFromMemoryIngest, durableStoreErrorHandler, () => environment.storeLookup(snapshotFromMemoryIngest.select, environment.createSnapshot, snapshotFromMemoryIngest.refresh));
+            });
+        };
+        if (keys(keysToRevive).length === 0) {
+            return ingestAndPublish({});
+        }
+        return durableStore
+            .getEntries(keys(keysToRevive), DefaultDurableSegment)
+            .then((entries) => {
+            const existingL2Records = create(null);
+            publishDurableStoreEntries(entries, (key, record) => {
+                existingL2Records[key] = record;
+            }, 
+            // we don't need to prime metadata
+            () => { });
+            return ingestAndPublish(existingL2Records);
         });
     };
     const handleErrorResponse = function (ingestAndBroadcastFunc) {

package/dist/umd/es2018/environments.js

@@ -622,23 +622,49 @@
             }
             return {};
         };
-        const handleSuccessResponse = function (ingestAndBroadcastFunc, _getResponseCacheKeysFunc, existingRecords) {
+        const handleSuccessResponse = function (ingestAndBroadcastFunc, getResponseCacheKeysFunc, existingRecords) {
             validateNotDisposed();
-            ingestStagingStore = new engine.Store();
-            if (existingRecords !== undefined) {
-                ingestStagingStore.records = existingRecords;
-            }
-            const snapshotFromMemoryIngest = ingestAndBroadcastFunc();
-            // now that ingestion is done flush staging store values to L2
-            return publishChangesToDurableStore().then(() => {
-                if (snapshotFromMemoryIngest === undefined) {
-                    return undefined;
+            const cacheKeySet = getResponseCacheKeysFunc();
+            const cacheKeys = new Set(keys(cacheKeySet));
+            const keysToRevive = {};
+            cacheKeys.forEach((cacheKey) => {
+                const key = cacheKeySet[cacheKey];
+                if (key.mergeable === true &&
+                    (existingRecords === undefined || existingRecords[cacheKey] === undefined)) {
+                    keysToRevive[cacheKey] = true;
                 }
-                if (snapshotFromMemoryIngest.state !== 'Unfulfilled') {
-                    return snapshotFromMemoryIngest;
-                }
-                // if snapshot from staging store lookup is unfulfilled then do an L2 lookup
-                return reviveSnapshot(environment, durableStore, snapshotFromMemoryIngest, durableStoreErrorHandler, () => environment.storeLookup(snapshotFromMemoryIngest.select, environment.createSnapshot, snapshotFromMemoryIngest.refresh));
+            });
+            const ingestAndPublish = (revivedRecords) => {
+                const toPrime = existingRecords !== undefined
+                    ? { ...revivedRecords, ...existingRecords }
+                    : revivedRecords;
+                ingestStagingStore = new engine.Store();
+                ingestStagingStore.records = toPrime;
+                const snapshotFromMemoryIngest = ingestAndBroadcastFunc();
+                return publishChangesToDurableStore().then(() => {
+                    if (snapshotFromMemoryIngest === undefined) {
+                        return undefined;
+                    }
+                    if (snapshotFromMemoryIngest.state !== 'Unfulfilled') {
+                        return snapshotFromMemoryIngest;
+                    }
+                    // if snapshot from staging store lookup is unfulfilled then do an L2 lookup
+                    return reviveSnapshot(environment, durableStore, snapshotFromMemoryIngest, durableStoreErrorHandler, () => environment.storeLookup(snapshotFromMemoryIngest.select, environment.createSnapshot, snapshotFromMemoryIngest.refresh));
+                });
+            };
+            if (keys(keysToRevive).length === 0) {
+                return ingestAndPublish({});
+            }
+            return durableStore
+                .getEntries(keys(keysToRevive), DefaultDurableSegment)
+                .then((entries) => {
+                const existingL2Records = create(null);
+                publishDurableStoreEntries(entries, (key, record) => {
+                    existingL2Records[key] = record;
+                }, 
+                // we don't need to prime metadata
+                () => { });
+                return ingestAndPublish(existingL2Records);
             });
         };
         const handleErrorResponse = function (ingestAndBroadcastFunc) {

package/dist/umd/es5/environments.js

@@ -665,25 +665,50 @@
             }
             return {};
         };
-        var handleSuccessResponse = function (ingestAndBroadcastFunc, _getResponseCacheKeysFunc, existingRecords) {
+        var handleSuccessResponse = function (ingestAndBroadcastFunc, getResponseCacheKeysFunc, existingRecords) {
             validateNotDisposed();
-            ingestStagingStore = new engine.Store();
-            if (existingRecords !== undefined) {
-                ingestStagingStore.records = existingRecords;
-            }
-            var snapshotFromMemoryIngest = ingestAndBroadcastFunc();
-            // now that ingestion is done flush staging store values to L2
-            return publishChangesToDurableStore().then(function () {
-                if (snapshotFromMemoryIngest === undefined) {
-                    return undefined;
+            var cacheKeySet = getResponseCacheKeysFunc();
+            var cacheKeys = new Set(keys(cacheKeySet));
+            var keysToRevive = {};
+            cacheKeys.forEach(function (cacheKey) {
+                var key = cacheKeySet[cacheKey];
+                if (key.mergeable === true &&
+                    (existingRecords === undefined || existingRecords[cacheKey] === undefined)) {
+                    keysToRevive[cacheKey] = true;
                 }
-                if (snapshotFromMemoryIngest.state !== 'Unfulfilled') {
-                    return snapshotFromMemoryIngest;
-                }
-                // if snapshot from staging store lookup is unfulfilled then do an L2 lookup
-                return reviveSnapshot(environment, durableStore, snapshotFromMemoryIngest, durableStoreErrorHandler, function () {
-                    return environment.storeLookup(snapshotFromMemoryIngest.select, environment.createSnapshot, snapshotFromMemoryIngest.refresh);
+            });
+            var ingestAndPublish = function (revivedRecords) {
+                var toPrime = existingRecords !== undefined
+                    ? __assign(__assign({}, revivedRecords), existingRecords) : revivedRecords;
+                ingestStagingStore = new engine.Store();
+                ingestStagingStore.records = toPrime;
+                var snapshotFromMemoryIngest = ingestAndBroadcastFunc();
+                return publishChangesToDurableStore().then(function () {
+                    if (snapshotFromMemoryIngest === undefined) {
+                        return undefined;
+                    }
+                    if (snapshotFromMemoryIngest.state !== 'Unfulfilled') {
+                        return snapshotFromMemoryIngest;
+                    }
+                    // if snapshot from staging store lookup is unfulfilled then do an L2 lookup
+                    return reviveSnapshot(environment, durableStore, snapshotFromMemoryIngest, durableStoreErrorHandler, function () {
+                        return environment.storeLookup(snapshotFromMemoryIngest.select, environment.createSnapshot, snapshotFromMemoryIngest.refresh);
+                    });
                 });
+            };
+            if (keys(keysToRevive).length === 0) {
+                return ingestAndPublish({});
+            }
+            return durableStore
+                .getEntries(keys(keysToRevive), DefaultDurableSegment)
+                .then(function (entries) {
+                var existingL2Records = create(null);
+                publishDurableStoreEntries(entries, function (key, record) {
+                    existingL2Records[key] = record;
+                }, 
+                // we don't need to prime metadata
+                function () { });
+                return ingestAndPublish(existingL2Records);
             });
         };
         var handleErrorResponse = function (ingestAndBroadcastFunc) {

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@luvio/environments",
-    "version": "0.77.1",
+    "version": "0.81.0",
     "description": "Luvio Environments",
     "main": "dist/umd/es2018/environments.js",
     "module": "dist/es/es2018/environments.js",
@@ -27,7 +27,7 @@
         "dist/"
     ],
     "dependencies": {
-        "@luvio/engine": "0.77.1"
+        "@luvio/engine": "0.81.0"
     },
     "bundlesize": [
         {