@peers-app/peers-device 0.0.1

package/dist/device-sync.test.js

@@ -0,0 +1,1618 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const peers_sdk_1 = require("@peers-app/peers-sdk");
+const lodash_1 = require("lodash");
+const zod_1 = require("zod");
+const device_sync_1 = require("./device-sync");
+const local_data_source_1 = require("./local.data-source");
+const tracked_data_source_1 = require("./tracked-data-source");
+jest.setTimeout(240_000);
+describe("peer-device", () => {
+    const allPeers = [];
+    afterEach(async () => {
+        await (0, peers_sdk_1.sleep)(1);
+        await Promise.all(allPeers.map(peer => peer.dispose()));
+    });
+    afterAll(async () => {
+        await Promise.all(allPeers.map(peer => peer.dispose()));
+        await (0, peers_sdk_1.sleep)(200);
+        console.log("List changes count: ", device_sync_1.DeviceSync.listChangesCount);
+        console.log("Apply changes count: ", device_sync_1.DeviceSync.applyChangesCount);
+        console.log("Network info count: ", device_sync_1.DeviceSync.getNetworkInfoCount);
+        console.log("Elections count: ", device_sync_1.DeviceSync.electPreferredConnectionsCount);
+        console.log("Sync with remote device count: ", device_sync_1.DeviceSync.syncWithRemoteDeviceCount);
+        console.log("Total count: ", device_sync_1.DeviceSync.listChangesCount + device_sync_1.DeviceSync.applyChangesCount + device_sync_1.DeviceSync.getNetworkInfoCount + device_sync_1.DeviceSync.electPreferredConnectionsCount);
+    });
+    const notesSchema = zod_1.z.object({
+        noteId: zod_1.z.string(),
+        title: zod_1.z.string(),
+        completed: zod_1.z.boolean().optional(),
+        number: zod_1.z.number().optional(),
+        string: zod_1.z.string().optional(),
+        date: zod_1.z.date().optional(),
+    });
+    const notesTableName = "notes-test";
+    const notesMetaData = {
+        name: notesTableName,
+        description: 'A table for notes',
+        primaryKeyName: 'noteId',
+        fields: (0, peers_sdk_1.schemaToFields)(notesSchema),
+    };
+    function getNotesTable(peer) {
+        return peer.tableContainer.getTable(notesMetaData, notesSchema);
+    }
+    let dbId = 1;
+    function buildPeer(userId = (0, peers_sdk_1.newid)(), deviceId = (0, peers_sdk_1.newid)()) {
+        const db = new local_data_source_1.DBLocal(':memory:');
+        const changeTrackingTable = new peers_sdk_1.ChangeTrackingTable({ db });
+        // Create a mock UserContext and DataContext for testing
+        const mockUserContext = {
+            userId: () => userId,
+            deviceId: () => deviceId,
+            dataSourceFactory: (metaData, schema) => {
+                const sqlDS = new peers_sdk_1.SQLDataSource(db, metaData, schema);
+                if (metaData.localOnly) {
+                    return sqlDS;
+                }
+                const trackedDS = new tracked_data_source_1.TrackedDataSource(sqlDS, changeTrackingTable);
+                return trackedDS;
+            }
+        };
+        const dataContext = new peers_sdk_1.DataContext(mockUserContext);
+        const peer = new device_sync_1.DeviceSync(dataContext, changeTrackingTable);
+        allPeers.push(peer);
+        return peer;
+    }
+    function buildRemotePeer({ userId = (0, peers_sdk_1.newid)(), deviceId = (0, peers_sdk_1.newid)(), errorRate = 0, latencyMs = 0 } = {}) {
+        const peer = buildPeer(userId, deviceId);
+        return {
+            peer,
+            remotePeer: {
+                deviceId: peer.deviceId,
+                userId: peer.userId,
+                role: peer.role,
+                listChanges: async (filter, opts) => {
+                    latencyMs && await (0, peers_sdk_1.sleep)(latencyMs);
+                    if (errorRate && Math.random() < errorRate) {
+                        throw new Error("Simulated error");
+                    }
+                    return peer.listChanges(filter, opts);
+                },
+                getNetworkInfo: async () => {
+                    latencyMs && await (0, peers_sdk_1.sleep)(latencyMs);
+                    if (errorRate && Math.random() < errorRate) {
+                        throw new Error("Simulated error");
+                    }
+                    return peer.getNetworkInfo();
+                },
+                notifyOfChanges: async (deviceId, timestampLastApplied) => {
+                    latencyMs && await (0, peers_sdk_1.sleep)(latencyMs);
+                    if (errorRate && Math.random() < errorRate) {
+                        throw new Error("Simulated error");
+                    }
+                    return peer.notifyOfChanges(deviceId, timestampLastApplied);
+                }
+            }
+        };
+    }
+    it("should have notes tables", async () => {
+        const peer = buildPeer();
+        const peerNotes = getNotesTable(peer);
+        expect(peerNotes).toBeDefined();
+        const note = await peerNotes.save({ noteId: (0, peers_sdk_1.newid)(), title: "Hello, World!" });
+        const notes = await peerNotes.list();
+        expect(notes.length).toBe(1);
+        expect(notes).toEqual([note]);
+    });
+    it("should sync with another peer", async () => {
+        const peer1 = buildPeer();
+        const peer1Notes = getNotesTable(peer1);
+        await peer1Notes.save({ noteId: (0, peers_sdk_1.newid)(), title: "Hello, World!" });
+        let notes1 = await peer1Notes.list();
+        expect(notes1.length).toBe(1);
+        const peer2 = buildPeer();
+        const peer2Notes = getNotesTable(peer2);
+        let notes2 = await peer2Notes.list();
+        expect(notes2.length).toBe(0);
+        await peer2.addConnection(peer1);
+        notes2 = await peer2Notes.list();
+        expect(notes2.length).toBe(1);
+        await peer1.addConnection(peer2);
+        notes1 = await peer1Notes.list();
+        notes2 = await peer2Notes.list();
+        expect(notes1).toEqual(notes2);
+    });
+    it("should handle applyChanges called in sequence with out-of-order changes", async () => {
+        const peer = buildPeer();
+        const peerNotes = getNotesTable(peer);
+        const noteId = (0, peers_sdk_1.newid)();
+        const now = Date.now();
+        const change2 = {
+            changeId: (0, peers_sdk_1.newid)(),
+            tableName: notesTableName,
+            recordId: noteId,
+            timestamp: now - 5000, // 5 seconds before change3
+            timestampApplied: now - 5000,
+            changeType: 'update',
+            oldRecord: { noteId, title: "note inserted" },
+            newRecord: { noteId: noteId, title: "note updated" },
+            jsonDiff: [{ op: 'replace', path: '/title', value: 'note updated' }]
+        };
+        await peer.applyChanges([change2]);
+        let note = await peerNotes.get(noteId);
+        expect(note).toEqual(change2.newRecord);
+        await peer.applyChanges([{
+                changeId: (0, peers_sdk_1.newid)(),
+                tableName: notesTableName,
+                recordId: noteId,
+                timestamp: now - 6000,
+                timestampApplied: now - 6000,
+                changeType: 'update',
+                newRecord: { noteId: noteId, title: "note updated first" },
+                jsonDiff: [{ op: 'replace', path: '/title', value: 'note updated first' }]
+            }]);
+        note = await peerNotes.get(noteId);
+        expect(note).toEqual(change2.newRecord);
+        // Create changes with different timestamps (newer to older)
+        const change3 = {
+            changeId: (0, peers_sdk_1.newid)(),
+            tableName: notesTableName,
+            recordId: noteId,
+            timestamp: now,
+            timestampApplied: now,
+            changeType: 'delete',
+            oldRecord: { noteId, title: "note deleted" }
+        };
+        await peer.applyChanges([change3]);
+        note = await peerNotes.get(noteId);
+        expect(note).toBeUndefined();
+        const change1 = {
+            changeId: (0, peers_sdk_1.newid)(),
+            tableName: notesTableName,
+            recordId: noteId,
+            timestamp: now - 10000, // 10 seconds before change3
+            timestampApplied: now - 10000,
+            changeType: 'insert',
+            newRecord: { noteId: noteId, title: "Note inserted" }
+        };
+        await peer.applyChanges([change1]);
+        note = await peerNotes.get(noteId);
+        expect(note).toBeUndefined();
+    });
+    it("should push changes to connected peers", async () => {
+        // Create two peers
+        const peer1 = buildPeer();
+        const peer2 = buildPeer();
+        // Connect them bidirectionally
+        await peer1.addConnection(peer2);
+        await peer2.addConnection(peer1);
+        // Get notes tables
+        const peer1Notes = getNotesTable(peer1);
+        const peer2Notes = getNotesTable(peer2);
+        // Create a note on peer1
+        const noteId = (0, peers_sdk_1.newid)();
+        const originalNote = { noteId, title: "Original Note" };
+        await peer1Notes.save(originalNote);
+        // Wait a moment for change to propagate
+        await (0, peers_sdk_1.sleep)(100);
+        // Verify the note was pushed to peer2
+        let peer2Note = await peer2Notes.get(noteId);
+        expect(peer2Note).toBeDefined();
+        expect(peer2Note?.title).toBe("Original Note");
+        // Update the note on peer1
+        const updatedNote = { noteId, title: "Updated Note" };
+        await peer1Notes.save(updatedNote);
+        // Wait a moment for change to propagate
+        await (0, peers_sdk_1.sleep)(100);
+        // Verify the update was pushed to peer2
+        peer2Note = await peer2Notes.get(noteId);
+        expect(peer2Note?.title).toBe("Updated Note");
+        // Delete the note on peer1
+        await peer1Notes.delete(noteId);
+        // Wait a moment for change to propagate
+        await (0, peers_sdk_1.sleep)(100);
+        // Verify the deletion was pushed to peer2
+        peer2Note = await peer2Notes.get(noteId);
+        expect(peer2Note).toBeUndefined();
+        // Test changes in the other direction too (peer2 -> peer1)
+        const note2Id = (0, peers_sdk_1.newid)();
+        await peer2Notes.save({ noteId: note2Id, title: "Note from Peer2" });
+        // Wait a moment for change to propagate
+        await (0, peers_sdk_1.sleep)(100);
+        // Verify the note was pushed to peer1
+        const peer1Note2 = await peer1Notes.get(note2Id);
+        expect(peer1Note2).toBeDefined();
+        expect(peer1Note2?.title).toBe("Note from Peer2");
+    });
+    // this is unreliable because it's based on the machine it runs on.  
+    // just use it for verifying performance if changes are made to syncing algorithm
+    it.skip("should only sync changes that were written after the last sync", async () => {
+        // Create two peers
+        const peer1 = buildPeer();
+        const peer2 = buildPeer();
+        // Get notes tables
+        const peer1Notes = getNotesTable(peer1);
+        const peer2Notes = getNotesTable(peer2);
+        // add a whole bunch of notes to both
+        for (let i = 0; i < 3_000; i++) {
+            await peer1Notes.save({ noteId: (0, peers_sdk_1.newid)(), title: `Note ${i}` });
+            await peer2Notes.save({ noteId: (0, peers_sdk_1.newid)(), title: `Note ${i}` });
+        }
+        // Connect peer2 to peer1 (only one direction)
+        const sync1 = peer2.addConnection(peer1);
+        const sync2 = peer1.addConnection(peer2);
+        // time the sync
+        const start = Date.now();
+        await Promise.all([sync1, sync2]);
+        const end = Date.now();
+        const syncTime = end - start;
+        expect(syncTime).toBeGreaterThan(400);
+        // Disconnect the peers
+        await peer1.removeConnection(peer2.deviceId);
+        await peer2.removeConnection(peer1.deviceId);
+        // add some more notes
+        await peer1Notes.save({ noteId: (0, peers_sdk_1.newid)(), title: `Note final` });
+        await peer2Notes.save({ noteId: (0, peers_sdk_1.newid)(), title: `Note final` });
+        // Reconnect the peers
+        const sync3 = peer2.addConnection(peer1);
+        const sync4 = peer1.addConnection(peer2);
+        const start2 = Date.now();
+        await Promise.all([sync3, sync4]);
+        const end2 = Date.now();
+        const syncTime2 = end2 - start2;
+        expect(syncTime2).toBeLessThan(200);
+        // verify they have the same notes
+        const notes1 = await peer1Notes.list();
+        const notes2 = await peer2Notes.list();
+        expect(notes1).toEqual(notes2);
+    });
+    it("should keep track of latency and errors for each connection", async () => {
+        // Create two peers
+        const remotePeer1 = buildRemotePeer();
+        const remotePeer2 = buildRemotePeer({ latencyMs: 10, errorRate: 0.9 });
+        const peer1 = remotePeer1.peer;
+        const peer2 = remotePeer2.peer;
+        // Get notes tables
+        const peer1Notes = getNotesTable(peer1);
+        // Connect them bidirectionally
+        await peer1.addConnection(remotePeer2.remotePeer);
+        await peer2.addConnection(remotePeer1.remotePeer);
+        for (let i = 0; i < 10; i++) {
+            await peer1Notes.save({ noteId: (0, peers_sdk_1.newid)(), title: `Hello, World! ${i}` });
+        }
+        await (0, peers_sdk_1.sleep)(200);
+        const conn1 = peer1.getConnections()[0];
+        expect(conn1.latencyMs).toBeGreaterThan(10);
+        expect(conn1.errorRate).toBeGreaterThan(0.1);
+    });
+    it("should efficiently sync large sets of changes (this is a flaky test and should be redone or skipped)", async () => {
+        // Create two peers
+        const peer1 = buildPeer();
+        const peer2 = buildPeer();
+        // Get notes tables
+        const peer1Notes = getNotesTable(peer1);
+        const peer2Notes = getNotesTable(peer2);
+        async function assertSyncMs(msLt, msGt = 1) {
+            // time the sync
+            const start = Date.now();
+            await Promise.all([
+                peer1.syncWithRemoteDevice(peer2),
+                peer2.syncWithRemoteDevice(peer1)
+            ]);
+            const end = Date.now();
+            const syncTime = end - start;
+            // console.log(`Sync time: ${syncTime}ms`);
+            expect(syncTime).toBeLessThanOrEqual(msLt);
+            expect(syncTime).toBeGreaterThan(msGt);
+        }
+        // add a whole bunch of notes to both
+        for (let i = 0; i < 100; i++) {
+            await peer1Notes.save({ noteId: (0, peers_sdk_1.newid)(), title: `Note ${i}` });
+            await peer2Notes.save({ noteId: (0, peers_sdk_1.newid)(), title: `Note ${i}` });
+        }
+        await assertSyncMs(1000, 0);
+        let syncBatch = 0;
+        for (const n of (0, lodash_1.range)(10)) {
+            syncBatch++;
+            // update a bunch of notes
+            const allNotes = await peer1Notes.list();
+            for (const note of allNotes) {
+                note.title = `Updated ${note.title} 1 - ${syncBatch}`;
+                await peer1Notes.save(note);
+                note.title = `Updated ${note.title} 2 - ${syncBatch}`;
+                await peer2Notes.save(note);
+            }
+            await assertSyncMs(1000);
+            // verify they have the same notes
+            const notes1 = await peer1Notes.list();
+            const notes2 = await peer2Notes.list();
+            expect(notes1).toEqual(notes2);
+        }
+    });
+    it("should handle conflicts from two peers being offline and many changes occurring", async () => {
+        // Create two peers
+        const peer1 = buildPeer();
+        const peer2 = buildPeer();
+        // Get notes tables
+        const peer1Notes = getNotesTable(peer1);
+        const peer2Notes = getNotesTable(peer2);
+        async function assertSync() {
+            // time the sync
+            const start = Date.now();
+            await Promise.all([
+                peer1.syncWithRemoteDevice(peer2),
+                peer2.syncWithRemoteDevice(peer1)
+            ]);
+            const end = Date.now();
+            const syncTime = end - start;
+            // console.log(`Sync time: ${syncTime}ms`);
+            // verify they have the same notes
+            const notes1 = await peer1Notes.list();
+            const notes2 = await peer2Notes.list();
+            expect(notes1).toEqual(notes2);
+        }
+        // add a whole bunch of notes to both
+        for (let i = 0; i < 100; i++) {
+            await peer1Notes.save({ noteId: (0, peers_sdk_1.newid)(), title: `Note ${i}` });
+            await peer2Notes.save({ noteId: (0, peers_sdk_1.newid)(), title: `Note ${i}` });
+        }
+        await assertSync();
+        let syncBatch = 0;
+        for (const n of (0, lodash_1.range)(10)) {
+            syncBatch++;
+            for (const table of [peer1Notes, peer2Notes]) {
+                const allNotes = await table.list();
+                for (const note of allNotes) {
+                    const rand = Math.random();
+                    if (rand < 0.05) {
+                        await table.delete(note.noteId);
+                    }
+                    else if (rand < 0.95) {
+                        note.title = `Updated ${note.title} ${Math.random().toString().substring(1, 2)} - ${syncBatch}`;
+                        await table.save(note);
+                    }
+                    else {
+                        await table.save({ noteId: (0, peers_sdk_1.newid)(), title: `new note - ${syncBatch}` });
+                    }
+                }
+            }
+        }
+        // verify they have the same notes
+        const notes1 = await peer1Notes.list();
+        const notes2 = await peer2Notes.list();
+        const diffs = [];
+        const ids = (0, lodash_1.uniq)([...notes1.map(n => n.noteId), ...notes2.map(n => n.noteId)]);
+        for (const id of ids) {
+            const note1 = notes1.find(n => n.noteId === id);
+            const note2 = notes2.find(n => n.noteId === id);
+            if ((0, lodash_1.isEqual)(note1, note2))
+                continue;
+            diffs.push({ id, note1, note2 });
+        }
+        expect(diffs.length).toBeGreaterThan(100);
+        await assertSync();
+    });
+    it("should correctly page through changes when syncing with a remote device", async () => {
+        // Create two peers
+        const peer1 = buildPeer();
+        const peer2 = buildPeer();
+        // Get notes tables
+        const peer1Notes = getNotesTable(peer1);
+        const peer2Notes = getNotesTable(peer2);
+        // add a whole bunch of notes to both
+        for (let i = 0; i < 4; i++) {
+            await peer1Notes.save({ noteId: (0, peers_sdk_1.newid)(), title: `Note ${i}` });
+            await peer2Notes.save({ noteId: (0, peers_sdk_1.newid)(), title: `Note ${i}` });
+        }
+        // time the sync
+        await peer1.syncWithRemoteDevice(peer2, { pageSize: 2 });
+        await peer2.syncWithRemoteDevice(peer1, { pageSize: 2 });
+        // verify they have the same notes
+        const notes1 = await peer1Notes.list();
+        const notes2 = await peer2Notes.list();
+        expect(notes1).toEqual(notes2);
+    });
+    it("should handle conflicts from three peers being offline and many changes occurring", async () => {
+        // Create two peers
+        const peer1 = buildPeer();
+        const peer2 = buildPeer();
+        const peer3 = buildPeer();
+        // Get notes tables
+        const peer1Notes = getNotesTable(peer1);
+        const peer2Notes = getNotesTable(peer2);
+        const peer3Notes = getNotesTable(peer3);
+        async function assertSync() {
+            // time the sync
+            const start = Date.now();
+            await Promise.all([
+                peer1.syncWithRemoteDevice(peer2),
+                peer1.syncWithRemoteDevice(peer3),
+                peer2.syncWithRemoteDevice(peer1),
+                peer2.syncWithRemoteDevice(peer3),
+                peer3.syncWithRemoteDevice(peer1),
+                peer3.syncWithRemoteDevice(peer2),
+            ]);
+            const end = Date.now();
+            const syncTime = end - start;
+            // console.log(`Sync time: ${syncTime}ms`);
+            // verify they have the same notes
+            const notes1 = await peer1Notes.list();
+            const notes2 = await peer2Notes.list();
+            const notes3 = await peer3Notes.list();
+            expect(notes1).toEqual(notes2);
+            expect(notes1).toEqual(notes3);
+        }
+        // add notes to all of them and sync
+        for (let i = 0; i < 40; i++) {
+            await peer1Notes.save({ noteId: (0, peers_sdk_1.newid)(), title: `Note ${i}` });
+            await peer2Notes.save({ noteId: (0, peers_sdk_1.newid)(), title: `Note ${i}` });
+            await peer3Notes.save({ noteId: (0, peers_sdk_1.newid)(), title: `Note ${i}` });
+        }
+        await assertSync();
+        // create many inserts, updates, and deletes in all of them
+        for (const syncBatch of (0, lodash_1.range)(10)) {
+            for (const table of [peer1Notes, peer2Notes, peer3Notes]) {
+                const allNotes = await table.list();
+                for (const note of allNotes) {
+                    const rand = Math.random();
+                    if (rand < 0.05) {
+                        await table.delete(note.noteId);
+                    }
+                    else if (rand < 0.95) {
+                        note.title = `Updated ${note.title} ${Math.random().toString().substring(1, 2)} - ${syncBatch}`;
+                        await table.save(note);
+                    }
+                    else {
+                        await table.save({ noteId: (0, peers_sdk_1.newid)(), title: `new note - ${syncBatch}` });
+                    }
+                }
+            }
+        }
+        // verify they sync to the same state
+        await assertSync();
+    });
+    it("should work with multiple tables and multiple peers with all different field types", async () => {
+        const peer1 = buildPeer();
+        const peer2 = buildPeer();
+        peer1.addConnection(peer2, { resyncInterval: 200 });
+        peer2.addConnection(peer1, { resyncInterval: 200 });
+        const tasksSchema = zod_1.z.object({
+            taskId: zod_1.z.string(),
+            title: zod_1.z.string(),
+            completed: zod_1.z.boolean().optional(),
+            number: zod_1.z.number().optional(),
+            string: zod_1.z.string().optional(),
+            date: zod_1.z.date().optional(),
+        });
+        const tasksMetaData = {
+            name: "tasks-test",
+            description: 'A table for tasks',
+            primaryKeyName: 'taskId',
+            fields: (0, peers_sdk_1.schemaToFields)(tasksSchema),
+        };
+        // Get notes tables
+        const peer1Notes = getNotesTable(peer1);
+        const peer2Notes = getNotesTable(peer2);
+        const peer1Tasks = peer1.tableContainer.getTable(tasksMetaData);
+        const peer2Tasks = peer2.tableContainer.getTable(tasksMetaData);
+        // create notes
+        for (let i = 0; i < 10; i++) {
+            await peer1Notes.save({ noteId: (0, peers_sdk_1.newid)(), title: `Note ${i}`, completed: false, number: i, string: `String ${i}`, date: new Date() });
+            await peer2Notes.save({ noteId: (0, peers_sdk_1.newid)(), title: `Note ${i}`, completed: false, number: i, string: `String ${i}`, date: new Date() });
+            await peer1Tasks.save({ taskId: (0, peers_sdk_1.newid)(), title: `Task ${i}`, completed: false, number: i, string: `String ${i}`, date: new Date() });
+            await peer2Tasks.save({ taskId: (0, peers_sdk_1.newid)(), title: `Task ${i}`, completed: false, number: i, string: `String ${i}`, date: new Date() });
+        }
+        await (0, peers_sdk_1.sleep)(1000);
+        let peer1NotesList = await peer1Notes.list();
+        let peer2NotesList = await peer2Notes.list();
+        let peer1TasksList = await peer1Tasks.list();
+        let peer2TasksList = await peer2Tasks.list();
+        expect(peer1NotesList.length).toBe(20);
+        expect(peer1TasksList.length).toBe(20);
+        expect(peer1NotesList).toEqual(peer2NotesList);
+        expect(peer1TasksList).toEqual(peer2TasksList);
+        for (const note of peer1NotesList) {
+            note.title = `Updated ${note.title}`;
+            note.completed = true;
+            note.number = Math.random();
+            note.string = `Updated ${note.string}`;
+            note.date = new Date();
+            await peer1Notes.save(note);
+        }
+        for (const task of peer1TasksList) {
+            task.title = `Updated ${task.title}`;
+            task.completed = true;
+            task.number = Math.random();
+            task.string = `Updated ${task.string}`;
+            task.date = new Date();
+            await peer2Tasks.save(task);
+        }
+        await (0, peers_sdk_1.sleep)(1000);
+        peer1NotesList = await peer1Notes.list();
+        peer2NotesList = await peer2Notes.list();
+        peer1TasksList = await peer1Tasks.list();
+        peer2TasksList = await peer2Tasks.list();
+        expect(peer1NotesList).toEqual(peer2NotesList);
+        expect(peer1TasksList).toEqual(peer2TasksList);
+        expect(peer1NotesList.length).toBe(20);
+        expect(peer1TasksList.length).toBe(20);
+        for (const note of peer1NotesList) {
+            await peer1Notes.delete(note);
+        }
+        for (const task of peer1TasksList) {
+            await peer2Tasks.delete(task);
+        }
+        await (0, peers_sdk_1.sleep)(1000);
+        peer1NotesList = await peer1Notes.list();
+        peer2NotesList = await peer2Notes.list();
+        peer1TasksList = await peer1Tasks.list();
+        peer2TasksList = await peer2Tasks.list();
+        expect(peer1NotesList).toEqual(peer2NotesList);
+        expect(peer1TasksList).toEqual(peer2TasksList);
+        expect(peer1NotesList.length).toBe(0);
+        expect(peer1TasksList.length).toBe(0);
+    });
+    it.skip("should not excessively call peer functions", async () => {
+        // this has to be run by itself while we use static variables to count calls
+        // Create two peers
+        const peer1 = buildRemotePeer();
+        const peer2 = buildRemotePeer();
+        function assertCounts(counts) {
+            expect(device_sync_1.DeviceSync.electPreferredConnectionsCount).toBe(counts.electPreferredConnectionsCount);
+            expect(device_sync_1.DeviceSync.syncWithRemoteDeviceCount).toBe(counts.syncWithRemoteDeviceCount);
+            expect(device_sync_1.DeviceSync.getNetworkInfoCount).toBe(counts.getNetworkInfoCount);
+            expect(device_sync_1.DeviceSync.applyChangesCount).toBe(counts.applyChangesCount);
+            expect(device_sync_1.DeviceSync.listChangesCount).toBe(counts.listChangesCount);
+            device_sync_1.DeviceSync.listChangesCount = 0;
+            device_sync_1.DeviceSync.applyChangesCount = 0;
+            device_sync_1.DeviceSync.getNetworkInfoCount = 0;
+            device_sync_1.DeviceSync.electPreferredConnectionsCount = 0;
+            device_sync_1.DeviceSync.syncWithRemoteDeviceCount = 0;
+        }
+        assertCounts({
+            listChangesCount: 0,
+            applyChangesCount: 0,
+            getNetworkInfoCount: 0,
+            electPreferredConnectionsCount: 0,
+            syncWithRemoteDeviceCount: 0,
+        });
+        await peer1.peer.addConnection(peer2.remotePeer);
+        await peer2.peer.addConnection(peer1.remotePeer);
+        await (0, peers_sdk_1.sleep)(1);
+        assertCounts({
+            electPreferredConnectionsCount: 2, // once for each peer
+            syncWithRemoteDeviceCount: 2, // once for each peer
+            listChangesCount: 2, // each peer syncs with the other
+            getNetworkInfoCount: 2, // network info on elections (use same network info for sync)
+            applyChangesCount: 0, // no changes to apply
+        });
+        // expect them to be synced with each other 
+        const peer1NetworkInfo = await peer1.peer.getNetworkInfo();
+        const peer1Conns = peer1NetworkInfo.connections;
+        expect(peer1Conns.length).toBe(1);
+        expect(peer1NetworkInfo.preferredDeviceIds).toEqual([peer2.peer.deviceId]);
+        const peer2NetworkInfo = await peer2.peer.getNetworkInfo();
+        const peer2Conns = peer2NetworkInfo.connections;
+        expect(peer2Conns.length).toBe(1);
+        expect(peer2NetworkInfo.preferredDeviceIds).toEqual([peer1.peer.deviceId]);
+        assertCounts({
+            electPreferredConnectionsCount: 0,
+            syncWithRemoteDeviceCount: 0,
+            listChangesCount: 0,
+            getNetworkInfoCount: 2, // manually called above
+            applyChangesCount: 0,
+        });
+        // Get notes tables
+        const peer1Notes = getNotesTable(peer1.peer);
+        const peer2Notes = getNotesTable(peer2.peer);
+        // add one note
+        await peer1Notes.save({ noteId: (0, peers_sdk_1.newid)(), title: `Note 1` });
+        await (0, peers_sdk_1.sleep)(300);
+        device_sync_1.DeviceSync.syncWithRemoteDeviceCount;
+        assertCounts({
+            electPreferredConnectionsCount: 0,
+            syncWithRemoteDeviceCount: 2, // once for each peer (peer1Changes -> peer2 -> peer2Changes -> peer1 (verifies it already has those changes))
+            getNetworkInfoCount: 2, // network info as part of sync
+            listChangesCount: 4, // I thinks the cursor uses a minimum of 2 list calls => 4 (2 for each peer)
+            applyChangesCount: 2, // each peer applies the other's changes
+        });
+        // add one note
+        await peer2Notes.save({ noteId: (0, peers_sdk_1.newid)(), title: `Note 2` });
+        await (0, peers_sdk_1.sleep)(300);
+        device_sync_1.DeviceSync.syncWithRemoteDeviceCount;
+        assertCounts({
+            electPreferredConnectionsCount: 0,
+            syncWithRemoteDeviceCount: 2,
+            getNetworkInfoCount: 2,
+            listChangesCount: 4,
+            applyChangesCount: 2,
+        });
+        // await sleep(300);
+        // verify they have the same notes
+        const notes1 = await peer1Notes.list();
+        const notes2 = await peer2Notes.list();
+        expect(notes1).toEqual(notes2);
+        await Promise.all([
+            peer1.peer.dispose(),
+            peer2.peer.dispose(),
+        ]);
+    });
+    it("should keep synced three connected peers that are all connected to each other", async () => {
+        // Create peers
+        const peer1 = buildPeer();
+        const peer2 = buildPeer();
+        const peer3 = buildPeer();
+        const peers = [peer1, peer2, peer3];
+        // Get notes tables
+        const peer1Notes = getNotesTable(peer1);
+        const peer2Notes = getNotesTable(peer2);
+        const peer3Notes = getNotesTable(peer3);
+        // add notes to all peers
+        for (let i = 0; i < 20; i++) {
+            for (const peer of peers) {
+                await getNotesTable(peer).save({ noteId: (0, peers_sdk_1.newid)(), title: `Note ${i}` });
+            }
+        }
+        // connect all peers    
+        for (const peer of peers) {
+            for (const otherPeer of peers) {
+                if (peer !== otherPeer) {
+                    await peer.addConnection(otherPeer, { resyncInterval: 9000 });
+                }
+            }
+        }
+        // create inserts, updates, and deletes in all peers
+        for (const changeBatch of (0, lodash_1.range)(10)) {
+            for (const table of [peer1Notes, peer2Notes, peer3Notes]) {
+                const allNotes = await table.list();
+                for (const note of allNotes) {
+                    const rand = Math.random();
+                    try {
+                        if (rand < 0.05) {
+                            await table.delete(note);
+                        }
+                        else if (rand < 0.95) {
+                            note.title = `Updated ${note.title} ${Math.random().toString().substring(1, 2)} - ${changeBatch}`;
+                            const exists = await table.get(note.noteId);
+                            if (!exists) {
+                                note.noteId = (0, peers_sdk_1.newid)();
+                            }
+                            await table.save(note);
+                        }
+                        else {
+                            await table.save({ noteId: (0, peers_sdk_1.newid)(), title: `new note - ${changeBatch}` });
+                        }
+                    }
+                    catch (error) {
+                        console.error(error);
+                    }
+                }
+            }
+        }
+        for (let i = 0; i < 20; i++) {
+            // verify they sync to the same state
+            const notes1 = await peer1Notes.list();
+            const notes2 = await peer2Notes.list();
+            const notes3 = await peer3Notes.list();
+            if ((0, lodash_1.isEqual)(notes1, notes2) && (0, lodash_1.isEqual)(notes1, notes3)) {
+                break;
+            }
+            console.log("Not fully synced yet...");
+            await (0, peers_sdk_1.sleep)(1000);
+        }
+        const notes1 = await peer1Notes.list();
+        const notes2 = await peer2Notes.list();
+        const notes3 = await peer3Notes.list();
+        expect(notes1).toEqual(notes2);
+        expect(notes1).toEqual(notes3);
+    });
+    it.skip("should keep synced three peers connected in a loop", async () => {
+        // This is slow and not realistic because it pretends the peers can have one-way connections
+        // The good news is that it does eventually sync which is a nice proof of concept
+        // Create two peers
+        const peer1 = buildPeer();
+        const peer2 = buildPeer();
+        const peer3 = buildPeer();
+        const peers = [peer1, peer2, peer3];
+        // Get notes tables
+        const peer1Notes = getNotesTable(peer1);
+        const peer2Notes = getNotesTable(peer2);
+        const peer3Notes = getNotesTable(peer3);
+        // add notes to all of them and sync
+        for (let i = 0; i < 20; i++) {
+            for (const peer of peers) {
+                await getNotesTable(peer).save({ noteId: (0, peers_sdk_1.newid)(), title: `Note ${i}` });
+            }
+        }
+        const syncPromises = [
+            // peer1 -> peer2 -> peer3 -> peer1
+            peer1.addConnection(peer2, { resyncInterval: 9000 }),
+            peer2.addConnection(peer3, { resyncInterval: 9000 }),
+            peer3.addConnection(peer1, { resyncInterval: 9000 }),
+        ];
+        await Promise.all(syncPromises);
+        // create many inserts, updates, and deletes in all of them
+        for (const changeBatch of (0, lodash_1.range)(10)) {
+            for (const table of [peer1Notes, peer2Notes, peer3Notes]) {
+                const allNotes = await table.list();
+                for (const note of allNotes) {
+                    const rand = Math.random();
+                    try {
+                        if (rand < 0.05) {
+                            await table.delete(note);
+                        }
+                        else if (rand < 0.95) {
+                            note.title = `Updated ${note.title} ${Math.random().toString().substring(1, 2)} - ${changeBatch}`;
+                            const exists = await table.get(note.noteId);
+                            if (!exists) {
+                                note.noteId = (0, peers_sdk_1.newid)();
+                            }
+                            await table.save(note);
+                        }
+                        else {
+                            await table.save({ noteId: (0, peers_sdk_1.newid)(), title: `new note - ${changeBatch}` });
+                        }
+                    }
+                    catch (error) {
+                        console.error(error);
+                    }
+                }
+            }
+        }
+        for (let i = 0; i < 20; i++) {
+            // verify they sync to the same state
+            const notes1 = await peer1Notes.list();
+            const notes2 = await peer2Notes.list();
+            const notes3 = await peer3Notes.list();
+            if ((0, lodash_1.isEqual)(notes1, notes2) && (0, lodash_1.isEqual)(notes1, notes3)) {
+                console.log("All peers are synced!");
+                break;
+            }
+            console.log("Not fully synced yet...");
+            await (0, peers_sdk_1.sleep)(1000);
+        }
+        const notes1 = await peer1Notes.list();
+        const notes2 = await peer2Notes.list();
+        const notes3 = await peer3Notes.list();
+        expect(notes1).toEqual(notes2);
+        expect(notes1).toEqual(notes3);
+    });
+    it("should keep synced three peers connected via a hub", async () => {
+        // Create two peers
+        const peer1 = buildPeer();
+        const peer2 = buildPeer();
+        const peer3 = buildPeer();
+        // Get notes tables
+        const peer1Notes = getNotesTable(peer1);
+        const peer2Notes = getNotesTable(peer2);
+        const peer3Notes = getNotesTable(peer3);
+        // add notes to all of them and sync
+        for (let i = 0; i < 20; i++) {
+            await peer1Notes.save({ noteId: (0, peers_sdk_1.newid)(), title: `Note ${i}` });
+            await peer2Notes.save({ noteId: (0, peers_sdk_1.newid)(), title: `Note ${i}` });
+            await peer3Notes.save({ noteId: (0, peers_sdk_1.newid)(), title: `Note ${i}` });
+        }
+        const syncPromises = [
+            // peer1 <-> peer2 <-> peer3
+            peer1.addConnection(peer2, { resyncInterval: 9000 }),
+            peer2.addConnection(peer1, { resyncInterval: 9000 }),
+            peer2.addConnection(peer3, { resyncInterval: 9000 }),
+            peer3.addConnection(peer2, { resyncInterval: 9000 }),
+        ];
+        // create many inserts, updates, and deletes in all of them
+        for (const changeBatch of (0, lodash_1.range)(10)) {
+            for (const table of [peer1Notes, peer2Notes, peer3Notes]) {
+                const allNotes = await table.list();
+                for (const note of allNotes) {
+                    const rand = Math.random();
+                    try {
+                        if (rand < 0.05) {
+                            await table.delete(note);
+                        }
+                        else if (rand < 0.95) {
+                            note.title = `Updated ${note.title} ${Math.random().toString().substring(1, 2)} - ${changeBatch}`;
+                            const exists = await table.get(note.noteId);
+                            if (!exists) {
+                                note.noteId = (0, peers_sdk_1.newid)();
+                            }
+                            await table.save(note);
+                        }
+                        else {
+                            await table.save({ noteId: (0, peers_sdk_1.newid)(), title: `new note - ${changeBatch}` });
+                        }
+                    }
+                    catch (error) {
+                        console.error(error);
+                    }
+                }
+            }
+        }
+        for (let i = 0; i < 10; i++) {
+            const stillSyncing = peer1.getConnections().some(c => !c.timestampLastApplied) ||
+                peer2.getConnections().some(c => !c.timestampLastApplied) ||
+                peer3.getConnections().some(c => !c.timestampLastApplied);
+            await (0, peers_sdk_1.sleep)(100);
+            if (!stillSyncing)
+                break;
+            console.log("Still syncing...");
+        }
+        for (let i = 0; i < 20; i++) {
+            // verify they sync to the same state
+            const notes1 = await peer1Notes.list();
+            const notes2 = await peer2Notes.list();
+            const notes3 = await peer3Notes.list();
+            if ((0, lodash_1.isEqual)(notes1, notes2) && (0, lodash_1.isEqual)(notes1, notes3)) {
+                break;
+            }
+            console.log("Not fully synced yet...");
+            await (0, peers_sdk_1.sleep)(1000);
+        }
+        const notes1 = await peer1Notes.list();
+        const notes2 = await peer2Notes.list();
+        const notes3 = await peer3Notes.list();
+        expect(notes1).toEqual(notes2);
+        expect(notes1).toEqual(notes3);
+    });
+    it("should keep synced four peers connected via two hubs", async () => {
+        // Create two peers
+        const peer1 = buildPeer();
+        const peer2 = buildPeer();
+        const peer3 = buildPeer();
+        const peer4 = buildPeer();
+        // Get notes tables
+        const peer1Notes = getNotesTable(peer1);
+        const peer2Notes = getNotesTable(peer2);
+        const peer3Notes = getNotesTable(peer3);
+        const peer4Notes = getNotesTable(peer4);
+        // add notes to all of them and sync
+        for (let i = 0; i < 10; i++) {
+            await peer1Notes.save({ noteId: (0, peers_sdk_1.newid)(), title: `Note ${i}` });
+            await peer2Notes.save({ noteId: (0, peers_sdk_1.newid)(), title: `Note ${i}` });
+            await peer3Notes.save({ noteId: (0, peers_sdk_1.newid)(), title: `Note ${i}` });
+            await peer4Notes.save({ noteId: (0, peers_sdk_1.newid)(), title: `Note ${i}` });
+        }
+        const syncPromises = [
+            // peer1 <-> peer2 <-> peer3 <-> peer4
+            peer1.addConnection(peer2, { resyncInterval: 9000 }),
+            peer2.addConnection(peer1, { resyncInterval: 9000 }),
+            peer2.addConnection(peer3, { resyncInterval: 9000 }),
+            peer3.addConnection(peer2, { resyncInterval: 9000 }),
+            peer3.addConnection(peer4, { resyncInterval: 9000 }),
+            peer4.addConnection(peer3, { resyncInterval: 9000 }),
+        ];
+        // create many inserts, updates, and deletes in all of them
+        for (const changeBatch of (0, lodash_1.range)(5)) {
+            for (const table of [peer1Notes, peer2Notes, peer3Notes, peer4Notes]) {
+                const allNotes = await table.list();
+                for (const note of allNotes) {
+                    const rand = Math.random();
+                    try {
+                        if (rand < 0.05) {
+                            await table.delete(note);
+                        }
+                        else if (rand < 0.95) {
+                            note.title = `Updated ${note.title} ${Math.random().toString().substring(1, 2)} - ${changeBatch}`;
+                            const exists = await table.get(note.noteId);
+                            if (!exists) {
+                                note.noteId = (0, peers_sdk_1.newid)();
+                            }
+                            await table.save(note);
+                        }
+                        else {
+                            await table.save({ noteId: (0, peers_sdk_1.newid)(), title: `new note - ${changeBatch}` });
+                        }
+                    }
+                    catch (error) {
+                        console.error(error);
+                    }
+                }
+            }
+        }
+        for (let i = 0; i < 10; i++) {
+            const stillSyncing = peer1.getConnections().some(c => !c.timestampLastApplied) ||
+                peer2.getConnections().some(c => !c.timestampLastApplied) ||
+                peer3.getConnections().some(c => !c.timestampLastApplied) ||
+                peer4.getConnections().some(c => !c.timestampLastApplied);
+            await (0, peers_sdk_1.sleep)(100);
+            if (!stillSyncing)
+                break;
+            console.log("Still syncing...");
+        }
+        for (let i = 0; i < 20; i++) {
+            // verify they sync to the same state
+            const notes1 = await peer1Notes.list();
+            const notes2 = await peer2Notes.list();
+            const notes3 = await peer3Notes.list();
+            const notes4 = await peer4Notes.list();
+            if ((0, lodash_1.isEqual)(notes1, notes2) && (0, lodash_1.isEqual)(notes1, notes3) && (0, lodash_1.isEqual)(notes1, notes4)) {
+                break;
+            }
+            console.log("Not fully synced yet...");
+            await (0, peers_sdk_1.sleep)(1000);
+        }
+        const notes1 = await peer1Notes.list();
+        const notes2 = await peer2Notes.list();
+        const notes3 = await peer3Notes.list();
+        const notes4 = await peer4Notes.list();
+        expect(notes1).toEqual(notes2);
+        expect(notes1).toEqual(notes3);
+        expect(notes1).toEqual(notes4);
+    });
+    // unreliable for CI/CD so skipping.  Use for local dev only
+    it.skip("after syncing with a peers, should skip forward to that peer's timestampAppliedLast for all it's connections", async () => {
+        // NOTE: I confirmed via execution time that this is working. 
+        // Speedup is dependent on amount of data to sync and page size of sync.
+        // It is significant for large data sets, but not for small ones.
+        // election overhead will be minimized over time for very active networks.
+        // for relatively inactive networks, the overhead is not significant.
+        /* all peers push and pull syncing
+          List changes count:  1980
+          Apply changes count:  3510
+          Network info count:  0
+          Elections count:  0
+          Total calls: 5490
+          Total time: 24.7s, 24.9s, 24.9s
+        */
+        /* add transitive syncing
+          List changes count:  612
+          Apply changes count:  2142
+          Network info count:  180
+          Elections count:  0
+          Total calls: 2934
+          Total time: 10.6s, 10.5s, 10.6s
+        */
+        /* add elections on connection changes
+          List changes count:  146
+          Apply changes count:  1715
+          Network info count:  593
+          Elections count:  90
+          Total calls: 2544
+        */
+        /* add push only to preferred connections
+          List changes count:  362
+          Apply changes count:  480
+          Network info count:  674
+          Elections count:  90
+          Total calls: 1606
+        */
+        /* add pull only from preferred connections
+          List changes count:  160
+          Apply changes count:  378
+          Network info count:  573
+          Elections count:  90
+          Total calls: 1201
+        */
+        const peerCnt = 10;
+        const errorRate = 0;
+        const latencyMs = 10;
+        const remotePeers = (0, lodash_1.range)(peerCnt).map(() => {
+            return buildRemotePeer({ errorRate, latencyMs });
+        });
+        const peers = remotePeers.map(p => p.peer);
+        for (const peer of peers) {
+            getNotesTable(peer);
+        }
+        // connect all peers to each other
+        for (const peer1 of peers) {
+            for (const peer2 of peers) {
+                if (peer1 === peer2)
+                    continue;
+                const remotePeer = remotePeers.find(p => p.peer === peer2)?.remotePeer;
+                if (!remotePeer)
+                    throw new Error("Remote peer not found");
+                await peer1.addConnection(remotePeer, { resyncInterval: 10_000 });
+            }
+        }
+        // add a whole bunch of notes and changes
+        for (const peer of peers) {
+            const notesTable = getNotesTable(peer);
+            for (let i = 0; i < 10; i++) {
+                await notesTable.save({ noteId: (0, peers_sdk_1.newid)(), title: `Note ${i}` });
+                const randomNote = (0, lodash_1.shuffle)(await notesTable.list(undefined, { pageSize: 10 }))[0];
+                if (!randomNote)
+                    continue;
+                randomNote.title += ` Updated ${i}`;
+                await notesTable.save(randomNote);
+            }
+        }
+        // sync all peers
+        // for (const peer1 of peers) {
+        //   for (const peer2 of peers) {
+        //     if (peer1 === peer2) continue;
+        //     const remotePeer = remotePeers.find(p => p.peer === peer2)?.remotePeer;
+        //     if (!remotePeer) throw new Error("Remote peer not found");
+        //     await peer1.syncWithRemoteDevice(remotePeer, { pageSize: 10 });
+        //   }
+        // }
+        // wait for all peers to sync
+        await (0, peers_sdk_1.sleep)(1000);
+        const myNotes = await getNotesTable(peers[0]).list();
+        expect(myNotes.length).toBeGreaterThan(peerCnt);
+        for (const peer of peers) {
+            const peerNotesTable = getNotesTable(peer);
+            const peerNotes = await peerNotesTable.list();
+            expect(peerNotes).toEqual(myNotes);
+        }
+        console.log("List changes count: ", device_sync_1.DeviceSync.listChangesCount);
+        console.log("Apply changes count: ", device_sync_1.DeviceSync.applyChangesCount);
+        console.log("Network info count: ", device_sync_1.DeviceSync.getNetworkInfoCount);
+        console.log("Elections count: ", device_sync_1.DeviceSync.electPreferredConnectionsCount);
+        console.log("Total calls: ", device_sync_1.DeviceSync.listChangesCount + device_sync_1.DeviceSync.applyChangesCount + device_sync_1.DeviceSync.getNetworkInfoCount + device_sync_1.DeviceSync.electPreferredConnectionsCount);
+        await Promise.all(peers.map(peer => peer.dispose()));
+    });
+    it.skip([
+        `should not slow down as data accumulates many changes`,
+        `(this is a long running that is left skipped unless explicitly checking for performance problems with syncing)`
+    ].join('\n        '), async () => {
+        // Create peers
+        const peer1 = buildPeer();
+        const peer2 = buildPeer();
+        const peer3 = buildPeer();
+        // Get notes tables
+        const peer1Notes = getNotesTable(peer1);
+        const peer2Notes = getNotesTable(peer2);
+        const peer3Notes = getNotesTable(peer3);
+        // add notes to all of them and sync
+        for (let i = 0; i < 50; i++) {
+            await peer1Notes.save({ noteId: (0, peers_sdk_1.newid)(), title: `Note ${i}` });
+            await peer2Notes.save({ noteId: (0, peers_sdk_1.newid)(), title: `Note ${i}` });
+            await peer3Notes.save({ noteId: (0, peers_sdk_1.newid)(), title: `Note ${i}` });
+        }
+        await Promise.all([
+            peer1.syncWithRemoteDevice(peer2),
+            peer1.syncWithRemoteDevice(peer3),
+            peer2.syncWithRemoteDevice(peer1),
+            peer2.syncWithRemoteDevice(peer3),
+            peer3.syncWithRemoteDevice(peer1),
+            peer3.syncWithRemoteDevice(peer2),
+        ]);
+        // create many inserts, updates, and deletes in all of them
+        let allNotes = await peer1Notes.list();
+        for (const changeBatch of (0, lodash_1.range)(100)) {
+            const startTime = Date.now();
+            for (const table of [peer1Notes, peer2Notes, peer3Notes]) {
+                if (!(changeBatch % 10)) {
+                    // await table.compact(Date.now());
+                }
+                // allNotes = await table.list();
+                // allNotes = shuffle(allNotes).splice(0, 300);
+                // console.log(`allNotes: ${allNotes.length}`);
+                for (const note of allNotes) {
+                    const rand = Math.random();
+                    try {
+                        if (rand < 0.05) {
+                            await table.delete(note);
+                            allNotes.splice(allNotes.findIndex(n => n.noteId === note.noteId), 1);
+                        }
+                        else if (rand < 0.95) {
+                            note.title = `Updated ${Math.random().toString().substring(1, 2)} - ${changeBatch}`;
+                            await table.save(note);
+                        }
+                        else {
+                            const newNote = await table.save({ noteId: (0, peers_sdk_1.newid)(), title: `new note - ${changeBatch}` });
+                            allNotes.push(newNote);
+                        }
+                    }
+                    catch (error) {
+                        console.error(error);
+                    }
+                }
+            }
+            await Promise.all([
+                peer1.syncWithRemoteDevice(peer2),
+                peer1.syncWithRemoteDevice(peer3),
+                peer2.syncWithRemoteDevice(peer1),
+                peer2.syncWithRemoteDevice(peer3),
+                peer3.syncWithRemoteDevice(peer1),
+                peer3.syncWithRemoteDevice(peer2),
+            ]);
+            const changesCount = (0, lodash_1.sum)([
+                await peer1.changeTrackingTable.count(),
+                await peer2.changeTrackingTable.count(),
+                await peer3.changeTrackingTable.count(),
+            ]);
+            console.log(`Change batch ${changeBatch}, time: ${Date.now() - startTime}ms, allNotes: ${allNotes.length}, allChanges: ${changesCount}`);
+        }
+        const notes1 = await peer1Notes.list();
+        const notes2 = await peer2Notes.list();
+        const notes3 = await peer3Notes.list();
+        expect(notes1).toEqual(notes2);
+        expect(notes1).toEqual(notes3);
+    });
+    // currently not working come back to this
+    it.skip("should eventually sync even with flaky connections (skipped because it's noisy and slow)", async () => {
+        const remoteMe = buildRemotePeer({ errorRate: 0.3, latencyMs: 200 });
+        const remotePeer = buildRemotePeer({ errorRate: 0.3, latencyMs: 200 });
+        const me = remoteMe.peer;
+        const peer = remotePeer.peer;
+        me.addConnection(remotePeer.remotePeer, { resyncInterval: 1000 });
+        peer.addConnection(remoteMe.remotePeer, { resyncInterval: 1000 });
+        const notesTable = getNotesTable(me);
+        // add notes
+        for (let i = 0; i < 10; i++) {
+            await notesTable.save({ noteId: (0, peers_sdk_1.newid)(), title: `Note ${i}` });
+            await (0, peers_sdk_1.sleep)(1000);
+        }
+        await (0, peers_sdk_1.sleep)(2000);
+        await me.syncWithRemoteDevice(remotePeer.remotePeer);
+        await peer.syncWithRemoteDevice(me);
+        console.log(me.getConnections()[0]);
+        expect(me.getConnections()[0].errorRate).toBeGreaterThan(0);
+        const myNotes = await notesTable.list();
+        const peerNotesTable = getNotesTable(peer);
+        const peerNotes = await peerNotesTable.list();
+        expect(peerNotes).toEqual(myNotes);
+        await Promise.all([
+            me.dispose(),
+            peer.dispose(),
+        ]);
+    });
+    it.skip("should should prioritize devices by lowest error * latency", async () => {
+        const peerCnt = 4;
+        const remotePeers = (0, lodash_1.range)(peerCnt).map((i) => {
+            const errorRate = 0; //0.1 * i;
+            const latencyMs = 100 * (i + 1);
+            return buildRemotePeer({ errorRate, latencyMs });
+        });
+        const peers = remotePeers.map(p => p.peer);
+        // ensures the table exists and is being tracked
+        for (const peer of peers) {
+            getNotesTable(peer);
+        }
+        for (const peer1 of peers) {
+            for (const peer2 of peers) {
+                if (peer1 === peer2)
+                    continue;
+                const remotePeer = remotePeers.find(p => p.peer === peer2)?.remotePeer;
+                if (!remotePeer)
+                    throw new Error("Remote peer not found");
+                await peer1.addConnection(remotePeer, { resyncInterval: 1000 });
+            }
+        }
+        for (const peer of peers) {
+            expect(peer.getConnections().length).toBe(peerCnt - 1);
+        }
+        // add a whole bunch of notes to one peer
+        const notesTable = getNotesTable(peers[0]);
+        for (let i = 0; i < 10; i++) {
+            await notesTable.save({ noteId: (0, peers_sdk_1.newid)(), title: `Note ${i}` });
+        }
+        // add notes to all peers
+        for (const peer of peers) {
+            const notesTable = getNotesTable(peer);
+            await notesTable.save({ noteId: (0, peers_sdk_1.newid)(), title: `Note from peer ${peer.deviceId}` });
+            await notesTable.save({ noteId: (0, peers_sdk_1.newid)(), title: `Note from peer ${peer.deviceId}` });
+            await notesTable.save({ noteId: (0, peers_sdk_1.newid)(), title: `Note from peer ${peer.deviceId}` });
+        }
+        await (0, peers_sdk_1.sleep)(8000);
+        const myNotes = await notesTable.list();
+        expect(myNotes.length).toBeGreaterThan(peerCnt);
+        for (const peer of peers) {
+            const peerNotesTable = getNotesTable(peer);
+            const peerNotes = await peerNotesTable.list();
+            expect(peerNotes).toEqual(myNotes);
+        }
+        const peer1DeviceId = peers[0].deviceId;
+        const peer2DeviceId = peers[1].deviceId;
+        for (const peer of peers) {
+            await peer.electPreferredConnections();
+            const networkInfo = await peer.getNetworkInfo();
+            if (peer.deviceId === peer1DeviceId) {
+                expect(networkInfo.preferredDeviceIds).toEqual([peer2DeviceId]);
+            }
+            else {
+                expect(networkInfo.preferredDeviceIds).toEqual([peer1DeviceId]);
+            }
+        }
+        for (const peer of peers) {
+            await peer.electPreferredConnections();
+            const networkInfo = await peer.getNetworkInfo();
+            if (peer.deviceId === peer1DeviceId) {
+                expect(networkInfo.preferredDeviceIds).toEqual([peer2DeviceId]);
+            }
+            else {
+                expect(networkInfo.preferredDeviceIds).toEqual([peer1DeviceId]);
+            }
+        }
+        const peer3DeviceId = peers[2].deviceId;
+        const peer4DeviceId = peers[3].deviceId;
+        const peer1 = peers[0];
+        expect(peer1.getConnections().map(c => c.deviceId)).toEqual([peer2DeviceId, peer3DeviceId, peer4DeviceId]);
+        // TODO this has been moved to the connection manager
+        // peer1.removeLeastPreferredConnection(); 
+        // expect(peer1.getConnections().map(c => c.deviceId)).toEqual([peer2DeviceId, peer3DeviceId]);
+        await Promise.all(peers.map(peer => peer.dispose()));
+    });
+    it.skip("should prune connections after 30 and changes should fully sync", async () => {
+        const peerCnt = 50;
+        const remotePeers = (0, lodash_1.range)(peerCnt).map(() => {
+            const errorRate = 0;
+            const latencyMs = 1;
+            return buildRemotePeer({ errorRate, latencyMs });
+        });
+        const peers = remotePeers.map(p => p.peer);
+        for (const peer of peers) {
+            getNotesTable(peer);
+        }
+        // connect all peers to each other
+        let connCnt = 0;
+        for (const peer1 of peers) {
+            for (const peer2 of peers) {
+                if (peer1 === peer2)
+                    continue;
+                const remotePeer = remotePeers.find(p => p.peer === peer2)?.remotePeer;
+                if (!remotePeer)
+                    throw new Error("Remote peer not found");
+                connCnt++;
+                await peer1.addConnection(remotePeer, {
+                    // resyncInterval: 10_000, 
+                    async onClose() {
+                        peer2.removeConnection(peer1.deviceId);
+                        peer1.removeConnection(peer2.deviceId);
+                    },
+                });
+            }
+        }
+        // await sleep(2000);
+        let stable = false;
+        while (!stable) {
+            console.log("Waiting for stable network info...");
+            const peers1NI = [];
+            for (const peer of peers) {
+                const networkInfo = await peer.getNetworkInfo();
+                peers1NI.push({ deviceId: peer.deviceId, preferredDeviceIds: networkInfo.preferredDeviceIds.length });
+            }
+            await Promise.all(peers.map(peer => peer.electPreferredConnections()));
+            // await sleep(2000);
+            const peers2NI = [];
+            for (const peer of peers) {
+                const networkInfo = await peer.getNetworkInfo();
+                peers2NI.push({ deviceId: peer.deviceId, preferredDeviceIds: networkInfo.preferredDeviceIds.length });
+            }
+            stable = (0, lodash_1.isEqual)(peers1NI, peers2NI);
+            console.log({ peers1NI, peers2NI });
+        }
+        // add a whole bunch of notes and changes
+        for (const peer of peers) {
+            const notesTable = getNotesTable(peer);
+            for (let i = 0; i < 2; i++) {
+                await notesTable.save({ noteId: (0, peers_sdk_1.newid)(), title: `Note ${i}` });
+                const randomNote = (0, lodash_1.shuffle)(await notesTable.list(undefined, { pageSize: 10 }))[0];
+                if (!randomNote)
+                    continue;
+                randomNote.title += ` Updated ${i}`;
+                await notesTable.save(randomNote);
+            }
+        }
+        // give time for all peers to sync
+        await (0, peers_sdk_1.sleep)(5000);
+        const myNotes = await getNotesTable(peers[0]).list();
+        expect(myNotes.length).toBeGreaterThan(peerCnt);
+        for (const peer of peers) {
+            const peerNotesTable = getNotesTable(peer);
+            const peerNotes = await peerNotesTable.list();
+            expect(peerNotes.length).toEqual(myNotes.length);
+            expect(peerNotes).toEqual(myNotes);
+            expect(peer.getConnections().length).toBeLessThanOrEqual(peers_sdk_1.PeerDeviceConsts.MAX_CONNECTIONS);
+        }
+        await Promise.all(peers.map(peer => peer.dispose()));
+    });
+    it.skip("should prune connections after 30 is reached but still sync the full network", async () => {
+        const peerCnt = 50;
+        const remotePeers = (0, lodash_1.range)(peerCnt).map(() => {
+            const errorRate = 0;
+            const latencyMs = 1;
+            return buildRemotePeer({ errorRate, latencyMs });
+        });
+        const peers = remotePeers.map(p => p.peer);
+        for (const peer of peers) {
+            getNotesTable(peer);
+        }
+        // connect all peers to each other
+        let connCnt = 0;
+        for (const peer1 of peers) {
+            for (const peer2 of peers) {
+                if (peer1 === peer2)
+                    continue;
+                const remotePeer = remotePeers.find(p => p.peer === peer2)?.remotePeer;
+                if (!remotePeer)
+                    throw new Error("Remote peer not found");
+                connCnt++;
+                await peer1.addConnection(remotePeer, {
+                    resyncInterval: 4_000, async onClose() {
+                        peer2.removeConnection(peer1.deviceId);
+                        peer1.removeConnection(peer2.deviceId);
+                    },
+                });
+            }
+        }
+        // await sleep(2000);
+        device_sync_1.DeviceSync.listChangesCount = 0;
+        device_sync_1.DeviceSync.applyChangesCount = 0;
+        device_sync_1.DeviceSync.getNetworkInfoCount = 0;
+        device_sync_1.DeviceSync.electPreferredConnectionsCount = 0;
+        // add a whole bunch of notes and changes
+        for (const peer of peers) {
+            const notesTable = getNotesTable(peer);
+            for (let i = 0; i < 2; i++) {
+                await notesTable.save({ noteId: (0, peers_sdk_1.newid)(), title: `Note ${i}` });
+                const randomNote = (0, lodash_1.shuffle)(await notesTable.list(undefined, { pageSize: 10 }))[0];
+                if (!randomNote)
+                    continue;
+                randomNote.title += ` Updated ${i}`;
+                await notesTable.save(randomNote);
+            }
+        }
+        // give time for all peers to sync
+        await (0, peers_sdk_1.sleep)(5000);
+        const myNotes = await getNotesTable(peers[0]).list();
+        expect(myNotes.length).toBeGreaterThan(peerCnt);
+        for (const peer of peers) {
+            const peerNotesTable = getNotesTable(peer);
+            const peerNotes = await peerNotesTable.list();
+            expect(peerNotes.length).toEqual(myNotes.length);
+            expect(peerNotes).toEqual(myNotes);
+            expect(peer.getConnections().length).toBeLessThanOrEqual(peers_sdk_1.PeerDeviceConsts.MAX_CONNECTIONS);
+        }
+        const totalNetworkOps = device_sync_1.DeviceSync.listChangesCount + device_sync_1.DeviceSync.applyChangesCount + device_sync_1.DeviceSync.getNetworkInfoCount + device_sync_1.DeviceSync.electPreferredConnectionsCount;
+        console.log("Total count: ", totalNetworkOps);
+        console.log("Total ops per peer: ", Math.round(totalNetworkOps / peerCnt));
+        let stable = false;
+        while (!stable) {
+            await (0, peers_sdk_1.sleep)(2000);
+            const deviceIdPriority1 = {};
+            for (const peer of peers) {
+                let preferredDeviceIds = (await peer.getNetworkInfo()).preferredDeviceIds;
+                const connections = peer.getConnections();
+                preferredDeviceIds = preferredDeviceIds.filter(deviceId => connections.find(c => c.deviceId === deviceId));
+                expect(preferredDeviceIds.length).toBeLessThanOrEqual(peers_sdk_1.PeerDeviceConsts.MAX_CONNECTIONS);
+                preferredDeviceIds.forEach((deviceId) => {
+                    deviceIdPriority1[deviceId] = (deviceIdPriority1[deviceId] || 0) + 1;
+                });
+            }
+            if (1 + 1 === 2) {
+                // setTimeout(() => {
+                //   console.log("Device ID priority1: ", deviceIdPriority1);
+                //   console.log("Total number of preferred connections: ", Object.values(deviceIdPriority1).reduce((a, b) => a + b, 0));
+                // }, 2000);
+                break;
+            }
+            for (const peer of peers) {
+                await (0, peers_sdk_1.sleep)(10);
+                peer.electPreferredConnections();
+            }
+            await (0, peers_sdk_1.sleep)(2000);
+            const deviceIdPriority2 = {};
+            for (const peer of peers) {
+                let preferredDeviceIds = (await peer.getNetworkInfo()).preferredDeviceIds;
+                const connections = peer.getConnections();
+                preferredDeviceIds = preferredDeviceIds.filter(deviceId => connections.find(c => c.deviceId === deviceId));
+                expect(preferredDeviceIds.length).toBeLessThanOrEqual(peers_sdk_1.PeerDeviceConsts.MAX_CONNECTIONS);
+                preferredDeviceIds.forEach((deviceId) => {
+                    deviceIdPriority2[deviceId] = (deviceIdPriority2[deviceId] || 0) + 1;
+                });
+            }
+            Object.keys(deviceIdPriority1).forEach((key) => {
+                if (deviceIdPriority1[key] < 2) {
+                    delete deviceIdPriority1[key];
+                }
+            });
+            Object.keys(deviceIdPriority2).forEach((key) => {
+                if (deviceIdPriority2[key] < 2) {
+                    delete deviceIdPriority2[key];
+                }
+            });
+            console.log("Device ID priority1: ", deviceIdPriority1);
+            console.log("Device ID priority2: ", deviceIdPriority2);
+            if ((0, lodash_1.isEqual)(deviceIdPriority1, deviceIdPriority2)) {
+                stable = true;
+                const highestPriority = (0, lodash_1.sortBy)(Object.entries(deviceIdPriority1), ([k, v]) => v).map(([k, v]) => k).reverse();
+                const peer = peers.find(p => p.deviceId === highestPriority[0]);
+                if (!peer)
+                    throw new Error("Peer not found");
+                const networkInfo = await peer.getNetworkInfo();
+                console.log(networkInfo);
+            }
+        }
+        await Promise.all(peers.map(peer => peer.dispose()));
+    });
+    it.skip("very large networks - should prune connections after 30 but maintain a fully connected network", async () => {
+        const peerCnt = 110;
+        const remotePeers = (0, lodash_1.range)(peerCnt).map(() => {
+            const errorRate = 0;
+            const latencyMs = 1;
+            return buildRemotePeer({ errorRate, latencyMs });
+        });
+        const peers = remotePeers.map(p => p.peer);
+        for (const peer of peers) {
+            getNotesTable(peer);
+        }
+        // connect all peers to each other
+        let connCnt = 0;
+        for (const peer1 of peers) {
+            for (const peer2 of peers) {
+                if (peer1 === peer2)
+                    continue;
+                const remotePeer = remotePeers.find(p => p.peer === peer2)?.remotePeer;
+                if (!remotePeer)
+                    throw new Error("Remote peer not found");
+                connCnt++;
+                await peer1.addConnection(remotePeer, {
+                    // resyncInterval: 4_000, 
+                    async onClose() {
+                        peer2.removeConnection(peer1.deviceId);
+                        peer1.removeConnection(peer2.deviceId);
+                    },
+                });
+            }
+        }
+        // await sleep(2000);
+        // PeerDevice.listChangesCount = 0;
+        // PeerDevice.applyChangesCount = 0;
+        // PeerDevice.getNetworkInfoCount = 0;
+        // PeerDevice.electPreferredConnectionsCount = 0;
+        let stable = false;
+        while (!stable) {
+            await (0, peers_sdk_1.sleep)(2000);
+            const deviceIdPriority1 = {};
+            for (const peer of peers) {
+                let preferredDeviceIds = (await peer.getNetworkInfo()).preferredDeviceIds;
+                const connections = peer.getConnections();
+                preferredDeviceIds = preferredDeviceIds.filter(deviceId => connections.find(c => c.deviceId === deviceId));
+                expect(preferredDeviceIds.length).toBeLessThanOrEqual(peers_sdk_1.PeerDeviceConsts.MAX_CONNECTIONS);
+                preferredDeviceIds.forEach((deviceId) => {
+                    deviceIdPriority1[deviceId] = (deviceIdPriority1[deviceId] || 0) + 1;
+                });
+            }
+            for (const peer of peers) {
+                await Promise.race([
+                    (0, peers_sdk_1.sleep)(20),
+                    peer.electPreferredConnections(),
+                ]);
+            }
+            await (0, peers_sdk_1.sleep)(2000);
+            const deviceIdPriority2 = {};
+            for (const peer of peers) {
+                let preferredDeviceIds = (await peer.getNetworkInfo()).preferredDeviceIds;
+                const connections = peer.getConnections();
+                preferredDeviceIds = preferredDeviceIds.filter(deviceId => connections.find(c => c.deviceId === deviceId));
+                expect(preferredDeviceIds.length).toBeLessThanOrEqual(peers_sdk_1.PeerDeviceConsts.MAX_CONNECTIONS);
+                preferredDeviceIds.forEach((deviceId) => {
+                    deviceIdPriority2[deviceId] = (deviceIdPriority2[deviceId] || 0) + 1;
+                });
+            }
+            if (!Object.keys(deviceIdPriority2).length) {
+                continue;
+            }
+            Object.keys(deviceIdPriority1).forEach((key) => {
+                if (deviceIdPriority1[key] < 3) {
+                    delete deviceIdPriority1[key];
+                }
+            });
+            Object.keys(deviceIdPriority2).forEach((key) => {
+                if (deviceIdPriority2[key] < 3) {
+                    delete deviceIdPriority2[key];
+                }
+            });
+            console.log("Device ID priority1: ", deviceIdPriority1);
+            console.log("Device ID priority2: ", deviceIdPriority2);
+            console.log("Total number of priority connections: ", Object.values(deviceIdPriority1).reduce((a, b) => a + b, 0));
+            // walk the network but only through priority connections
+            const connectedDevices = new Set();
+            let connectedPeers = [peers[0]];
+            while (connectedPeers.length) {
+                const peer = connectedPeers.pop();
+                if (!peer)
+                    break;
+                connectedDevices.add(peer.deviceId);
+                const priorityDeviceIds = peer.priorityDeviceIds.priorityDeviceIds;
+                for (const deviceId of priorityDeviceIds) {
+                    if (!connectedDevices.has(deviceId)) {
+                        const peer = peers.find(p => p.deviceId === deviceId);
+                        if (!peer)
+                            throw new Error("Peer not found");
+                        connectedPeers.push(peer);
+                    }
+                }
+            }
+            // // check if all devices are a preferred connection by at least one other device
+            // const preferredDeviceIds = new Set<string>();
+            // for (const peer of peers) {
+            //   peer.priorityDeviceIds.preferredDeviceIds.forEach((deviceId) => {
+            //     preferredDeviceIds.add(deviceId);
+            //   });
+            // }
+            if (connectedDevices.size < peerCnt) {
+                console.warn("Could not walk entire network through just priority connections");
+            }
+            // if (preferredDeviceIds.size < peerCnt) {
+            //   console.warn("Not all devices are connected through preferred connections");
+            // }
+            if ((0, lodash_1.isEqual)(deviceIdPriority1, deviceIdPriority2)) {
+                stable = true;
+                console.log("highest priority devices: ", (0, lodash_1.sortBy)(Object.entries(deviceIdPriority1), ([k, v]) => v).map(([k, v]) => [k, v]).reverse().slice(0, 20));
+                expect(connectedDevices.size).toEqual(peerCnt);
+                // expect(preferredDeviceIds.size).toEqual(peerCnt);
+            }
+        }
+        await Promise.all(peers.map(peer => peer.dispose()));
+    });
+    // For some reason this test fails when run with the rest but works when run alone
+    it.skip("should eventually recover when a change has data that doesn't match the schema", async () => {
+        const peer1 = buildPeer();
+        const peer2 = buildPeer();
+        const peer1Notes = getNotesTable(peer1);
+        const peer2Notes = getNotesTable(peer2);
+        const noteId = (0, peers_sdk_1.newid)();
+        const note1 = await peer1Notes.save({ noteId, title: "note inserted" });
+        const note2 = await peer1Notes.save({ noteId: (0, peers_sdk_1.newid)(), title: "note inserted" });
+        const now = Date.now();
+        await peer1.changeTrackingTable.insert({
+            changeId: (0, peers_sdk_1.newid)(),
+            tableName: notesTableName,
+            recordId: noteId,
+            timestamp: now,
+            timestampApplied: now,
+            changeType: 'update',
+            newRecord: { noteId, title: 1 },
+            jsonDiff: [{ op: 'replace', path: '/title', value: 1 }]
+        });
+        await peer2.syncWithRemoteDevice(peer1);
+        let notes1 = await peer1Notes.list();
+        let notes2 = await peer2Notes.list();
+        // Peer1 has both notes
+        expect(notes1.length).toEqual(2);
+        // Peer2 has only the second note, because the first one has the erroneous change which is preventing it from being synced
+        expect(notes2.length).toEqual(1);
+        // peer1 overwrites the bad change
+        await peer1Notes.update({ noteId, title: "note updated" });
+        await peer2.syncWithRemoteDevice(peer1);
+        notes1 = await peer1Notes.list();
+        notes2 = await peer2Notes.list();
+        // this time the first note made it through
+        expect(notes1).toEqual(notes2);
+    });
+    it("should handle changes that can't be inserted", async () => {
+        const peer1 = buildPeer();
+        const peer1Notes = getNotesTable(peer1);
+        const recordId = (0, peers_sdk_1.newid)();
+        await peer1.applyChanges([
+            {
+                changeId: (0, peers_sdk_1.newid)(),
+                tableName: notesTableName,
+                recordId,
+                timestamp: Date.now(),
+                timestampApplied: Date.now(),
+                changeType: 'insert',
+                newRecord: { noteId: recordId, title: "note inserted" },
+            },
+            // @ts-ignore
+            {
+                changeId: (0, peers_sdk_1.newid)(),
+                tableName: notesTableName,
+                recordId,
+                timestamp: Date.now(),
+                timestampApplied: Date.now(),
+                changeType: 'update',
+                newRecord: { noteId: recordId, title: "note inserted" },
+            },
+            {
+                changeId: (0, peers_sdk_1.newid)(),
+                tableName: notesTableName,
+                recordId,
+                timestamp: Date.now(),
+                timestampApplied: Date.now(),
+                changeType: 'update',
+                newRecord: { noteId: recordId, title: "note updated" },
+                jsonDiff: [{ op: 'replace', path: '/title', value: "note updated" }]
+            }
+        ]);
+        const notes = await peer1Notes.list();
+        expect(notes).toEqual([{ noteId: recordId, title: "note updated" }]);
+    });
+    it.todo("should establish connections with remote peers to try to become 'well' connected");
+    it.todo("should correctly apply a batch of changes that includes multiple tables with interleaved timestamps");
+    it.todo("should ensure connected devices agree on the current time");
+    it.todo("should not allow changes with a timestamp or timestampApplied in the future");
+});
+//# sourceMappingURL=device-sync.test.js.map