@powersync/service-core-tests 0.14.0 → 0.15.1

package/dist/tests/register-compacting-tests.js

@@ -50,12 +50,13 @@ var __disposeResources = (this && this.__disposeResources) || (function (Suppres
     var e = new Error(message);
     return e.name = "SuppressedError", e.error = error, e.suppressed = suppressed, e;
 });
-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';
-const TEST_TABLE = test_utils.makeTestTable('test', ['id']);
-export function registerCompactTests(generateStorageFactory) {
+import { bucketRequest } from '../test-utils/test-utils-index.js';
+import { bucketRequestMap, bucketRequests } from './util.js';
+export function registerCompactTests(config) {
+    const generateStorageFactory = config.factory;
     test('compacting (1)', async () => {
         const env_1 = { stack: [], error: void 0, hasError: false };
         try {
@@ -66,52 +67,52 @@ bucket_definitions:
     data: [select * from test]
     `));
             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 batch.save({
-                    sourceTable: TEST_TABLE,
-                    tag: storage.SaveOperationTag.UPDATE,
-                    after: {
-                        id: 't2'
-                    },
-                    afterReplicaId: test_utils.rid('t2')
-                });
-                await batch.commit('1/1');
+            const writer = __addDisposableResource(env_1, await bucketStorage.createWriter(test_utils.BATCH_OPTIONS), true);
+            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.save({
+                sourceTable: testTable,
+                tag: storage.SaveOperationTag.INSERT,
+                after: {
+                    id: 't2'
+                },
+                afterReplicaId: test_utils.rid('t2')
+            });
+            await writer.save({
+                sourceTable: testTable,
+                tag: storage.SaveOperationTag.UPDATE,
+                after: {
+                    id: 't2'
+                },
+                afterReplicaId: test_utils.rid('t2')
             });
-            const checkpoint = result.flushed_op;
-            const batchBefore = await test_utils.oneFromAsync(bucketStorage.getBucketDataBatch(checkpoint, bucketRequestMap(syncRules, [['global[]', 0n]])));
+            await writer.commit('1/1');
+            await writer.flush();
+            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'
@@ -125,33 +126,28 @@ bucket_definitions:
                 minBucketChanges: 1,
                 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);
         }
         catch (e_1) {
@@ -174,69 +170,65 @@ bucket_definitions:
     data: [select * from test]
     `));
             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 batch.save({
-                    sourceTable: TEST_TABLE,
-                    tag: storage.SaveOperationTag.DELETE,
-                    before: {
-                        id: 't1'
-                    },
-                    beforeReplicaId: test_utils.rid('t1')
-                });
-                await batch.save({
-                    sourceTable: TEST_TABLE,
-                    tag: storage.SaveOperationTag.UPDATE,
-                    after: {
-                        id: 't2'
-                    },
-                    afterReplicaId: test_utils.rid('t2')
-                });
-                await batch.commit('1/1');
+            const writer = __addDisposableResource(env_2, await bucketStorage.createWriter(test_utils.BATCH_OPTIONS), true);
+            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.save({
+                sourceTable: testTable,
+                tag: storage.SaveOperationTag.INSERT,
+                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 writer.save({
+                sourceTable: testTable,
+                tag: storage.SaveOperationTag.UPDATE,
+                after: {
+                    id: 't2'
+                },
+                afterReplicaId: test_utils.rid('t2')
             });
-            const checkpoint = result.flushed_op;
-            const batchBefore = await test_utils.oneFromAsync(bucketStorage.getBucketDataBatch(checkpoint, bucketRequestMap(syncRules, [['global[]', 0n]])));
+            await writer.commit('1/1');
+            await writer.flush();
+            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'
                 }
             ]);
             await bucketStorage.compact({
@@ -246,26 +238,24 @@ bucket_definitions:
                 minBucketChanges: 1,
                 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[]']));
-            expect(batchAfter.targetOp).toEqual(4n);
+            const checksumAfter = await bucketStorage.getChecksums(checkpoint, [request]);
+            expect(batchAfter.targetOp).toBeLessThanOrEqual(checkpoint);
             expect(dataAfter).toMatchObject([
                 {
-                    checksum: -1778190028,
-                    op: 'CLEAR',
-                    op_id: '3'
+                    checksum: addChecksums(addChecksums(dataBefore[0].checksum, dataBefore[1].checksum), dataBefore[2].checksum),
+                    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
             });
             test_utils.validateCompactedBucket(dataBefore, dataAfter);
@@ -290,47 +280,50 @@ bucket_definitions:
     data: [select * from test]
     `));
             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 batch.commit('1/1');
+            const writer = __addDisposableResource(env_3, await bucketStorage.createWriter(test_utils.BATCH_OPTIONS), true);
+            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'
             });
-            const checkpoint1 = result.flushed_op;
-            const checksumBefore = await bucketStorage.getChecksums(checkpoint1, 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: 't2'
-                    },
-                    beforeReplicaId: 't2'
-                });
-                await batch.commit('2/1');
+            await writer.save({
+                sourceTable: testTable,
+                tag: storage.SaveOperationTag.INSERT,
+                after: {
+                    id: 't2'
+                },
+                afterReplicaId: 't2'
             });
-            const checkpoint2 = result2.flushed_op;
+            await writer.save({
+                sourceTable: testTable,
+                tag: storage.SaveOperationTag.DELETE,
+                before: {
+                    id: 't1'
+                },
+                beforeReplicaId: 't1'
+            });
+            await writer.commit('1/1');
+            await writer.flush();
+            const checkpoint1 = writer.last_flushed_op;
+            const request = bucketRequest(syncRules, 'global[]');
+            const writer2 = __addDisposableResource(env_3, await bucketStorage.createWriter(test_utils.BATCH_OPTIONS), true);
+            const testTable2 = await test_utils.resolveTestTable(writer2, 'test', ['id'], config);
+            await writer2.save({
+                sourceTable: testTable2,
+                tag: storage.SaveOperationTag.DELETE,
+                before: {
+                    id: 't2'
+                },
+                beforeReplicaId: 't2'
+            });
+            await writer2.commit('2/1');
+            await writer2.flush();
+            const checkpoint2 = writer2.last_flushed_op;
             await bucketStorage.compact({
                 clearBatchLimit: 2,
                 moveBatchLimit: 1,
@@ -338,22 +331,19 @@ bucket_definitions:
                 minBucketChanges: 1,
                 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[]']));
-            expect(batchAfter.targetOp).toEqual(4n);
+            const checksumAfter = await bucketStorage.getChecksums(checkpoint2, [request]);
             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
             });
         }
         catch (e_3) {
@@ -379,69 +369,71 @@ bucket_definitions:
             data:
               - select * from test where b = bucket.b`));
             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');
-                }
-            });
-            const checkpoint = result.flushed_op;
+            const writer = __addDisposableResource(env_4, await bucketStorage.createWriter(test_utils.BATCH_OPTIONS), true);
+            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')
+                });
+                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,
                 moveBatchLimit: 100,
@@ -498,33 +490,35 @@ bucket_definitions:
     data: [select * from test]
     `));
             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 batch.commit('1/1');
+            const writer = __addDisposableResource(env_5, await bucketStorage.createWriter(test_utils.BATCH_OPTIONS), true);
+            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 writer.save({
+                sourceTable: testTable,
+                tag: storage.SaveOperationTag.INSERT,
+                after: {
+                    id: 't2'
+                },
+                afterReplicaId: 't2'
+            });
+            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,
@@ -532,25 +526,29 @@ bucket_definitions:
                 minBucketChanges: 1,
                 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');
+            const writer2 = __addDisposableResource(env_5, await bucketStorage.createWriter(test_utils.BATCH_OPTIONS), true);
+            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();
         }
         catch (e_5) {
             env_5.error = e_5;
@@ -572,38 +570,41 @@ bucket_definitions:
     data: [select * from test]
     `));
             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 batch.commit('1/1');
+            const writer = __addDisposableResource(env_6, await bucketStorage.createWriter(test_utils.BATCH_OPTIONS), true);
+            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 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[]']));
+            const writer2 = __addDisposableResource(env_6, await bucketStorage.createWriter(test_utils.BATCH_OPTIONS), true);
+            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,
                 moveBatchLimit: 10,
@@ -611,14 +612,17 @@ bucket_definitions:
                 minBucketChanges: 1,
                 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();
         }
         catch (e_6) {
             env_6.error = e_6;
@@ -630,5 +634,64 @@ bucket_definitions:
                 await result_6;
         }
     });
+    test('defaults maxOpId to current checkpoint', async () => {
+        const env_7 = { stack: [], error: void 0, hasError: false };
+        try {
+            const factory = __addDisposableResource(env_7, await generateStorageFactory(), true);
+            const syncRules = await factory.updateSyncRules(updateSyncRulesFromYaml(`
+bucket_definitions:
+  global:
+    data: [select * from test]
+      `));
+            const bucketStorage = factory.getInstance(syncRules);
+            const writer = __addDisposableResource(env_7, await bucketStorage.createWriter(test_utils.BATCH_OPTIONS), true);
+            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;
+            const writer2 = __addDisposableResource(env_7, await bucketStorage.createWriter(test_utils.BATCH_OPTIONS), true);
+            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' }
+            ]);
+        }
+        catch (e_7) {
+            env_7.error = e_7;
+            env_7.hasError = true;
+        }
+        finally {
+            const result_7 = __disposeResources(env_7);
+            if (result_7)
+                await result_7;
+        }
+    });
 }
 //# sourceMappingURL=register-compacting-tests.js.map