@powersync/service-core-tests 0.15.0 → 0.15.2

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

@@ -53,7 +53,6 @@ export function registerSyncTests(
     maxDataFetchConcurrency: 2
   });
 
-  const TEST_TABLE = test_utils.makeTestTable('test', ['id'], config);
   const updateSyncRules = (bucketStorageFactory: storage.BucketStorageFactory, updateOptions: { content: string }) => {
     return bucketStorageFactory.updateSyncRules(
       updateSyncRulesFromYaml(updateOptions.content, {
@@ -71,33 +70,33 @@ export function registerSyncTests(
     });
 
     const bucketStorage = f.getInstance(syncRules);
+    await using writer = await bucketStorage.createWriter(test_utils.BATCH_OPTIONS);
+    const sourceTable = await test_utils.resolveTestTable(writer, 'test', ['id'], config);
 
-    await bucketStorage.startBatch(test_utils.BATCH_OPTIONS, async (batch) => {
-      await batch.markAllSnapshotDone('0/1');
+    await writer.markAllSnapshotDone('0/1');
 
-      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 writer.save({
+      sourceTable,
+      tag: storage.SaveOperationTag.INSERT,
+      after: {
+        id: 't1',
+        description: 'Test 1'
+      },
+      afterReplicaId: 't1'
+    });
 
-      await batch.commit('0/1');
+    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,
@@ -134,32 +133,32 @@ bucket_definitions:
     });
 
     const bucketStorage = f.getInstance(syncRules);
+    await using writer = await bucketStorage.createWriter(test_utils.BATCH_OPTIONS);
+    const testTable = await test_utils.resolveTestTable(writer, 'test', ['id'], config);
+
+    await writer.markAllSnapshotDone('0/1');
+    await writer.save({
+      sourceTable: testTable,
+      tag: storage.SaveOperationTag.INSERT,
+      after: {
+        id: 't1',
+        description: 'Test 1'
+      },
+      afterReplicaId: 't1'
+    });
 
-    await bucketStorage.startBatch(test_utils.BATCH_OPTIONS, async (batch) => {
-      await batch.markAllSnapshotDone('0/1');
-      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');
+    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,
@@ -196,33 +195,33 @@ bucket_definitions:
     });
 
     const bucketStorage = f.getInstance(syncRules);
-
-    await bucketStorage.startBatch(test_utils.BATCH_OPTIONS, async (batch) => {
-      await batch.markAllSnapshotDone('0/1');
-      // Initial data: Add one priority row and 10k low-priority rows.
-      await batch.save({
-        sourceTable: TEST_TABLE,
+    await using writer = await bucketStorage.createWriter(test_utils.BATCH_OPTIONS);
+    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,
@@ -250,20 +249,18 @@ bucket_definitions:
           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
             // 1000 low-priority items were synchronized.
@@ -307,33 +304,33 @@ bucket_definitions:
     });
 
     const bucketStorage = f.getInstance(syncRules);
-
-    await bucketStorage.startBatch(test_utils.BATCH_OPTIONS, async (batch) => {
-      await batch.markAllSnapshotDone('0/1');
-      // Initial data: Add one priority row and 10k low-priority rows.
-      await batch.save({
-        sourceTable: TEST_TABLE,
+    await using writer = await bucketStorage.createWriter(test_utils.BATCH_OPTIONS);
+    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,
@@ -366,20 +363,18 @@ 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);
             expect(sentRows).toBe(10002);
@@ -400,20 +395,18 @@ 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');
           }
         }
       }
@@ -449,33 +442,33 @@ bucket_definitions:
     });
 
     const bucketStorage = f.getInstance(syncRules);
-
-    await bucketStorage.startBatch(test_utils.BATCH_OPTIONS, async (batch) => {
-      await batch.markAllSnapshotDone('0/1');
-      // Initial data: Add one priority row and 10k low-priority rows.
-      await batch.save({
-        sourceTable: TEST_TABLE,
+    await using writer = await bucketStorage.createWriter(test_utils.BATCH_OPTIONS);
+    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,
@@ -512,31 +505,29 @@ bucket_definitions:
 
           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) {
@@ -579,20 +570,20 @@ bucket_definitions:
       content: BASIC_SYNC_RULES
     });
     const bucketStorage = f.getInstance(syncRules);
-
-    await bucketStorage.startBatch(test_utils.BATCH_OPTIONS, async (batch) => {
-      await batch.markAllSnapshotDone('0/1');
-      await batch.save({
-        sourceTable: TEST_TABLE,
-        tag: storage.SaveOperationTag.INSERT,
-        after: {
-          id: 't1',
-          description: 'sync'
-        },
-        afterReplicaId: 't1'
-      });
-      await batch.commit('0/1');
+    await using writer = await bucketStorage.createWriter(test_utils.BATCH_OPTIONS);
+    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,
@@ -623,9 +614,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;
           }
@@ -637,30 +626,30 @@ bucket_definitions:
   });
 
   test('sync legacy non-raw data', async () => {
-    const f = await factory();
+    await using 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.markAllSnapshotDone('0/1');
-      await batch.save({
-        sourceTable: TEST_TABLE,
-        tag: storage.SaveOperationTag.INSERT,
-        after: {
-          id: 't1',
-          description: 'Test\n"string"',
-          large_num: 12345678901234567890n
-        },
-        afterReplicaId: 't1'
-      });
-
-      await batch.commit('0/1');
+    await using writer = await bucketStorage.createWriter(test_utils.BATCH_OPTIONS);
+    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\n"string"',
+        large_num: 12345678901234567890n
+      },
+      afterReplicaId: 't1'
     });
 
+    await writer.commit('0/1');
+
     const stream = sync.streamResponse({
       syncContext,
       bucketStorage,
@@ -716,11 +705,11 @@ bucket_definitions:
     });
 
     const bucketStorage = await f.getInstance(syncRules);
+    await using writer = await bucketStorage.createWriter(test_utils.BATCH_OPTIONS);
+    const testTable = await test_utils.resolveTestTable(writer, 'test', ['id'], config);
     // Activate
-    await bucketStorage.startBatch(test_utils.BATCH_OPTIONS, async (batch) => {
-      await batch.markAllSnapshotDone('0/0');
-      await batch.keepalive('0/0');
-    });
+    await writer.markAllSnapshotDone('0/0');
+    await writer.keepalive('0/0');
 
     const stream = sync.streamResponse({
       syncContext,
@@ -742,36 +731,32 @@ bucket_definitions:
 
     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'
     });
 
-    expect(await getCheckpointLines(iter)).toMatchSnapshot();
+    await writer.commit('0/1');
 
-    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'
-      });
+    expect(await getCheckpointLines(iter)).toMatchSnapshot();
 
-      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();
   });
 
@@ -787,15 +772,13 @@ bucket_definitions:
 `
     });
 
-    const usersTable = test_utils.makeTestTable('users', ['id'], config);
-    const listsTable = test_utils.makeTestTable('lists', ['id'], config);
-
     const bucketStorage = await f.getInstance(syncRules);
+    await using writer = await bucketStorage.createWriter(test_utils.BATCH_OPTIONS);
+    const usersTable = await test_utils.resolveTestTable(writer, 'users', ['id'], config, 1);
+
     // Activate
-    await bucketStorage.startBatch(test_utils.BATCH_OPTIONS, async (batch) => {
-      await batch.markAllSnapshotDone('0/0');
-      await batch.keepalive('0/0');
-    });
+    await writer.markAllSnapshotDone('0/0');
+    await writer.keepalive('0/0');
 
     const stream = sync.streamResponse({
       syncContext,
@@ -821,22 +804,21 @@ bucket_definitions:
     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'
     });
 
-    const { bucket } = bucketRequest(syncRules, 'by_user["user1"]');
+    await writer.commit('0/1');
+
     const checkpoint2 = await getCheckpointLines(iter);
+
+    const { bucket } = test_utils.bucketRequest(syncRules, 'by_user["user1"]');
     expect(
       (checkpoint2[0] as StreamingSyncCheckpointDiff).checkpoint_diff?.updated_buckets?.map((b) => b.bucket)
     ).toEqual([bucket]);
@@ -855,26 +837,24 @@ bucket_definitions:
 `
     });
 
-    const usersTable = test_utils.makeTestTable('users', ['id'], config);
-    const listsTable = test_utils.makeTestTable('lists', ['id'], config);
-
     const bucketStorage = await f.getInstance(syncRules);
-
-    await bucketStorage.startBatch(test_utils.BATCH_OPTIONS, async (batch) => {
-      await batch.markAllSnapshotDone('0/1');
-      await batch.save({
-        sourceTable: usersTable,
-        tag: storage.SaveOperationTag.INSERT,
-        after: {
-          id: 'user1',
-          name: 'User 1'
-        },
-        afterReplicaId: 'user1'
-      });
-
-      await batch.commit('0/1');
+    await using writer = await bucketStorage.createWriter(test_utils.BATCH_OPTIONS);
+    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,
@@ -895,24 +875,23 @@ bucket_definitions:
 
     const { bucket } = bucketRequest(syncRules, 'by_user["user1"]');
     const checkpoint1 = await getCheckpointLines(iter);
+
     expect((checkpoint1[0] as StreamingSyncCheckpoint).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] as StreamingSyncCheckpointDiff).checkpoint_diff?.updated_buckets?.map((b) => b.bucket)
@@ -932,15 +911,13 @@ bucket_definitions:
 `
     });
 
-    const usersTable = test_utils.makeTestTable('users', ['id'], config);
-    const listsTable = test_utils.makeTestTable('lists', ['id'], config);
-
     const bucketStorage = await f.getInstance(syncRules);
+    await using writer = await bucketStorage.createWriter(test_utils.BATCH_OPTIONS);
+    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.markAllSnapshotDone('0/0');
-      await batch.keepalive('0/0');
-    });
+    await writer.markAllSnapshotDone('0/0');
+    await writer.keepalive('0/0');
 
     const stream = sync.streamResponse({
       syncContext,
@@ -963,33 +940,32 @@ bucket_definitions:
     // Initial empty checkpoint
     expect(await getCheckpointLines(iter)).toMatchSnapshot();
 
-    await bucketStorage.startBatch(test_utils.BATCH_OPTIONS, async (batch) => {
-      await batch.markAllSnapshotDone('0/1');
-      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 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 batch.commit('0/1');
+    await writer.save({
+      sourceTable: usersTable,
+      tag: storage.SaveOperationTag.INSERT,
+      after: {
+        id: 'user1',
+        name: 'User 1'
+      },
+      afterReplicaId: 'user1'
     });
 
-    const { bucket } = bucketRequest(syncRules, 'by_user["user1"]');
+    await writer.commit('0/1');
+
+    const { bucket } = test_utils.bucketRequest(syncRules, 'by_user["user1"]');
+
     const checkpoint2 = await getCheckpointLines(iter);
     expect(
       (checkpoint2[0] as StreamingSyncCheckpointDiff).checkpoint_diff?.updated_buckets?.map((b) => b.bucket)
@@ -1005,11 +981,10 @@ bucket_definitions:
     });
 
     const bucketStorage = await f.getInstance(syncRules);
+    await using writer = await bucketStorage.createWriter(test_utils.BATCH_OPTIONS);
     // Activate
-    await bucketStorage.startBatch(test_utils.BATCH_OPTIONS, async (batch) => {
-      await batch.markAllSnapshotDone('0/0');
-      await batch.keepalive('0/0');
-    });
+    await writer.markAllSnapshotDone('0/0');
+    await writer.keepalive('0/0');
 
     const exp = Date.now() / 1000 + 0.1;
 
@@ -1051,32 +1026,32 @@ bucket_definitions:
     });
 
     const bucketStorage = await f.getInstance(syncRules);
+    await using writer = await bucketStorage.createWriter(test_utils.BATCH_OPTIONS);
+    const testTable = await test_utils.resolveTestTable(writer, 'test', ['id'], config);
+
+    await writer.markAllSnapshotDone('0/1');
+    await writer.save({
+      sourceTable: testTable,
+      tag: storage.SaveOperationTag.INSERT,
+      after: {
+        id: 't1',
+        description: 'Test 1'
+      },
+      afterReplicaId: 't1'
+    });
 
-    await bucketStorage.startBatch(test_utils.BATCH_OPTIONS, async (batch) => {
-      await batch.markAllSnapshotDone('0/1');
-      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');
+    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,
@@ -1108,31 +1083,29 @@ 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.markAllSnapshotDone('0/1');
-      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 writer.markAllSnapshotDone('0/1');
+    await writer.save({
+      sourceTable: testTable,
+      tag: storage.SaveOperationTag.UPDATE,
+      after: {
+        id: 't1',
+        description: 'Test 1b'
+      },
+      afterReplicaId: 't1'
+    });
 
-      await batch.commit('0/2');
+    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
@@ -1196,12 +1169,11 @@ bucket_definitions:
     });
 
     const bucketStorage = f.getInstance(syncRules);
+    await using writer = await bucketStorage.createWriter(test_utils.BATCH_OPTIONS);
 
-    await bucketStorage.startBatch(test_utils.BATCH_OPTIONS, async (batch) => {
-      await batch.markAllSnapshotDone('0/1');
-      // <= the managed write checkpoint LSN below
-      await batch.commit('0/1');
-    });
+    await writer.markAllSnapshotDone('0/1');
+    // <= the managed write checkpoint LSN below
+    await writer.commit('0/1');
 
     const checkpoint = await bucketStorage.createManagedWriteCheckpoint({
       user_id: 'test',
@@ -1233,11 +1205,9 @@ bucket_definitions:
       })
     });
 
-    await bucketStorage.startBatch(test_utils.BATCH_OPTIONS, async (batch) => {
-      await batch.markAllSnapshotDone('0/1');
-      // 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.
@@ -1251,9 +1221,12 @@ bucket_definitions:
     });
   });
 
-  test('encodes sync rules id in buckes for streams', async () => {
+  test('encodes sync rules id in buckets for streams', async () => {
     await using f = await factory();
-    const rules = `
+    // 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
@@ -1261,27 +1234,38 @@ 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
+        content: rules[i]
       });
       const bucketStorage = f.getInstance(syncRules);
+      await using writer = await bucketStorage.createWriter(test_utils.BATCH_OPTIONS);
+
+      const testTable = await test_utils.resolveTestTable(writer, 'test', ['id'], config, i + 1);
 
-      await bucketStorage.startBatch(test_utils.BATCH_OPTIONS, async (batch) => {
-        await batch.markAllSnapshotDone('0/1');
-        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.markAllSnapshotDone('0/1');
+      await writer.save({
+        sourceTable: testTable,
+        tag: storage.SaveOperationTag.INSERT,
+        after: {
+          id: 't1',
+          description: 'Test 1'
+        },
+        afterReplicaId: 't1'
       });
+      await writer.commit('0/1');
 
       const stream = sync.streamResponse({
         syncContext,