@luvio/adapter-test-library 0.63.1 → 0.65.0

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

@@ -1,11 +1,11 @@
 import { DurableStore, DurableStoreEntries, OnDurableStoreChangedListener, DurableStoreOperation, DurableStoreChange } from '@luvio/environments';
+import { DurableStorePersistence } from './durableStorePersistence';
 export declare class MockDurableStore implements DurableStore {
     listeners: Set<OnDurableStoreChangedListener>;
-    segments: {
-        [id: string]: DurableStoreEntries<unknown>;
-    };
+    persistence: DurableStorePersistence;
+    constructor(persistence?: DurableStorePersistence);
     getEntries<T>(entryIds: string[], segment: string): Promise<DurableStoreEntries<T> | undefined>;
-    getAllEntries<T>(segment: string): Promise<DurableStoreEntries<T> | undefined>;
+    getAllEntries<T>(segment: string): Promise<DurableStoreEntries<T>>;
     setEntries<T>(entries: DurableStoreEntries<T>, segment: string): Promise<void>;
     evictEntries(ids: string[], segment: string): Promise<void>;
     registerOnChangedListener(listener: OnDurableStoreChangedListener): () => Promise<void>;

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

@@ -0,0 +1,11 @@
+export interface DurableStorePersistence {
+    get<T>(key: string): Promise<T | undefined>;
+    set<T>(key: string, value: T): Promise<void>;
+    delete(key: string): Promise<void>;
+}
+export declare class MemoryDurableStorePersistence implements DurableStorePersistence {
+    private store;
+    get<T>(key: string): Promise<T | undefined>;
+    set<T>(key: string, value: T): Promise<void>;
+    delete(key: string): Promise<void>;
+}

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

@@ -3,3 +3,4 @@ export { verifyImmutable, isImmutable } from './verification';
 export { getMockLuvioWithFulfilledSnapshot, getMockFulfilledSnapshot } from './mocks';
 export { stripProperties } from './utils';
 export { MockDurableStore } from './durableStore';
+export { MemoryDurableStorePersistence, DurableStorePersistence } from './durableStorePersistence';

package/dist/es/es2018/test-library.js

@@ -277,35 +277,51 @@ function getMockFulfilledSnapshot() {
     return mockFulfilledSnapshot;
 }
 
-class MockDurableStore {
+class MemoryDurableStorePersistence {
     constructor() {
+        this.store = {};
+    }
+    async get(key) {
+        return this.store[key];
+    }
+    async set(key, value) {
+        this.store[key] = value;
+    }
+    async delete(key) {
+        delete this.store[key];
+    }
+}
+
+class MockDurableStore {
+    constructor(persistence) {
+        // NOTE: This mock class doesn't enforce read/write synchronization
         this.listeners = new Set();
-        this.segments = {};
+        this.persistence = persistence || new MemoryDurableStorePersistence();
     }
     getEntries(entryIds, segment) {
         const returnSource = Object.create(null);
-        const entries = this.segments[segment];
-        if (entries === undefined) {
-            return Promise.resolve(undefined);
-        }
-        for (const entryId of entryIds) {
-            const entry = entries[entryId];
-            if (entry !== undefined) {
-                returnSource[entryId] = clone(entry);
+        return this.persistence.get(segment).then((entries) => {
+            if (entries === undefined) {
+                return undefined;
             }
-        }
-        return Promise.resolve(returnSource);
+            for (const entryId of entryIds) {
+                const entry = entries[entryId];
+                if (entry !== undefined) {
+                    returnSource[entryId] = clone(entry);
+                }
+            }
+            return returnSource;
+        });
     }
     getAllEntries(segment) {
         const returnSource = Object.create(null);
-        let entries = this.segments[segment];
-        if (entries === undefined) {
-            entries = {};
-        }
-        for (const key of Object.keys(entries)) {
-            returnSource[key] = clone(entries[key]);
-        }
-        return Promise.resolve(returnSource);
+        return this.persistence.get(segment).then((rawEntries) => {
+            const entries = rawEntries === undefined ? {} : rawEntries;
+            for (const key of Object.keys(entries)) {
+                returnSource[key] = clone(entries[key]);
+            }
+            return returnSource;
+        });
     }
     setEntries(entries, segment) {
         return this.batchOperations([
@@ -324,41 +340,36 @@ class MockDurableStore {
             return Promise.resolve();
         };
     }
-    batchOperations(operations) {
-        const allPromises = operations.map((operation) => {
-            return this.performOperation(operation);
-        });
-        return Promise.all(allPromises).then((changes) => {
-            // IMPORTANT - listeners are called after `.then` so it's on the next
-            // tick
-            this.listeners.forEach((listener) => {
-                listener(changes);
-            });
+    async batchOperations(operations) {
+        const changes = [];
+        for (let i = 0; i < operations.length; i++) {
+            changes.push(await this.performOperation(operations[i]));
+        }
+        this.listeners.forEach((listener) => {
+            listener(changes);
         });
     }
-    performOperation(operation) {
+    async performOperation(operation) {
         const segment = operation.segment;
-        let existingEntries = this.segments[segment];
-        if (existingEntries === undefined) {
-            existingEntries = {};
-        }
-        let ids;
+        const rawEntries = await this.persistence.get(segment);
+        const entries = rawEntries === undefined ? {} : rawEntries;
+        let ids = [];
         switch (operation.type) {
             case DurableStoreOperationType.SetEntries:
                 ids = Object.keys(operation.entries);
                 ids.forEach((id) => {
-                    existingEntries[id] = clone(operation.entries[id]);
+                    entries[id] = clone(operation.entries[id]);
                 });
                 break;
             case DurableStoreOperationType.EvictEntries:
                 ids = operation.ids;
                 ids.forEach((id) => {
-                    delete existingEntries[id];
+                    delete entries[id];
                 });
         }
-        this.segments[operation.segment] = existingEntries;
-        return Promise.resolve({ ids, segment, type: operation.type });
+        await this.persistence.set(operation.segment, entries);
+        return { ids, segment, type: operation.type };
     }
 }
 
-export { ConnectivityState, MockDurableStore, buildErrorMockPayload, buildFetchResponse, buildMockNetworkAdapter, buildSuccessMockPayload, getMockFulfilledSnapshot, getMockLuvioWithFulfilledSnapshot, getMockNetworkAdapterCallCount, isImmutable, overrideMockNetworkResponses, resetMockNetworkAdapter, setMockNetworkPayloads, setNetworkConnectivity, stripProperties, verifyImmutable };
+export { ConnectivityState, MemoryDurableStorePersistence, MockDurableStore, buildErrorMockPayload, buildFetchResponse, buildMockNetworkAdapter, buildSuccessMockPayload, getMockFulfilledSnapshot, getMockLuvioWithFulfilledSnapshot, getMockNetworkAdapterCallCount, isImmutable, overrideMockNetworkResponses, resetMockNetworkAdapter, setMockNetworkPayloads, setNetworkConnectivity, stripProperties, verifyImmutable };

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

@@ -1,11 +1,11 @@
 import { DurableStore, DurableStoreEntries, OnDurableStoreChangedListener, DurableStoreOperation, DurableStoreChange } from '@luvio/environments';
+import { DurableStorePersistence } from './durableStorePersistence';
 export declare class MockDurableStore implements DurableStore {
     listeners: Set<OnDurableStoreChangedListener>;
-    segments: {
-        [id: string]: DurableStoreEntries<unknown>;
-    };
+    persistence: DurableStorePersistence;
+    constructor(persistence?: DurableStorePersistence);
     getEntries<T>(entryIds: string[], segment: string): Promise<DurableStoreEntries<T> | undefined>;
-    getAllEntries<T>(segment: string): Promise<DurableStoreEntries<T> | undefined>;
+    getAllEntries<T>(segment: string): Promise<DurableStoreEntries<T>>;
     setEntries<T>(entries: DurableStoreEntries<T>, segment: string): Promise<void>;
     evictEntries(ids: string[], segment: string): Promise<void>;
     registerOnChangedListener(listener: OnDurableStoreChangedListener): () => Promise<void>;

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

@@ -0,0 +1,11 @@
+export interface DurableStorePersistence {
+    get<T>(key: string): Promise<T | undefined>;
+    set<T>(key: string, value: T): Promise<void>;
+    delete(key: string): Promise<void>;
+}
+export declare class MemoryDurableStorePersistence implements DurableStorePersistence {
+    private store;
+    get<T>(key: string): Promise<T | undefined>;
+    set<T>(key: string, value: T): Promise<void>;
+    delete(key: string): Promise<void>;
+}

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

@@ -3,3 +3,4 @@ export { verifyImmutable, isImmutable } from './verification';
 export { getMockLuvioWithFulfilledSnapshot, getMockFulfilledSnapshot } from './mocks';
 export { stripProperties } from './utils';
 export { MockDurableStore } from './durableStore';
+export { MemoryDurableStorePersistence, DurableStorePersistence } from './durableStorePersistence';

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

@@ -284,35 +284,51 @@
         return mockFulfilledSnapshot;
     }
 
-    class MockDurableStore {
+    class MemoryDurableStorePersistence {
         constructor() {
+            this.store = {};
+        }
+        async get(key) {
+            return this.store[key];
+        }
+        async set(key, value) {
+            this.store[key] = value;
+        }
+        async delete(key) {
+            delete this.store[key];
+        }
+    }
+
+    class MockDurableStore {
+        constructor(persistence) {
+            // NOTE: This mock class doesn't enforce read/write synchronization
             this.listeners = new Set();
-            this.segments = {};
+            this.persistence = persistence || new MemoryDurableStorePersistence();
         }
         getEntries(entryIds, segment) {
             const returnSource = Object.create(null);
-            const entries = this.segments[segment];
-            if (entries === undefined) {
-                return Promise.resolve(undefined);
-            }
-            for (const entryId of entryIds) {
-                const entry = entries[entryId];
-                if (entry !== undefined) {
-                    returnSource[entryId] = clone(entry);
+            return this.persistence.get(segment).then((entries) => {
+                if (entries === undefined) {
+                    return undefined;
                 }
-            }
-            return Promise.resolve(returnSource);
+                for (const entryId of entryIds) {
+                    const entry = entries[entryId];
+                    if (entry !== undefined) {
+                        returnSource[entryId] = clone(entry);
+                    }
+                }
+                return returnSource;
+            });
         }
         getAllEntries(segment) {
             const returnSource = Object.create(null);
-            let entries = this.segments[segment];
-            if (entries === undefined) {
-                entries = {};
-            }
-            for (const key of Object.keys(entries)) {
-                returnSource[key] = clone(entries[key]);
-            }
-            return Promise.resolve(returnSource);
+            return this.persistence.get(segment).then((rawEntries) => {
+                const entries = rawEntries === undefined ? {} : rawEntries;
+                for (const key of Object.keys(entries)) {
+                    returnSource[key] = clone(entries[key]);
+                }
+                return returnSource;
+            });
         }
         setEntries(entries, segment) {
             return this.batchOperations([
@@ -331,43 +347,39 @@
                 return Promise.resolve();
             };
         }
-        batchOperations(operations) {
-            const allPromises = operations.map((operation) => {
-                return this.performOperation(operation);
-            });
-            return Promise.all(allPromises).then((changes) => {
-                // IMPORTANT - listeners are called after `.then` so it's on the next
-                // tick
-                this.listeners.forEach((listener) => {
-                    listener(changes);
-                });
+        async batchOperations(operations) {
+            const changes = [];
+            for (let i = 0; i < operations.length; i++) {
+                changes.push(await this.performOperation(operations[i]));
+            }
+            this.listeners.forEach((listener) => {
+                listener(changes);
             });
         }
-        performOperation(operation) {
+        async performOperation(operation) {
             const segment = operation.segment;
-            let existingEntries = this.segments[segment];
-            if (existingEntries === undefined) {
-                existingEntries = {};
-            }
-            let ids;
+            const rawEntries = await this.persistence.get(segment);
+            const entries = rawEntries === undefined ? {} : rawEntries;
+            let ids = [];
             switch (operation.type) {
                 case environments.DurableStoreOperationType.SetEntries:
                     ids = Object.keys(operation.entries);
                     ids.forEach((id) => {
-                        existingEntries[id] = clone(operation.entries[id]);
+                        entries[id] = clone(operation.entries[id]);
                     });
                     break;
                 case environments.DurableStoreOperationType.EvictEntries:
                     ids = operation.ids;
                     ids.forEach((id) => {
-                        delete existingEntries[id];
+                        delete entries[id];
                     });
             }
-            this.segments[operation.segment] = existingEntries;
-            return Promise.resolve({ ids, segment, type: operation.type });
+            await this.persistence.set(operation.segment, entries);
+            return { ids, segment, type: operation.type };
         }
     }
 
+    exports.MemoryDurableStorePersistence = MemoryDurableStorePersistence;
     exports.MockDurableStore = MockDurableStore;
     exports.buildErrorMockPayload = buildErrorMockPayload;
     exports.buildFetchResponse = buildFetchResponse;

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

@@ -1,11 +1,11 @@
 import { DurableStore, DurableStoreEntries, OnDurableStoreChangedListener, DurableStoreOperation, DurableStoreChange } from '@luvio/environments';
+import { DurableStorePersistence } from './durableStorePersistence';
 export declare class MockDurableStore implements DurableStore {
     listeners: Set<OnDurableStoreChangedListener>;
-    segments: {
-        [id: string]: DurableStoreEntries<unknown>;
-    };
+    persistence: DurableStorePersistence;
+    constructor(persistence?: DurableStorePersistence);
     getEntries<T>(entryIds: string[], segment: string): Promise<DurableStoreEntries<T> | undefined>;
-    getAllEntries<T>(segment: string): Promise<DurableStoreEntries<T> | undefined>;
+    getAllEntries<T>(segment: string): Promise<DurableStoreEntries<T>>;
     setEntries<T>(entries: DurableStoreEntries<T>, segment: string): Promise<void>;
     evictEntries(ids: string[], segment: string): Promise<void>;
     registerOnChangedListener(listener: OnDurableStoreChangedListener): () => Promise<void>;

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

@@ -0,0 +1,11 @@
+export interface DurableStorePersistence {
+    get<T>(key: string): Promise<T | undefined>;
+    set<T>(key: string, value: T): Promise<void>;
+    delete(key: string): Promise<void>;
+}
+export declare class MemoryDurableStorePersistence implements DurableStorePersistence {
+    private store;
+    get<T>(key: string): Promise<T | undefined>;
+    set<T>(key: string, value: T): Promise<void>;
+    delete(key: string): Promise<void>;
+}

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

@@ -3,3 +3,4 @@ export { verifyImmutable, isImmutable } from './verification';
 export { getMockLuvioWithFulfilledSnapshot, getMockFulfilledSnapshot } from './mocks';
 export { stripProperties } from './utils';
 export { MockDurableStore } from './durableStore';
+export { MemoryDurableStorePersistence, DurableStorePersistence } from './durableStorePersistence';

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

@@ -233,10 +233,10 @@
                     throw new Error('IE11 does not throw when mutating a frozen object');
                 }
             }) === false) {
-                throw new Error("Unexpected mutable property found at " + path + ": Array is extensible!");
+                throw new Error("Unexpected mutable property found at ".concat(path, ": Array is extensible!"));
             }
             value.forEach(function (item, index) {
-                verifyImmutable(item, path + "." + index);
+                verifyImmutable(item, "".concat(path, ".").concat(index));
             });
             return;
         }
@@ -246,7 +246,7 @@
                 throw new Error('IE11 does not throw when mutating a frozen object');
             }
         }) === false) {
-            throw new Error("Unexpected mutable property found at " + path + ": Object is extensible!");
+            throw new Error("Unexpected mutable property found at ".concat(path, ": Object is extensible!"));
         }
         Object.keys(value).forEach(function (key) {
             if (doesThrow(function () {
@@ -256,9 +256,9 @@
                     throw new Error('IE11 does not throw when mutating a frozen object');
                 }
             }) === false) {
-                throw new Error("Unexpected mutable property found at " + path + ": \"" + path + "." + key + "\" is mutable!");
+                throw new Error("Unexpected mutable property found at ".concat(path, ": \"").concat(path, ".").concat(key, "\" is mutable!"));
             }
-            verifyImmutable(value[key], path + "." + key);
+            verifyImmutable(value[key], "".concat(path, ".").concat(key));
         });
     }
 
@@ -289,37 +289,121 @@
         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 = {};
+        }
+        MemoryDurableStorePersistence.prototype.get = function (key) {
+            return __awaiter(this, void 0, void 0, function () {
+                return __generator(this, function (_a) {
+                    return [2 /*return*/, this.store[key]];
+                });
+            });
+        };
+        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*/];
+                });
+            });
+        };
+        MemoryDurableStorePersistence.prototype.delete = function (key) {
+            return __awaiter(this, void 0, void 0, function () {
+                return __generator(this, function (_a) {
+                    delete this.store[key];
+                    return [2 /*return*/];
+                });
+            });
+        };
+        return MemoryDurableStorePersistence;
+    }());
+
     var MockDurableStore = /** @class */ (function () {
-        function MockDurableStore() {
+        function MockDurableStore(persistence) {
+            // NOTE: This mock class doesn't enforce read/write synchronization
             this.listeners = new Set();
-            this.segments = {};
+            this.persistence = persistence || new MemoryDurableStorePersistence();
         }
         MockDurableStore.prototype.getEntries = function (entryIds, segment) {
             var returnSource = Object.create(null);
-            var entries = this.segments[segment];
-            if (entries === undefined) {
-                return Promise.resolve(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 this.persistence.get(segment).then(function (entries) {
+                if (entries === undefined) {
+                    return undefined;
                 }
-            }
-            return Promise.resolve(returnSource);
+                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 returnSource;
+            });
         };
         MockDurableStore.prototype.getAllEntries = function (segment) {
             var returnSource = Object.create(null);
-            var entries = this.segments[segment];
-            if (entries === undefined) {
-                entries = {};
-            }
-            for (var _i = 0, _a = Object.keys(entries); _i < _a.length; _i++) {
-                var key = _a[_i];
-                returnSource[key] = clone(entries[key]);
-            }
-            return Promise.resolve(returnSource);
+            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;
+            });
         };
         MockDurableStore.prototype.setEntries = function (entries, segment) {
             return this.batchOperations([
@@ -340,44 +424,70 @@
             };
         };
         MockDurableStore.prototype.batchOperations = function (operations) {
-            var _this = this;
-            var allPromises = operations.map(function (operation) {
-                return _this.performOperation(operation);
-            });
-            return Promise.all(allPromises).then(function (changes) {
-                // IMPORTANT - listeners are called after `.then` so it's on the next
-                // tick
-                _this.listeners.forEach(function (listener) {
-                    listener(changes);
+            return __awaiter(this, void 0, void 0, function () {
+                var changes, i, _a, _b;
+                return __generator(this, function (_c) {
+                    switch (_c.label) {
+                        case 0:
+                            changes = [];
+                            i = 0;
+                            _c.label = 1;
+                        case 1:
+                            if (!(i < operations.length)) return [3 /*break*/, 4];
+                            _b = (_a = changes).push;
+                            return [4 /*yield*/, this.performOperation(operations[i])];
+                        case 2:
+                            _b.apply(_a, [_c.sent()]);
+                            _c.label = 3;
+                        case 3:
+                            i++;
+                            return [3 /*break*/, 1];
+                        case 4:
+                            this.listeners.forEach(function (listener) {
+                                listener(changes);
+                            });
+                            return [2 /*return*/];
+                    }
                 });
             });
         };
         MockDurableStore.prototype.performOperation = function (operation) {
-            var segment = operation.segment;
-            var existingEntries = this.segments[segment];
-            if (existingEntries === undefined) {
-                existingEntries = {};
-            }
-            var ids;
-            switch (operation.type) {
-                case environments.DurableStoreOperationType.SetEntries:
-                    ids = Object.keys(operation.entries);
-                    ids.forEach(function (id) {
-                        existingEntries[id] = clone(operation.entries[id]);
-                    });
-                    break;
-                case environments.DurableStoreOperationType.EvictEntries:
-                    ids = operation.ids;
-                    ids.forEach(function (id) {
-                        delete existingEntries[id];
-                    });
-            }
-            this.segments[operation.segment] = existingEntries;
-            return Promise.resolve({ ids: ids, segment: segment, type: operation.type });
+            return __awaiter(this, void 0, void 0, function () {
+                var segment, rawEntries, entries, ids;
+                return __generator(this, function (_a) {
+                    switch (_a.label) {
+                        case 0:
+                            segment = operation.segment;
+                            return [4 /*yield*/, this.persistence.get(segment)];
+                        case 1:
+                            rawEntries = _a.sent();
+                            entries = rawEntries === undefined ? {} : rawEntries;
+                            ids = [];
+                            switch (operation.type) {
+                                case environments.DurableStoreOperationType.SetEntries:
+                                    ids = Object.keys(operation.entries);
+                                    ids.forEach(function (id) {
+                                        entries[id] = clone(operation.entries[id]);
+                                    });
+                                    break;
+                                case environments.DurableStoreOperationType.EvictEntries:
+                                    ids = operation.ids;
+                                    ids.forEach(function (id) {
+                                        delete entries[id];
+                                    });
+                            }
+                            return [4 /*yield*/, this.persistence.set(operation.segment, entries)];
+                        case 2:
+                            _a.sent();
+                            return [2 /*return*/, { ids: ids, segment: segment, type: operation.type }];
+                    }
+                });
+            });
         };
         return MockDurableStore;
     }());
 
+    exports.MemoryDurableStorePersistence = MemoryDurableStorePersistence;
     exports.MockDurableStore = MockDurableStore;
     exports.buildErrorMockPayload = buildErrorMockPayload;
     exports.buildFetchResponse = buildFetchResponse;

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@luvio/adapter-test-library",
-    "version": "0.63.1",
+    "version": "0.65.0",
     "description": "Test library for luvio adapters",
     "main": "dist/umd/es2018/test-library.js",
     "module": "dist/es/es2018/test-library.js",
@@ -13,8 +13,8 @@
         "test": "jest"
     },
     "devDependencies": {
-        "@luvio/engine": "0.63.1",
-        "@luvio/environments": "0.63.1",
+        "@luvio/engine": "0.65.0",
+        "@luvio/environments": "0.65.0",
         "@types/sinon": "^7.5.2"
     },
     "dependencies": {

package/src/durableStore.ts

@@ -7,40 +7,48 @@ import {
     DurableStoreChange,
 } from '@luvio/environments';
 import { clone } from './utils';
+import { DurableStorePersistence, MemoryDurableStorePersistence } from './durableStorePersistence';
 export class MockDurableStore implements DurableStore {
+    // NOTE: This mock class doesn't enforce read/write synchronization
+
     listeners = new Set<OnDurableStoreChangedListener>();
-    segments: { [id: string]: DurableStoreEntries<unknown> } = {};
+    persistence: DurableStorePersistence;
+
+    constructor(persistence?: DurableStorePersistence) {
+        this.persistence = persistence || new MemoryDurableStorePersistence();
+    }
 
     getEntries<T>(
         entryIds: string[],
         segment: string
     ): Promise<DurableStoreEntries<T> | undefined> {
         const returnSource = Object.create(null);
-        const entries = this.segments[segment];
-
-        if (entries === undefined) {
-            return Promise.resolve(undefined);
-        }
+        return this.persistence.get<DurableStoreEntries<T>>(segment).then((entries) => {
+            if (entries === undefined) {
+                return undefined;
+            }
 
-        for (const entryId of entryIds) {
-            const entry = entries[entryId];
-            if (entry !== undefined) {
-                returnSource[entryId] = clone(entry);
+            for (const entryId of entryIds) {
+                const entry = entries[entryId];
+                if (entry !== undefined) {
+                    returnSource[entryId] = clone(entry);
+                }
             }
-        }
-        return Promise.resolve(returnSource);
+            return returnSource;
+        });
     }
 
-    getAllEntries<T>(segment: string): Promise<DurableStoreEntries<T> | undefined> {
+    getAllEntries<T>(segment: string): Promise<DurableStoreEntries<T>> {
         const returnSource = Object.create(null);
-        let entries = this.segments[segment];
-        if (entries === undefined) {
-            entries = {};
-        }
-        for (const key of Object.keys(entries)) {
-            returnSource[key] = clone(entries[key]);
-        }
-        return Promise.resolve(returnSource);
+
+        return this.persistence.get<DurableStoreEntries<T>>(segment).then((rawEntries) => {
+            const entries = rawEntries === undefined ? {} : rawEntries;
+
+            for (const key of Object.keys(entries)) {
+                returnSource[key] = clone(entries[key]);
+            }
+            return returnSource;
+        });
     }
 
     setEntries<T>(entries: DurableStoreEntries<T>, segment: string): Promise<void> {
@@ -63,43 +71,37 @@ export class MockDurableStore implements DurableStore {
         };
     }
 
-    batchOperations<T>(operations: DurableStoreOperation<T>[]): Promise<void> {
-        const allPromises = operations.map((operation) => {
-            return this.performOperation(operation);
-        });
+    async batchOperations<T>(operations: DurableStoreOperation<T>[]): Promise<void> {
+        const changes: DurableStoreChange[] = [];
+        for (let i = 0; i < operations.length; i++) {
+            changes.push(await this.performOperation(operations[i]));
+        }
 
-        return Promise.all(allPromises).then((changes) => {
-            // IMPORTANT - listeners are called after `.then` so it's on the next
-            // tick
-            this.listeners.forEach((listener) => {
-                listener(changes);
-            });
+        this.listeners.forEach((listener) => {
+            listener(changes);
         });
     }
 
-    performOperation<T>(operation: DurableStoreOperation<T>): Promise<DurableStoreChange> {
+    async performOperation<T>(operation: DurableStoreOperation<T>): Promise<DurableStoreChange> {
         const segment = operation.segment;
-        let existingEntries = this.segments[segment];
-        if (existingEntries === undefined) {
-            existingEntries = {};
-        }
-
-        let ids: string[];
+        const rawEntries = await this.persistence.get<DurableStoreEntries<T>>(segment);
+        const entries = rawEntries === undefined ? {} : rawEntries;
+        let ids: string[] = [];
         switch (operation.type) {
             case DurableStoreOperationType.SetEntries:
                 ids = Object.keys(operation.entries);
                 ids.forEach((id) => {
-                    existingEntries[id] = clone(operation.entries[id]);
+                    entries[id] = clone(operation.entries[id]);
                 });
                 break;
             case DurableStoreOperationType.EvictEntries:
                 ids = operation.ids;
                 ids.forEach((id) => {
-                    delete existingEntries[id];
+                    delete entries[id];
                 });
         }
 
-        this.segments[operation.segment] = existingEntries;
-        return Promise.resolve({ ids, segment, type: operation.type });
+        await this.persistence.set(operation.segment, entries);
+        return { ids, segment, type: operation.type };
     }
 }

package/src/durableStorePersistence.ts

@@ -0,0 +1,21 @@
+export interface DurableStorePersistence {
+    get<T>(key: string): Promise<T | undefined>;
+    set<T>(key: string, value: T): Promise<void>;
+    delete(key: string): Promise<void>;
+}
+
+export class MemoryDurableStorePersistence implements DurableStorePersistence {
+    private store: Record<string, any> = {};
+
+    async get<T>(key: string): Promise<T | undefined> {
+        return this.store[key];
+    }
+
+    async set<T>(key: string, value: T): Promise<void> {
+        this.store[key] = value;
+    }
+
+    async delete(key: string): Promise<void> {
+        delete this.store[key];
+    }
+}

package/src/main.ts

@@ -15,3 +15,4 @@ export { verifyImmutable, isImmutable } from './verification';
 export { getMockLuvioWithFulfilledSnapshot, getMockFulfilledSnapshot } from './mocks';
 export { stripProperties } from './utils';
 export { MockDurableStore } from './durableStore';
+export { MemoryDurableStorePersistence, DurableStorePersistence } from './durableStorePersistence';