@powersync/service-core-tests 0.14.0 → 0.15.1

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

@@ -14,14 +14,11 @@ 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:
@@ -39,7 +36,15 @@ export const SYNC_SNAPSHOT_PATH = path.resolve(__dirname, '../__snapshots/sync.t
  * });
  * ```
  */
-export function registerSyncTests(factory: storage.TestStorageFactory, options: { storageVersion?: number } = {}) {
+export function registerSyncTests(
+  configOrFactory: storage.TestStorageConfig | storage.TestStorageFactory,
+  options: { storageVersion?: number; tableIdStrings?: boolean } = {}
+) {
+  const config: storage.TestStorageConfig =
+    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({
@@ -65,31 +70,33 @@ export function registerSyncTests(factory: storage.TestStorageFactory, options:
     });
 
     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);
 
-    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 writer.markAllSnapshotDone('0/1');
 
-      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,
@@ -126,31 +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'
+    });
 
-    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');
+    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,
@@ -187,32 +195,33 @@ 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,
+    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,
@@ -240,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.
@@ -297,32 +304,33 @@ 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,
+    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,
@@ -355,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);
@@ -389,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');
           }
         }
       }
@@ -438,32 +442,33 @@ 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,
+    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,
@@ -500,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) {
@@ -567,19 +570,20 @@ 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');
+    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,
@@ -610,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;
           }
@@ -624,29 +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.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,
@@ -702,10 +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.keepalive('0/0');
-    });
+    await writer.markAllSnapshotDone('0/0');
+    await writer.keepalive('0/0');
 
     const stream = sync.streamResponse({
       syncContext,
@@ -727,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();
   });
 
@@ -772,14 +772,13 @@ bucket_definitions:
 `
     });
 
-    const usersTable = test_utils.makeTestTable('users', ['id']);
-    const listsTable = test_utils.makeTestTable('lists', ['id']);
-
     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.keepalive('0/0');
-    });
+    await writer.markAllSnapshotDone('0/0');
+    await writer.keepalive('0/0');
 
     const stream = sync.streamResponse({
       syncContext,
@@ -805,24 +804,24 @@ 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'
     });
 
+    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([bucketRequest(syncRules, 'by_user["user1"]')]);
+    ).toEqual([bucket]);
     expect(checkpoint2).toMatchSnapshot();
   });
 
@@ -838,25 +837,24 @@ bucket_definitions:
 `
     });
 
-    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');
+    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,
@@ -875,31 +873,29 @@ bucket_definitions:
       iter.return?.();
     });
 
+    const { bucket } = bucketRequest(syncRules, 'by_user["user1"]');
     const checkpoint1 = await getCheckpointLines(iter);
-    expect((checkpoint1[0] as StreamingSyncCheckpoint).checkpoint?.buckets?.map((b) => b.bucket)).toEqual([
-      bucketRequest(syncRules, 'by_user["user1"]')
-    ]);
-    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'
-      });
+    expect((checkpoint1[0] as StreamingSyncCheckpoint).checkpoint?.buckets?.map((b) => b.bucket)).toEqual([bucket]);
+    expect(checkpoint1).toMatchSnapshot();
 
-      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)
-    ).toEqual([bucketRequest(syncRules, 'by_user["user1"]')]);
+    ).toEqual([bucket]);
     expect(checkpoint2).toMatchSnapshot();
   });
 
@@ -915,14 +911,13 @@ bucket_definitions:
 `
     });
 
-    const usersTable = test_utils.makeTestTable('users', ['id']);
-    const listsTable = test_utils.makeTestTable('lists', ['id']);
-
     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.keepalive('0/0');
-    });
+    await writer.markAllSnapshotDone('0/0');
+    await writer.keepalive('0/0');
 
     const stream = sync.streamResponse({
       syncContext,
@@ -945,35 +940,36 @@ 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 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'
     });
 
+    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)
-    ).toEqual([bucketRequest(syncRules, 'by_user["user1"]')]);
+    ).toEqual([bucket]);
     expect(checkpoint2).toMatchSnapshot();
   });
 
@@ -985,10 +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.keepalive('0/0');
-    });
+    await writer.markAllSnapshotDone('0/0');
+    await writer.keepalive('0/0');
 
     const exp = Date.now() / 1000 + 0.1;
 
@@ -1030,31 +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.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,
@@ -1086,30 +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.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
@@ -1173,11 +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) => {
-      // <= 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',
@@ -1209,10 +1205,9 @@ bucket_definitions:
       })
     });
 
-    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.
@@ -1226,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
@@ -1236,26 +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.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,