@peers-app/peers-device 0.15.0 → 0.15.2

package/dist/tracked-data-source.test.js

@@ -6,7 +6,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 const peers_sdk_1 = require("@peers-app/peers-sdk");
 const tracked_data_source_1 = require("./tracked-data-source");
 const local_data_source_1 = require("./local.data-source");
-describe('TrackedDataSource', () => {
+describe("TrackedDataSource", () => {
     let db;
     let sqlDataSource;
     // let Notes: Table<INote>;
@@ -21,13 +21,13 @@ describe('TrackedDataSource', () => {
         links: peers_sdk_1.zodAnyObject.optional(),
     });
     const NotesMetaData = {
-        name: 'notes',
-        description: '',
-        primaryKeyName: 'noteId',
+        name: "notes",
+        description: "",
+        primaryKeyName: "noteId",
         fields: (0, peers_sdk_1.schemaToFields)(notesSchema),
     };
     beforeAll(async () => {
-        db = new local_data_source_1.DBLocal(':memory:');
+        db = new local_data_source_1.DBLocal(":memory:");
     });
     afterEach(() => {
         trackedTable.preserveHistory = false;
@@ -38,9 +38,9 @@ describe('TrackedDataSource', () => {
         }
     });
     async function dataSourceFactory(db) {
-        let createDb = !db;
+        const createDb = !db;
         if (!db) {
-            db = new local_data_source_1.DBLocal(':memory:');
+            db = new local_data_source_1.DBLocal(":memory:");
         }
         // Create fresh instances for each test
         sqlDataSource = new peers_sdk_1.SQLDataSource(db, NotesMetaData, notesSchema);
@@ -71,19 +71,23 @@ describe('TrackedDataSource', () => {
     beforeEach(async () => {
         [changeTrackingTable, trackedTable] = await dataSourceFactory(db);
     });
-    describe('Insert Operations', () => {
-        it('should insert a record and create a single full-object change', async () => {
-            const note = await trackedTable.insert({ noteId: (0, peers_sdk_1.newid)(), title: 'test note', completed: false });
+    describe("Insert Operations", () => {
+        it("should insert a record and create a single full-object change", async () => {
+            const note = await trackedTable.insert({
+                noteId: (0, peers_sdk_1.newid)(),
+                title: "test note",
+                completed: false,
+            });
             expect(note.noteId).toBeDefined();
-            expect(note.title).toBe('test note');
+            expect(note.title).toBe("test note");
             // Check that changes were recorded
-            const changes = await changeTrackingTable.list({ tableName: 'notes', recordId: note.noteId });
+            const changes = await changeTrackingTable.list({ tableName: "notes", recordId: note.noteId });
             // Should have exactly one change at path "/"
             expect(changes.length).toBe(1);
-            expect(changes[0].op).toBe('set');
-            expect(changes[0].path).toBe('/');
+            expect(changes[0].op).toBe("set");
+            expect(changes[0].path).toBe("/");
             expect(changes[0].value).toBeNull(); // value is null in the changes table; resolved at query time via listChanges
-            expect(changes[0].tableName).toBe('notes');
+            expect(changes[0].tableName).toBe("notes");
             expect(changes[0].recordId).toBe(note.noteId);
             expect(changes[0].createdAt).toBeDefined();
             expect(changes[0].appliedAt).toBeDefined();
@@ -94,59 +98,78 @@ describe('TrackedDataSource', () => {
             const resolvedChanges = await trackedTable.listChanges({ recordId: note.noteId });
             expect(resolvedChanges[0].value).toEqual(note);
         });
-        it('should auto-generate noteId if not provided', async () => {
-            const note = await trackedTable.insert({ title: 'test note' });
+        it("should auto-generate noteId if not provided", async () => {
+            const note = await trackedTable.insert({ title: "test note" });
             expect(note.noteId).toBeDefined();
             expect(note.noteId.length).toBeGreaterThan(0);
         });
-        it('should store operations in sequential timestamp order', async () => {
-            const note = await trackedTable.insert({ noteId: (0, peers_sdk_1.newid)(), title: 'test note', completed: false });
-            const changes = await changeTrackingTable.list({ tableName: 'notes', recordId: note.noteId }, { sortBy: ['createdAt'] });
+        it("should store operations in sequential timestamp order", async () => {
+            const note = await trackedTable.insert({
+                noteId: (0, peers_sdk_1.newid)(),
+                title: "test note",
+                completed: false,
+            });
+            const changes = await changeTrackingTable.list({ tableName: "notes", recordId: note.noteId }, { sortBy: ["createdAt"] });
             // Verify timestamps are sequential
             for (let i = 1; i < changes.length; i++) {
                 expect(changes[i].createdAt).toBeGreaterThan(changes[i - 1].createdAt);
             }
         });
     });
-    describe('Update Operations', () => {
-        it('should update a record and store granular change records', async () => {
+    describe("Update Operations", () => {
+        it("should update a record and store granular change records", async () => {
             // Insert
-            const note = await trackedTable.insert({ noteId: (0, peers_sdk_1.newid)(), title: 'original' });
+            const note = await trackedTable.insert({ noteId: (0, peers_sdk_1.newid)(), title: "original" });
             // Count initial changes
-            const initialChanges = await changeTrackingTable.list({ tableName: 'notes', recordId: note.noteId });
+            const initialChanges = await changeTrackingTable.list({
+                tableName: "notes",
+                recordId: note.noteId,
+            });
             const initialCount = initialChanges.length;
             // Update
-            note.title = 'updated';
+            note.title = "updated";
             note.completed = true;
             await trackedTable.update(note);
             // Check that new changes were added
-            const allChanges = await changeTrackingTable.list({ tableName: 'notes', recordId: note.noteId });
+            const allChanges = await changeTrackingTable.list({
+                tableName: "notes",
+                recordId: note.noteId,
+            });
             expect(allChanges.length).toBeGreaterThan(initialCount);
             // The new changes should be 'replace' or 'add' operations
             const updateChanges = allChanges.slice(initialCount);
             updateChanges.forEach((change) => {
-                expect(['set', 'delete', 'patch-text']).toContain(change.op);
+                expect(["set", "delete", "patch-text"]).toContain(change.op);
             });
             // Verify the record was actually updated
             const retrieved = await trackedTable.get(note.noteId);
-            expect(retrieved?.title).toBe('updated');
+            expect(retrieved?.title).toBe("updated");
             expect(retrieved?.completed).toBe(true);
         });
-        it('should handle no-op updates gracefully', async () => {
-            const note = await trackedTable.insert({ noteId: (0, peers_sdk_1.newid)(), title: 'test' });
-            const changesBeforeUpdate = await changeTrackingTable.list({ tableName: 'notes', recordId: note.noteId });
+        it("should handle no-op updates gracefully", async () => {
+            const note = await trackedTable.insert({ noteId: (0, peers_sdk_1.newid)(), title: "test" });
+            const changesBeforeUpdate = await changeTrackingTable.list({
+                tableName: "notes",
+                recordId: note.noteId,
+            });
             // Update with same values
             await trackedTable.update(note);
-            const changesAfterUpdate = await changeTrackingTable.list({ tableName: 'notes', recordId: note.noteId });
+            const changesAfterUpdate = await changeTrackingTable.list({
+                tableName: "notes",
+                recordId: note.noteId,
+            });
             expect(changesAfterUpdate.length).toBe(changesBeforeUpdate.length); // No new changes
         });
-        it('should mark old changes as superseded when saveAsSnapshot is true', async () => {
-            const note = await trackedTable.insert({ noteId: (0, peers_sdk_1.newid)(), title: 'original' });
+        it("should mark old changes as superseded when saveAsSnapshot is true", async () => {
+            const note = await trackedTable.insert({ noteId: (0, peers_sdk_1.newid)(), title: "original" });
             // Get initial changes
-            const initialChanges = await changeTrackingTable.list({ tableName: 'notes', recordId: note.noteId });
+            const initialChanges = await changeTrackingTable.list({
+                tableName: "notes",
+                recordId: note.noteId,
+            });
             expect(initialChanges.every((c) => !c.supersededAt)).toBe(true);
             // Update with saveAsSnapshot
-            note.title = 'updated';
+            note.title = "updated";
             await trackedTable.save(note, { saveAsSnapshot: true });
             // Check that old changes are marked as superseded
             const oldChanges = await changeTrackingTable.list({
@@ -168,30 +191,30 @@ describe('TrackedDataSource', () => {
             });
         });
     });
-    describe('Delete Operations', () => {
-        it('should delete a record and create a remove operation', async () => {
-            const note = await trackedTable.insert({ noteId: (0, peers_sdk_1.newid)(), title: 'test' });
+    describe("Delete Operations", () => {
+        it("should delete a record and create a remove operation", async () => {
+            const note = await trackedTable.insert({ noteId: (0, peers_sdk_1.newid)(), title: "test" });
             await trackedTable.delete(note);
             // Check for remove operation
-            const changes = await changeTrackingTable.list({ tableName: 'notes', recordId: note.noteId });
-            const removeOp = changes.find((c) => c.op === 'delete');
+            const changes = await changeTrackingTable.list({ tableName: "notes", recordId: note.noteId });
+            const removeOp = changes.find((c) => c.op === "delete");
             expect(removeOp).toBeDefined();
-            expect(removeOp?.op).toBe('delete');
+            expect(removeOp?.op).toBe("delete");
             // Verify record was deleted
             const retrieved = await trackedTable.get(note.noteId);
             expect(retrieved).toBeUndefined();
         });
-        it('should delete by string ID', async () => {
-            const note = await trackedTable.insert({ noteId: (0, peers_sdk_1.newid)(), title: 'test' });
+        it("should delete by string ID", async () => {
+            const note = await trackedTable.insert({ noteId: (0, peers_sdk_1.newid)(), title: "test" });
             await trackedTable.delete(note.noteId);
             const retrieved = await trackedTable.get(note.noteId);
             expect(retrieved).toBeUndefined();
         });
-        it('should mark old changes as superseded after delete', async () => {
-            const note = await trackedTable.insert({ noteId: (0, peers_sdk_1.newid)(), title: 'test' });
+        it("should mark old changes as superseded after delete", async () => {
+            const note = await trackedTable.insert({ noteId: (0, peers_sdk_1.newid)(), title: "test" });
             // Initial changes should not be superseded
             const beforeDelete = await changeTrackingTable.list({
-                tableName: 'notes',
+                tableName: "notes",
                 recordId: note.noteId,
                 supersededAt: { $exists: false },
             });
@@ -199,16 +222,16 @@ describe('TrackedDataSource', () => {
             await trackedTable.delete(note);
             // Old changes should now be superseded (except the remove operation)
             const superseded = await changeTrackingTable.list({
-                tableName: 'notes',
+                tableName: "notes",
                 recordId: note.noteId,
                 supersededAt: { $exists: true },
             });
             expect(superseded.length).toBeGreaterThan(0);
         });
     });
-    describe('Restore Operations', () => {
-        it('should restore a deleted record', async () => {
-            const note = await trackedTable.insert({ noteId: (0, peers_sdk_1.newid)(), title: 'test' });
+    describe("Restore Operations", () => {
+        it("should restore a deleted record", async () => {
+            const note = await trackedTable.insert({ noteId: (0, peers_sdk_1.newid)(), title: "test" });
             await trackedTable.delete(note);
             // Restore
             const restored = await trackedTable.restore(note);
@@ -218,52 +241,58 @@ describe('TrackedDataSource', () => {
             const retrieved = await trackedTable.get(note.noteId);
             expect(retrieved).toEqual(note);
         });
-        it('should create a single add operation for restored record', async () => {
-            const note = await trackedTable.insert({ noteId: (0, peers_sdk_1.newid)(), title: 'test' });
+        it("should create a single add operation for restored record", async () => {
+            const note = await trackedTable.insert({ noteId: (0, peers_sdk_1.newid)(), title: "test" });
             const noteId = note.noteId;
             await trackedTable.delete(note);
             // Count changes before restore
-            const beforeRestore = await changeTrackingTable.list({ tableName: 'notes', recordId: noteId });
+            const beforeRestore = await changeTrackingTable.list({
+                tableName: "notes",
+                recordId: noteId,
+            });
             await trackedTable.restore(note);
-            const afterRestore = await changeTrackingTable.list({ tableName: 'notes', recordId: noteId });
+            const afterRestore = await changeTrackingTable.list({ tableName: "notes", recordId: noteId });
             expect(afterRestore.length).toBe(beforeRestore.length + 1);
             // Find the new 'add' operation from restore (should be exactly one at path "/")
             const restoreOps = afterRestore.filter((c) => !c.supersededAt);
             expect(restoreOps.length).toBe(1);
-            expect(restoreOps[0].op).toBe('set');
-            expect(restoreOps[0].path).toBe('/');
+            expect(restoreOps[0].op).toBe("set");
+            expect(restoreOps[0].path).toBe("/");
             expect(restoreOps[0].value).toBeNull(); // value is null in the changes table; resolved at query time
         });
-        it('should mark old changes as superseded after restore', async () => {
-            const note = await trackedTable.insert({ noteId: (0, peers_sdk_1.newid)(), title: 'test' });
+        it("should mark old changes as superseded after restore", async () => {
+            const note = await trackedTable.insert({ noteId: (0, peers_sdk_1.newid)(), title: "test" });
             await trackedTable.delete(note);
             await trackedTable.restore(note);
             const superseded = await changeTrackingTable.list({
-                tableName: 'notes',
+                tableName: "notes",
                 recordId: note.noteId,
                 supersededAt: { $exists: true },
             });
             expect(superseded.length).toBeGreaterThan(0);
         });
     });
-    describe('Save Operations', () => {
-        it('should route to insert for new records', async () => {
-            const note = await trackedTable.save({ noteId: (0, peers_sdk_1.newid)(), title: 'test' });
+    describe("Save Operations", () => {
+        it("should route to insert for new records", async () => {
+            const note = await trackedTable.save({ noteId: (0, peers_sdk_1.newid)(), title: "test" });
             expect(note.noteId).toBeDefined();
-            const changes = await changeTrackingTable.list({ tableName: 'notes', recordId: note.noteId });
+            const changes = await changeTrackingTable.list({ tableName: "notes", recordId: note.noteId });
             expect(changes.length).toBeGreaterThan(0);
-            expect(changes.every((c) => c.op === 'set')).toBe(true);
+            expect(changes.every((c) => c.op === "set")).toBe(true);
         });
-        it('should route to update for existing records', async () => {
-            const note = await trackedTable.insert({ noteId: (0, peers_sdk_1.newid)(), title: 'original' });
-            const initialCount = (await changeTrackingTable.list({ tableName: 'notes', recordId: note.noteId })).length;
-            note.title = 'updated';
+        it("should route to update for existing records", async () => {
+            const note = await trackedTable.insert({ noteId: (0, peers_sdk_1.newid)(), title: "original" });
+            const initialCount = (await changeTrackingTable.list({ tableName: "notes", recordId: note.noteId })).length;
+            note.title = "updated";
             await trackedTable.save(note);
-            const allChanges = await changeTrackingTable.list({ tableName: 'notes', recordId: note.noteId });
+            const allChanges = await changeTrackingTable.list({
+                tableName: "notes",
+                recordId: note.noteId,
+            });
             expect(allChanges.length).toBeGreaterThan(initialCount);
         });
-        it('should restore deleted record when restoreIfDeleted is true', async () => {
-            const note = await trackedTable.insert({ noteId: (0, peers_sdk_1.newid)(), title: 'test' });
+        it("should restore deleted record when restoreIfDeleted is true", async () => {
+            const note = await trackedTable.insert({ noteId: (0, peers_sdk_1.newid)(), title: "test" });
             await trackedTable.delete(note);
             // Try to save with restoreIfDeleted option
             const restored = await trackedTable.save(note, { restoreIfDeleted: true });
@@ -271,15 +300,15 @@ describe('TrackedDataSource', () => {
             const retrieved = await trackedTable.get(note.noteId);
             expect(retrieved).toBeDefined();
         });
-        it('should throw error when saving deleted record without restoreIfDeleted', async () => {
-            const note = await trackedTable.insert({ noteId: (0, peers_sdk_1.newid)(), title: 'test' });
+        it("should throw error when saving deleted record without restoreIfDeleted", async () => {
+            const note = await trackedTable.insert({ noteId: (0, peers_sdk_1.newid)(), title: "test" });
             await trackedTable.delete(note);
-            await expect(trackedTable.save(note)).rejects.toThrow('has been deleted');
+            await expect(trackedTable.save(note)).rejects.toThrow("has been deleted");
         });
-        it('should save snapshots as a single add at root path', async () => {
-            const note = await trackedTable.insert({ noteId: (0, peers_sdk_1.newid)(), title: 'original', count: 1 });
-            const updatedNote = await trackedTable.save({ ...note, title: 'updated', count: 2 }, { saveAsSnapshot: true });
-            const changes = await changeTrackingTable.list({ recordId: note.noteId }, { sortBy: ['createdAt'] });
+        it("should save snapshots as a single add at root path", async () => {
+            const note = await trackedTable.insert({ noteId: (0, peers_sdk_1.newid)(), title: "original", count: 1 });
+            const updatedNote = await trackedTable.save({ ...note, title: "updated", count: 2 }, { saveAsSnapshot: true });
+            const changes = await changeTrackingTable.list({ recordId: note.noteId }, { sortBy: ["createdAt"] });
             expect(changes.length).toBe(2); // One for insert, one for snapshot save
             // Both insert and snapshot changes store null value (resolved at query time)
             expect(changes[0].value).toBeNull();
@@ -290,84 +319,84 @@ describe('TrackedDataSource', () => {
             expect(resolvedChanges[0].value).toEqual(updatedNote);
             expect(resolvedChanges[1].value).toEqual(updatedNote);
         });
-        it('should save non-snapshot updates as individual changes', async () => {
-            const note = await trackedTable.insert({ noteId: (0, peers_sdk_1.newid)(), title: 'original', count: 1 });
-            await trackedTable.save({ ...note, title: 'updated', count: 2 });
-            const changes = await changeTrackingTable.list({ recordId: note.noteId }, { sortBy: ['createdAt'] });
+        it("should save non-snapshot updates as individual changes", async () => {
+            const note = await trackedTable.insert({ noteId: (0, peers_sdk_1.newid)(), title: "original", count: 1 });
+            await trackedTable.save({ ...note, title: "updated", count: 2 });
+            const changes = await changeTrackingTable.list({ recordId: note.noteId }, { sortBy: ["createdAt"] });
             expect(changes.length).toBe(3); // One for insert, two for field updates
             expect(changes[0].value).toBeNull(); // Insert change stores null; resolved at query time
             // Granular field updates still store their values inline
-            const titleChange = changes.find(c => c.path === '/title');
-            const countChange = changes.find(c => c.path === '/count');
-            expect(titleChange?.value).toBe('updated');
+            const titleChange = changes.find((c) => c.path === "/title");
+            const countChange = changes.find((c) => c.path === "/count");
+            expect(titleChange?.value).toBe("updated");
             expect(countChange?.value).toBe(2);
         });
     });
-    describe('weakInsert Option', () => {
-        it('should use weak timestamp (1 + Math.random()) for insert with weakInsert: true', async () => {
-            const note = await trackedTable.insert({ noteId: (0, peers_sdk_1.newid)(), title: 'test' }, { weakInsert: true });
+    describe("weakInsert Option", () => {
+        it("should use weak timestamp (1 + Math.random()) for insert with weakInsert: true", async () => {
+            const note = await trackedTable.insert({ noteId: (0, peers_sdk_1.newid)(), title: "test" }, { weakInsert: true });
             const now = Date.now() - 2;
-            const changes = await changeTrackingTable.list({ tableName: 'notes', recordId: note.noteId });
+            const changes = await changeTrackingTable.list({ tableName: "notes", recordId: note.noteId });
             expect(changes.length).toBe(1);
             const change = changes[0];
             expect(change.createdAt).toBeGreaterThanOrEqual(1);
             expect(change.createdAt).toBeLessThan(2); // 1 + Math.random() is between 1 and 2
-            expect(change.appliedAt).toBeGreaterThanOrEqual(now); // appliedAt should be the current datetime 
+            expect(change.appliedAt).toBeGreaterThanOrEqual(now); // appliedAt should be the current datetime
         });
-        it('should use normal timestamp for insert without weakInsert', async () => {
-            const note = await trackedTable.insert({ noteId: (0, peers_sdk_1.newid)(), title: 'test' });
-            const changes = await changeTrackingTable.list({ tableName: 'notes', recordId: note.noteId });
+        it("should use normal timestamp for insert without weakInsert", async () => {
+            const note = await trackedTable.insert({ noteId: (0, peers_sdk_1.newid)(), title: "test" });
+            const changes = await changeTrackingTable.list({ tableName: "notes", recordId: note.noteId });
             expect(changes.length).toBe(1);
             const change = changes[0];
             // Normal timestamp should be much larger (performance.timeOrigin + performance.now() or Date.now())
             expect(change.createdAt).toBeGreaterThan(1000);
         });
-        it('should use normal timestamp for insert with weakInsert: false', async () => {
-            const note = await trackedTable.insert({ noteId: (0, peers_sdk_1.newid)(), title: 'test' }, { weakInsert: false });
-            const changes = await changeTrackingTable.list({ tableName: 'notes', recordId: note.noteId });
+        it("should use normal timestamp for insert with weakInsert: false", async () => {
+            const note = await trackedTable.insert({ noteId: (0, peers_sdk_1.newid)(), title: "test" }, { weakInsert: false });
+            const changes = await changeTrackingTable.list({ tableName: "notes", recordId: note.noteId });
             expect(changes.length).toBe(1);
             const change = changes[0];
             // weakInsert: false should use normal timestamp
             expect(change.createdAt).toBeGreaterThan(1000);
         });
-        it('should use weak timestamp for save (new record) with weakInsert: true', async () => {
-            const note = await trackedTable.save({ noteId: (0, peers_sdk_1.newid)(), title: 'test' }, { weakInsert: true });
-            const changes = await changeTrackingTable.list({ tableName: 'notes', recordId: note.noteId });
+        it("should use weak timestamp for save (new record) with weakInsert: true", async () => {
+            const note = await trackedTable.save({ noteId: (0, peers_sdk_1.newid)(), title: "test" }, { weakInsert: true });
+            const changes = await changeTrackingTable.list({ tableName: "notes", recordId: note.noteId });
             expect(changes.length).toBe(1);
             const change = changes[0];
             expect(change.createdAt).toBeGreaterThanOrEqual(1);
             expect(change.createdAt).toBeLessThan(2);
         });
-        it('should not affect update operations (weakInsert ignored for updates)', async () => {
+        it("should not affect update operations (weakInsert ignored for updates)", async () => {
             // Insert with normal timestamp
-            const note = await trackedTable.insert({ noteId: (0, peers_sdk_1.newid)(), title: 'original' });
-            const initialChange = (await changeTrackingTable.list({ tableName: 'notes', recordId: note.noteId }))[0];
+            const note = await trackedTable.insert({ noteId: (0, peers_sdk_1.newid)(), title: "original" });
+            const initialChange = (await changeTrackingTable.list({ tableName: "notes", recordId: note.noteId }))[0];
             const initialTimestamp = initialChange.createdAt;
             // Update with weakInsert - should not affect the update timestamp
-            note.title = 'updated';
+            note.title = "updated";
             await trackedTable.save(note, { weakInsert: true });
-            const allChanges = await changeTrackingTable.list({ tableName: 'notes', recordId: note.noteId }, { sortBy: ['createdAt'] });
+            const allChanges = await changeTrackingTable.list({ tableName: "notes", recordId: note.noteId }, { sortBy: ["createdAt"] });
             // Should have more changes (the update)
             expect(allChanges.length).toBeGreaterThan(1);
             // The update changes should have normal timestamps (not weak)
             const updateChanges = allChanges.slice(1);
-            updateChanges.forEach(change => {
+            updateChanges.forEach((change) => {
                 expect(change.createdAt).toBeGreaterThan(initialTimestamp);
                 expect(change.createdAt).toBeGreaterThan(1000); // Normal timestamp
             });
         });
-        it('should use weak timestamp when save routes to insert (existing ID but no record)', async () => {
+        it("should use weak timestamp when save routes to insert (existing ID but no record)", async () => {
             const noteId = (0, peers_sdk_1.newid)();
             // Save with an ID but no existing record - this routes to _insert
-            const note = await trackedTable.save({ noteId, title: 'test' }, { weakInsert: true });
-            const changes = await changeTrackingTable.list({ tableName: 'notes', recordId: noteId });
+            const note = await trackedTable.save({ noteId, title: "test" }, { weakInsert: true });
+            const changes = await changeTrackingTable.list({ tableName: "notes", recordId: noteId });
             expect(changes.length).toBe(1);
             const change = changes[0];
             expect(change.createdAt).toBeGreaterThanOrEqual(1);
             expect(change.createdAt).toBeLessThan(2);
         });
-        it('should work with restoreIfDeleted option', async () => {
-            const note = await trackedTable.insert({ noteId: (0, peers_sdk_1.newid)(), title: 'test' });
+        it("should work with restoreIfDeleted option", async () => {
+            const note = await trackedTable.insert({ noteId: (0, peers_sdk_1.newid)(), title: "test" });
             await trackedTable.delete(note);
             // Restore with weakInsert - note: restore doesn't use weakInsert, but we can test the combination
             const restored = await trackedTable.save(note, { restoreIfDeleted: true, weakInsert: true });
@@ -377,34 +406,34 @@ describe('TrackedDataSource', () => {
             const retrieved = await trackedTable.get(note.noteId);
             expect(retrieved).toBeDefined();
         });
-        it('should work with saveAsSnapshot option', async () => {
-            const note = await trackedTable.insert({ noteId: (0, peers_sdk_1.newid)(), title: 'original' });
+        it("should work with saveAsSnapshot option", async () => {
+            const note = await trackedTable.insert({ noteId: (0, peers_sdk_1.newid)(), title: "original" });
             // Save as snapshot with weakInsert
-            const updated = await trackedTable.save({ ...note, title: 'updated' }, { saveAsSnapshot: true, weakInsert: true });
+            const updated = await trackedTable.save({ ...note, title: "updated" }, { saveAsSnapshot: true, weakInsert: true });
             // The snapshot save is an update, so weakInsert won't affect it
             // But we can verify the operation completed successfully
             const retrieved = await trackedTable.get(note.noteId);
-            expect(retrieved?.title).toBe('updated');
+            expect(retrieved?.title).toBe("updated");
         });
-        it('should allow weak writes to be superseded by normal writes', async () => {
+        it("should allow weak writes to be superseded by normal writes", async () => {
             const noteId = (0, peers_sdk_1.newid)();
             // First, insert with weakInsert (simulating a new device creating the record)
-            const note1 = await trackedTable.insert({ noteId, title: 'weak write 1' }, { weakInsert: true });
-            const change1 = (await changeTrackingTable.list({ tableName: 'notes', recordId: noteId }))[0];
+            const note1 = await trackedTable.insert({ noteId, title: "weak write 1" }, { weakInsert: true });
+            const change1 = (await changeTrackingTable.list({ tableName: "notes", recordId: noteId }))[0];
             expect(change1.createdAt).toBeLessThan(2);
             expect(change1.createdAt).toBeGreaterThanOrEqual(1);
             // Wait a bit to ensure normal timestamp is later
             await (0, peers_sdk_1.sleep)(10);
             // Then, update with normal write (simulating another device with authoritative data)
             // This simulates the scenario where an existing device updates the record
-            note1.title = 'normal write';
+            note1.title = "normal write";
             await trackedTable.save(note1); // Normal save without weakInsert
-            const allChanges = await changeTrackingTable.list({ tableName: 'notes', recordId: noteId }, { sortBy: ['createdAt'] });
+            const allChanges = await changeTrackingTable.list({ tableName: "notes", recordId: noteId }, { sortBy: ["createdAt"] });
             // Should have more than 1 change (initial insert + update changes)
             expect(allChanges.length).toBeGreaterThan(1);
             // The update changes should have normal timestamps
             const updateChanges = allChanges.slice(1);
-            updateChanges.forEach(change => {
+            updateChanges.forEach((change) => {
                 expect(change.createdAt).toBeGreaterThan(1000); // Normal timestamp
             });
             // Verify that the initial weak write has a weak timestamp
@@ -412,45 +441,45 @@ describe('TrackedDataSource', () => {
             expect(change1.createdAt).toBeGreaterThanOrEqual(1);
             // The final record should reflect the normal write (update takes precedence)
             const final = await trackedTable.get(noteId);
-            expect(final?.title).toBe('normal write');
+            expect(final?.title).toBe("normal write");
             // Note: The initial change at path "/" may or may not be superseded depending on the update logic.
-            // The key point is that weak writes have very small timestamps (1 + Math.random()) and normal writes 
-            // have large timestamps, so when syncing between devices, the normal writes will take precedence 
+            // The key point is that weak writes have very small timestamps (1 + Math.random()) and normal writes
+            // have large timestamps, so when syncing between devices, the normal writes will take precedence
             // due to their later timestamps.
         });
-        it('should use weak timestamp for insert called via save when recordId is provided but record does not exist', async () => {
+        it("should use weak timestamp for insert called via save when recordId is provided but record does not exist", async () => {
             const noteId = (0, peers_sdk_1.newid)();
             // Save with an ID but no existing record - routes to _insert with skipDeletedCheck=true
-            const note = await trackedTable.save({ noteId, title: 'test' }, { weakInsert: true });
-            const changes = await changeTrackingTable.list({ tableName: 'notes', recordId: noteId });
+            const note = await trackedTable.save({ noteId, title: "test" }, { weakInsert: true });
+            const changes = await changeTrackingTable.list({ tableName: "notes", recordId: noteId });
             expect(changes.length).toBe(1);
             const change = changes[0];
             expect(change.createdAt).toBeGreaterThanOrEqual(1);
             expect(change.createdAt).toBeLessThan(2);
         });
     });
-    describe('Read Operations', () => {
-        it('should get a record by id', async () => {
-            const note = await trackedTable.insert({ noteId: (0, peers_sdk_1.newid)(), title: 'test' });
+    describe("Read Operations", () => {
+        it("should get a record by id", async () => {
+            const note = await trackedTable.insert({ noteId: (0, peers_sdk_1.newid)(), title: "test" });
             const retrieved = await trackedTable.get(note.noteId);
             expect(retrieved).toEqual(note);
         });
-        it('should list records with filters', async () => {
-            await trackedTable.insert({ noteId: (0, peers_sdk_1.newid)(), title: 'note1', completed: true });
-            await trackedTable.insert({ noteId: (0, peers_sdk_1.newid)(), title: 'note2', completed: false });
+        it("should list records with filters", async () => {
+            await trackedTable.insert({ noteId: (0, peers_sdk_1.newid)(), title: "note1", completed: true });
+            await trackedTable.insert({ noteId: (0, peers_sdk_1.newid)(), title: "note2", completed: false });
             const completed = await trackedTable.list({ completed: true });
             expect(completed.length).toBe(1);
-            expect(completed[0].title).toBe('note1');
+            expect(completed[0].title).toBe("note1");
         });
-        it('should count records', async () => {
-            await trackedTable.insert({ noteId: (0, peers_sdk_1.newid)(), title: 'note1' });
-            await trackedTable.insert({ noteId: (0, peers_sdk_1.newid)(), title: 'note2' });
+        it("should count records", async () => {
+            await trackedTable.insert({ noteId: (0, peers_sdk_1.newid)(), title: "note1" });
+            await trackedTable.insert({ noteId: (0, peers_sdk_1.newid)(), title: "note2" });
             const count = await trackedTable.count();
             expect(count).toBe(2);
         });
-        it('should iterate records with cursor', async () => {
-            await trackedTable.insert({ noteId: (0, peers_sdk_1.newid)(), title: 'note1' });
-            await trackedTable.insert({ noteId: (0, peers_sdk_1.newid)(), title: 'note2' });
+        it("should iterate records with cursor", async () => {
+            await trackedTable.insert({ noteId: (0, peers_sdk_1.newid)(), title: "note1" });
+            await trackedTable.insert({ noteId: (0, peers_sdk_1.newid)(), title: "note2" });
             const cursor = trackedTable.cursor();
             const notes = [];
             for await (const note of cursor) {
@@ -459,25 +488,25 @@ describe('TrackedDataSource', () => {
             expect(notes.length).toBe(2);
         });
     });
-    describe('Change Tracking Methods', () => {
-        it('should list changes for this table', async () => {
-            await trackedTable.insert({ noteId: (0, peers_sdk_1.newid)(), title: 'test' });
+    describe("Change Tracking Methods", () => {
+        it("should list changes for this table", async () => {
+            await trackedTable.insert({ noteId: (0, peers_sdk_1.newid)(), title: "test" });
             const changes = await trackedTable.listChanges();
             expect(changes.length).toBeGreaterThan(0);
             changes.forEach((c) => {
-                expect(c.tableName).toBe('notes');
+                expect(c.tableName).toBe("notes");
             });
         });
-        it('should filter changes by recordId', async () => {
-            const note1 = await trackedTable.insert({ noteId: (0, peers_sdk_1.newid)(), title: 'note1' });
-            const note2 = await trackedTable.insert({ noteId: (0, peers_sdk_1.newid)(), title: 'note2' });
+        it("should filter changes by recordId", async () => {
+            const note1 = await trackedTable.insert({ noteId: (0, peers_sdk_1.newid)(), title: "note1" });
+            const note2 = await trackedTable.insert({ noteId: (0, peers_sdk_1.newid)(), title: "note2" });
             const changes1 = await trackedTable.listChanges({ recordId: note1.noteId });
             expect(changes1.every((c) => c.recordId === note1.noteId)).toBe(true);
             const changes2 = await trackedTable.listChanges({ recordId: note2.noteId });
             expect(changes2.every((c) => c.recordId === note2.noteId)).toBe(true);
         });
-        it('should use cursor for changes', async () => {
-            await trackedTable.insert({ noteId: (0, peers_sdk_1.newid)(), title: 'test' });
+        it("should use cursor for changes", async () => {
+            await trackedTable.insert({ noteId: (0, peers_sdk_1.newid)(), title: "test" });
             const cursor = await trackedTable.cursorChanges();
             const changes = [];
             for await (const change of cursor) {
@@ -486,36 +515,41 @@ describe('TrackedDataSource', () => {
             expect(changes.length).toBeGreaterThan(0);
         });
     });
-    describe('Helper Methods', () => {
-        it('should identify deleted records', async () => {
-            const note1 = await trackedTable.insert({ noteId: (0, peers_sdk_1.newid)(), title: 'note1' });
-            const note2 = await trackedTable.insert({ noteId: (0, peers_sdk_1.newid)(), title: 'note2' });
+    describe("Helper Methods", () => {
+        it("should identify deleted records", async () => {
+            const note1 = await trackedTable.insert({ noteId: (0, peers_sdk_1.newid)(), title: "note1" });
+            const note2 = await trackedTable.insert({ noteId: (0, peers_sdk_1.newid)(), title: "note2" });
             await trackedTable.delete(note1);
             const deletedIds = await changeTrackingTable.filterToDeletedIds([note1.noteId, note2.noteId]);
             expect(deletedIds).toContain(note1.noteId);
             expect(deletedIds).not.toContain(note2.noteId);
         });
-        it('should handle empty array in filterToDeletedIds', async () => {
+        it("should handle empty array in filterToDeletedIds", async () => {
             const deletedIds = await changeTrackingTable.filterToDeletedIds([]);
             expect(deletedIds).toEqual([]);
         });
     });
-    describe('Edge Cases', () => {
-        it('should handle insert with all optional fields', async () => {
-            const note = await trackedTable.insert({ noteId: (0, peers_sdk_1.newid)(), title: 'minimal' });
+    describe("Edge Cases", () => {
+        it("should handle insert with all optional fields", async () => {
+            const note = await trackedTable.insert({ noteId: (0, peers_sdk_1.newid)(), title: "minimal" });
             expect(note.completed).toBeUndefined();
             expect(note.count).toBeUndefined();
         });
-        it('should handle update removing optional fields', async () => {
-            const note = await trackedTable.insert({ noteId: (0, peers_sdk_1.newid)(), title: 'test', completed: true, count: 5 });
+        it("should handle update removing optional fields", async () => {
+            const note = await trackedTable.insert({
+                noteId: (0, peers_sdk_1.newid)(),
+                title: "test",
+                completed: true,
+                count: 5,
+            });
             // Update to remove optional fields
-            const updated = { noteId: note.noteId, title: 'test' };
+            const updated = { noteId: note.noteId, title: "test" };
             await trackedTable.update(updated);
             const retrieved = await trackedTable.get(note.noteId);
-            expect(retrieved?.title).toBe('test');
+            expect(retrieved?.title).toBe("test");
             // The optional fields behavior depends on the underlying implementation
         });
-        it('should handle concurrent operations on different records', async () => {
+        it("should handle concurrent operations on different records", async () => {
             const promises = [];
             for (let i = 0; i < 5; i++) {
                 promises.push(trackedTable.insert({ noteId: (0, peers_sdk_1.newid)(), title: `note${i}` }));
@@ -525,12 +559,12 @@ describe('TrackedDataSource', () => {
             const count = await trackedTable.count();
             expect(count).toBe(5);
         });
-        it('should handle distributed deletion scenario', async () => {
+        it("should handle distributed deletion scenario", async () => {
             // Scenario: One peer deletes a record, another peer (disconnected) makes changes
             const noteId = (0, peers_sdk_1.newid)();
             trackedTable.preserveHistory = true;
             // Peer 1: Create record
-            await trackedTable.insert({ noteId, title: 'original', completed: false });
+            await trackedTable.insert({ noteId, title: "original", completed: false });
             // Peer 1: Delete record at timestamp 2000
             await trackedTable.delete(noteId);
             // Peer 2: Makes changes AFTER deletion (while disconnected)
@@ -539,20 +573,20 @@ describe('TrackedDataSource', () => {
             // Peer 2 writes to specific paths (doesn't know about deletion)
             const laterChange1 = {
                 changeId: (0, peers_sdk_1.newid)(),
-                tableName: 'notes',
+                tableName: "notes",
                 recordId: noteId,
-                op: 'set',
-                path: '/title',
-                value: 'updated by peer 2',
+                op: "set",
+                path: "/title",
+                value: "updated by peer 2",
                 createdAt: laterTimestamp,
                 appliedAt: laterTimestamp,
             };
             const laterChange2 = {
                 changeId: (0, peers_sdk_1.newid)(),
-                tableName: 'notes',
+                tableName: "notes",
                 recordId: noteId,
-                op: 'set',
-                path: '/completed',
+                op: "set",
+                path: "/completed",
                 value: true,
                 createdAt: laterTimestamp + 1,
                 appliedAt: laterTimestamp + 1,
@@ -563,7 +597,7 @@ describe('TrackedDataSource', () => {
             const deletedIds = await changeTrackingTable.filterToDeletedIds([noteId]);
             expect(deletedIds).toContain(noteId);
             // Verify the later changes are marked as superseded
-            const allChanges = await changeTrackingTable.list({ tableName: 'notes', recordId: noteId }, { sortBy: ['createdAt'] });
+            const allChanges = await changeTrackingTable.list({ tableName: "notes", recordId: noteId }, { sortBy: ["createdAt"] });
             // Find the changes with the later timestamps (the ones we manually added)
             const change1InDb = allChanges.find((c) => c.changeId === laterChange1.changeId);
             const change2InDb = allChanges.find((c) => c.changeId === laterChange2.changeId);
@@ -576,49 +610,49 @@ describe('TrackedDataSource', () => {
             const record = await trackedTable.get(noteId);
             expect(record).toBeUndefined();
         });
-        it('should handle insert with existing deleted record', async () => {
+        it("should handle insert with existing deleted record", async () => {
             const noteId = (0, peers_sdk_1.newid)();
             // Insert and then delete a record
-            await trackedTable.insert({ noteId, title: 'original note' });
+            await trackedTable.insert({ noteId, title: "original note" });
             await trackedTable.delete(noteId);
             // Try to insert with same ID - should fail
-            await expect(trackedTable.insert({ noteId, title: 'new note' })).rejects.toThrow('because it has been deleted');
+            await expect(trackedTable.insert({ noteId, title: "new note" })).rejects.toThrow("because it has been deleted");
         });
-        it('should handle update with missing record', async () => {
+        it("should handle update with missing record", async () => {
             const noteId = (0, peers_sdk_1.newid)();
             // Try to update non-existent record
-            await expect(trackedTable.update({ noteId, title: 'new note' })).rejects.toThrow('No record found to update');
+            await expect(trackedTable.update({ noteId, title: "new note" })).rejects.toThrow("No record found to update");
         });
-        it('should handle delete with string ID', async () => {
+        it("should handle delete with string ID", async () => {
             const noteId = (0, peers_sdk_1.newid)();
             // Insert a record first
-            await trackedTable.insert({ noteId, title: 'test note' });
+            await trackedTable.insert({ noteId, title: "test note" });
             // Delete by string ID should work
             await trackedTable.delete(noteId);
             // Verify it was deleted
             const note = await trackedTable.get(noteId);
             expect(note).toBeUndefined();
         });
-        it('should find and track untracked records', async () => {
+        it("should find and track untracked records", async () => {
             // Insert records directly into the underlying data source (bypassing change tracking)
-            const note1 = { noteId: (0, peers_sdk_1.newid)(), title: 'untracked 1' };
-            const note2 = { noteId: (0, peers_sdk_1.newid)(), title: 'untracked 2' };
-            const note3 = { noteId: (0, peers_sdk_1.newid)(), title: 'untracked 3' };
+            const note1 = { noteId: (0, peers_sdk_1.newid)(), title: "untracked 1" };
+            const note2 = { noteId: (0, peers_sdk_1.newid)(), title: "untracked 2" };
+            const note3 = { noteId: (0, peers_sdk_1.newid)(), title: "untracked 3" };
             await sqlDataSource.insert(note1);
             await sqlDataSource.insert(note2);
             await sqlDataSource.insert(note3);
             // Verify no change records exist for these
-            let changes = await changeTrackingTable.list({ tableName: 'notes' });
+            let changes = await changeTrackingTable.list({ tableName: "notes" });
             expect(changes.length).toBe(0);
             // Run findAndTrackRecords
             await trackedTable.findAndTrackRecords();
             // Verify change records were created
-            changes = await changeTrackingTable.list({ tableName: 'notes' });
+            changes = await changeTrackingTable.list({ tableName: "notes" });
             expect(changes.length).toBe(3);
             // All should be 'set' operations at path "/"
-            changes.forEach(change => {
-                expect(change.op).toBe('set');
-                expect(change.path).toBe('/');
+            changes.forEach((change) => {
+                expect(change.op).toBe("set");
+                expect(change.path).toBe("/");
                 expect(change.createdAt).toBeLessThan(10); // Low timestamp
                 expect(change.appliedAt).toBeGreaterThan(Date.now() - 1000); // Recent appliedAt
             });
@@ -626,21 +660,21 @@ describe('TrackedDataSource', () => {
             const allNotes = await trackedTable.list();
             expect(allNotes.length).toBe(3);
         });
-        it('should compact superseded changes older than given timestamp', async () => {
-            const note = await trackedTable.insert({ noteId: (0, peers_sdk_1.newid)(), title: 'test' });
+        it("should compact superseded changes older than given timestamp", async () => {
+            const note = await trackedTable.insert({ noteId: (0, peers_sdk_1.newid)(), title: "test" });
             const noteId = note.noteId;
             // Make several updates to create multiple changes
-            await trackedTable.update({ noteId, title: 'update 1' });
+            await trackedTable.update({ noteId, title: "update 1" });
             await (0, peers_sdk_1.sleep)(10);
-            await trackedTable.update({ noteId, title: 'update 2' });
+            await trackedTable.update({ noteId, title: "update 2" });
             await (0, peers_sdk_1.sleep)(10);
-            await trackedTable.update({ noteId, title: 'update 3' });
+            await trackedTable.update({ noteId, title: "update 3" });
             await (0, peers_sdk_1.sleep)(10);
             // Get all changes before compacting
             const changesBefore = await changeTrackingTable.list({ recordId: noteId });
             expect(changesBefore.length).toBeGreaterThan(1);
             // Count superseded changes
-            const supersededBefore = changesBefore.filter(c => c.supersededAt).length;
+            const supersededBefore = changesBefore.filter((c) => c.supersededAt).length;
             expect(supersededBefore).toBeGreaterThan(0);
             // Compact (remove all superseded changes by using future timestamp)
             await trackedTable.compact(Date.now() + 1000);
@@ -649,25 +683,25 @@ describe('TrackedDataSource', () => {
             // Should have fewer changes now
             expect(changesAfter.length).toBeLessThan(changesBefore.length);
             // Should have no superseded changes left
-            const supersededAfter = changesAfter.filter(c => c.supersededAt).length;
+            const supersededAfter = changesAfter.filter((c) => c.supersededAt).length;
             expect(supersededAfter).toBe(0);
             // Verify the record is still accessible and correct
             const retrieved = await trackedTable.get(noteId);
-            expect(retrieved?.title).toBe('update 3');
+            expect(retrieved?.title).toBe("update 3");
         });
-        it('should compact only changes superseded before given timestamp', async () => {
-            const note = await trackedTable.insert({ noteId: (0, peers_sdk_1.newid)(), title: 'test' });
+        it("should compact only changes superseded before given timestamp", async () => {
+            const note = await trackedTable.insert({ noteId: (0, peers_sdk_1.newid)(), title: "test" });
             const noteId = note.noteId;
             // Make updates
-            await trackedTable.update({ noteId, title: 'update 1' });
+            await trackedTable.update({ noteId, title: "update 1" });
             await (0, peers_sdk_1.sleep)(10);
             const midTimestamp = Date.now();
             await (0, peers_sdk_1.sleep)(10);
-            await trackedTable.update({ noteId, title: 'update 2' });
+            await trackedTable.update({ noteId, title: "update 2" });
             await (0, peers_sdk_1.sleep)(10);
-            await trackedTable.update({ noteId, title: 'update 3' });
-            const changesBefore = await changeTrackingTable.list({ recordId: noteId }, { sortBy: ['createdAt'] });
-            const supersededBefore = changesBefore.filter(c => c.supersededAt).length;
+            await trackedTable.update({ noteId, title: "update 3" });
+            const changesBefore = await changeTrackingTable.list({ recordId: noteId }, { sortBy: ["createdAt"] });
+            const supersededBefore = changesBefore.filter((c) => c.supersededAt).length;
             // Compact only changes superseded before midTimestamp
             await trackedTable.compact(midTimestamp);
             const changesAfter = await changeTrackingTable.list({ recordId: noteId });
@@ -677,138 +711,312 @@ describe('TrackedDataSource', () => {
             // Therefore, no changes should be removed.
             expect(changesAfter.length).toBe(changesBefore.length); // No changes should be removed
             // There should still be superseded changes (the ones after midTimestamp)
-            const supersededAfter = changesAfter.filter(c => c.supersededAt).length;
+            const supersededAfter = changesAfter.filter((c) => c.supersededAt).length;
             expect(supersededAfter).toBe(supersededBefore); // Same number of superseded changes
         });
     });
-    describe('applyChanges', () => {
-        it('should save but supersede remote changes that are older', async () => {
+    describe("applyChanges", () => {
+        it("should save but supersede remote changes that are older", async () => {
             const noteId = `000000000000000000note001`;
             trackedTable.preserveHistory = true;
-            const note = await trackedTable.save({ noteId, title: 'original' });
+            const note = await trackedTable.save({ noteId, title: "original" });
             const timeUpdatedRemote = (0, peers_sdk_1.getTimestamp)();
-            note.title = 'updated1';
+            note.title = "updated1";
             await trackedTable.save(note);
             const changes = await changeTrackingTable.list({ recordId: note.noteId });
             expect(changes.length).toBe(2);
             // Create changes to apply
             const remoteChange = {
                 changeId: (0, peers_sdk_1.newid)(),
-                tableName: 'notes',
+                tableName: "notes",
                 recordId: note.noteId,
-                op: 'set',
-                path: '/title',
-                value: 'updated2',
+                op: "set",
+                path: "/title",
+                value: "updated2",
                 createdAt: timeUpdatedRemote,
                 appliedAt: timeUpdatedRemote,
             };
             await trackedTable.applyChanges([remoteChange]);
             const finalRecord = await trackedTable.get(note.noteId);
             expect(finalRecord).toBeDefined();
-            expect(finalRecord?.title).toBe('updated1'); // because remote change is superseded
-            const finalChanges = await changeTrackingTable.list({ recordId: note.noteId }, { sortBy: ['createdAt'] });
+            expect(finalRecord?.title).toBe("updated1"); // because remote change is superseded
+            const finalChanges = await changeTrackingTable.list({ recordId: note.noteId }, { sortBy: ["createdAt"] });
             expect(finalChanges.length).toBe(3);
             const remoteChangeInDb = finalChanges.find((c) => c.changeId === remoteChange.changeId);
             expect(remoteChangeInDb).toBeDefined();
             expect(remoteChangeInDb?.supersededAt).toBeDefined();
         });
-        it('should replace the entire array when an item in the array is added or removed', async () => {
-            const note = await trackedTable.save({ noteId: (0, peers_sdk_1.newid)(), title: 'original', tags: ['tag1', 'tag2'] });
-            note.tags = ['tag1', 'tag2', 'tag3'];
+        it("should replace the entire array when an item in the array is added or removed", async () => {
+            const note = await trackedTable.save({
+                noteId: (0, peers_sdk_1.newid)(),
+                title: "original",
+                tags: ["tag1", "tag2"],
+            });
+            note.tags = ["tag1", "tag2", "tag3"];
             await trackedTable.save(note);
             const changes = await changeTrackingTable.list({ recordId: note.noteId });
             expect(changes.length).toBe(2);
-            const addTagChange = changes.find((c) => c.op === 'set' && c.path === '/tags');
+            const addTagChange = changes.find((c) => c.op === "set" && c.path === "/tags");
             expect(addTagChange).toBeDefined();
-            expect(addTagChange?.value).toEqual(['tag1', 'tag2', 'tag3']);
+            expect(addTagChange?.value).toEqual(["tag1", "tag2", "tag3"]);
         });
-        it('should updating two similarly named fields', async () => {
-            const note = await trackedTable.save({ noteId: (0, peers_sdk_1.newid)(), title: 'original', links: { a: 1, aa: 2 } });
+        it("should updating two similarly named fields", async () => {
+            const note = await trackedTable.save({
+                noteId: (0, peers_sdk_1.newid)(),
+                title: "original",
+                links: { a: 1, aa: 2 },
+            });
             const ts = (0, peers_sdk_1.getTimestamp)();
             await trackedTable.applyChanges([
-                { changeId: (0, peers_sdk_1.newid)(), tableName: 'notes', recordId: note.noteId, op: 'set', path: '/links/aa', value: 3, createdAt: ts, appliedAt: ts },
-                { changeId: (0, peers_sdk_1.newid)(), tableName: 'notes', recordId: note.noteId, op: 'set', path: '/links/a', value: 4, createdAt: ts + 1, appliedAt: ts + 1 },
+                {
+                    changeId: (0, peers_sdk_1.newid)(),
+                    tableName: "notes",
+                    recordId: note.noteId,
+                    op: "set",
+                    path: "/links/aa",
+                    value: 3,
+                    createdAt: ts,
+                    appliedAt: ts,
+                },
+                {
+                    changeId: (0, peers_sdk_1.newid)(),
+                    tableName: "notes",
+                    recordId: note.noteId,
+                    op: "set",
+                    path: "/links/a",
+                    value: 4,
+                    createdAt: ts + 1,
+                    appliedAt: ts + 1,
+                },
             ]);
-            const dbNote = await trackedTable.get(note.noteId);
+            const dbNote = (await trackedTable.get(note.noteId));
             expect(dbNote).toBeDefined();
             expect(dbNote?.links).toBeDefined();
             expect(dbNote?.links?.aa).toBe(3);
             expect(dbNote?.links?.a).toBe(4);
         });
-        it('should apply deep changes after higher changes', async () => {
+        it("should apply deep changes after higher changes", async () => {
             const noteId = `000000000000000000note001`;
             let note = {
                 noteId,
-                title: 'original',
+                title: "original",
             };
             const ts = (0, peers_sdk_1.getTimestamp)();
             await trackedTable.applyChanges([
-                { changeId: (0, peers_sdk_1.newid)(), tableName: 'notes', recordId: noteId, op: 'set', path: '/', value: note, createdAt: ts, appliedAt: ts },
-                { changeId: (0, peers_sdk_1.newid)(), tableName: 'notes', recordId: noteId, op: 'set', path: '/links', value: { a: 1 }, createdAt: ts + 1, appliedAt: ts + 1 },
-                { changeId: (0, peers_sdk_1.newid)(), tableName: 'notes', recordId: noteId, op: 'set', path: '/links/a', value: '2', createdAt: ts + 2, appliedAt: ts + 2 },
+                {
+                    changeId: (0, peers_sdk_1.newid)(),
+                    tableName: "notes",
+                    recordId: noteId,
+                    op: "set",
+                    path: "/",
+                    value: note,
+                    createdAt: ts,
+                    appliedAt: ts,
+                },
+                {
+                    changeId: (0, peers_sdk_1.newid)(),
+                    tableName: "notes",
+                    recordId: noteId,
+                    op: "set",
+                    path: "/links",
+                    value: { a: 1 },
+                    createdAt: ts + 1,
+                    appliedAt: ts + 1,
+                },
+                {
+                    changeId: (0, peers_sdk_1.newid)(),
+                    tableName: "notes",
+                    recordId: noteId,
+                    op: "set",
+                    path: "/links/a",
+                    value: "2",
+                    createdAt: ts + 2,
+                    appliedAt: ts + 2,
+                },
             ]);
-            note = await trackedTable.get(noteId);
+            note = (await trackedTable.get(noteId));
             expect(note).toBeDefined();
             expect(note?.links).toBeDefined();
-            expect(note?.links?.a).toBe('2');
+            expect(note?.links?.a).toBe("2");
         });
-        it('should correctly apply and supersede changes from a single batch', async () => {
+        it("should correctly apply and supersede changes from a single batch", async () => {
             const noteId = `000000000000000000note001`;
             let note = {
                 noteId,
-                title: 'original',
+                title: "original",
             };
             const ts = (0, peers_sdk_1.getTimestamp)();
             await trackedTable.applyChanges([
-                { changeId: (0, peers_sdk_1.newid)(), tableName: 'notes', recordId: noteId, op: 'set', path: '/', value: note, createdAt: ts, appliedAt: ts },
-                { changeId: (0, peers_sdk_1.newid)(), tableName: 'notes', recordId: noteId, op: 'set', path: '/links', value: { a: 1 }, createdAt: ts + 1, appliedAt: ts + 1 },
-                { changeId: (0, peers_sdk_1.newid)(), tableName: 'notes', recordId: noteId, op: 'set', path: '/links/a', value: '2', createdAt: ts + 2, appliedAt: ts + 2 },
-                { changeId: (0, peers_sdk_1.newid)(), tableName: 'notes', recordId: noteId, op: 'delete', path: '/links', createdAt: ts + 3, appliedAt: ts + 3 },
+                {
+                    changeId: (0, peers_sdk_1.newid)(),
+                    tableName: "notes",
+                    recordId: noteId,
+                    op: "set",
+                    path: "/",
+                    value: note,
+                    createdAt: ts,
+                    appliedAt: ts,
+                },
+                {
+                    changeId: (0, peers_sdk_1.newid)(),
+                    tableName: "notes",
+                    recordId: noteId,
+                    op: "set",
+                    path: "/links",
+                    value: { a: 1 },
+                    createdAt: ts + 1,
+                    appliedAt: ts + 1,
+                },
+                {
+                    changeId: (0, peers_sdk_1.newid)(),
+                    tableName: "notes",
+                    recordId: noteId,
+                    op: "set",
+                    path: "/links/a",
+                    value: "2",
+                    createdAt: ts + 2,
+                    appliedAt: ts + 2,
+                },
+                {
+                    changeId: (0, peers_sdk_1.newid)(),
+                    tableName: "notes",
+                    recordId: noteId,
+                    op: "delete",
+                    path: "/links",
+                    createdAt: ts + 3,
+                    appliedAt: ts + 3,
+                },
             ]);
-            note = await trackedTable.get(noteId);
+            note = (await trackedTable.get(noteId));
             expect(note).toBeDefined();
             expect(note?.links).toBeUndefined();
         });
-        it('should delete records on a delete change on path /', async () => {
-            let note = await trackedTable.save({ noteId: (0, peers_sdk_1.newid)(), title: 'to be deleted' });
+        it("should delete records on a delete change on path /", async () => {
+            let note = await trackedTable.save({ noteId: (0, peers_sdk_1.newid)(), title: "to be deleted" });
             const ts = (0, peers_sdk_1.getTimestamp)();
             await trackedTable.applyChanges([
-                { changeId: (0, peers_sdk_1.newid)(), tableName: 'notes', recordId: note.noteId, op: 'delete', path: '/', createdAt: ts + 4, appliedAt: ts + 4 },
+                {
+                    changeId: (0, peers_sdk_1.newid)(),
+                    tableName: "notes",
+                    recordId: note.noteId,
+                    op: "delete",
+                    path: "/",
+                    createdAt: ts + 4,
+                    appliedAt: ts + 4,
+                },
             ]);
-            note = await trackedTable.get(note.noteId);
+            note = (await trackedTable.get(note.noteId));
             expect(note).toBeUndefined();
         });
-        it('should correctly apply and supersede changes from a single batch that includes both creating and deleting the object', async () => {
+        it("should correctly apply and supersede changes from a single batch that includes both creating and deleting the object", async () => {
             const noteId = `000000000000000000note001`;
             let note = {
                 noteId,
-                title: 'original',
+                title: "original",
             };
             const ts = (0, peers_sdk_1.getTimestamp)();
             await trackedTable.applyChanges([
-                { changeId: (0, peers_sdk_1.newid)(), tableName: 'notes', recordId: noteId, op: 'set', path: '/', value: note, createdAt: ts, appliedAt: ts },
-                { changeId: (0, peers_sdk_1.newid)(), tableName: 'notes', recordId: noteId, op: 'set', path: '/links', value: { a: 1 }, createdAt: ts + 1, appliedAt: ts + 1 },
-                { changeId: (0, peers_sdk_1.newid)(), tableName: 'notes', recordId: noteId, op: 'set', path: '/links/a', value: '2', createdAt: ts + 2, appliedAt: ts + 2 },
-                { changeId: (0, peers_sdk_1.newid)(), tableName: 'notes', recordId: noteId, op: 'delete', path: '/links', createdAt: ts + 3, appliedAt: ts + 3 },
-                { changeId: (0, peers_sdk_1.newid)(), tableName: 'notes', recordId: noteId, op: 'delete', path: '/', createdAt: ts + 4, appliedAt: ts + 4 },
+                {
+                    changeId: (0, peers_sdk_1.newid)(),
+                    tableName: "notes",
+                    recordId: noteId,
+                    op: "set",
+                    path: "/",
+                    value: note,
+                    createdAt: ts,
+                    appliedAt: ts,
+                },
+                {
+                    changeId: (0, peers_sdk_1.newid)(),
+                    tableName: "notes",
+                    recordId: noteId,
+                    op: "set",
+                    path: "/links",
+                    value: { a: 1 },
+                    createdAt: ts + 1,
+                    appliedAt: ts + 1,
+                },
+                {
+                    changeId: (0, peers_sdk_1.newid)(),
+                    tableName: "notes",
+                    recordId: noteId,
+                    op: "set",
+                    path: "/links/a",
+                    value: "2",
+                    createdAt: ts + 2,
+                    appliedAt: ts + 2,
+                },
+                {
+                    changeId: (0, peers_sdk_1.newid)(),
+                    tableName: "notes",
+                    recordId: noteId,
+                    op: "delete",
+                    path: "/links",
+                    createdAt: ts + 3,
+                    appliedAt: ts + 3,
+                },
+                {
+                    changeId: (0, peers_sdk_1.newid)(),
+                    tableName: "notes",
+                    recordId: noteId,
+                    op: "delete",
+                    path: "/",
+                    createdAt: ts + 4,
+                    appliedAt: ts + 4,
+                },
             ]);
-            note = await trackedTable.get(noteId);
+            note = (await trackedTable.get(noteId));
             expect(note).toBeUndefined();
         });
-        it('should correctly apply and supersede changes from a single batch that includes both creating, deleting the object, and restoring the object', async () => {
+        it("should correctly apply and supersede changes from a single batch that includes both creating, deleting the object, and restoring the object", async () => {
             const noteId = `000000000000000000note001`;
             const note = {
                 noteId,
-                title: 'original',
+                title: "original",
             };
             const ts = (0, peers_sdk_1.getTimestamp)();
             await trackedTable.applyChanges([
-                { changeId: (0, peers_sdk_1.newid)(), tableName: 'notes', recordId: noteId, op: 'set', path: '/', value: note, createdAt: ts, appliedAt: ts },
-                { changeId: (0, peers_sdk_1.newid)(), tableName: 'notes', recordId: noteId, op: 'set', path: '/links', value: { a: 1 }, createdAt: ts + 2, appliedAt: ts + 2 },
-                { changeId: (0, peers_sdk_1.newid)(), tableName: 'notes', recordId: noteId, op: 'delete', path: '/', createdAt: ts + 4, appliedAt: ts + 4 },
-                { changeId: (0, peers_sdk_1.newid)(), tableName: 'notes', recordId: noteId, op: 'set', path: '/', value: note, createdAt: ts + 5, appliedAt: ts + 5 },
+                {
+                    changeId: (0, peers_sdk_1.newid)(),
+                    tableName: "notes",
+                    recordId: noteId,
+                    op: "set",
+                    path: "/",
+                    value: note,
+                    createdAt: ts,
+                    appliedAt: ts,
+                },
+                {
+                    changeId: (0, peers_sdk_1.newid)(),
+                    tableName: "notes",
+                    recordId: noteId,
+                    op: "set",
+                    path: "/links",
+                    value: { a: 1 },
+                    createdAt: ts + 2,
+                    appliedAt: ts + 2,
+                },
+                {
+                    changeId: (0, peers_sdk_1.newid)(),
+                    tableName: "notes",
+                    recordId: noteId,
+                    op: "delete",
+                    path: "/",
+                    createdAt: ts + 4,
+                    appliedAt: ts + 4,
+                },
+                {
+                    changeId: (0, peers_sdk_1.newid)(),
+                    tableName: "notes",
+                    recordId: noteId,
+                    op: "set",
+                    path: "/",
+                    value: note,
+                    createdAt: ts + 5,
+                    appliedAt: ts + 5,
+                },
             ]);
-            const dbNote = await trackedTable.get(noteId);
+            const dbNote = (await trackedTable.get(noteId));
             expect(dbNote).toEqual(note);
         });
         // // not sure we want to support this behavior
@@ -826,61 +1034,61 @@ describe('TrackedDataSource', () => {
         //   const dbNote = await trackedTable.get(noteId) as INote;
         //   expect(dbNote?.links?.a).toEqual(1);
         // });
-        it('should handle two peers adding items to an array separately (last write wins)', async () => {
+        it("should handle two peers adding items to an array separately (last write wins)", async () => {
             const [changeTrackingTable, trackedTable] = await dataSourceFactory();
             const [changeTrackingTableRemote, trackedTableRemote] = await dataSourceFactory();
             const noteId = `000000000000000000note001`;
-            const note = await trackedTable.save({ noteId, title: 'original', tags: ['tag1', 'tag2'] });
+            const note = await trackedTable.save({ noteId, title: "original", tags: ["tag1", "tag2"] });
             // Use listChanges (resolves insert change values) instead of changeTrackingTable.list
             await trackedTableRemote.applyChanges(await trackedTable.listChanges({ recordId: note.noteId }));
             let noteLocal = await trackedTable.get(note.noteId);
             let noteRemote = await trackedTableRemote.get(note.noteId);
             expect(noteLocal).toEqual(noteRemote);
-            noteLocal.tags.push('tag3');
+            noteLocal.tags.push("tag3");
             await trackedTable.save(noteLocal);
-            noteRemote.tags.push('tag4');
+            noteRemote.tags.push("tag4");
             await trackedTableRemote.save(noteRemote);
             await trackedTableRemote.applyChanges(await trackedTable.listChanges({ recordId: note.noteId }));
             await trackedTable.applyChanges(await trackedTableRemote.listChanges({ recordId: note.noteId }));
             noteRemote = await trackedTableRemote.get(note.noteId);
             noteLocal = await trackedTable.get(note.noteId);
             // changes to arrays are treated as full replacements, so last write wins
-            expect(noteRemote?.tags).toEqual(['tag1', 'tag2', 'tag4']);
-            expect(noteLocal?.tags).toEqual(['tag1', 'tag2', 'tag4']);
+            expect(noteRemote?.tags).toEqual(["tag1", "tag2", "tag4"]);
+            expect(noteLocal?.tags).toEqual(["tag1", "tag2", "tag4"]);
         });
-        it('should treat changes to objects nested in arrays as a full replacement of the array', async () => {
+        it("should treat changes to objects nested in arrays as a full replacement of the array", async () => {
             const noteId = `000000000000000000note001`;
-            const note = { noteId, title: 'original', links: { a: [{ b: 1 }, { c: 2 }] }, };
+            const note = { noteId, title: "original", links: { a: [{ b: 1 }, { c: 2 }] } };
             const noteInserted = await trackedTable.save(note);
             noteInserted.links.a[0].b = 2;
             const noteUpdated = await trackedTable.save(noteInserted);
             expect(noteUpdated).toEqual(noteInserted);
-            const changes = await changeTrackingTable.list({ recordId: noteId }, { sortBy: ['createdAt'] });
+            const changes = await changeTrackingTable.list({ recordId: noteId }, { sortBy: ["createdAt"] });
             expect(changes.length).toBe(2);
             const arrayChange = changes[1];
-            expect(arrayChange.path).toBe('/links/a');
+            expect(arrayChange.path).toBe("/links/a");
             expect(arrayChange.value).toEqual([{ b: 2 }, { c: 2 }]);
         });
-        it('should treat changes to arrays nested in another array as a full replacement of the top array', async () => {
+        it("should treat changes to arrays nested in another array as a full replacement of the top array", async () => {
             const noteId = `000000000000000000note001`;
-            const note = { noteId, title: 'original', links: { a: [[{ b: 1 }, { c: 2 }, 2], 3] }, };
+            const note = { noteId, title: "original", links: { a: [[{ b: 1 }, { c: 2 }, 2], 3] } };
             const noteInserted = await trackedTable.save(note);
             noteInserted.links.a[0][0].b = 2;
             const noteUpdated = await trackedTable.save(noteInserted);
             expect(noteUpdated).toEqual(noteInserted);
-            const changes = await changeTrackingTable.list({ recordId: noteId }, { sortBy: ['createdAt'] });
+            const changes = await changeTrackingTable.list({ recordId: noteId }, { sortBy: ["createdAt"] });
             expect(changes.length).toBe(2);
             const arrayChange = changes[1];
-            expect(arrayChange.path).toBe('/links/a');
+            expect(arrayChange.path).toBe("/links/a");
             expect(arrayChange.value).toEqual([[{ b: 2 }, { c: 2 }, 2], 3]);
         });
     });
-    describe('Transaction Support', () => {
-        it('should support runInTransaction on DBLocal', async () => {
+    describe("Transaction Support", () => {
+        it("should support runInTransaction on DBLocal", async () => {
             // Verify that DBLocal supports transactions
-            expect(typeof db.runInTransaction).toBe('function');
+            expect(typeof db.runInTransaction).toBe("function");
         });
-        it('should apply multiple changes in a single transaction via applyChanges', async () => {
+        it("should apply multiple changes in a single transaction via applyChanges", async () => {
             // Create a separate "remote" data source to generate changes
             const [changeTrackingTableRemote, trackedTableRemote] = await dataSourceFactory();
             // Insert multiple records on the remote
@@ -889,7 +1097,7 @@ describe('TrackedDataSource', () => {
                 const note = await trackedTableRemote.insert({
                     noteId: (0, peers_sdk_1.newid)(),
                     title: `note ${i}`,
-                    completed: false
+                    completed: false,
                 });
                 records.push(note);
             }
@@ -906,7 +1114,7 @@ describe('TrackedDataSource', () => {
             const localChanges = await changeTrackingTable.list({});
             expect(localChanges.length).toBe(remoteChanges.length);
         });
-        it('should handle large batches of changes efficiently', async () => {
+        it("should handle large batches of changes efficiently", async () => {
             // Create a separate "remote" data source
             const [changeTrackingTableRemote, trackedTableRemote] = await dataSourceFactory();
             // Insert many records
@@ -940,16 +1148,16 @@ describe('TrackedDataSource', () => {
             // Log performance (informational)
             console.log(`Applied ${remoteChanges.length} changes in ${endTime - startTime}ms`);
         });
-        it('should bulk insert changes correctly', async () => {
+        it("should bulk insert changes correctly", async () => {
             const changes = [];
             for (let i = 0; i < 5; i++) {
                 const noteId = (0, peers_sdk_1.newid)();
                 changes.push({
                     changeId: (0, peers_sdk_1.newid)(),
-                    tableName: 'notes',
+                    tableName: "notes",
                     recordId: noteId,
-                    op: 'set',
-                    path: '/',
+                    op: "set",
+                    path: "/",
                     value: { noteId, title: `bulk note ${i}`, completed: false },
                     createdAt: (0, peers_sdk_1.getTimestamp)(),
                     appliedAt: (0, peers_sdk_1.getTimestamp)(),
@@ -961,20 +1169,20 @@ describe('TrackedDataSource', () => {
             const insertedChanges = await changeTrackingTable.list({});
             expect(insertedChanges.length).toBeGreaterThanOrEqual(5);
             for (const change of changes) {
-                const found = insertedChanges.find(c => c.changeId === change.changeId);
+                const found = insertedChanges.find((c) => c.changeId === change.changeId);
                 expect(found).toBeDefined();
-                expect(found?.tableName).toBe('notes');
+                expect(found?.tableName).toBe("notes");
             }
         });
-        it('should handle mixed insert/update/delete in applyChanges transaction', async () => {
+        it("should handle mixed insert/update/delete in applyChanges transaction", async () => {
             // Create a separate "remote" data source
             const [changeTrackingTableRemote, trackedTableRemote] = await dataSourceFactory();
             // Insert some records
-            const note1 = await trackedTableRemote.insert({ noteId: (0, peers_sdk_1.newid)(), title: 'note 1' });
-            const note2 = await trackedTableRemote.insert({ noteId: (0, peers_sdk_1.newid)(), title: 'note 2' });
-            const note3 = await trackedTableRemote.insert({ noteId: (0, peers_sdk_1.newid)(), title: 'note 3' });
+            const note1 = await trackedTableRemote.insert({ noteId: (0, peers_sdk_1.newid)(), title: "note 1" });
+            const note2 = await trackedTableRemote.insert({ noteId: (0, peers_sdk_1.newid)(), title: "note 2" });
+            const note3 = await trackedTableRemote.insert({ noteId: (0, peers_sdk_1.newid)(), title: "note 3" });
             // Update one
-            note1.title = 'updated note 1';
+            note1.title = "updated note 1";
             await trackedTableRemote.update(note1);
             // Delete one
             await trackedTableRemote.delete(note2.noteId);
@@ -984,19 +1192,19 @@ describe('TrackedDataSource', () => {
             await trackedTable.applyChanges(remoteChanges);
             // Verify results
             const localNote1 = await trackedTable.get(note1.noteId);
-            expect(localNote1?.title).toBe('updated note 1');
+            expect(localNote1?.title).toBe("updated note 1");
             const localNote2 = await trackedTable.get(note2.noteId);
             expect(localNote2).toBeUndefined();
             const localNote3 = await trackedTable.get(note3.noteId);
-            expect(localNote3?.title).toBe('note 3');
+            expect(localNote3?.title).toBe("note 3");
         });
-        it('should support sync methods on SQLDataSource', async () => {
+        it("should support sync methods on SQLDataSource", async () => {
             // Test sync methods directly on sqlDataSource
             await sqlDataSource.initTable();
             // Test insertSync via bulkInsert
             const records = [
-                { noteId: (0, peers_sdk_1.newid)(), title: 'sync test 1' },
-                { noteId: (0, peers_sdk_1.newid)(), title: 'sync test 2' },
+                { noteId: (0, peers_sdk_1.newid)(), title: "sync test 1" },
+                { noteId: (0, peers_sdk_1.newid)(), title: "sync test 2" },
             ];
             const inserted = await sqlDataSource.bulkInsert(records);
             expect(inserted.length).toBe(2);
@@ -1006,30 +1214,30 @@ describe('TrackedDataSource', () => {
                 expect(found?.title).toBe(record.title);
             }
             // Test bulkDelete
-            await sqlDataSource.bulkDelete(inserted.map(r => r.noteId));
+            await sqlDataSource.bulkDelete(inserted.map((r) => r.noteId));
             // Verify records are deleted
             for (const record of inserted) {
                 const found = await sqlDataSource.get(record.noteId);
                 expect(found).toBeUndefined();
             }
         });
-        it('should support bulkSave on SQLDataSource', async () => {
+        it("should support bulkSave on SQLDataSource", async () => {
             await sqlDataSource.initTable();
             // Insert some records
             const records = [
-                { noteId: (0, peers_sdk_1.newid)(), title: 'bulk save 1' },
-                { noteId: (0, peers_sdk_1.newid)(), title: 'bulk save 2' },
+                { noteId: (0, peers_sdk_1.newid)(), title: "bulk save 1" },
+                { noteId: (0, peers_sdk_1.newid)(), title: "bulk save 2" },
             ];
             // First bulkSave should insert
             const inserted = await sqlDataSource.bulkSave(records);
             expect(inserted.length).toBe(2);
             // Modify and bulkSave again should update
-            inserted[0].title = 'updated bulk save 1';
+            inserted[0].title = "updated bulk save 1";
             inserted[1].completed = true;
             const updated = await sqlDataSource.bulkSave(inserted);
             // Verify updates
             const found1 = await sqlDataSource.get(inserted[0].noteId);
-            expect(found1?.title).toBe('updated bulk save 1');
+            expect(found1?.title).toBe("updated bulk save 1");
             const found2 = await sqlDataSource.get(inserted[1].noteId);
             expect(found2?.completed).toBe(true);
         });