@powersync/service-core-tests 0.14.0 → 0.15.1

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

@@ -57,11 +57,9 @@ import * as timers from 'timers/promises';
 import { fileURLToPath } from 'url';
 import { expect, test } from 'vitest';
 import * as test_utils from '../test-utils/test-utils-index.js';
-import { METRICS_HELPER } from '../test-utils/test-utils-index.js';
-import { bucketRequest } from './util.js';
+import { bucketRequest, METRICS_HELPER } from '../test-utils/test-utils-index.js';
 const __filename = fileURLToPath(import.meta.url);
 const __dirname = path.dirname(__filename);
-const TEST_TABLE = test_utils.makeTestTable('test', ['id']);
 const BASIC_SYNC_RULES = `
 bucket_definitions:
   mybucket:
@@ -77,7 +75,11 @@ export const SYNC_SNAPSHOT_PATH = path.resolve(__dirname, '../__snapshots/sync.t
  * });
  * ```
  */
-export function registerSyncTests(factory, options = {}) {
+export function registerSyncTests(configOrFactory, options = {}) {
+    const config = typeof configOrFactory == 'function'
+        ? { factory: configOrFactory, tableIdStrings: options.tableIdStrings ?? true }
+        : configOrFactory;
+    const factory = config.factory;
     createCoreAPIMetrics(METRICS_HELPER.metricsEngine);
     const tracker = new sync.RequestTracker(METRICS_HELPER.metricsEngine);
     const syncContext = new sync.SyncContext({
@@ -99,27 +101,28 @@ export function registerSyncTests(factory, options = {}) {
                 content: BASIC_SYNC_RULES
             });
             const bucketStorage = f.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',
-                        description: 'Test 1'
-                    },
-                    afterReplicaId: 't1'
-                });
-                await batch.save({
-                    sourceTable: TEST_TABLE,
-                    tag: storage.SaveOperationTag.INSERT,
-                    after: {
-                        id: 't2',
-                        description: 'Test 2'
-                    },
-                    afterReplicaId: 't2'
-                });
-                await batch.commit('0/1');
+            const writer = __addDisposableResource(env_1, await bucketStorage.createWriter(test_utils.BATCH_OPTIONS), true);
+            const sourceTable = await test_utils.resolveTestTable(writer, 'test', ['id'], config);
+            await writer.markAllSnapshotDone('0/1');
+            await writer.save({
+                sourceTable,
+                tag: storage.SaveOperationTag.INSERT,
+                after: {
+                    id: 't1',
+                    description: 'Test 1'
+                },
+                afterReplicaId: 't1'
+            });
+            await writer.save({
+                sourceTable,
+                tag: storage.SaveOperationTag.INSERT,
+                after: {
+                    id: 't2',
+                    description: 'Test 2'
+                },
+                afterReplicaId: 't2'
             });
+            await writer.commit('0/1');
             const stream = sync.streamResponse({
                 syncContext,
                 bucketStorage: bucketStorage,
@@ -164,27 +167,28 @@ bucket_definitions:
     `
             });
             const bucketStorage = f.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',
-                        description: 'Test 1'
-                    },
-                    afterReplicaId: 't1'
-                });
-                await batch.save({
-                    sourceTable: TEST_TABLE,
-                    tag: storage.SaveOperationTag.INSERT,
-                    after: {
-                        id: 'earlier',
-                        description: 'Test 2'
-                    },
-                    afterReplicaId: 'earlier'
-                });
-                await batch.commit('0/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('0/1');
+            await writer.save({
+                sourceTable: testTable,
+                tag: storage.SaveOperationTag.INSERT,
+                after: {
+                    id: 't1',
+                    description: 'Test 1'
+                },
+                afterReplicaId: 't1'
+            });
+            await writer.save({
+                sourceTable: testTable,
+                tag: storage.SaveOperationTag.INSERT,
+                after: {
+                    id: 'earlier',
+                    description: 'Test 2'
+                },
+                afterReplicaId: 'earlier'
             });
+            await writer.commit('0/1');
             const stream = sync.streamResponse({
                 syncContext,
                 bucketStorage,
@@ -229,30 +233,31 @@ bucket_definitions:
     `
             });
             const bucketStorage = f.getInstance(syncRules);
-            await bucketStorage.startBatch(test_utils.BATCH_OPTIONS, async (batch) => {
-                // Initial data: Add one priority row and 10k low-priority rows.
-                await batch.save({
-                    sourceTable: TEST_TABLE,
+            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('0/1');
+            // Initial data: Add one priority row and 10k low-priority rows.
+            await writer.save({
+                sourceTable: testTable,
+                tag: storage.SaveOperationTag.INSERT,
+                after: {
+                    id: 'highprio',
+                    description: 'High priority row'
+                },
+                afterReplicaId: 'highprio'
+            });
+            for (let i = 0; i < 10_000; i++) {
+                await writer.save({
+                    sourceTable: testTable,
                     tag: storage.SaveOperationTag.INSERT,
                     after: {
-                        id: 'highprio',
-                        description: 'High priority row'
+                        id: `${i}`,
+                        description: 'low prio'
                     },
-                    afterReplicaId: 'highprio'
+                    afterReplicaId: `${i}`
                 });
-                for (let i = 0; i < 10_000; i++) {
-                    await batch.save({
-                        sourceTable: TEST_TABLE,
-                        tag: storage.SaveOperationTag.INSERT,
-                        after: {
-                            id: `${i}`,
-                            description: 'low prio'
-                        },
-                        afterReplicaId: `${i}`
-                    });
-                }
-                await batch.commit('0/1');
-            });
+            }
+            await writer.commit('0/1');
             const stream = sync.streamResponse({
                 syncContext,
                 bucketStorage,
@@ -276,19 +281,17 @@ bucket_definitions:
                     if ('partial_checkpoint_complete' in next) {
                         if (sentCheckpoints == 1) {
                             // Save new data to interrupt the low-priority sync.
-                            await bucketStorage.startBatch(test_utils.BATCH_OPTIONS, async (batch) => {
-                                // Add another high-priority row. This should interrupt the long-running low-priority sync.
-                                await batch.save({
-                                    sourceTable: TEST_TABLE,
-                                    tag: storage.SaveOperationTag.INSERT,
-                                    after: {
-                                        id: 'highprio2',
-                                        description: 'Another high-priority row'
-                                    },
-                                    afterReplicaId: 'highprio2'
-                                });
-                                await batch.commit('0/2');
+                            // Add another high-priority row. This should interrupt the long-running low-priority sync.
+                            await writer.save({
+                                sourceTable: testTable,
+                                tag: storage.SaveOperationTag.INSERT,
+                                after: {
+                                    id: 'highprio2',
+                                    description: 'Another high-priority row'
+                                },
+                                afterReplicaId: 'highprio2'
                             });
+                            await writer.commit('0/2');
                         }
                         else {
                             // Low-priority sync from the first checkpoint was interrupted. This should not happen before
@@ -340,30 +343,31 @@ bucket_definitions:
     `
             });
             const bucketStorage = f.getInstance(syncRules);
-            await bucketStorage.startBatch(test_utils.BATCH_OPTIONS, async (batch) => {
-                // Initial data: Add one priority row and 10k low-priority rows.
-                await batch.save({
-                    sourceTable: TEST_TABLE,
+            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('0/1');
+            // Initial data: Add one priority row and 10k low-priority rows.
+            await writer.save({
+                sourceTable: testTable,
+                tag: storage.SaveOperationTag.INSERT,
+                after: {
+                    id: 'highprio',
+                    description: 'user_one'
+                },
+                afterReplicaId: 'highprio'
+            });
+            for (let i = 0; i < 10_000; i++) {
+                await writer.save({
+                    sourceTable: testTable,
                     tag: storage.SaveOperationTag.INSERT,
                     after: {
-                        id: 'highprio',
-                        description: 'user_one'
+                        id: `${i}`,
+                        description: 'low prio'
                     },
-                    afterReplicaId: 'highprio'
+                    afterReplicaId: `${i}`
                 });
-                for (let i = 0; i < 10_000; i++) {
-                    await batch.save({
-                        sourceTable: TEST_TABLE,
-                        tag: storage.SaveOperationTag.INSERT,
-                        after: {
-                            id: `${i}`,
-                            description: 'low prio'
-                        },
-                        afterReplicaId: `${i}`
-                    });
-                }
-                await batch.commit('0/1');
-            });
+            }
+            await writer.commit('0/1');
             const stream = sync.streamResponse({
                 syncContext,
                 bucketStorage,
@@ -392,19 +396,17 @@ bucket_definitions:
                 if (typeof next === 'object' && next !== null) {
                     if ('partial_checkpoint_complete' in next) {
                         if (sentCheckpoints == 1) {
-                            await bucketStorage.startBatch(test_utils.BATCH_OPTIONS, async (batch) => {
-                                // Add a high-priority row that doesn't affect this sync stream.
-                                await batch.save({
-                                    sourceTable: TEST_TABLE,
-                                    tag: storage.SaveOperationTag.INSERT,
-                                    after: {
-                                        id: 'highprio2',
-                                        description: 'user_two'
-                                    },
-                                    afterReplicaId: 'highprio2'
-                                });
-                                await batch.commit('0/2');
+                            // Add a high-priority row that doesn't affect this sync stream.
+                            await writer.save({
+                                sourceTable: testTable,
+                                tag: storage.SaveOperationTag.INSERT,
+                                after: {
+                                    id: 'highprio2',
+                                    description: 'user_two'
+                                },
+                                afterReplicaId: 'highprio2'
                             });
+                            await writer.commit('0/2');
                         }
                         else {
                             expect(sentCheckpoints).toBe(2);
@@ -424,19 +426,17 @@ bucket_definitions:
                         }
                         if (completedCheckpoints == 1) {
                             expect(sentRows).toBe(10001);
-                            await bucketStorage.startBatch(test_utils.BATCH_OPTIONS, async (batch) => {
-                                // Add a high-priority row that affects this sync stream.
-                                await batch.save({
-                                    sourceTable: TEST_TABLE,
-                                    tag: storage.SaveOperationTag.INSERT,
-                                    after: {
-                                        id: 'highprio3',
-                                        description: 'user_one'
-                                    },
-                                    afterReplicaId: 'highprio3'
-                                });
-                                await batch.commit('0/3');
+                            // Add a high-priority row that affects this sync stream.
+                            await writer.save({
+                                sourceTable: testTable,
+                                tag: storage.SaveOperationTag.INSERT,
+                                after: {
+                                    id: 'highprio3',
+                                    description: 'user_one'
+                                },
+                                afterReplicaId: 'highprio3'
                             });
+                            await writer.commit('0/3');
                         }
                     }
                 }
@@ -479,30 +479,31 @@ bucket_definitions:
     `
             });
             const bucketStorage = f.getInstance(syncRules);
-            await bucketStorage.startBatch(test_utils.BATCH_OPTIONS, async (batch) => {
-                // Initial data: Add one priority row and 10k low-priority rows.
-                await batch.save({
-                    sourceTable: TEST_TABLE,
+            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('0/1');
+            // Initial data: Add one priority row and 10k low-priority rows.
+            await writer.save({
+                sourceTable: testTable,
+                tag: storage.SaveOperationTag.INSERT,
+                after: {
+                    id: 'highprio',
+                    description: 'High priority row'
+                },
+                afterReplicaId: 'highprio'
+            });
+            for (let i = 0; i < 2_000; i++) {
+                await writer.save({
+                    sourceTable: testTable,
                     tag: storage.SaveOperationTag.INSERT,
                     after: {
-                        id: 'highprio',
-                        description: 'High priority row'
+                        id: `${i}`,
+                        description: 'low prio'
                     },
-                    afterReplicaId: 'highprio'
+                    afterReplicaId: `${i}`
                 });
-                for (let i = 0; i < 2_000; i++) {
-                    await batch.save({
-                        sourceTable: TEST_TABLE,
-                        tag: storage.SaveOperationTag.INSERT,
-                        after: {
-                            id: `${i}`,
-                            description: 'low prio'
-                        },
-                        afterReplicaId: `${i}`
-                    });
-                }
-                await batch.commit('0/1');
-            });
+            }
+            await writer.commit('0/1');
             const stream = sync.streamResponse({
                 syncContext,
                 bucketStorage,
@@ -534,29 +535,27 @@ bucket_definitions:
                         sentRows += next.data.data.length;
                         if (sentRows == 1001) {
                             // Save new data to interrupt the low-priority sync.
-                            await bucketStorage.startBatch(test_utils.BATCH_OPTIONS, async (batch) => {
-                                // Add another high-priority row. This should interrupt the long-running low-priority sync.
-                                await batch.save({
-                                    sourceTable: TEST_TABLE,
-                                    tag: storage.SaveOperationTag.INSERT,
-                                    after: {
-                                        id: 'highprio2',
-                                        description: 'Another high-priority row'
-                                    },
-                                    afterReplicaId: 'highprio2'
-                                });
-                                // Also add a low-priority row
-                                await batch.save({
-                                    sourceTable: TEST_TABLE,
-                                    tag: storage.SaveOperationTag.INSERT,
-                                    after: {
-                                        id: '2001',
-                                        description: 'Another low-priority row'
-                                    },
-                                    afterReplicaId: '2001'
-                                });
-                                await batch.commit('0/2');
+                            // Add another high-priority row. This should interrupt the long-running low-priority sync.
+                            await writer.save({
+                                sourceTable: testTable,
+                                tag: storage.SaveOperationTag.INSERT,
+                                after: {
+                                    id: 'highprio2',
+                                    description: 'Another high-priority row'
+                                },
+                                afterReplicaId: 'highprio2'
+                            });
+                            // Also add a low-priority row
+                            await writer.save({
+                                sourceTable: testTable,
+                                tag: storage.SaveOperationTag.INSERT,
+                                after: {
+                                    id: '2001',
+                                    description: 'Another low-priority row'
+                                },
+                                afterReplicaId: '2001'
                             });
+                            await writer.commit('0/2');
                         }
                         if (sentRows >= 1000 && sentRows <= 2001) {
                             // pause for a bit to give the stream time to process interruptions.
@@ -607,18 +606,19 @@ bucket_definitions:
                 content: BASIC_SYNC_RULES
             });
             const bucketStorage = f.getInstance(syncRules);
-            await bucketStorage.startBatch(test_utils.BATCH_OPTIONS, async (batch) => {
-                await batch.save({
-                    sourceTable: TEST_TABLE,
-                    tag: storage.SaveOperationTag.INSERT,
-                    after: {
-                        id: 't1',
-                        description: 'sync'
-                    },
-                    afterReplicaId: 't1'
-                });
-                await batch.commit('0/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('0/1');
+            await writer.save({
+                sourceTable: testTable,
+                tag: storage.SaveOperationTag.INSERT,
+                after: {
+                    id: 't1',
+                    description: 'sync'
+                },
+                afterReplicaId: 't1'
             });
+            await writer.commit('0/1');
             const stream = sync.streamResponse({
                 syncContext,
                 bucketStorage,
@@ -645,9 +645,7 @@ bucket_definitions:
                         if (receivedCompletions == 1) {
                             // Trigger an empty bucket update.
                             await bucketStorage.createManagedWriteCheckpoint({ user_id: '', heads: { '1': '1/0' } });
-                            await bucketStorage.startBatch(test_utils.BATCH_OPTIONS, async (batch) => {
-                                await batch.commit('1/0');
-                            });
+                            await writer.commit('1/0');
                         }
                         else {
                             break;
@@ -668,14 +666,18 @@ bucket_definitions:
         }
     });
     test('sync legacy non-raw data', async () => {
-        const f = await factory();
-        const syncRules = await updateSyncRules(f, {
-            content: BASIC_SYNC_RULES
-        });
-        const bucketStorage = await f.getInstance(syncRules);
-        const result = await bucketStorage.startBatch(test_utils.BATCH_OPTIONS, async (batch) => {
-            await batch.save({
-                sourceTable: TEST_TABLE,
+        const env_7 = { stack: [], error: void 0, hasError: false };
+        try {
+            const f = __addDisposableResource(env_7, await factory(), true);
+            const syncRules = await updateSyncRules(f, {
+                content: BASIC_SYNC_RULES
+            });
+            const bucketStorage = await f.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('0/1');
+            await writer.save({
+                sourceTable: testTable,
                 tag: storage.SaveOperationTag.INSERT,
                 after: {
                     id: 't1',
@@ -684,30 +686,39 @@ bucket_definitions:
                 },
                 afterReplicaId: 't1'
             });
-            await batch.commit('0/1');
-        });
-        const stream = sync.streamResponse({
-            syncContext,
-            bucketStorage,
-            syncRules: bucketStorage.getParsedSyncRules(test_utils.PARSE_OPTIONS),
-            params: {
-                buckets: [],
-                include_checksum: true,
-                raw_data: false
-            },
-            tracker,
-            token: new JwtPayload({ sub: '', exp: Date.now() / 1000 + 10 }),
-            isEncodingAsBson: false
-        });
-        const lines = await consumeCheckpointLines(stream);
-        expect(lines).toMatchSnapshot();
-        // Specifically check the number - this is the important part of the test
-        expect(lines[1].data.data[0].data.large_num).toEqual(12345678901234567890n);
+            await writer.commit('0/1');
+            const stream = sync.streamResponse({
+                syncContext,
+                bucketStorage,
+                syncRules: bucketStorage.getParsedSyncRules(test_utils.PARSE_OPTIONS),
+                params: {
+                    buckets: [],
+                    include_checksum: true,
+                    raw_data: false
+                },
+                tracker,
+                token: new JwtPayload({ sub: '', exp: Date.now() / 1000 + 10 }),
+                isEncodingAsBson: false
+            });
+            const lines = await consumeCheckpointLines(stream);
+            expect(lines).toMatchSnapshot();
+            // Specifically check the number - this is the important part of the test
+            expect(lines[1].data.data[0].data.large_num).toEqual(12345678901234567890n);
+        }
+        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;
+        }
     });
     test('expired token', async () => {
-        const env_7 = { stack: [], error: void 0, hasError: false };
+        const env_8 = { stack: [], error: void 0, hasError: false };
         try {
-            const f = __addDisposableResource(env_7, await factory(), true);
+            const f = __addDisposableResource(env_8, await factory(), true);
             const syncRules = await updateSyncRules(f, {
                 content: BASIC_SYNC_RULES
             });
@@ -728,28 +739,29 @@ bucket_definitions:
             const lines = await consumeCheckpointLines(stream);
             expect(lines).toMatchSnapshot();
         }
-        catch (e_7) {
-            env_7.error = e_7;
-            env_7.hasError = true;
+        catch (e_8) {
+            env_8.error = e_8;
+            env_8.hasError = true;
         }
         finally {
-            const result_7 = __disposeResources(env_7);
-            if (result_7)
-                await result_7;
+            const result_8 = __disposeResources(env_8);
+            if (result_8)
+                await result_8;
         }
     });
     test('sync updates to global data', async (context) => {
-        const env_8 = { stack: [], error: void 0, hasError: false };
+        const env_9 = { stack: [], error: void 0, hasError: false };
         try {
-            const f = __addDisposableResource(env_8, await factory(), true);
+            const f = __addDisposableResource(env_9, await factory(), true);
             const syncRules = await updateSyncRules(f, {
                 content: BASIC_SYNC_RULES
             });
             const bucketStorage = await f.getInstance(syncRules);
+            const writer = __addDisposableResource(env_9, await bucketStorage.createWriter(test_utils.BATCH_OPTIONS), true);
+            const testTable = await test_utils.resolveTestTable(writer, 'test', ['id'], config);
             // Activate
-            await bucketStorage.startBatch(test_utils.BATCH_OPTIONS, async (batch) => {
-                await batch.keepalive('0/0');
-            });
+            await writer.markAllSnapshotDone('0/0');
+            await writer.keepalive('0/0');
             const stream = sync.streamResponse({
                 syncContext,
                 bucketStorage,
@@ -768,47 +780,43 @@ bucket_definitions:
                 iter.return?.();
             });
             expect(await getCheckpointLines(iter)).toMatchSnapshot();
-            await bucketStorage.startBatch(test_utils.BATCH_OPTIONS, async (batch) => {
-                await batch.save({
-                    sourceTable: TEST_TABLE,
-                    tag: storage.SaveOperationTag.INSERT,
-                    after: {
-                        id: 't1',
-                        description: 'Test 1'
-                    },
-                    afterReplicaId: 't1'
-                });
-                await batch.commit('0/1');
+            await writer.save({
+                sourceTable: testTable,
+                tag: storage.SaveOperationTag.INSERT,
+                after: {
+                    id: 't1',
+                    description: 'Test 1'
+                },
+                afterReplicaId: 't1'
             });
+            await writer.commit('0/1');
             expect(await getCheckpointLines(iter)).toMatchSnapshot();
-            await bucketStorage.startBatch(test_utils.BATCH_OPTIONS, async (batch) => {
-                await batch.save({
-                    sourceTable: TEST_TABLE,
-                    tag: storage.SaveOperationTag.INSERT,
-                    after: {
-                        id: 't2',
-                        description: 'Test 2'
-                    },
-                    afterReplicaId: 't2'
-                });
-                await batch.commit('0/2');
+            await writer.save({
+                sourceTable: testTable,
+                tag: storage.SaveOperationTag.INSERT,
+                after: {
+                    id: 't2',
+                    description: 'Test 2'
+                },
+                afterReplicaId: 't2'
             });
+            await writer.commit('0/2');
             expect(await getCheckpointLines(iter)).toMatchSnapshot();
         }
-        catch (e_8) {
-            env_8.error = e_8;
-            env_8.hasError = true;
+        catch (e_9) {
+            env_9.error = e_9;
+            env_9.hasError = true;
         }
         finally {
-            const result_8 = __disposeResources(env_8);
-            if (result_8)
-                await result_8;
+            const result_9 = __disposeResources(env_9);
+            if (result_9)
+                await result_9;
         }
     });
     test('sync updates to parameter query only', async (context) => {
-        const env_9 = { stack: [], error: void 0, hasError: false };
+        const env_10 = { stack: [], error: void 0, hasError: false };
         try {
-            const f = __addDisposableResource(env_9, await factory(), true);
+            const f = __addDisposableResource(env_10, await factory(), true);
             const syncRules = await updateSyncRules(f, {
                 content: `bucket_definitions:
   by_user:
@@ -817,13 +825,12 @@ bucket_definitions:
       - select * from lists where user_id = bucket.user_id
 `
             });
-            const usersTable = test_utils.makeTestTable('users', ['id']);
-            const listsTable = test_utils.makeTestTable('lists', ['id']);
             const bucketStorage = await f.getInstance(syncRules);
+            const writer = __addDisposableResource(env_10, await bucketStorage.createWriter(test_utils.BATCH_OPTIONS), true);
+            const usersTable = await test_utils.resolveTestTable(writer, 'users', ['id'], config, 1);
             // Activate
-            await bucketStorage.startBatch(test_utils.BATCH_OPTIONS, async (batch) => {
-                await batch.keepalive('0/0');
-            });
+            await writer.markAllSnapshotDone('0/0');
+            await writer.keepalive('0/0');
             const stream = sync.streamResponse({
                 syncContext,
                 bucketStorage,
@@ -846,36 +853,35 @@ bucket_definitions:
             expect(checkpoint1[0].checkpoint?.buckets?.map((b) => b.bucket)).toEqual([]);
             expect(checkpoint1).toMatchSnapshot();
             // Add user
-            await bucketStorage.startBatch(test_utils.BATCH_OPTIONS, async (batch) => {
-                await batch.save({
-                    sourceTable: usersTable,
-                    tag: storage.SaveOperationTag.INSERT,
-                    after: {
-                        id: 'user1',
-                        name: 'User 1'
-                    },
-                    afterReplicaId: 'user1'
-                });
-                await batch.commit('0/1');
+            await writer.save({
+                sourceTable: usersTable,
+                tag: storage.SaveOperationTag.INSERT,
+                after: {
+                    id: 'user1',
+                    name: 'User 1'
+                },
+                afterReplicaId: 'user1'
             });
+            await writer.commit('0/1');
             const checkpoint2 = await getCheckpointLines(iter);
-            expect(checkpoint2[0].checkpoint_diff?.updated_buckets?.map((b) => b.bucket)).toEqual([bucketRequest(syncRules, 'by_user["user1"]')]);
+            const { bucket } = test_utils.bucketRequest(syncRules, 'by_user["user1"]');
+            expect(checkpoint2[0].checkpoint_diff?.updated_buckets?.map((b) => b.bucket)).toEqual([bucket]);
             expect(checkpoint2).toMatchSnapshot();
         }
-        catch (e_9) {
-            env_9.error = e_9;
-            env_9.hasError = true;
+        catch (e_10) {
+            env_10.error = e_10;
+            env_10.hasError = true;
         }
         finally {
-            const result_9 = __disposeResources(env_9);
-            if (result_9)
-                await result_9;
+            const result_10 = __disposeResources(env_10);
+            if (result_10)
+                await result_10;
         }
     });
     test('sync updates to data query only', async (context) => {
-        const env_10 = { stack: [], error: void 0, hasError: false };
+        const env_11 = { stack: [], error: void 0, hasError: false };
         try {
-            const f = __addDisposableResource(env_10, await factory(), true);
+            const f = __addDisposableResource(env_11, await factory(), true);
             const syncRules = await updateSyncRules(f, {
                 content: `bucket_definitions:
   by_user:
@@ -884,21 +890,21 @@ bucket_definitions:
       - select * from lists where user_id = bucket.user_id
 `
             });
-            const usersTable = test_utils.makeTestTable('users', ['id']);
-            const listsTable = test_utils.makeTestTable('lists', ['id']);
             const bucketStorage = await f.getInstance(syncRules);
-            await bucketStorage.startBatch(test_utils.BATCH_OPTIONS, async (batch) => {
-                await batch.save({
-                    sourceTable: usersTable,
-                    tag: storage.SaveOperationTag.INSERT,
-                    after: {
-                        id: 'user1',
-                        name: 'User 1'
-                    },
-                    afterReplicaId: 'user1'
-                });
-                await batch.commit('0/1');
+            const writer = __addDisposableResource(env_11, await bucketStorage.createWriter(test_utils.BATCH_OPTIONS), true);
+            const usersTable = await test_utils.resolveTestTable(writer, 'users', ['id'], config, 1);
+            const listsTable = await test_utils.resolveTestTable(writer, 'lists', ['id'], config, 2);
+            await writer.markAllSnapshotDone('0/1');
+            await writer.save({
+                sourceTable: usersTable,
+                tag: storage.SaveOperationTag.INSERT,
+                after: {
+                    id: 'user1',
+                    name: 'User 1'
+                },
+                afterReplicaId: 'user1'
             });
+            await writer.commit('0/1');
             const stream = sync.streamResponse({
                 syncContext,
                 bucketStorage,
@@ -916,42 +922,39 @@ bucket_definitions:
             context.onTestFinished(() => {
                 iter.return?.();
             });
+            const { bucket } = bucketRequest(syncRules, 'by_user["user1"]');
             const checkpoint1 = await getCheckpointLines(iter);
-            expect(checkpoint1[0].checkpoint?.buckets?.map((b) => b.bucket)).toEqual([
-                bucketRequest(syncRules, 'by_user["user1"]')
-            ]);
+            expect(checkpoint1[0].checkpoint?.buckets?.map((b) => b.bucket)).toEqual([bucket]);
             expect(checkpoint1).toMatchSnapshot();
-            await bucketStorage.startBatch(test_utils.BATCH_OPTIONS, async (batch) => {
-                await batch.save({
-                    sourceTable: listsTable,
-                    tag: storage.SaveOperationTag.INSERT,
-                    after: {
-                        id: 'list1',
-                        user_id: 'user1',
-                        name: 'User 1'
-                    },
-                    afterReplicaId: 'list1'
-                });
-                await batch.commit('0/1');
+            await writer.save({
+                sourceTable: listsTable,
+                tag: storage.SaveOperationTag.INSERT,
+                after: {
+                    id: 'list1',
+                    user_id: 'user1',
+                    name: 'User 1'
+                },
+                afterReplicaId: 'list1'
             });
+            await writer.commit('0/1');
             const checkpoint2 = await getCheckpointLines(iter);
-            expect(checkpoint2[0].checkpoint_diff?.updated_buckets?.map((b) => b.bucket)).toEqual([bucketRequest(syncRules, 'by_user["user1"]')]);
+            expect(checkpoint2[0].checkpoint_diff?.updated_buckets?.map((b) => b.bucket)).toEqual([bucket]);
             expect(checkpoint2).toMatchSnapshot();
         }
-        catch (e_10) {
-            env_10.error = e_10;
-            env_10.hasError = true;
+        catch (e_11) {
+            env_11.error = e_11;
+            env_11.hasError = true;
         }
         finally {
-            const result_10 = __disposeResources(env_10);
-            if (result_10)
-                await result_10;
+            const result_11 = __disposeResources(env_11);
+            if (result_11)
+                await result_11;
         }
     });
     test('sync updates to parameter query + data', async (context) => {
-        const env_11 = { stack: [], error: void 0, hasError: false };
+        const env_12 = { stack: [], error: void 0, hasError: false };
         try {
-            const f = __addDisposableResource(env_11, await factory(), true);
+            const f = __addDisposableResource(env_12, await factory(), true);
             const syncRules = await updateSyncRules(f, {
                 content: `bucket_definitions:
   by_user:
@@ -960,13 +963,13 @@ bucket_definitions:
       - select * from lists where user_id = bucket.user_id
 `
             });
-            const usersTable = test_utils.makeTestTable('users', ['id']);
-            const listsTable = test_utils.makeTestTable('lists', ['id']);
             const bucketStorage = await f.getInstance(syncRules);
+            const writer = __addDisposableResource(env_12, await bucketStorage.createWriter(test_utils.BATCH_OPTIONS), true);
+            const usersTable = await test_utils.resolveTestTable(writer, 'users', ['id'], config, 1);
+            const listsTable = await test_utils.resolveTestTable(writer, 'lists', ['id'], config, 2);
             // Activate
-            await bucketStorage.startBatch(test_utils.BATCH_OPTIONS, async (batch) => {
-                await batch.keepalive('0/0');
-            });
+            await writer.markAllSnapshotDone('0/0');
+            await writer.keepalive('0/0');
             const stream = sync.streamResponse({
                 syncContext,
                 bucketStorage,
@@ -986,54 +989,54 @@ bucket_definitions:
             });
             // Initial empty checkpoint
             expect(await getCheckpointLines(iter)).toMatchSnapshot();
-            await bucketStorage.startBatch(test_utils.BATCH_OPTIONS, async (batch) => {
-                await batch.save({
-                    sourceTable: listsTable,
-                    tag: storage.SaveOperationTag.INSERT,
-                    after: {
-                        id: 'list1',
-                        user_id: 'user1',
-                        name: 'User 1'
-                    },
-                    afterReplicaId: 'list1'
-                });
-                await batch.save({
-                    sourceTable: usersTable,
-                    tag: storage.SaveOperationTag.INSERT,
-                    after: {
-                        id: 'user1',
-                        name: 'User 1'
-                    },
-                    afterReplicaId: 'user1'
-                });
-                await batch.commit('0/1');
+            await writer.markAllSnapshotDone('0/1');
+            await writer.save({
+                sourceTable: listsTable,
+                tag: storage.SaveOperationTag.INSERT,
+                after: {
+                    id: 'list1',
+                    user_id: 'user1',
+                    name: 'User 1'
+                },
+                afterReplicaId: 'list1'
+            });
+            await writer.save({
+                sourceTable: usersTable,
+                tag: storage.SaveOperationTag.INSERT,
+                after: {
+                    id: 'user1',
+                    name: 'User 1'
+                },
+                afterReplicaId: 'user1'
             });
+            await writer.commit('0/1');
+            const { bucket } = test_utils.bucketRequest(syncRules, 'by_user["user1"]');
             const checkpoint2 = await getCheckpointLines(iter);
-            expect(checkpoint2[0].checkpoint_diff?.updated_buckets?.map((b) => b.bucket)).toEqual([bucketRequest(syncRules, 'by_user["user1"]')]);
+            expect(checkpoint2[0].checkpoint_diff?.updated_buckets?.map((b) => b.bucket)).toEqual([bucket]);
             expect(checkpoint2).toMatchSnapshot();
         }
-        catch (e_11) {
-            env_11.error = e_11;
-            env_11.hasError = true;
+        catch (e_12) {
+            env_12.error = e_12;
+            env_12.hasError = true;
         }
         finally {
-            const result_11 = __disposeResources(env_11);
-            if (result_11)
-                await result_11;
+            const result_12 = __disposeResources(env_12);
+            if (result_12)
+                await result_12;
         }
     });
     test('expiring token', async (context) => {
-        const env_12 = { stack: [], error: void 0, hasError: false };
+        const env_13 = { stack: [], error: void 0, hasError: false };
         try {
-            const f = __addDisposableResource(env_12, await factory(), true);
+            const f = __addDisposableResource(env_13, await factory(), true);
             const syncRules = await updateSyncRules(f, {
                 content: BASIC_SYNC_RULES
             });
             const bucketStorage = await f.getInstance(syncRules);
+            const writer = __addDisposableResource(env_13, await bucketStorage.createWriter(test_utils.BATCH_OPTIONS), true);
             // Activate
-            await bucketStorage.startBatch(test_utils.BATCH_OPTIONS, async (batch) => {
-                await batch.keepalive('0/0');
-            });
+            await writer.markAllSnapshotDone('0/0');
+            await writer.keepalive('0/0');
             const exp = Date.now() / 1000 + 0.1;
             const stream = sync.streamResponse({
                 syncContext,
@@ -1057,49 +1060,50 @@ bucket_definitions:
             const expLines = await getCheckpointLines(iter);
             expect(expLines).toMatchSnapshot();
         }
-        catch (e_12) {
-            env_12.error = e_12;
-            env_12.hasError = true;
+        catch (e_13) {
+            env_13.error = e_13;
+            env_13.hasError = true;
         }
         finally {
-            const result_12 = __disposeResources(env_12);
-            if (result_12)
-                await result_12;
+            const result_13 = __disposeResources(env_13);
+            if (result_13)
+                await result_13;
         }
     });
     test('compacting data - invalidate checkpoint', async (context) => {
-        const env_13 = { stack: [], error: void 0, hasError: false };
+        const env_14 = { stack: [], error: void 0, hasError: false };
         try {
             // This tests a case of a compact operation invalidating a checkpoint in the
             // middle of syncing data.
             // This is expected to be rare in practice, but it is important to handle
             // this case correctly to maintain consistency on the client.
-            const f = __addDisposableResource(env_13, await factory(), true);
+            const f = __addDisposableResource(env_14, await factory(), true);
             const syncRules = await updateSyncRules(f, {
                 content: BASIC_SYNC_RULES
             });
             const bucketStorage = await f.getInstance(syncRules);
-            await bucketStorage.startBatch(test_utils.BATCH_OPTIONS, async (batch) => {
-                await batch.save({
-                    sourceTable: TEST_TABLE,
-                    tag: storage.SaveOperationTag.INSERT,
-                    after: {
-                        id: 't1',
-                        description: 'Test 1'
-                    },
-                    afterReplicaId: 't1'
-                });
-                await batch.save({
-                    sourceTable: TEST_TABLE,
-                    tag: storage.SaveOperationTag.INSERT,
-                    after: {
-                        id: 't2',
-                        description: 'Test 2'
-                    },
-                    afterReplicaId: 't2'
-                });
-                await batch.commit('0/1');
+            const writer = __addDisposableResource(env_14, await bucketStorage.createWriter(test_utils.BATCH_OPTIONS), true);
+            const testTable = await test_utils.resolveTestTable(writer, 'test', ['id'], config);
+            await writer.markAllSnapshotDone('0/1');
+            await writer.save({
+                sourceTable: testTable,
+                tag: storage.SaveOperationTag.INSERT,
+                after: {
+                    id: 't1',
+                    description: 'Test 1'
+                },
+                afterReplicaId: 't1'
             });
+            await writer.save({
+                sourceTable: testTable,
+                tag: storage.SaveOperationTag.INSERT,
+                after: {
+                    id: 't2',
+                    description: 'Test 2'
+                },
+                afterReplicaId: 't2'
+            });
+            await writer.commit('0/1');
             const stream = sync.streamResponse({
                 syncContext,
                 bucketStorage,
@@ -1127,27 +1131,26 @@ bucket_definitions:
             });
             // Now we save additional data AND compact before continuing.
             // This invalidates the checkpoint we've received above.
-            await bucketStorage.startBatch(test_utils.BATCH_OPTIONS, async (batch) => {
-                await batch.save({
-                    sourceTable: TEST_TABLE,
-                    tag: storage.SaveOperationTag.UPDATE,
-                    after: {
-                        id: 't1',
-                        description: 'Test 1b'
-                    },
-                    afterReplicaId: 't1'
-                });
-                await batch.save({
-                    sourceTable: TEST_TABLE,
-                    tag: storage.SaveOperationTag.UPDATE,
-                    after: {
-                        id: 't2',
-                        description: 'Test 2b'
-                    },
-                    afterReplicaId: 't2'
-                });
-                await batch.commit('0/2');
+            await writer.markAllSnapshotDone('0/1');
+            await writer.save({
+                sourceTable: testTable,
+                tag: storage.SaveOperationTag.UPDATE,
+                after: {
+                    id: 't1',
+                    description: 'Test 1b'
+                },
+                afterReplicaId: 't1'
             });
+            await writer.save({
+                sourceTable: testTable,
+                tag: storage.SaveOperationTag.UPDATE,
+                after: {
+                    id: 't2',
+                    description: 'Test 2b'
+                },
+                afterReplicaId: 't2'
+            });
+            await writer.commit('0/2');
             await bucketStorage.compact({
                 minBucketChanges: 1,
                 minChangeRatio: 0
@@ -1195,28 +1198,28 @@ bucket_definitions:
                 })
             });
         }
-        catch (e_13) {
-            env_13.error = e_13;
-            env_13.hasError = true;
+        catch (e_14) {
+            env_14.error = e_14;
+            env_14.hasError = true;
         }
         finally {
-            const result_13 = __disposeResources(env_13);
-            if (result_13)
-                await result_13;
+            const result_14 = __disposeResources(env_14);
+            if (result_14)
+                await result_14;
         }
     });
     test('write checkpoint', async () => {
-        const env_14 = { stack: [], error: void 0, hasError: false };
+        const env_15 = { stack: [], error: void 0, hasError: false };
         try {
-            const f = __addDisposableResource(env_14, await factory(), true);
+            const f = __addDisposableResource(env_15, await factory(), true);
             const syncRules = await updateSyncRules(f, {
                 content: BASIC_SYNC_RULES
             });
             const bucketStorage = f.getInstance(syncRules);
-            await bucketStorage.startBatch(test_utils.BATCH_OPTIONS, async (batch) => {
-                // <= the managed write checkpoint LSN below
-                await batch.commit('0/1');
-            });
+            const writer = __addDisposableResource(env_15, await bucketStorage.createWriter(test_utils.BATCH_OPTIONS), true);
+            await writer.markAllSnapshotDone('0/1');
+            // <= the managed write checkpoint LSN below
+            await writer.commit('0/1');
             const checkpoint = await bucketStorage.createManagedWriteCheckpoint({
                 user_id: 'test',
                 heads: { '1': '1/0' }
@@ -1244,10 +1247,9 @@ bucket_definitions:
                     write_checkpoint: undefined
                 })
             });
-            await bucketStorage.startBatch(test_utils.BATCH_OPTIONS, async (batch) => {
-                // must be >= the managed write checkpoint LSN
-                await batch.commit('1/0');
-            });
+            await writer.markAllSnapshotDone('0/1');
+            // must be >= the managed write checkpoint LSN
+            await writer.commit('1/0');
             // At this point the LSN has advanced, so the write checkpoint should be
             // included in the next checkpoint message.
             const stream2 = sync.streamResponse(params);
@@ -1259,21 +1261,24 @@ bucket_definitions:
                 })
             });
         }
-        catch (e_14) {
-            env_14.error = e_14;
-            env_14.hasError = true;
+        catch (e_15) {
+            env_15.error = e_15;
+            env_15.hasError = true;
         }
         finally {
-            const result_14 = __disposeResources(env_14);
-            if (result_14)
-                await result_14;
+            const result_15 = __disposeResources(env_15);
+            if (result_15)
+                await result_15;
         }
     });
-    test('encodes sync rules id in buckes for streams', async () => {
-        const env_15 = { stack: [], error: void 0, hasError: false };
+    test('encodes sync rules id in buckets for streams', async () => {
+        const env_16 = { stack: [], error: void 0, hasError: false };
         try {
-            const f = __addDisposableResource(env_15, await factory(), true);
-            const rules = `
+            const f = __addDisposableResource(env_16, await factory(), true);
+            // This test relies making an actual update to sync rules to test the different bucket names.
+            // The actual naming scheme may change, as long as the two buckets have different names.
+            const rules = [
+                `
 streams:
   test:
     auto_subscribe: true
@@ -1281,15 +1286,29 @@ streams:
 
 config:
   edition: 2
-`;
+`,
+                `
+streams:
+  test2:
+    auto_subscribe: true
+    query: SELECT * FROM test WHERE 1;
+
+config:
+  edition: 2
+`
+            ];
             for (let i = 0; i < 2; i++) {
-                const syncRules = await updateSyncRules(f, {
-                    content: rules
-                });
-                const bucketStorage = f.getInstance(syncRules);
-                await bucketStorage.startBatch(test_utils.BATCH_OPTIONS, async (batch) => {
-                    await batch.save({
-                        sourceTable: TEST_TABLE,
+                const env_17 = { stack: [], error: void 0, hasError: false };
+                try {
+                    const syncRules = await updateSyncRules(f, {
+                        content: rules[i]
+                    });
+                    const bucketStorage = f.getInstance(syncRules);
+                    const writer = __addDisposableResource(env_17, await bucketStorage.createWriter(test_utils.BATCH_OPTIONS), true);
+                    const testTable = await test_utils.resolveTestTable(writer, 'test', ['id'], config, i + 1);
+                    await writer.markAllSnapshotDone('0/1');
+                    await writer.save({
+                        sourceTable: testTable,
                         tag: storage.SaveOperationTag.INSERT,
                         after: {
                             id: 't1',
@@ -1297,33 +1316,42 @@ config:
                         },
                         afterReplicaId: 't1'
                     });
-                    await batch.commit('0/1');
-                });
-                const stream = sync.streamResponse({
-                    syncContext,
-                    bucketStorage: bucketStorage,
-                    syncRules: bucketStorage.getParsedSyncRules(test_utils.PARSE_OPTIONS),
-                    params: {
-                        buckets: [],
-                        include_checksum: true,
-                        raw_data: true
-                    },
-                    tracker,
-                    token: new JwtPayload({ sub: '', exp: Date.now() / 1000 + 10 }),
-                    isEncodingAsBson: false
-                });
-                const lines = await consumeCheckpointLines(stream);
-                expect(lines).toMatchSnapshot();
+                    await writer.commit('0/1');
+                    const stream = sync.streamResponse({
+                        syncContext,
+                        bucketStorage: bucketStorage,
+                        syncRules: bucketStorage.getParsedSyncRules(test_utils.PARSE_OPTIONS),
+                        params: {
+                            buckets: [],
+                            include_checksum: true,
+                            raw_data: true
+                        },
+                        tracker,
+                        token: new JwtPayload({ sub: '', exp: Date.now() / 1000 + 10 }),
+                        isEncodingAsBson: false
+                    });
+                    const lines = await consumeCheckpointLines(stream);
+                    expect(lines).toMatchSnapshot();
+                }
+                catch (e_16) {
+                    env_17.error = e_16;
+                    env_17.hasError = true;
+                }
+                finally {
+                    const result_16 = __disposeResources(env_17);
+                    if (result_16)
+                        await result_16;
+                }
             }
         }
-        catch (e_15) {
-            env_15.error = e_15;
-            env_15.hasError = true;
+        catch (e_17) {
+            env_16.error = e_17;
+            env_16.hasError = true;
         }
         finally {
-            const result_15 = __disposeResources(env_15);
-            if (result_15)
-                await result_15;
+            const result_17 = __disposeResources(env_16);
+            if (result_17)
+                await result_17;
         }
     });
 }