@powersync/service-core-tests 0.14.0 → 0.15.1

package/src/tests/register-compacting-tests.ts

@@ -1,11 +1,12 @@
-import { storage, updateSyncRulesFromYaml } from '@powersync/service-core';
+import { addChecksums, storage, updateSyncRulesFromYaml } from '@powersync/service-core';
 import { expect, test } from 'vitest';
 import * as test_utils from '../test-utils/test-utils-index.js';
-import { bucketRequest, bucketRequestMap, bucketRequests } from './util.js';
+import { bucketRequest } from '../test-utils/test-utils-index.js';
+import { bucketRequestMap, bucketRequests } from './util.js';
 
-const TEST_TABLE = test_utils.makeTestTable('test', ['id']);
+export function registerCompactTests(config: storage.TestStorageConfig) {
+  const generateStorageFactory = config.factory;
 
-export function registerCompactTests(generateStorageFactory: storage.TestStorageFactory) {
   test('compacting (1)', async () => {
     await using factory = await generateStorageFactory();
     const syncRules = await factory.updateSyncRules(
@@ -17,60 +18,59 @@ bucket_definitions:
     );
     const bucketStorage = factory.getInstance(syncRules);
 
-    const result = await bucketStorage.startBatch(test_utils.BATCH_OPTIONS, async (batch) => {
-      await batch.save({
-        sourceTable: TEST_TABLE,
-        tag: storage.SaveOperationTag.INSERT,
-        after: {
-          id: 't1'
-        },
-        afterReplicaId: test_utils.rid('t1')
-      });
-
-      await batch.save({
-        sourceTable: TEST_TABLE,
-        tag: storage.SaveOperationTag.INSERT,
-        after: {
-          id: 't2'
-        },
-        afterReplicaId: test_utils.rid('t2')
-      });
+    await using writer = await bucketStorage.createWriter(test_utils.BATCH_OPTIONS);
+    const testTable = await test_utils.resolveTestTable(writer, 'test', ['id'], config);
+    await writer.markAllSnapshotDone('1/1');
+    await writer.save({
+      sourceTable: testTable,
+      tag: storage.SaveOperationTag.INSERT,
+      after: {
+        id: 't1'
+      },
+      afterReplicaId: test_utils.rid('t1')
+    });
 
-      await batch.save({
-        sourceTable: TEST_TABLE,
-        tag: storage.SaveOperationTag.UPDATE,
-        after: {
-          id: 't2'
-        },
-        afterReplicaId: test_utils.rid('t2')
-      });
+    await writer.save({
+      sourceTable: testTable,
+      tag: storage.SaveOperationTag.INSERT,
+      after: {
+        id: 't2'
+      },
+      afterReplicaId: test_utils.rid('t2')
+    });
 
-      await batch.commit('1/1');
+    await writer.save({
+      sourceTable: testTable,
+      tag: storage.SaveOperationTag.UPDATE,
+      after: {
+        id: 't2'
+      },
+      afterReplicaId: test_utils.rid('t2')
     });
 
-    const checkpoint = result!.flushed_op;
+    await writer.commit('1/1');
+    await writer.flush();
 
-    const batchBefore = await test_utils.oneFromAsync(
-      bucketStorage.getBucketDataBatch(checkpoint, bucketRequestMap(syncRules, [['global[]', 0n]]))
-    );
+    const checkpoint = writer.last_flushed_op!;
+
+    const request = bucketRequest(syncRules, 'global[]');
+
+    const batchBefore = await test_utils.oneFromAsync(bucketStorage.getBucketDataBatch(checkpoint, [request]));
     const dataBefore = batchBefore.chunkData.data;
-    const checksumBefore = await bucketStorage.getChecksums(checkpoint, bucketRequests(syncRules, ['global[]']));
+    const checksumBefore = await bucketStorage.getChecksums(checkpoint, [request]);
 
     expect(dataBefore).toMatchObject([
       {
-        checksum: 2634521662,
         object_id: 't1',
         op: 'PUT',
         op_id: '1'
       },
       {
-        checksum: 4243212114,
         object_id: 't2',
         op: 'PUT',
         op_id: '2'
       },
       {
-        checksum: 4243212114,
         object_id: 't2',
         op: 'PUT',
         op_id: '3'
@@ -86,41 +86,30 @@ bucket_definitions:
       minChangeRatio: 0
     });
 
-    const batchAfter = await test_utils.oneFromAsync(
-      bucketStorage.getBucketDataBatch(checkpoint, bucketRequestMap(syncRules, [['global[]', 0n]]))
-    );
+    const batchAfter = await test_utils.oneFromAsync(bucketStorage.getBucketDataBatch(checkpoint, [request]));
     const dataAfter = batchAfter.chunkData.data;
-    const checksumAfter = await bucketStorage.getChecksums(checkpoint, bucketRequests(syncRules, ['global[]']));
+    const checksumAfter = await bucketStorage.getChecksums(checkpoint, [request]);
     bucketStorage.clearChecksumCache();
-    const checksumAfter2 = await bucketStorage.getChecksums(checkpoint, bucketRequests(syncRules, ['global[]']));
+    const checksumAfter2 = await bucketStorage.getChecksums(checkpoint, [request]);
 
     expect(batchAfter.targetOp).toEqual(3n);
     expect(dataAfter).toMatchObject([
+      dataBefore[0],
       {
-        checksum: 2634521662,
-        object_id: 't1',
-        op: 'PUT',
-        op_id: '1'
-      },
-      {
-        checksum: 4243212114,
+        checksum: dataBefore[1].checksum,
         op: 'MOVE',
         op_id: '2'
       },
       {
-        checksum: 4243212114,
+        checksum: dataBefore[2].checksum,
         object_id: 't2',
         op: 'PUT',
         op_id: '3'
       }
     ]);
 
-    expect(checksumAfter.get(bucketRequest(syncRules, 'global[]'))).toEqual(
-      checksumBefore.get(bucketRequest(syncRules, 'global[]'))
-    );
-    expect(checksumAfter2.get(bucketRequest(syncRules, 'global[]'))).toEqual(
-      checksumBefore.get(bucketRequest(syncRules, 'global[]'))
-    );
+    expect(checksumAfter.get(request.bucket)).toEqual(checksumBefore.get(request.bucket));
+    expect(checksumAfter2.get(request.bucket)).toEqual(checksumBefore.get(request.bucket));
 
     test_utils.validateCompactedBucket(dataBefore, dataAfter);
   });
@@ -136,78 +125,72 @@ bucket_definitions:
     );
     const bucketStorage = factory.getInstance(syncRules);
 
-    const result = await bucketStorage.startBatch(test_utils.BATCH_OPTIONS, async (batch) => {
-      await batch.save({
-        sourceTable: TEST_TABLE,
-        tag: storage.SaveOperationTag.INSERT,
-        after: {
-          id: 't1'
-        },
-        afterReplicaId: test_utils.rid('t1')
-      });
-
-      await batch.save({
-        sourceTable: TEST_TABLE,
-        tag: storage.SaveOperationTag.INSERT,
-        after: {
-          id: 't2'
-        },
-        afterReplicaId: test_utils.rid('t2')
-      });
+    await using writer = await bucketStorage.createWriter(test_utils.BATCH_OPTIONS);
+    const testTable = await test_utils.resolveTestTable(writer, 'test', ['id'], config);
+    await writer.markAllSnapshotDone('1/1');
+    await writer.save({
+      sourceTable: testTable,
+      tag: storage.SaveOperationTag.INSERT,
+      after: {
+        id: 't1'
+      },
+      afterReplicaId: test_utils.rid('t1')
+    });
 
-      await batch.save({
-        sourceTable: TEST_TABLE,
-        tag: storage.SaveOperationTag.DELETE,
-        before: {
-          id: 't1'
-        },
-        beforeReplicaId: test_utils.rid('t1')
-      });
+    await writer.save({
+      sourceTable: testTable,
+      tag: storage.SaveOperationTag.INSERT,
+      after: {
+        id: 't2'
+      },
+      afterReplicaId: test_utils.rid('t2')
+    });
 
-      await batch.save({
-        sourceTable: TEST_TABLE,
-        tag: storage.SaveOperationTag.UPDATE,
-        after: {
-          id: 't2'
-        },
-        afterReplicaId: test_utils.rid('t2')
-      });
+    await writer.save({
+      sourceTable: testTable,
+      tag: storage.SaveOperationTag.DELETE,
+      before: {
+        id: 't1'
+      },
+      beforeReplicaId: test_utils.rid('t1')
+    });
 
-      await batch.commit('1/1');
+    await writer.save({
+      sourceTable: testTable,
+      tag: storage.SaveOperationTag.UPDATE,
+      after: {
+        id: 't2'
+      },
+      afterReplicaId: test_utils.rid('t2')
     });
 
-    const checkpoint = result!.flushed_op;
+    await writer.commit('1/1');
+    await writer.flush();
 
-    const batchBefore = await test_utils.oneFromAsync(
-      bucketStorage.getBucketDataBatch(checkpoint, bucketRequestMap(syncRules, [['global[]', 0n]]))
-    );
+    const checkpoint = writer.last_flushed_op!;
+    const request = bucketRequest(syncRules, 'global[]');
+
+    const batchBefore = await test_utils.oneFromAsync(bucketStorage.getBucketDataBatch(checkpoint, [request]));
     const dataBefore = batchBefore.chunkData.data;
-    const checksumBefore = await bucketStorage.getChecksums(checkpoint, bucketRequests(syncRules, ['global[]']));
+    const checksumBefore = await bucketStorage.getChecksums(checkpoint, [request]);
 
+    // op_id sequence depends on the storage implementation
     expect(dataBefore).toMatchObject([
       {
-        checksum: 2634521662,
         object_id: 't1',
-        op: 'PUT',
-        op_id: '1'
+        op: 'PUT'
       },
       {
-        checksum: 4243212114,
         object_id: 't2',
-        op: 'PUT',
-        op_id: '2'
+        op: 'PUT'
       },
       {
-        checksum: 4228978084,
         object_id: 't1',
-        op: 'REMOVE',
-        op_id: '3'
+        op: 'REMOVE'
       },
       {
-        checksum: 4243212114,
         object_id: 't2',
-        op: 'PUT',
-        op_id: '4'
+        op: 'PUT'
       }
     ]);
 
@@ -219,29 +202,28 @@ bucket_definitions:
       minChangeRatio: 0
     });
 
-    const batchAfter = await test_utils.oneFromAsync(
-      bucketStorage.getBucketDataBatch(checkpoint, bucketRequestMap(syncRules, [['global[]', 0n]]))
-    );
+    const batchAfter = await test_utils.oneFromAsync(bucketStorage.getBucketDataBatch(checkpoint, [request]));
     const dataAfter = batchAfter.chunkData.data;
     bucketStorage.clearChecksumCache();
-    const checksumAfter = await bucketStorage.getChecksums(checkpoint, bucketRequests(syncRules, ['global[]']));
+    const checksumAfter = await bucketStorage.getChecksums(checkpoint, [request]);
 
-    expect(batchAfter.targetOp).toEqual(4n);
+    expect(batchAfter.targetOp).toBeLessThanOrEqual(checkpoint);
     expect(dataAfter).toMatchObject([
       {
-        checksum: -1778190028,
-        op: 'CLEAR',
-        op_id: '3'
+        checksum: addChecksums(
+          addChecksums(dataBefore[0].checksum as number, dataBefore[1].checksum as number),
+          dataBefore[2].checksum as number
+        ),
+        op: 'CLEAR'
       },
       {
-        checksum: 4243212114,
+        checksum: dataBefore[3].checksum,
         object_id: 't2',
-        op: 'PUT',
-        op_id: '4'
+        op: 'PUT'
       }
     ]);
-    expect(checksumAfter.get(bucketRequest(syncRules, 'global[]'))).toEqual({
-      ...checksumBefore.get(bucketRequest(syncRules, 'global[]')),
+    expect(checksumAfter.get(request.bucket)).toEqual({
+      ...checksumBefore.get(request.bucket),
       count: 2
     });
 
@@ -259,52 +241,54 @@ bucket_definitions:
     );
     const bucketStorage = factory.getInstance(syncRules);
 
-    const result = await bucketStorage.startBatch(test_utils.BATCH_OPTIONS, async (batch) => {
-      await batch.save({
-        sourceTable: TEST_TABLE,
-        tag: storage.SaveOperationTag.INSERT,
-        after: {
-          id: 't1'
-        },
-        afterReplicaId: 't1'
-      });
-
-      await batch.save({
-        sourceTable: TEST_TABLE,
-        tag: storage.SaveOperationTag.INSERT,
-        after: {
-          id: 't2'
-        },
-        afterReplicaId: 't2'
-      });
-
-      await batch.save({
-        sourceTable: TEST_TABLE,
-        tag: storage.SaveOperationTag.DELETE,
-        before: {
-          id: 't1'
-        },
-        beforeReplicaId: 't1'
-      });
+    await using writer = await bucketStorage.createWriter(test_utils.BATCH_OPTIONS);
+    const testTable = await test_utils.resolveTestTable(writer, 'test', ['id'], config);
+    await writer.markAllSnapshotDone('1/1');
+    await writer.save({
+      sourceTable: testTable,
+      tag: storage.SaveOperationTag.INSERT,
+      after: {
+        id: 't1'
+      },
+      afterReplicaId: 't1'
+    });
 
-      await batch.commit('1/1');
+    await writer.save({
+      sourceTable: testTable,
+      tag: storage.SaveOperationTag.INSERT,
+      after: {
+        id: 't2'
+      },
+      afterReplicaId: 't2'
     });
 
-    const checkpoint1 = result!.flushed_op;
-    const checksumBefore = await bucketStorage.getChecksums(checkpoint1, bucketRequests(syncRules, ['global[]']));
+    await writer.save({
+      sourceTable: testTable,
+      tag: storage.SaveOperationTag.DELETE,
+      before: {
+        id: 't1'
+      },
+      beforeReplicaId: 't1'
+    });
 
-    const result2 = await bucketStorage.startBatch(test_utils.BATCH_OPTIONS, async (batch) => {
-      await batch.save({
-        sourceTable: TEST_TABLE,
-        tag: storage.SaveOperationTag.DELETE,
-        before: {
-          id: 't2'
-        },
-        beforeReplicaId: 't2'
-      });
-      await batch.commit('2/1');
+    await writer.commit('1/1');
+    await writer.flush();
+
+    const checkpoint1 = writer.last_flushed_op!;
+    const request = bucketRequest(syncRules, 'global[]');
+    await using writer2 = await bucketStorage.createWriter(test_utils.BATCH_OPTIONS);
+    const testTable2 = await test_utils.resolveTestTable(writer2, 'test', ['id'], config);
+    await writer2.save({
+      sourceTable: testTable2,
+      tag: storage.SaveOperationTag.DELETE,
+      before: {
+        id: 't2'
+      },
+      beforeReplicaId: 't2'
     });
-    const checkpoint2 = result2!.flushed_op;
+    await writer2.commit('2/1');
+    await writer2.flush();
+    const checkpoint2 = writer2.last_flushed_op!;
 
     await bucketStorage.compact({
       clearBatchLimit: 2,
@@ -314,25 +298,20 @@ bucket_definitions:
       minChangeRatio: 0
     });
 
-    const batchAfter = await test_utils.oneFromAsync(
-      bucketStorage.getBucketDataBatch(checkpoint2, bucketRequestMap(syncRules, [['global[]', 0n]]))
-    );
+    const batchAfter = await test_utils.oneFromAsync(bucketStorage.getBucketDataBatch(checkpoint2, [request]));
     const dataAfter = batchAfter.chunkData.data;
     await bucketStorage.clearChecksumCache();
-    const checksumAfter = await bucketStorage.getChecksums(checkpoint2, bucketRequests(syncRules, ['global[]']));
+    const checksumAfter = await bucketStorage.getChecksums(checkpoint2, [request]);
 
-    expect(batchAfter.targetOp).toEqual(4n);
     expect(dataAfter).toMatchObject([
       {
-        checksum: 1874612650,
-        op: 'CLEAR',
-        op_id: '4'
+        op: 'CLEAR'
       }
     ]);
-    expect(checksumAfter.get(bucketRequest(syncRules, 'global[]'))).toEqual({
-      bucket: bucketRequest(syncRules, 'global[]'),
+    expect(checksumAfter.get(request.bucket)).toEqual({
+      bucket: request.bucket,
       count: 1,
-      checksum: 1874612650
+      checksum: dataAfter[0].checksum
     });
   });
 
@@ -350,75 +329,78 @@ bucket_definitions:
     );
     const bucketStorage = factory.getInstance(syncRules);
 
-    const result = await bucketStorage.startBatch(test_utils.BATCH_OPTIONS, async (batch) => {
-      /**
-       * Repeatedly create operations which fall into different buckets.
-       * The bucket operations are purposely interleaved as the op_id increases.
-       * A large amount of operations are created here.
-       * The configured window of compacting operations is 100. This means the initial window will
-       * contain operations from multiple buckets.
-       */
-      for (let count = 0; count < 100; count++) {
-        await batch.save({
-          sourceTable: TEST_TABLE,
-          tag: storage.SaveOperationTag.INSERT,
-          after: {
-            id: 't1',
-            b: 'b1',
-            value: 'start'
-          },
-          afterReplicaId: test_utils.rid('t1')
-        });
-
-        await batch.save({
-          sourceTable: TEST_TABLE,
-          tag: storage.SaveOperationTag.UPDATE,
-          after: {
-            id: 't1',
-            b: 'b1',
-            value: 'intermediate'
-          },
-          afterReplicaId: test_utils.rid('t1')
-        });
-
-        await batch.save({
-          sourceTable: TEST_TABLE,
-          tag: storage.SaveOperationTag.INSERT,
-          after: {
-            id: 't2',
-            b: 'b2',
-            value: 'start'
-          },
-          afterReplicaId: test_utils.rid('t2')
-        });
-
-        await batch.save({
-          sourceTable: TEST_TABLE,
-          tag: storage.SaveOperationTag.UPDATE,
-          after: {
-            id: 't1',
-            b: 'b1',
-            value: 'final'
-          },
-          afterReplicaId: test_utils.rid('t1')
-        });
-
-        await batch.save({
-          sourceTable: TEST_TABLE,
-          tag: storage.SaveOperationTag.UPDATE,
-          after: {
-            id: 't2',
-            b: 'b2',
-            value: 'final'
-          },
-          afterReplicaId: test_utils.rid('t2')
-        });
-
-        await batch.commit('1/1');
-      }
-    });
+    await using writer = await bucketStorage.createWriter(test_utils.BATCH_OPTIONS);
+    const testTable = await test_utils.resolveTestTable(writer, 'test', ['id'], config);
+    await writer.markAllSnapshotDone('1/1');
+    /**
+     * Repeatedly create operations which fall into different buckets.
+     * The bucket operations are purposely interleaved as the op_id increases.
+     * A large amount of operations are created here.
+     * The configured window of compacting operations is 100. This means the initial window will
+     * contain operations from multiple buckets.
+     */
+    for (let count = 0; count < 100; count++) {
+      await writer.save({
+        sourceTable: testTable,
+        tag: storage.SaveOperationTag.INSERT,
+        after: {
+          id: 't1',
+          b: 'b1',
+          value: 'start'
+        },
+        afterReplicaId: test_utils.rid('t1')
+      });
+
+      await writer.save({
+        sourceTable: testTable,
+        tag: storage.SaveOperationTag.UPDATE,
+        after: {
+          id: 't1',
+          b: 'b1',
+          value: 'intermediate'
+        },
+        afterReplicaId: test_utils.rid('t1')
+      });
+
+      await writer.save({
+        sourceTable: testTable,
+        tag: storage.SaveOperationTag.INSERT,
+        after: {
+          id: 't2',
+          b: 'b2',
+          value: 'start'
+        },
+        afterReplicaId: test_utils.rid('t2')
+      });
 
-    const checkpoint = result!.flushed_op;
+      await writer.save({
+        sourceTable: testTable,
+        tag: storage.SaveOperationTag.UPDATE,
+        after: {
+          id: 't1',
+          b: 'b1',
+          value: 'final'
+        },
+        afterReplicaId: test_utils.rid('t1')
+      });
+
+      await writer.save({
+        sourceTable: testTable,
+        tag: storage.SaveOperationTag.UPDATE,
+        after: {
+          id: 't2',
+          b: 'b2',
+          value: 'final'
+        },
+        afterReplicaId: test_utils.rid('t2')
+      });
+
+      await writer.commit('1/1');
+    }
+
+    await writer.flush();
+
+    const checkpoint = writer.last_flushed_op!;
 
     await bucketStorage.compact({
       clearBatchLimit: 100,
@@ -477,37 +459,39 @@ bucket_definitions:
     );
     const bucketStorage = factory.getInstance(syncRules);
 
-    const result = await bucketStorage.startBatch(test_utils.BATCH_OPTIONS, async (batch) => {
-      await batch.save({
-        sourceTable: TEST_TABLE,
-        tag: storage.SaveOperationTag.INSERT,
-        after: {
-          id: 't1'
-        },
-        afterReplicaId: 't1'
-      });
-
-      await batch.save({
-        sourceTable: TEST_TABLE,
-        tag: storage.SaveOperationTag.INSERT,
-        after: {
-          id: 't2'
-        },
-        afterReplicaId: 't2'
-      });
+    await using writer = await bucketStorage.createWriter(test_utils.BATCH_OPTIONS);
+    const testTable = await test_utils.resolveTestTable(writer, 'test', ['id'], config);
+    await writer.markAllSnapshotDone('1/1');
+    await writer.save({
+      sourceTable: testTable,
+      tag: storage.SaveOperationTag.INSERT,
+      after: {
+        id: 't1'
+      },
+      afterReplicaId: 't1'
+    });
 
-      await batch.save({
-        sourceTable: TEST_TABLE,
-        tag: storage.SaveOperationTag.DELETE,
-        before: {
-          id: 't1'
-        },
-        beforeReplicaId: 't1'
-      });
+    await writer.save({
+      sourceTable: testTable,
+      tag: storage.SaveOperationTag.INSERT,
+      after: {
+        id: 't2'
+      },
+      afterReplicaId: 't2'
+    });
 
-      await batch.commit('1/1');
+    await writer.save({
+      sourceTable: testTable,
+      tag: storage.SaveOperationTag.DELETE,
+      before: {
+        id: 't1'
+      },
+      beforeReplicaId: 't1'
     });
 
+    await writer.commit('1/1');
+    await writer.flush();
+
     await bucketStorage.compact({
       clearBatchLimit: 2,
       moveBatchLimit: 1,
@@ -516,25 +500,30 @@ bucket_definitions:
       minChangeRatio: 0
     });
 
-    const result2 = await bucketStorage.startBatch(test_utils.BATCH_OPTIONS, async (batch) => {
-      await batch.save({
-        sourceTable: TEST_TABLE,
-        tag: storage.SaveOperationTag.DELETE,
-        before: {
-          id: 't2'
-        },
-        beforeReplicaId: 't2'
-      });
-      await batch.commit('2/1');
+    await using writer2 = await bucketStorage.createWriter(test_utils.BATCH_OPTIONS);
+    const testTable2 = await test_utils.resolveTestTable(writer2, 'test', ['id'], config);
+    await writer2.save({
+      sourceTable: testTable2,
+      tag: storage.SaveOperationTag.DELETE,
+      before: {
+        id: 't2'
+      },
+      beforeReplicaId: 't2'
     });
-    const checkpoint2 = result2!.flushed_op;
+    await writer2.commit('2/1');
+    await writer2.flush();
+    const checkpoint2 = writer2.last_flushed_op!;
+    const request = bucketRequest(syncRules, 'global[]');
     await bucketStorage.clearChecksumCache();
-    const checksumAfter = await bucketStorage.getChecksums(checkpoint2, bucketRequests(syncRules, ['global[]']));
-    expect(checksumAfter.get(bucketRequest(syncRules, 'global[]'))).toEqual({
-      bucket: bucketRequest(syncRules, 'global[]'),
-      count: 4,
-      checksum: 1874612650
+    const checksumAfter = await bucketStorage.getChecksums(checkpoint2, [request]);
+    const globalChecksum = checksumAfter.get(request.bucket);
+    expect(globalChecksum).toMatchObject({
+      bucket: request.bucket,
+      count: 4
     });
+
+    // storage-specific checksum - just check that it does not change
+    expect(globalChecksum).toMatchSnapshot();
   });
 
   test('partial checksums after compacting (2)', async () => {
@@ -548,41 +537,44 @@ bucket_definitions:
     );
     const bucketStorage = factory.getInstance(syncRules);
 
-    const result = await bucketStorage.startBatch(test_utils.BATCH_OPTIONS, async (batch) => {
-      await batch.save({
-        sourceTable: TEST_TABLE,
-        tag: storage.SaveOperationTag.INSERT,
-        after: {
-          id: 't1'
-        },
-        afterReplicaId: 't1'
-      });
-
-      await batch.save({
-        sourceTable: TEST_TABLE,
-        tag: storage.SaveOperationTag.UPDATE,
-        after: {
-          id: 't1'
-        },
-        afterReplicaId: 't1'
-      });
+    await using writer = await bucketStorage.createWriter(test_utils.BATCH_OPTIONS);
+    const testTable = await test_utils.resolveTestTable(writer, 'test', ['id'], config);
+    await writer.markAllSnapshotDone('1/1');
+    await writer.save({
+      sourceTable: testTable,
+      tag: storage.SaveOperationTag.INSERT,
+      after: {
+        id: 't1'
+      },
+      afterReplicaId: 't1'
+    });
 
-      await batch.commit('1/1');
+    await writer.save({
+      sourceTable: testTable,
+      tag: storage.SaveOperationTag.UPDATE,
+      after: {
+        id: 't1'
+      },
+      afterReplicaId: 't1'
     });
 
+    await writer.commit('1/1');
+    await writer.flush();
+
     // Get checksums here just to populate the cache
-    await bucketStorage.getChecksums(result!.flushed_op, bucketRequests(syncRules, ['global[]']));
-    const result2 = await bucketStorage.startBatch(test_utils.BATCH_OPTIONS, async (batch) => {
-      await batch.save({
-        sourceTable: TEST_TABLE,
-        tag: storage.SaveOperationTag.DELETE,
-        before: {
-          id: 't1'
-        },
-        beforeReplicaId: 't1'
-      });
-      await batch.commit('2/1');
+    await bucketStorage.getChecksums(writer.last_flushed_op!, bucketRequests(syncRules, ['global[]']));
+    await using writer2 = await bucketStorage.createWriter(test_utils.BATCH_OPTIONS);
+    const testTable2 = await test_utils.resolveTestTable(writer2, 'test', ['id'], config);
+    await writer2.save({
+      sourceTable: testTable2,
+      tag: storage.SaveOperationTag.DELETE,
+      before: {
+        id: 't1'
+      },
+      beforeReplicaId: 't1'
     });
+    await writer2.commit('2/1');
+    await writer2.flush();
 
     await bucketStorage.compact({
       clearBatchLimit: 20,
@@ -592,13 +584,75 @@ bucket_definitions:
       minChangeRatio: 0
     });
 
-    const checkpoint2 = result2!.flushed_op;
+    const checkpoint2 = writer2.last_flushed_op!;
+    const request = bucketRequest(syncRules, 'global[]');
     // Check that the checksum was correctly updated with the clear operation after having a cached checksum
-    const checksumAfter = await bucketStorage.getChecksums(checkpoint2, bucketRequests(syncRules, ['global[]']));
-    expect(checksumAfter.get(bucketRequest(syncRules, 'global[]'))).toMatchObject({
-      bucket: bucketRequest(syncRules, 'global[]'),
-      count: 1,
-      checksum: -1481659821
+    const checksumAfter = await bucketStorage.getChecksums(checkpoint2, [request]);
+    const globalChecksum = checksumAfter.get(request.bucket);
+    expect(globalChecksum).toMatchObject({
+      bucket: request.bucket,
+      count: 1
+    });
+    // storage-specific checksum - just check that it does not change
+    expect(globalChecksum).toMatchSnapshot();
+  });
+
+  test('defaults maxOpId to current checkpoint', async () => {
+    await using factory = await generateStorageFactory();
+    const syncRules = await factory.updateSyncRules(
+      updateSyncRulesFromYaml(`
+bucket_definitions:
+  global:
+    data: [select * from test]
+      `)
+    );
+    const bucketStorage = factory.getInstance(syncRules);
+
+    await using writer = await bucketStorage.createWriter(test_utils.BATCH_OPTIONS);
+    const testTable = await test_utils.resolveTestTable(writer, 'test', ['id'], config);
+    await writer.markAllSnapshotDone('1/1');
+    await writer.save({
+      sourceTable: testTable,
+      tag: storage.SaveOperationTag.INSERT,
+      after: { id: 't1' },
+      afterReplicaId: test_utils.rid('t1')
     });
+    await writer.commit('1/1');
+    await writer.flush();
+
+    const checkpoint1 = writer.last_flushed_op!;
+
+    await using writer2 = await bucketStorage.createWriter(test_utils.BATCH_OPTIONS);
+    const testTable2 = await test_utils.resolveTestTable(writer2, 'test', ['id'], config);
+    // This is flushed but not committed (does not advance the checkpoint)
+    await writer2.save({
+      sourceTable: testTable2,
+      tag: storage.SaveOperationTag.UPDATE,
+      after: { id: 't1' },
+      afterReplicaId: test_utils.rid('t1')
+    });
+    await writer2.flush();
+    const checkpoint2 = writer2.last_flushed_op!;
+
+    const checkpointBeforeCompact = await bucketStorage.getCheckpoint();
+    expect(checkpointBeforeCompact.checkpoint).toEqual(checkpoint1);
+
+    // With default options, Postgres compaction should use the active checkpoint.
+    await bucketStorage.compact({
+      moveBatchLimit: 1,
+      moveBatchQueryLimit: 1,
+      minBucketChanges: 1,
+      minChangeRatio: 0
+    });
+
+    const batchAfterDefaultCompact = await test_utils.oneFromAsync(
+      bucketStorage.getBucketDataBatch(checkpoint2, bucketRequestMap(syncRules, [['global[]', 0n]]))
+    );
+
+    // Operation 1 should remain a PUT because op_id=2 is above the default maxOpId checkpoint.
+    expect(batchAfterDefaultCompact.chunkData.data).toMatchObject([
+      { op_id: '1', op: 'PUT', object_id: 't1' },
+      { op_id: '2', op: 'PUT', object_id: 't1' }
+    ]);
   });
 }