@peers-app/peers-device 0.0.1

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

@@ -0,0 +1,825 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const lodash_1 = require("lodash");
+const peers_sdk_1 = require("@peers-app/peers-sdk");
+const zod_1 = require("zod");
+const tracked_data_source_1 = require("./tracked-data-source");
+const local_data_source_1 = require("./local.data-source");
+describe('tracked-table', () => {
+    const db = new local_data_source_1.DBLocal(':memory:');
+    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 NotesMetaData = {
+        name: 'notes',
+        description: '',
+        primaryKeyName: 'noteId',
+        fields: (0, peers_sdk_1.schemaToFields)(notesSchema),
+    };
+    const sqlDataSource = new peers_sdk_1.SQLDataSource(db, NotesMetaData, notesSchema);
+    const mockDataContext = {
+        dataSourceFactory: () => sqlDataSource,
+        eventRegistry: {
+            getEmitter: () => ({
+                event: { subscribe: () => { } },
+                emit: () => { }
+            })
+        }
+    };
+    const deps = {
+        dataSource: sqlDataSource,
+        eventRegistry: mockDataContext.eventRegistry
+    };
+    const Notes = new peers_sdk_1.Table(NotesMetaData, deps);
+    const changeTrackingTable = new peers_sdk_1.ChangeTrackingTable({ db });
+    const trackedTable = new tracked_data_source_1.TrackedDataSource(Notes, changeTrackingTable);
+    beforeEach(async () => {
+        // await Notes.dropTableIfExists();
+        await changeTrackingTable.dropTableIfExists();
+        await (0, peers_sdk_1.sleep)(200);
+    });
+    afterAll(async () => {
+        await (0, peers_sdk_1.sleep)(200);
+    });
+    it('should track changes when inserting data', async () => {
+        // Insert a new record
+        const note = await trackedTable.insert({ noteId: (0, peers_sdk_1.newid)(), title: 'test note' });
+        expect(note.noteId).toBeDefined();
+        // Check that the change was recorded
+        const changes = await changeTrackingTable.list();
+        expect(changes.length).toBe(1);
+        expect(changes[0].tableName).toBe('notes');
+        const change = changes[0];
+        expect(change).toEqual({
+            changeId: expect.any(String),
+            changeType: 'insert',
+            timestamp: expect.any(Number),
+            timestampApplied: expect.any(Number),
+            tableName: 'notes',
+            recordId: note.noteId,
+            newRecord: note,
+        });
+    });
+    it('should track changes when updating data', async () => {
+        // Insert a new record
+        const note = await trackedTable.insert({ noteId: (0, peers_sdk_1.newid)(), title: 'test note' });
+        // Update the record
+        note.title = 'updated note';
+        note.completed = true;
+        await trackedTable.update(note);
+        // Check that both changes were recorded
+        const changes = await changeTrackingTable.list({ tableName: 'notes' }, { sortBy: ['timestamp'] });
+        expect(changes.length).toBe(2);
+        // Verify insert change
+        expect(changes[0]).toEqual({
+            changeId: expect.any(String),
+            changeType: 'insert',
+            timestamp: expect.any(Number),
+            timestampApplied: expect.any(Number),
+            tableName: 'notes',
+            recordId: note.noteId,
+            newRecord: expect.objectContaining({
+                title: 'test note',
+                noteId: note.noteId
+            }),
+        });
+        // Verify update change
+        const updateChange = changes[1];
+        expect(updateChange).toEqual({
+            changeId: expect.any(String),
+            changeType: 'update',
+            timestamp: expect.any(Number),
+            timestampApplied: expect.any(Number),
+            tableName: 'notes',
+            recordId: note.noteId,
+            newRecord: expect.objectContaining({
+                title: 'updated note',
+                noteId: note.noteId,
+                completed: true
+            }),
+            jsonDiff: expect.any(Array),
+        });
+        // TypeScript needs this cast for type narrowing
+        expect(updateChange.jsonDiff.length).toBeGreaterThan(0);
+    });
+    it('should track changes when deleting data', async () => {
+        // Insert a new record
+        const note = await trackedTable.insert({ noteId: (0, peers_sdk_1.newid)(), title: 'test note' });
+        // Delete the record
+        await trackedTable.delete(note);
+        // Check that both changes were recorded
+        const changes = await changeTrackingTable.list({ tableName: 'notes' }, { sortBy: ['timestamp'] });
+        expect(changes.length).toBe(2);
+        // Get the changes in the right order
+        const insertChange = changes.find(c => c.changeType === 'insert');
+        const deleteChange = changes.find(c => c.changeType === 'delete');
+        expect(insertChange).toEqual({
+            changeId: expect.any(String),
+            changeType: 'insert',
+            timestamp: expect.any(Number),
+            timestampApplied: expect.any(Number),
+            tableName: 'notes',
+            recordId: note.noteId,
+            newRecord: expect.objectContaining({
+                title: 'test note',
+                noteId: note.noteId
+            }),
+        });
+        // Verify delete change
+        expect(deleteChange).toEqual({
+            changeId: expect.any(String),
+            changeType: 'delete',
+            timestamp: expect.any(Number),
+            timestampApplied: expect.any(Number),
+            tableName: 'notes',
+            recordId: note.noteId,
+            oldRecord: expect.objectContaining({
+                title: 'test note',
+                noteId: note.noteId
+            }),
+        });
+    });
+    it('should track changes when using save method for new records', async () => {
+        // Save a new record
+        const note = await trackedTable.save({ noteId: (0, peers_sdk_1.newid)(), title: 'test note' });
+        // Check that the change was recorded
+        const changes = await changeTrackingTable.list();
+        expect(changes.length).toBe(1);
+        expect(changes[0]).toEqual({
+            changeId: expect.any(String),
+            changeType: 'insert',
+            timestamp: expect.any(Number),
+            timestampApplied: expect.any(Number),
+            tableName: 'notes',
+            recordId: note.noteId,
+            newRecord: expect.objectContaining({
+                title: 'test note',
+                noteId: note.noteId
+            }),
+        });
+    });
+    it('should track changes when using save method for existing records', async () => {
+        // Save a new record
+        const note = await trackedTable.save({ noteId: (0, peers_sdk_1.newid)(), title: 'test note' });
+        // Update using save
+        note.title = 'updated note';
+        await trackedTable.save(note);
+        // Check that both changes were recorded
+        const changes = await changeTrackingTable.list({ tableName: 'notes' }, { sortBy: ['timestamp'] });
+        expect(changes.length).toBe(2);
+        // Verify first change (insert)
+        expect(changes[0]).toEqual({
+            changeId: expect.any(String),
+            changeType: 'insert',
+            timestamp: expect.any(Number),
+            timestampApplied: expect.any(Number),
+            tableName: 'notes',
+            recordId: note.noteId,
+            newRecord: expect.objectContaining({
+                title: 'test note',
+                noteId: note.noteId
+            }),
+        });
+        // Verify second change (update)
+        const updateChange = changes[1];
+        expect(updateChange).toEqual({
+            changeId: expect.any(String),
+            changeType: 'update',
+            timestamp: expect.any(Number),
+            timestampApplied: expect.any(Number),
+            tableName: 'notes',
+            recordId: note.noteId,
+            newRecord: expect.objectContaining({
+                title: 'updated note',
+                noteId: note.noteId
+            }),
+            jsonDiff: expect.any(Array),
+        });
+        // TypeScript needs this cast for type narrowing
+        expect(updateChange.jsonDiff.length).toBeGreaterThan(0);
+    });
+    it('should not track read operations', async () => {
+        // Insert a record
+        const note = await trackedTable.insert({ noteId: (0, peers_sdk_1.newid)(), title: 'test note' });
+        // Perform read operations
+        await trackedTable.get(note.noteId);
+        await trackedTable.list();
+        await trackedTable.cursor();
+        // Only the insert should be recorded
+        const changes = await changeTrackingTable.list();
+        expect(changes.length).toBe(1);
+        expect(changes[0].changeType).toBe('insert');
+    });
+    it('should handle snapshot changes', async () => {
+        const noteId = (0, peers_sdk_1.newid)();
+        // Create a snapshot change directly
+        const snapshotChange = {
+            changeId: (0, peers_sdk_1.newid)(),
+            changeType: 'snapshot',
+            timestamp: Date.now(),
+            timestampApplied: Date.now(),
+            tableName: 'notes',
+            recordId: noteId,
+            newRecord: { noteId, title: 'snapshot note', completed: false }
+        };
+        // Apply the snapshot change
+        await trackedTable.applyChanges([snapshotChange]);
+        // Verify the record was created
+        const note = await trackedTable.get(noteId);
+        expect(note).toEqual({ noteId, title: 'snapshot note', completed: false });
+        // Verify the snapshot change was recorded
+        const changes = await changeTrackingTable.list({ recordId: noteId });
+        expect(changes.length).toBe(1);
+        expect(changes[0]).toEqual({
+            changeId: snapshotChange.changeId,
+            changeType: 'snapshot',
+            timestamp: snapshotChange.timestamp,
+            timestampApplied: expect.any(Number),
+            tableName: 'notes',
+            recordId: noteId,
+            newRecord: expect.objectContaining({
+                noteId,
+                title: 'snapshot note',
+                completed: false
+            })
+        });
+    });
+    it('should list changes for a specific table', async () => {
+        // Insert a record
+        const note = await trackedTable.insert({ noteId: (0, peers_sdk_1.newid)(), title: 'test note' });
+        // Update the record
+        note.title = 'updated note';
+        await trackedTable.update(note);
+        // Delete the record
+        await trackedTable.delete(note);
+        // Use listChanges to get changes
+        const changes = await trackedTable.listChanges({}, { sortBy: ['timestamp'] });
+        // Verify we have 3 changes (insert, update, delete)
+        expect(changes.length).toBe(3);
+        expect(changes[0].changeType).toBe('insert');
+        expect(changes[1].changeType).toBe('update');
+        expect(changes[2].changeType).toBe('delete');
+        // Test filtering by changeType
+        const insertChanges = await trackedTable.listChanges({ changeType: 'insert' });
+        expect(insertChanges.length).toBe(1);
+        expect(insertChanges[0].changeType).toBe('insert');
+        // Test filtering by recordId
+        const recordChanges = await trackedTable.listChanges({ recordId: note.noteId }, { sortBy: ['timestamp'] });
+        expect(recordChanges.length).toBe(3);
+        expect(recordChanges.map(c => c.changeType)).toEqual(['insert', 'update', 'delete']);
+    });
+    it('should apply new changes to a table and remove old, irrelevant changes', async () => {
+        // Create a change to insert a record
+        const noteId = (0, peers_sdk_1.newid)();
+        const insertChange = {
+            changeId: (0, peers_sdk_1.newid)(),
+            changeType: 'insert',
+            timestamp: Date.now(),
+            timestampApplied: Date.now(),
+            tableName: 'notes',
+            recordId: noteId,
+            newRecord: { noteId, title: 'test note' }
+        };
+        // Apply the insert change
+        await trackedTable.applyChanges([insertChange]);
+        // Verify the record was inserted
+        const note = await trackedTable.get(noteId);
+        expect(note).toEqual({ noteId, title: 'test note' });
+        // Create an update change
+        const updateChange = {
+            changeId: (0, peers_sdk_1.newid)(),
+            changeType: 'update',
+            timestamp: insertChange.timestamp + 1,
+            timestampApplied: insertChange.timestamp + 1,
+            tableName: 'notes',
+            recordId: noteId,
+            oldRecord: { noteId, title: 'test note' },
+            newRecord: { noteId, title: 'updated note', completed: true },
+            jsonDiff: [{ op: 'replace', path: '/title', value: 'updated note' },
+                { op: 'add', path: '/completed', value: true }]
+        };
+        // Apply the update change
+        await trackedTable.applyChanges([updateChange]);
+        // Verify the record was updated
+        const updatedNote = await trackedTable.get(noteId);
+        expect(updatedNote).toEqual({ noteId, title: 'updated note', completed: true });
+        // Verify the changes were recorded in the change tracking table
+        let changes = await changeTrackingTable.list({ recordId: noteId }, { sortBy: ['timestamp'] });
+        expect(changes.length).toBe(2);
+        expect(changes.map(c => c.changeType)).toEqual(['insert', 'update']);
+        // Create a delete change
+        const deleteChange = {
+            changeId: (0, peers_sdk_1.newid)(),
+            changeType: 'delete',
+            timestamp: insertChange.timestamp + 2,
+            timestampApplied: insertChange.timestamp + 2,
+            tableName: 'notes',
+            recordId: noteId,
+            oldRecord: { noteId, title: 'updated note', completed: true },
+        };
+        // Apply the delete change
+        await trackedTable.applyChanges([deleteChange]);
+        // Verify the record was deleted
+        const deletedNote = await trackedTable.get(noteId);
+        expect(deletedNote).toBeUndefined();
+        // Verify the delete change was recorded and removed older (and no longer applicable changes)
+        changes = await changeTrackingTable.list({ recordId: noteId }, { sortBy: ['timestamp'] });
+        expect(changes.length).toBe(1);
+        expect(changes.map(c => c.changeType)).toEqual(['delete']);
+        // reapply the insert change
+        // Create a change to insert a record
+        const insertChange2 = {
+            changeId: (0, peers_sdk_1.newid)(),
+            changeType: 'insert',
+            timestamp: insertChange.timestamp + 3,
+            timestampApplied: insertChange.timestamp + 3,
+            tableName: 'notes',
+            recordId: noteId,
+            newRecord: { noteId, title: 'reinsert note' }
+        };
+        // Apply the insert change
+        await trackedTable.applyChanges([insertChange2]);
+        // Verify the insert change was recorded and removed older (and no longer applicable delete change)
+        changes = await changeTrackingTable.list({ recordId: noteId }, { sortBy: ['timestamp'] });
+        expect(changes.length).toBe(1);
+        expect(changes.map(c => c.changeType)).toEqual(['insert']);
+    });
+    it('should not reapply changes that have already been applied', async () => {
+        // Create a test change
+        const noteId = (0, peers_sdk_1.newid)();
+        const changeId = (0, peers_sdk_1.newid)();
+        const insertChange = {
+            changeId,
+            changeType: 'insert',
+            timestamp: Date.now(),
+            timestampApplied: Date.now(),
+            tableName: 'notes',
+            recordId: noteId,
+            newRecord: { noteId, title: 'duplicate test' }
+        };
+        // Apply the change
+        await trackedTable.applyChanges([insertChange]);
+        // Verify the record was inserted
+        const note = await trackedTable.get(noteId);
+        expect(note).toEqual({ noteId, title: 'duplicate test' });
+        // Try to apply the same change again
+        await trackedTable.applyChanges([insertChange]);
+        // Verify the change was only recorded once
+        const changes = await changeTrackingTable.list({ changeId });
+        expect(changes.length).toBe(1);
+    });
+    it('should apply changes in timestamp order', async () => {
+        const noteId = (0, peers_sdk_1.newid)();
+        const now = Date.now();
+        // Create changes with out-of-order timestamps
+        const changes = [
+            {
+                changeId: (0, peers_sdk_1.newid)(),
+                changeType: 'update',
+                timestamp: now + 200,
+                timestampApplied: now + 200,
+                tableName: 'notes',
+                recordId: noteId,
+                oldRecord: { noteId, title: 'second title' },
+                newRecord: { noteId, title: 'final title' },
+                jsonDiff: [{ op: 'replace', path: '/title', value: 'final title' }]
+            },
+            {
+                changeId: (0, peers_sdk_1.newid)(),
+                changeType: 'insert',
+                timestamp: now,
+                timestampApplied: now,
+                tableName: 'notes',
+                recordId: noteId,
+                newRecord: { noteId, title: 'initial title' }
+            },
+            {
+                changeId: (0, peers_sdk_1.newid)(),
+                changeType: 'update',
+                timestamp: now + 100,
+                timestampApplied: now + 100,
+                tableName: 'notes',
+                recordId: noteId,
+                oldRecord: { noteId, title: 'initial title' },
+                newRecord: { noteId, title: 'second title' },
+                jsonDiff: [{ op: 'replace', path: '/title', value: 'second title' }]
+            }
+        ];
+        // Store the changeIds for verification later
+        const changeIds = {
+            insert: changes[1].changeId,
+            update1: changes[2].changeId,
+            update2: changes[0].changeId
+        };
+        // Apply the out-of-order changes
+        await trackedTable.applyChanges(changes);
+        // Verify the final state reflects the changes applied in timestamp order
+        const note = await trackedTable.get(noteId);
+        expect(note).toEqual({ noteId, title: 'final title' });
+        // Verify the changes were recorded in order
+        const recordedChanges = await changeTrackingTable.list({ recordId: noteId }, { sortBy: ['timestamp'] });
+        expect(recordedChanges.length).toBe(3);
+        expect(recordedChanges.map(c => c.changeId)).toEqual([
+            changeIds.insert,
+            changeIds.update1,
+            changeIds.update2
+        ]);
+    });
+    it('should require a restore operation to bring a record back after being deleted', async () => {
+        // Create a change to insert a record
+        const noteId = (0, peers_sdk_1.newid)();
+        const insertChange = {
+            changeId: (0, peers_sdk_1.newid)(),
+            changeType: 'insert',
+            timestamp: Date.now(),
+            timestampApplied: Date.now(),
+            tableName: 'notes',
+            recordId: noteId,
+            newRecord: { noteId, title: 'test note' }
+        };
+        // Apply the insert change
+        await trackedTable.applyChanges([insertChange]);
+        // Verify the record was inserted
+        const note = await trackedTable.get(noteId);
+        expect(note).toEqual({ noteId, title: 'test note' });
+        // Create a delete change
+        const deleteChange = {
+            changeId: (0, peers_sdk_1.newid)(),
+            changeType: 'delete',
+            timestamp: insertChange.timestamp + 1,
+            timestampApplied: insertChange.timestamp + 1,
+            tableName: 'notes',
+            recordId: noteId,
+            oldRecord: { noteId, title: 'test note' }
+        };
+        // Apply the delete change
+        await trackedTable.applyChanges([deleteChange]);
+        // Verify the record was deleted
+        const deletedNote = await trackedTable.get(noteId);
+        expect(deletedNote).toBeUndefined();
+        // Create an update change
+        const updateChange = {
+            changeId: (0, peers_sdk_1.newid)(),
+            changeType: 'update',
+            timestamp: insertChange.timestamp + 1,
+            timestampApplied: insertChange.timestamp + 1,
+            tableName: 'notes',
+            recordId: noteId,
+            oldRecord: { noteId, title: 'test note' },
+            newRecord: { noteId, title: 'updated note', completed: true },
+            jsonDiff: [{ op: 'replace', path: '/title', value: 'updated note' },
+                { op: 'add', path: '/completed', value: true }]
+        };
+        // Apply the update change
+        await trackedTable.applyChanges([updateChange]);
+        // Verify the record was not updated
+        const updatedNote = await trackedTable.get(noteId);
+        expect(updatedNote).toBeUndefined();
+        // Create a restore change
+        const restoreChange = {
+            changeId: (0, peers_sdk_1.newid)(),
+            changeType: 'restore',
+            timestamp: insertChange.timestamp + 2,
+            timestampApplied: insertChange.timestamp + 2,
+            tableName: 'notes',
+            recordId: noteId,
+            newRecord: { noteId, title: 'restored note' }
+        };
+        // Apply the restore change
+        await trackedTable.applyChanges([restoreChange]);
+        // Verify the record was restored
+        const restoredNote = await trackedTable.get(noteId);
+        expect(restoredNote).toEqual({ noteId, title: 'restored note' });
+    });
+    it('should correctly and efficiently apply new changes to records with a very large amount of existing writes', async () => {
+        const db2 = new local_data_source_1.DBLocal(':memory:');
+        const mockDataContext2 = {
+            dataSourceFactory: () => new peers_sdk_1.SQLDataSource(db2, NotesMetaData, notesSchema),
+            eventRegistry: {
+                getEmitter: () => ({
+                    event: { subscribe: () => { } },
+                    emit: () => { }
+                })
+            }
+        };
+        const deps2 = {
+            dataSource: new (require("@peers-app/peers-sdk")).SQLDataSource(db2, NotesMetaData, notesSchema),
+            eventRegistry: mockDataContext2.eventRegistry,
+        };
+        const Notes2 = new peers_sdk_1.Table(NotesMetaData, deps2);
+        const changeTrackingTable2 = new peers_sdk_1.ChangeTrackingTable({ db: db2 });
+        const trackedTable2 = new tracked_data_source_1.TrackedDataSource(Notes2, changeTrackingTable2);
+        // Create a record with a large number of changes
+        const noteId = (0, peers_sdk_1.newid)();
+        const note = { noteId, title: 'test note' };
+        const checkpointCount = 20;
+        const writesBetweenCheckpointsCount = 20;
+        let lastCheckpointTimestamp = 0;
+        let note1Deleted = false;
+        let note2Deleted = false;
+        async function save1() {
+            if (note1Deleted) {
+                await trackedTable.save(note, { restoreIfDeleted: true });
+                note1Deleted = false;
+            }
+            else {
+                await trackedTable.save(note);
+            }
+        }
+        async function save2() {
+            if (note2Deleted) {
+                await trackedTable2.save(note, { restoreIfDeleted: true });
+                note2Deleted = false;
+            }
+            else {
+                await trackedTable2.save(note);
+            }
+        }
+        for (let i = 0; i < checkpointCount; i++) {
+            for (let j = 0; j < writesBetweenCheckpointsCount; j++) {
+                note.title = `update ${i} ${j}`;
+                note.completed = (0, lodash_1.random)(0, 10) === 0;
+                if ((0, lodash_1.random)(0, 10) === 0) {
+                    note.number = (0, lodash_1.random)(0, 1000);
+                }
+                if ((0, lodash_1.random)(0, 2) === 0) {
+                    note.string = (note.string || '') + note.title;
+                    note.string = (note.string || '') + note.title;
+                    const replaceStartI = (0, lodash_1.random)(0, note.string.length - 1);
+                    const replaceEndI = (0, lodash_1.random)(replaceStartI, note.string.length - 1);
+                    note.string = note.string.replace(note.string?.substring(replaceStartI, replaceEndI), note.title);
+                }
+                if ((0, lodash_1.random)(0, 4) > 0) {
+                    note.date = new Date();
+                }
+                if ((0, lodash_1.random)(0, 10) > 0 || j === writesBetweenCheckpointsCount - 1) {
+                    await save1();
+                }
+                if ((0, lodash_1.random)(0, 10) > 0) {
+                    await save2();
+                }
+                // random delete
+                if ((0, lodash_1.random)(0, 10) === 0) {
+                    await trackedTable.delete(note);
+                    note1Deleted = true;
+                }
+                if ((0, lodash_1.random)(0, 10) === 0) {
+                    await trackedTable2.delete(note);
+                    note2Deleted = true;
+                }
+            }
+            if (note1Deleted !== note2Deleted) {
+                note.title = `checkpoint ${i}`;
+                await save1();
+                await save2();
+                note1Deleted = false;
+                note2Deleted = false;
+            }
+            let changes = await trackedTable.listChanges({ timestamp: { $gte: lastCheckpointTimestamp } }, { sortBy: ['timestamp'] });
+            let changes2 = await trackedTable2.listChanges({ timestamp: { $gte: lastCheckpointTimestamp } }, { sortBy: ['timestamp'] });
+            await trackedTable.applyChanges(changes2);
+            await trackedTable2.applyChanges(changes);
+            changes = await trackedTable.listChanges({ timestamp: { $gte: lastCheckpointTimestamp } }, { sortBy: ['timestamp'] });
+            changes2 = await trackedTable2.listChanges({ timestamp: { $gte: lastCheckpointTimestamp } }, { sortBy: ['timestamp'] });
+            expect(changes.map(c => c.changeId)).toEqual(changes2.map(c => c.changeId));
+            lastCheckpointTimestamp = changes[changes.length - 1].timestamp;
+        }
+        const changes = await changeTrackingTable.list({ recordId: noteId }, { sortBy: ['timestamp'] });
+        const changes2 = await changeTrackingTable2.list({ recordId: noteId }, { sortBy: ['timestamp'] });
+        expect(changes.map(c => c.changeId)).toEqual(changes2.map(c => c.changeId));
+        const dbNote = await Notes.get(noteId);
+        expect(dbNote).toEqual(note);
+        const dbNote2 = await Notes2.get(noteId);
+        expect(dbNote2).toEqual(note);
+    });
+    it("should be able to compact changes to remain performant", async () => {
+        const db = new local_data_source_1.DBLocal(':memory:');
+        const mockDataContext3 = {
+            dataSourceFactory: () => new peers_sdk_1.SQLDataSource(db, NotesMetaData, notesSchema),
+            eventRegistry: {
+                getEmitter: () => ({
+                    event: { subscribe: () => { } },
+                    emit: () => { }
+                })
+            }
+        };
+        const deps3 = {
+            dataSource: new (require("@peers-app/peers-sdk")).SQLDataSource(db, NotesMetaData, notesSchema),
+            eventRegistry: mockDataContext3.eventRegistry,
+        };
+        const NotesTable = new peers_sdk_1.Table(NotesMetaData, deps3);
+        const changeTrackingTable = new peers_sdk_1.ChangeTrackingTable({ db: db });
+        const trackedTable = new tracked_data_source_1.TrackedDataSource(NotesTable, changeTrackingTable);
+        // Create a record with a large number of updates
+        const noteId = (0, peers_sdk_1.newid)();
+        const note = { noteId, title: 'test note' };
+        const writesCount = 200;
+        for (let i = 0; i < writesCount; i++) {
+            note.title = `update ${i}`;
+            note.completed = (0, lodash_1.random)(0, 10) === 0;
+            if ((0, lodash_1.random)(0, 10) === 0) {
+                note.number = (0, lodash_1.random)(0, 1000);
+            }
+            if ((0, lodash_1.random)(0, 2) === 0) {
+                note.string = (note.string || '') + note.title;
+                note.string = (note.string || '') + note.title;
+                const replaceStartI = (0, lodash_1.random)(0, note.string.length - 1);
+                const replaceEndI = (0, lodash_1.random)(replaceStartI, note.string.length - 1);
+                note.string = note.string.replace(note.string?.substring(replaceStartI, replaceEndI), note.title);
+            }
+            if ((0, lodash_1.random)(0, 4) > 0) {
+                note.date = new Date();
+            }
+            await trackedTable.save(note);
+        }
+        let dbNote = await NotesTable.get(noteId);
+        expect(dbNote).toEqual(note);
+        const changesBeforeCompact = await changeTrackingTable.list({ recordId: noteId }, { sortBy: ['timestamp'] });
+        expect(changesBeforeCompact.length).toBeGreaterThan(100);
+        const tenthLastChange = changesBeforeCompact[changesBeforeCompact.length - 10];
+        await trackedTable.compact(tenthLastChange.timestamp);
+        const changesAfterCompact = await changeTrackingTable.list({ recordId: noteId }, { sortBy: ['timestamp'] });
+        expect(changesAfterCompact.length).toEqual(11);
+        dbNote = await NotesTable.get(noteId);
+        expect(dbNote).toEqual(note);
+    });
+    it('should handle restore operation correctly', async () => {
+        const noteId = (0, peers_sdk_1.newid)();
+        // Insert and then delete a record
+        await trackedTable.insert({ noteId, title: 'original note' });
+        await trackedTable.delete(noteId);
+        // Verify it's deleted
+        const deletedNote = await trackedTable.get(noteId);
+        expect(deletedNote).toBeUndefined();
+        // Restore the record
+        const restoredNote = await trackedTable.restore({ noteId, title: 'restored note' });
+        expect(restoredNote).toEqual({ noteId, title: 'restored note' });
+        // Verify it's restored
+        const retrievedNote = await trackedTable.get(noteId);
+        expect(retrievedNote).toEqual({ noteId, title: 'restored note' });
+        // Verify restore change was tracked
+        const changes = await trackedTable.listChanges({ recordId: noteId, changeType: 'restore' });
+        expect(changes.length).toBe(1);
+        expect(changes[0].changeType).toBe('restore');
+    });
+    it('should handle restore without recordId provided', async () => {
+        await expect(trackedTable.restore({ title: 'no id' })).rejects.toThrow('No recordId provided to restore');
+    });
+    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.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.  Use restore instead');
+    });
+    it('should handle save with deleted record without restore flag', async () => {
+        const noteId = (0, peers_sdk_1.newid)();
+        // Insert and then delete a record
+        await trackedTable.insert({ noteId, title: 'original note' });
+        await trackedTable.delete(noteId);
+        // Try to save without restore flag - should fail
+        await expect(trackedTable.save({ noteId, title: 'new note' })).rejects.toThrow('because it has been deleted.  Use restore instead');
+    });
+    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');
+    });
+    it('should handle delete with string ID for non-existent record', async () => {
+        const noteId = (0, peers_sdk_1.newid)();
+        // Mock console.warn to capture the warning
+        const warnSpy = jest.spyOn(console, 'warn').mockImplementation();
+        // Try to delete non-existent record
+        await trackedTable.delete(noteId);
+        // Verify warning was logged
+        expect(warnSpy).toHaveBeenCalledWith(expect.stringContaining('Record not found'));
+        warnSpy.mockRestore();
+    });
+    it('should handle update with no changes', async () => {
+        const note = await trackedTable.insert({ noteId: (0, peers_sdk_1.newid)(), title: 'test note' });
+        // Update with same data - should return unchanged
+        const result = await trackedTable.update(note);
+        expect(result).toEqual(note);
+        // Should still only have one change (the insert)
+        const changes = await trackedTable.listChanges({ recordId: note.noteId });
+        expect(changes.length).toBe(1);
+        expect(changes[0].changeType).toBe('insert');
+    });
+    it('should handle compact with default timestamp', async () => {
+        const noteId = (0, peers_sdk_1.newid)();
+        const note = { noteId, title: 'test note' };
+        // Create some changes
+        await trackedTable.save(note);
+        note.title = 'updated';
+        await trackedTable.save(note);
+        // Test compact with default timestamp (should use 2 weeks ago)
+        await trackedTable.compact();
+        // Should still have changes since they're recent
+        const changes = await trackedTable.listChanges({ recordId: noteId });
+        expect(changes.length).toBeGreaterThan(0);
+    });
+    it('should handle findAndTrackRecords method', async () => {
+        // Use separate instance for isolation
+        const db = new local_data_source_1.DBLocal(':memory:');
+        const mockDataContext4 = {
+            dataSourceFactory: () => new peers_sdk_1.SQLDataSource(db, NotesMetaData, notesSchema),
+            eventRegistry: {
+                getEmitter: () => ({
+                    event: { subscribe: () => { } },
+                    emit: () => { }
+                })
+            }
+        };
+        const deps4 = {
+            dataSource: new (require("@peers-app/peers-sdk")).SQLDataSource(db, NotesMetaData, notesSchema),
+            eventRegistry: mockDataContext4.eventRegistry,
+        };
+        const NotesTable = new peers_sdk_1.Table(NotesMetaData, deps4);
+        const changeTrackingTable = new peers_sdk_1.ChangeTrackingTable({ db });
+        const isolatedTrackedTable = new tracked_data_source_1.TrackedDataSource(NotesTable, changeTrackingTable);
+        // Insert some records directly to data source (bypassing tracking)
+        const note1 = { noteId: (0, peers_sdk_1.newid)(), title: 'untracked 1' };
+        const note2 = { noteId: (0, peers_sdk_1.newid)(), title: 'untracked 2' };
+        await NotesTable.insert(note1);
+        await NotesTable.insert(note2);
+        // Mock console.log to capture output
+        const logSpy = jest.spyOn(console, 'log').mockImplementation();
+        // Find and track records
+        await isolatedTrackedTable.findAndTrackRecords(1);
+        // Verify records were tracked
+        const changes = await isolatedTrackedTable.listChanges({ changeType: 'snapshot' });
+        expect(changes.length).toBe(2);
+        // Verify console output
+        expect(logSpy).toHaveBeenCalledWith(expect.stringContaining('Tracking recordId'));
+        logSpy.mockRestore();
+    });
+    it('should handle apply changes with restore after delete', async () => {
+        const noteId = (0, peers_sdk_1.newid)();
+        // Apply delete change
+        const deleteChange = {
+            changeId: (0, peers_sdk_1.newid)(),
+            changeType: 'delete',
+            timestamp: Date.now(),
+            timestampApplied: Date.now(),
+            tableName: 'notes',
+            recordId: noteId,
+            oldRecord: { noteId, title: 'deleted note' }
+        };
+        await trackedTable.applyChanges([deleteChange]);
+        // Apply restore change
+        const restoreChange = {
+            changeId: (0, peers_sdk_1.newid)(),
+            changeType: 'restore',
+            timestamp: Date.now() + 1,
+            timestampApplied: Date.now() + 1,
+            tableName: 'notes',
+            recordId: noteId,
+            newRecord: { noteId, title: 'restored note' }
+        };
+        await trackedTable.applyChanges([restoreChange]);
+        // Verify record was restored
+        const note = await trackedTable.get(noteId);
+        expect(note).toEqual({ noteId, title: 'restored note' });
+    });
+    it('should handle error cases in applyChanges', async () => {
+        const noteId = (0, peers_sdk_1.newid)();
+        // Create a change with unsupported type
+        const unsupportedChange = {
+            changeId: (0, peers_sdk_1.newid)(),
+            changeType: 'unsupported',
+            timestamp: Date.now(),
+            timestampApplied: Date.now(),
+            tableName: 'notes',
+            recordId: noteId,
+        };
+        await expect(trackedTable.applyChanges([unsupportedChange])).rejects.toThrow('Unsupported change type');
+    });
+    it('should handle insert without primaryKey', async () => {
+        // Test insert without providing primary key
+        const result = await trackedTable.insert({ title: 'no id' });
+        expect(result.noteId).toBeDefined();
+        expect(result.title).toBe('no id');
+    });
+    it('should handle save with record that needs insert', async () => {
+        const noteId = (0, peers_sdk_1.newid)();
+        // Test save with new record (should insert)
+        const result = await trackedTable.save({ noteId, title: 'new record' });
+        expect(result).toEqual({ noteId, title: 'new record' });
+        // Verify it was inserted
+        const retrieved = await trackedTable.get(noteId);
+        expect(retrieved).toEqual({ noteId, title: 'new record' });
+    });
+    it('should handle save without primaryKey', async () => {
+        // Test save without providing primary key (should insert)
+        const result = await trackedTable.save({ title: 'no id' });
+        expect(result.noteId).toBeDefined();
+        expect(result.title).toBe('no id');
+    });
+});
+//# sourceMappingURL=tracked-data-source.test.js.map