@luvio/adapter-test-library 0.105.0 → 0.108.0

package/dist/umd/es5/test-library.js

@@ -1,13 +1,66 @@
 (function (global, factory) {
-    typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports, require('sinon'), require('@luvio/environments')) :
-    typeof define === 'function' && define.amd ? define(['exports', 'sinon', '@luvio/environments'], factory) :
-    (global = typeof globalThis !== 'undefined' ? globalThis : global || self, factory(global.luvioAdapterTestLibrary = {}, global.sinon, global.environments));
-})(this, (function (exports, sinon, environments) { 'use strict';
+    typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports, require('sinon')) :
+    typeof define === 'function' && define.amd ? define(['exports', 'sinon'], factory) :
+    (global = typeof globalThis !== 'undefined' ? globalThis : global || self, factory(global.luvioAdapterTestLibrary = {}, global.sinon));
+})(this, (function (exports, sinon) { 'use strict';
 
     function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'default' in e ? e : { 'default': e }; }
 
     var sinon__default = /*#__PURE__*/_interopDefaultLegacy(sinon);
 
+    /*! *****************************************************************************
+    Copyright (c) Microsoft Corporation.
+
+    Permission to use, copy, modify, and/or distribute this software for any
+    purpose with or without fee is hereby granted.
+
+    THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH
+    REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
+    AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,
+    INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
+    LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR
+    OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
+    PERFORMANCE OF THIS SOFTWARE.
+    ***************************************************************************** */
+
+    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 };
+        }
+    }
+
     /**
      * Clone an object
      *
@@ -56,6 +109,9 @@
             return true;
         }
         return false;
+    }
+    function flushPromises() {
+        return new Promise(function (resolve) { return setTimeout(resolve, 0); });
     }
 
     var networkConnectivityStateMap = new WeakMap();
@@ -101,6 +157,31 @@
     function isOkResponse(status) {
         return status >= 200 && status <= 299;
     }
+    /**
+     * Flushes any pending network requests.  Useful for tests that need to ensure all
+     * un-awaited background refreshes are complete
+     *
+     * @param _mockNetworkAdapter {NetworkAdapter} The network adapter instance to flush
+     */
+    function flushPendingNetworkRequests(_mockNetworkAdapter) {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: 
+                    // since the network mock is actually synchronous (just returns things wrapped
+                    // in Promise.resolve/reject) the only thing necessary to flush any pending
+                    // network activity is to flush the pending microtask queue
+                    return [4 /*yield*/, flushPromises()];
+                    case 1:
+                        // since the network mock is actually synchronous (just returns things wrapped
+                        // in Promise.resolve/reject) the only thing necessary to flush any pending
+                        // network activity is to flush the pending microtask queue
+                        _a.sent();
+                        return [2 /*return*/];
+                }
+            });
+        });
+    }
     function buildMockNetworkAdapter(mockPayloads) {
         // any endpoints not setup with a fake will return a rejected promise
         var networkAdapter = sinon__default["default"].stub().rejects(buildMockSetupError());
@@ -285,59 +366,6 @@
         return mockFulfilledSnapshot;
     }
 
-    /*! *****************************************************************************
-    Copyright (c) Microsoft Corporation.
-
-    Permission to use, copy, modify, and/or distribute this software for any
-    purpose with or without fee is hereby granted.
-
-    THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH
-    REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
-    AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,
-    INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
-    LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR
-    OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
-    PERFORMANCE OF THIS SOFTWARE.
-    ***************************************************************************** */
-
-    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 };
-        }
-    }
-
     var MemoryDurableStorePersistence = /** @class */ (function () {
         function MemoryDurableStorePersistence() {
             this.store = {};
@@ -352,8 +380,18 @@
         MemoryDurableStorePersistence.prototype.set = function (key, value) {
             return __awaiter(this, void 0, void 0, function () {
                 return __generator(this, function (_a) {
-                    this.store[key] = value;
-                    return [2 /*return*/];
+                    switch (_a.label) {
+                        case 0: 
+                        // simulate a more realistic durable store by making the write wait a
+                        // tick before actually setting the value
+                        return [4 /*yield*/, flushPromises()];
+                        case 1:
+                            // simulate a more realistic durable store by making the write wait a
+                            // tick before actually setting the value
+                            _a.sent();
+                            this.store[key] = value;
+                            return [2 /*return*/];
+                    }
                 });
             });
         };
@@ -365,51 +403,95 @@
                 });
             });
         };
+        MemoryDurableStorePersistence.prototype.flushPendingWork = function () {
+            return __awaiter(this, void 0, void 0, function () {
+                return __generator(this, function (_a) {
+                    switch (_a.label) {
+                        case 0: 
+                        // since this implementation does actual "IO" synchronously the only
+                        // thing necessary to await any pending IO is to flush the current
+                        // microtask queue
+                        return [4 /*yield*/, flushPromises()];
+                        case 1:
+                            // since this implementation does actual "IO" synchronously the only
+                            // thing necessary to await any pending IO is to flush the current
+                            // microtask queue
+                            _a.sent();
+                            return [2 /*return*/];
+                    }
+                });
+            });
+        };
         return MemoryDurableStorePersistence;
     }());
 
+    function waitForPromiseSet(set) {
+        // NOTE: we are building an array from the Set at this point in time.  If
+        // more Promises are added to the Set while this is awaiting it won't
+        // await the newly-added Promise.  That's what we want.
+        return Promise.all(Array.from(set)).then();
+    }
     var MockDurableStore = /** @class */ (function () {
         function MockDurableStore(persistence) {
-            // NOTE: This mock class doesn't enforce read/write synchronization
+            // for read/write synchronization
+            this.writePromises = new Set();
             this.listeners = new Set();
             this.persistence = persistence || new MemoryDurableStorePersistence();
         }
         MockDurableStore.prototype.getEntries = function (entryIds, segment) {
-            var returnSource = Object.create(null);
-            return this.persistence.get(segment).then(function (entries) {
-                if (entries === undefined) {
-                    return undefined;
-                }
-                for (var _i = 0, entryIds_1 = entryIds; _i < entryIds_1.length; _i++) {
-                    var entryId = entryIds_1[_i];
-                    var entry = entries[entryId];
-                    if (entry !== undefined) {
-                        returnSource[entryId] = clone(entry);
+            return __awaiter(this, void 0, void 0, function () {
+                var entries, returnSource, _i, entryIds_1, entryId, entry;
+                return __generator(this, function (_a) {
+                    switch (_a.label) {
+                        case 0:
+                            if (!(this.writePromises.size > 0)) return [3 /*break*/, 2];
+                            return [4 /*yield*/, waitForPromiseSet(this.writePromises)];
+                        case 1:
+                            _a.sent();
+                            _a.label = 2;
+                        case 2: return [4 /*yield*/, this.persistence.get(segment)];
+                        case 3:
+                            entries = _a.sent();
+                            if (entries === undefined) {
+                                return [2 /*return*/, undefined];
+                            }
+                            returnSource = Object.create(null);
+                            for (_i = 0, entryIds_1 = entryIds; _i < entryIds_1.length; _i++) {
+                                entryId = entryIds_1[_i];
+                                entry = entries[entryId];
+                                if (entry !== undefined) {
+                                    returnSource[entryId] = clone(entry);
+                                }
+                            }
+                            return [2 /*return*/, returnSource];
                     }
-                }
-                return returnSource;
+                });
             });
         };
         MockDurableStore.prototype.getAllEntries = function (segment) {
-            var returnSource = Object.create(null);
-            return this.persistence.get(segment).then(function (rawEntries) {
-                var entries = rawEntries === undefined ? {} : rawEntries;
-                for (var _i = 0, _a = Object.keys(entries); _i < _a.length; _i++) {
-                    var key = _a[_i];
-                    returnSource[key] = clone(entries[key]);
-                }
-                return returnSource;
+            return __awaiter(this, void 0, void 0, function () {
+                var entries;
+                return __generator(this, function (_a) {
+                    switch (_a.label) {
+                        case 0:
+                            if (!(this.writePromises.size > 0)) return [3 /*break*/, 2];
+                            return [4 /*yield*/, waitForPromiseSet(this.writePromises)];
+                        case 1:
+                            _a.sent();
+                            _a.label = 2;
+                        case 2: return [4 /*yield*/, this.persistence.get(segment)];
+                        case 3:
+                            entries = _a.sent();
+                            return [2 /*return*/, entries];
+                    }
+                });
             });
         };
         MockDurableStore.prototype.setEntries = function (entries, segment) {
-            return this.batchOperations([
-                { entries: entries, segment: segment, type: environments.DurableStoreOperationType.SetEntries },
-            ]);
+            return this.batchOperations([{ entries: entries, segment: segment, type: 'setEntries' }]);
         };
         MockDurableStore.prototype.evictEntries = function (ids, segment) {
-            return this.batchOperations([
-                { ids: ids, segment: segment, type: environments.DurableStoreOperationType.EvictEntries },
-            ]);
+            return this.batchOperations([{ ids: ids, segment: segment, type: 'evictEntries' }]);
         };
         MockDurableStore.prototype.registerOnChangedListener = function (listener) {
             var _this = this;
@@ -421,24 +503,52 @@
         };
         MockDurableStore.prototype.batchOperations = function (operations) {
             return __awaiter(this, void 0, void 0, function () {
-                var changes, i, _a, _b;
-                return __generator(this, function (_c) {
-                    switch (_c.label) {
+                var changes, writePromise;
+                var _this = this;
+                return __generator(this, function (_a) {
+                    switch (_a.label) {
                         case 0:
-                            changes = [];
-                            i = 0;
-                            _c.label = 1;
+                            if (!(this.writePromises.size > 0)) return [3 /*break*/, 2];
+                            return [4 /*yield*/, waitForPromiseSet(this.writePromises)];
                         case 1:
-                            if (!(i < operations.length)) return [3 /*break*/, 4];
-                            _b = (_a = changes).push;
-                            return [4 /*yield*/, this.performOperation(operations[i])];
+                            _a.sent();
+                            _a.label = 2;
                         case 2:
-                            _b.apply(_a, [_c.sent()]);
-                            _c.label = 3;
+                            changes = [];
+                            writePromise = (function () { return __awaiter(_this, void 0, void 0, function () {
+                                var _i, operations_1, operation, _a, _b;
+                                return __generator(this, function (_c) {
+                                    switch (_c.label) {
+                                        case 0:
+                                            _i = 0, operations_1 = operations;
+                                            _c.label = 1;
+                                        case 1:
+                                            if (!(_i < operations_1.length)) return [3 /*break*/, 4];
+                                            operation = operations_1[_i];
+                                            _b = (_a = changes).push;
+                                            return [4 /*yield*/, this.performOperation(operation)];
+                                        case 2:
+                                            _b.apply(_a, [_c.sent()]);
+                                            _c.label = 3;
+                                        case 3:
+                                            _i++;
+                                            return [3 /*break*/, 1];
+                                        case 4: return [2 /*return*/];
+                                    }
+                                });
+                            }); })();
+                            this.writePromises.add(writePromise);
+                            _a.label = 3;
                         case 3:
-                            i++;
-                            return [3 /*break*/, 1];
+                            _a.trys.push([3, , 5, 6]);
+                            return [4 /*yield*/, writePromise];
                         case 4:
+                            _a.sent();
+                            return [3 /*break*/, 6];
+                        case 5:
+                            this.writePromises.delete(writePromise);
+                            return [7 /*endfinally*/];
+                        case 6:
                             this.listeners.forEach(function (listener) {
                                 listener(changes);
                             });
@@ -460,13 +570,13 @@
                             entries = rawEntries === undefined ? {} : rawEntries;
                             ids = [];
                             switch (operation.type) {
-                                case environments.DurableStoreOperationType.SetEntries:
+                                case 'setEntries':
                                     ids = Object.keys(operation.entries);
                                     ids.forEach(function (id) {
                                         entries[id] = clone(operation.entries[id]);
                                     });
                                     break;
-                                case environments.DurableStoreOperationType.EvictEntries:
+                                case 'evictEntries':
                                     ids = operation.ids;
                                     ids.forEach(function (id) {
                                         delete entries[id];
@@ -480,6 +590,28 @@
                 });
             });
         };
+        MockDurableStore.prototype.flushPendingOperations = function () {
+            return __awaiter(this, void 0, void 0, function () {
+                return __generator(this, function (_a) {
+                    switch (_a.label) {
+                        case 0: 
+                        // flush any pending read operations
+                        return [4 /*yield*/, this.persistence.flushPendingWork()];
+                        case 1:
+                            // flush any pending read operations
+                            _a.sent();
+                            _a.label = 2;
+                        case 2:
+                            if (!(this.writePromises.size > 0)) return [3 /*break*/, 4];
+                            return [4 /*yield*/, waitForPromiseSet(this.writePromises)];
+                        case 3:
+                            _a.sent();
+                            return [3 /*break*/, 2];
+                        case 4: return [2 /*return*/];
+                    }
+                });
+            });
+        };
         return MockDurableStore;
     }());
 
@@ -489,6 +621,7 @@
     exports.buildFetchResponse = buildFetchResponse;
     exports.buildMockNetworkAdapter = buildMockNetworkAdapter;
     exports.buildSuccessMockPayload = buildSuccessMockPayload;
+    exports.flushPendingNetworkRequests = flushPendingNetworkRequests;
     exports.getMockFulfilledSnapshot = getMockFulfilledSnapshot;
     exports.getMockLuvioWithFulfilledSnapshot = getMockLuvioWithFulfilledSnapshot;
     exports.getMockNetworkAdapterCallCount = getMockNetworkAdapterCallCount;

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

@@ -19,3 +19,4 @@ export declare function stripProperties(obj: {
     [s: string]: any;
 }, props: string[]): any;
 export declare function doesThrow(predicate: () => void): boolean;
+export declare function flushPromises(): Promise<unknown>;

package/jest.config.js

@@ -0,0 +1,16 @@
+const baseConfig = require('../../../scripts/jest/base.config');
+
+module.exports = {
+    ...baseConfig,
+
+    displayName: '@luvio/adapter-test-library',
+
+    roots: ['<rootDir>/src'],
+    coverageThreshold: {
+        global: {
+            branches: 0,
+            functions: 0,
+            lines: 0,
+        },
+    },
+};

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@luvio/adapter-test-library",
-    "version": "0.105.0",
+    "version": "0.108.0",
     "description": "Test library for luvio adapters",
     "repository": {
         "type": "git",
@@ -18,11 +18,11 @@
         "watch": "yarn build --watch"
     },
     "dependencies": {
-        "sinon": "^7.5.0"
+        "sinon": "^14.0.0"
     },
     "devDependencies": {
-        "@luvio/engine": "0.105.0",
-        "@luvio/environments": "0.105.0",
+        "@luvio/engine": "0.108.0",
+        "@luvio/environments": "0.108.0",
         "@types/sinon": "^7.5.2"
     },
     "nx": {

package/rollup.config.js

@@ -8,13 +8,16 @@ function rollupConfig(config) {
     const { formats, target } = config;
     return {
         input: entry,
+        external: ['sinon'],
         output: formats.map((format) => {
             return {
                 file: `${dist}/${format}/${target}/test-library.js`,
                 format,
                 name: 'luvioAdapterTestLibrary',
+                globals: { sinon: 'sinon' },
             };
         }),
+
         plugins: [
             typescript({
                 clean: true,

package/src/MockDurableStore.ts

@@ -0,0 +1,142 @@
+import type {
+    DurableStore,
+    DurableStoreEntries,
+    OnDurableStoreChangedListener,
+    DurableStoreOperation,
+    DurableStoreChange,
+} from '@luvio/environments';
+import { clone } from './utils';
+import type { DurableStorePersistence } from './durableStorePersistence';
+import { MemoryDurableStorePersistence } from './durableStorePersistence';
+
+function waitForPromiseSet(set: Set<Promise<unknown>>): Promise<void> {
+    // NOTE: we are building an array from the Set at this point in time.  If
+    // more Promises are added to the Set while this is awaiting it won't
+    // await the newly-added Promise.  That's what we want.
+    return Promise.all(Array.from(set)).then();
+}
+
+export class MockDurableStore implements DurableStore {
+    // for read/write synchronization
+    private writePromises = new Set<Promise<unknown>>();
+
+    listeners = new Set<OnDurableStoreChangedListener>();
+    persistence: DurableStorePersistence;
+
+    constructor(persistence?: DurableStorePersistence) {
+        this.persistence = persistence || new MemoryDurableStorePersistence();
+    }
+
+    async getEntries<T>(
+        entryIds: string[],
+        segment: string
+    ): Promise<DurableStoreEntries<T> | undefined> {
+        // await any current write operations
+        if (this.writePromises.size > 0) {
+            await waitForPromiseSet(this.writePromises);
+        }
+
+        const entries = await this.persistence.get<DurableStoreEntries<T>>(segment);
+
+        if (entries === undefined) {
+            return undefined;
+        }
+
+        const returnSource = Object.create(null);
+        for (const entryId of entryIds) {
+            const entry = entries[entryId];
+            if (entry !== undefined) {
+                returnSource[entryId] = clone(entry);
+            }
+        }
+        return returnSource;
+    }
+
+    async getAllEntries<T>(segment: string): Promise<DurableStoreEntries<T> | undefined> {
+        // await any current write operations
+        if (this.writePromises.size > 0) {
+            await waitForPromiseSet(this.writePromises);
+        }
+
+        const entries = await this.persistence.get<DurableStoreEntries<T>>(segment);
+
+        return entries;
+    }
+
+    setEntries<T>(entries: DurableStoreEntries<T>, segment: string): Promise<void> {
+        return this.batchOperations([{ entries, segment, type: 'setEntries' }]);
+    }
+
+    evictEntries(ids: string[], segment: string): Promise<void> {
+        return this.batchOperations([{ ids, segment, type: 'evictEntries' }]);
+    }
+
+    registerOnChangedListener(listener: OnDurableStoreChangedListener): () => Promise<void> {
+        this.listeners.add(listener);
+        return () => {
+            this.listeners.delete(listener);
+            return Promise.resolve();
+        };
+    }
+
+    async batchOperations<T>(operations: DurableStoreOperation<T>[]): Promise<void> {
+        // await any current write operations
+        if (this.writePromises.size > 0) {
+            await waitForPromiseSet(this.writePromises);
+        }
+
+        const changes: DurableStoreChange[] = [];
+
+        const writePromise = (async () => {
+            for (const operation of operations) {
+                changes.push(await this.performOperation(operation));
+            }
+        })();
+        this.writePromises.add(writePromise);
+
+        try {
+            await writePromise;
+        } finally {
+            this.writePromises.delete(writePromise);
+        }
+
+        this.listeners.forEach((listener) => {
+            listener(changes);
+        });
+    }
+
+    private async performOperation<T>(
+        operation: DurableStoreOperation<T>
+    ): Promise<DurableStoreChange> {
+        const segment = operation.segment;
+        const rawEntries = await this.persistence.get<DurableStoreEntries<T>>(segment);
+        const entries = rawEntries === undefined ? {} : rawEntries;
+        let ids: string[] = [];
+        switch (operation.type) {
+            case 'setEntries':
+                ids = Object.keys(operation.entries);
+                ids.forEach((id) => {
+                    entries[id] = clone(operation.entries[id]);
+                });
+                break;
+            case 'evictEntries':
+                ids = operation.ids;
+                ids.forEach((id) => {
+                    delete entries[id];
+                });
+        }
+
+        await this.persistence.set(operation.segment, entries);
+        return { ids, segment, type: operation.type };
+    }
+
+    async flushPendingOperations(): Promise<void> {
+        // flush any pending read operations
+        await this.persistence.flushPendingWork();
+
+        // wait for any pending writes to finish
+        while (this.writePromises.size > 0) {
+            await waitForPromiseSet(this.writePromises);
+        }
+    }
+}