@powersync/service-core-tests 0.14.0 → 0.15.1

package/dist/tests/register-data-storage-parameter-tests.js

@@ -50,11 +50,12 @@ var __disposeResources = (this && this.__disposeResources) || (function (Suppres
     var e = new Error(message);
     return e.name = "SuppressedError", e.error = error, e.suppressed = suppressed, e;
 });
-import { JwtPayload, storage, updateSyncRulesFromYaml } from '@powersync/service-core';
+import { CURRENT_STORAGE_VERSION, JwtPayload, storage, updateSyncRulesFromYaml } from '@powersync/service-core';
 import { RequestParameters, ScopedParameterLookup } from '@powersync/service-sync-rules';
 import { expect, test } from 'vitest';
 import * as test_utils from '../test-utils/test-utils-index.js';
-import { bucketRequest, TEST_TABLE } from './util.js';
+import { bucketRequest } from '../test-utils/test-utils-index.js';
+import { parameterLookupScope } from './util.js';
 /**
  * @example
  * ```TypeScript
@@ -65,8 +66,10 @@ import { bucketRequest, TEST_TABLE } from './util.js';
  *
  * ```
  */
-export function registerDataStorageParameterTests(generateStorageFactory) {
-    const MYBUCKET_1 = { lookupName: 'mybucket', queryId: '1' };
+export function registerDataStorageParameterTests(config) {
+    const generateStorageFactory = config.factory;
+    const storageVersion = config.storageVersion ?? CURRENT_STORAGE_VERSION;
+    const MYBUCKET_1 = parameterLookupScope('mybucket', '1');
     test('save and load parameters', async () => {
         const env_1 = { stack: [], error: void 0, hasError: false };
         try {
@@ -77,33 +80,36 @@ bucket_definitions:
     parameters:
       - SELECT group_id FROM test WHERE id1 = token_parameters.user_id OR id2 = token_parameters.user_id
     data: []
-    `));
+    `, {
+                storageVersion
+            }));
             const bucketStorage = factory.getInstance(syncRules);
-            await bucketStorage.startBatch(test_utils.BATCH_OPTIONS, async (batch) => {
-                await batch.save({
-                    sourceTable: TEST_TABLE,
-                    tag: storage.SaveOperationTag.INSERT,
-                    after: {
-                        id: 't2',
-                        id1: 'user3',
-                        id2: 'user4',
-                        group_id: 'group2a'
-                    },
-                    afterReplicaId: test_utils.rid('t2')
-                });
-                await batch.save({
-                    sourceTable: TEST_TABLE,
-                    tag: storage.SaveOperationTag.INSERT,
-                    after: {
-                        id: 't1',
-                        id1: 'user1',
-                        id2: 'user2',
-                        group_id: 'group1a'
-                    },
-                    afterReplicaId: test_utils.rid('t1')
-                });
-                await batch.commit('1/1');
+            const writer = __addDisposableResource(env_1, await bucketStorage.createWriter(test_utils.BATCH_OPTIONS), true);
+            const testTable = await test_utils.resolveTestTable(writer, 'test', ['id'], config);
+            await writer.markAllSnapshotDone('1/1');
+            await writer.save({
+                sourceTable: testTable,
+                tag: storage.SaveOperationTag.INSERT,
+                after: {
+                    id: 't2',
+                    id1: 'user3',
+                    id2: 'user4',
+                    group_id: 'group2a'
+                },
+                afterReplicaId: test_utils.rid('t2')
+            });
+            await writer.save({
+                sourceTable: testTable,
+                tag: storage.SaveOperationTag.INSERT,
+                after: {
+                    id: 't1',
+                    id1: 'user1',
+                    id2: 'user2',
+                    group_id: 'group1a'
+                },
+                afterReplicaId: test_utils.rid('t1')
             });
+            await writer.commit('1/1');
             const checkpoint = await bucketStorage.getCheckpoint();
             const parameters = await checkpoint.getParameterSets([ScopedParameterLookup.direct(MYBUCKET_1, ['user1'])]);
             expect(parameters).toEqual([
@@ -132,33 +138,34 @@ bucket_definitions:
     parameters:
       - SELECT group_id FROM test WHERE id = token_parameters.user_id
     data: []
-    `));
+    `, {
+                storageVersion
+            }));
             const bucketStorage = factory.getInstance(syncRules);
-            await bucketStorage.startBatch(test_utils.BATCH_OPTIONS, async (batch) => {
-                await batch.save({
-                    sourceTable: TEST_TABLE,
-                    tag: storage.SaveOperationTag.INSERT,
-                    after: {
-                        id: 'user1',
-                        group_id: 'group1'
-                    },
-                    afterReplicaId: test_utils.rid('user1')
-                });
-                await batch.commit('1/1');
+            const writer = __addDisposableResource(env_2, await bucketStorage.createWriter(test_utils.BATCH_OPTIONS), true);
+            const testTable = await test_utils.resolveTestTable(writer, 'test', ['id'], config);
+            await writer.markAllSnapshotDone('1/1');
+            await writer.save({
+                sourceTable: testTable,
+                tag: storage.SaveOperationTag.INSERT,
+                after: {
+                    id: 'user1',
+                    group_id: 'group1'
+                },
+                afterReplicaId: test_utils.rid('user1')
             });
+            await writer.commit('1/1');
             const checkpoint1 = await bucketStorage.getCheckpoint();
-            await bucketStorage.startBatch(test_utils.BATCH_OPTIONS, async (batch) => {
-                await batch.save({
-                    sourceTable: TEST_TABLE,
-                    tag: storage.SaveOperationTag.INSERT,
-                    after: {
-                        id: 'user1',
-                        group_id: 'group2'
-                    },
-                    afterReplicaId: test_utils.rid('user1')
-                });
-                await batch.commit('1/2');
+            await writer.save({
+                sourceTable: testTable,
+                tag: storage.SaveOperationTag.INSERT,
+                after: {
+                    id: 'user1',
+                    group_id: 'group2'
+                },
+                afterReplicaId: test_utils.rid('user1')
             });
+            await writer.commit('1/2');
             const checkpoint2 = await bucketStorage.getCheckpoint();
             const parameters = await checkpoint2.getParameterSets([ScopedParameterLookup.direct(MYBUCKET_1, ['user1'])]);
             expect(parameters).toEqual([
@@ -196,44 +203,42 @@ bucket_definitions:
         FROM todos
         WHERE list_id IN token_parameters.list_id
     data: []
-    `));
+    `, { storageVersion }));
             const bucketStorage = factory.getInstance(syncRules);
-            const table = test_utils.makeTestTable('todos', ['id', 'list_id']);
-            await bucketStorage.startBatch(test_utils.BATCH_OPTIONS, async (batch) => {
-                // Create two todos which initially belong to different lists
-                await batch.save({
-                    sourceTable: table,
-                    tag: storage.SaveOperationTag.INSERT,
-                    after: {
-                        id: 'todo1',
-                        list_id: 'list1'
-                    },
-                    afterReplicaId: test_utils.rid('todo1')
-                });
-                await batch.save({
-                    sourceTable: table,
-                    tag: storage.SaveOperationTag.INSERT,
-                    after: {
-                        id: 'todo2',
-                        list_id: 'list2'
-                    },
-                    afterReplicaId: test_utils.rid('todo2')
-                });
-                await batch.commit('1/1');
+            const writer = __addDisposableResource(env_3, await bucketStorage.createWriter(test_utils.BATCH_OPTIONS), true);
+            const table = await test_utils.resolveTestTable(writer, 'todos', ['id', 'list_id'], config);
+            await writer.markAllSnapshotDone('1/1');
+            // Create two todos which initially belong to different lists
+            await writer.save({
+                sourceTable: table,
+                tag: storage.SaveOperationTag.INSERT,
+                after: {
+                    id: 'todo1',
+                    list_id: 'list1'
+                },
+                afterReplicaId: test_utils.rid('todo1')
             });
-            await bucketStorage.startBatch(test_utils.BATCH_OPTIONS, async (batch) => {
-                // Update the second todo item to now belong to list 1
-                await batch.save({
-                    sourceTable: table,
-                    tag: storage.SaveOperationTag.UPDATE,
-                    after: {
-                        id: 'todo2',
-                        list_id: 'list1'
-                    },
-                    afterReplicaId: test_utils.rid('todo2')
-                });
-                await batch.commit('1/1');
+            await writer.save({
+                sourceTable: table,
+                tag: storage.SaveOperationTag.INSERT,
+                after: {
+                    id: 'todo2',
+                    list_id: 'list2'
+                },
+                afterReplicaId: test_utils.rid('todo2')
             });
+            await writer.commit('1/1');
+            // Update the second todo item to now belong to list 1
+            await writer.save({
+                sourceTable: table,
+                tag: storage.SaveOperationTag.UPDATE,
+                after: {
+                    id: 'todo2',
+                    list_id: 'list1'
+                },
+                afterReplicaId: test_utils.rid('todo2')
+            });
+            await writer.commit('1/1');
             // We specifically request the todo_ids for both lists.
             // There removal operation for the association of `list2`::`todo2` should not interfere with the new
             // association of `list1`::`todo2`
@@ -271,23 +276,26 @@ bucket_definitions:
     parameters:
       - SELECT group_id FROM test WHERE n1 = token_parameters.n1 and f2 = token_parameters.f2 and f3 = token_parameters.f3
     data: []
-    `));
+    `, {
+                storageVersion
+            }));
             const bucketStorage = factory.getInstance(syncRules);
-            await bucketStorage.startBatch(test_utils.BATCH_OPTIONS, async (batch) => {
-                await batch.save({
-                    sourceTable: TEST_TABLE,
-                    tag: storage.SaveOperationTag.INSERT,
-                    after: {
-                        id: 't1',
-                        group_id: 'group1',
-                        n1: 314n,
-                        f2: 314,
-                        f3: 3.14
-                    },
-                    afterReplicaId: test_utils.rid('t1')
-                });
-                await batch.commit('1/1');
+            const writer = __addDisposableResource(env_4, await bucketStorage.createWriter(test_utils.BATCH_OPTIONS), true);
+            const testTable = await test_utils.resolveTestTable(writer, 'test', ['id'], config);
+            await writer.markAllSnapshotDone('1/1');
+            await writer.save({
+                sourceTable: testTable,
+                tag: storage.SaveOperationTag.INSERT,
+                after: {
+                    id: 't1',
+                    group_id: 'group1',
+                    n1: 314n,
+                    f2: 314,
+                    f3: 3.14
+                },
+                afterReplicaId: test_utils.rid('t1')
             });
+            await writer.commit('1/1');
             const TEST_PARAMS = { group_id: 'group1' };
             const checkpoint = await bucketStorage.getCheckpoint();
             const parameters1 = await checkpoint.getParameterSets([
@@ -324,33 +332,36 @@ bucket_definitions:
     parameters:
       - SELECT group_id FROM test WHERE n1 = token_parameters.n1
     data: []
-    `));
+    `, {
+                storageVersion
+            }));
             const bucketStorage = factory.getInstance(syncRules);
-            await bucketStorage.startBatch(test_utils.BATCH_OPTIONS, async (batch) => {
-                await batch.save({
-                    sourceTable: TEST_TABLE,
-                    tag: storage.SaveOperationTag.INSERT,
-                    after: {
-                        id: 't1',
-                        group_id: 'group1',
-                        n1: 1152921504606846976n // 2^60
-                    },
-                    afterReplicaId: test_utils.rid('t1')
-                });
-                await batch.save({
-                    sourceTable: TEST_TABLE,
-                    tag: storage.SaveOperationTag.UPDATE,
-                    after: {
-                        id: 't1',
-                        group_id: 'group1',
-                        // Simulate a TOAST value, even though it can't happen for values like this
-                        // in practice.
-                        n1: undefined
-                    },
-                    afterReplicaId: test_utils.rid('t1')
-                });
-                await batch.commit('1/1');
+            const writer = __addDisposableResource(env_5, await bucketStorage.createWriter(test_utils.BATCH_OPTIONS), true);
+            const testTable = await test_utils.resolveTestTable(writer, 'test', ['id'], config);
+            await writer.markAllSnapshotDone('1/1');
+            await writer.save({
+                sourceTable: testTable,
+                tag: storage.SaveOperationTag.INSERT,
+                after: {
+                    id: 't1',
+                    group_id: 'group1',
+                    n1: 1152921504606846976n // 2^60
+                },
+                afterReplicaId: test_utils.rid('t1')
+            });
+            await writer.save({
+                sourceTable: testTable,
+                tag: storage.SaveOperationTag.UPDATE,
+                after: {
+                    id: 't1',
+                    group_id: 'group1',
+                    // Simulate a TOAST value, even though it can't happen for values like this
+                    // in practice.
+                    n1: undefined
+                },
+                afterReplicaId: test_utils.rid('t1')
             });
+            await writer.commit('1/1');
             const TEST_PARAMS = { group_id: 'group1' };
             const checkpoint = await bucketStorage.getCheckpoint();
             const parameters1 = await checkpoint.getParameterSets([
@@ -371,7 +382,6 @@ bucket_definitions:
     test('save and load parameters with workspaceId', async () => {
         const env_6 = { stack: [], error: void 0, hasError: false };
         try {
-            const WORKSPACE_TABLE = test_utils.makeTestTable('workspace', ['id']);
             const factory = __addDisposableResource(env_6, await generateStorageFactory(), true);
             const syncRules = await factory.updateSyncRules(updateSyncRulesFromYaml(`
 bucket_definitions:
@@ -380,27 +390,30 @@ bucket_definitions:
         - SELECT id as workspace_id FROM workspace WHERE
           workspace."userId" = token_parameters.user_id
       data: []
-    `));
+    `, {
+                storageVersion
+            }));
             const sync_rules = syncRules.parsed(test_utils.PARSE_OPTIONS).hydratedSyncRules();
             const bucketStorage = factory.getInstance(syncRules);
-            await bucketStorage.startBatch(test_utils.BATCH_OPTIONS, async (batch) => {
-                await batch.save({
-                    sourceTable: WORKSPACE_TABLE,
-                    tag: storage.SaveOperationTag.INSERT,
-                    after: {
-                        id: 'workspace1',
-                        userId: 'u1'
-                    },
-                    afterReplicaId: test_utils.rid('workspace1')
-                });
-                await batch.commit('1/1');
+            const writer = __addDisposableResource(env_6, await bucketStorage.createWriter(test_utils.BATCH_OPTIONS), true);
+            const workspaceTable = await test_utils.resolveTestTable(writer, 'workspace', ['id'], config);
+            await writer.markAllSnapshotDone('1/1');
+            await writer.save({
+                sourceTable: workspaceTable,
+                tag: storage.SaveOperationTag.INSERT,
+                after: {
+                    id: 'workspace1',
+                    userId: 'u1'
+                },
+                afterReplicaId: test_utils.rid('workspace1')
             });
+            await writer.commit('1/1');
             const checkpoint = await bucketStorage.getCheckpoint();
             const parameters = new RequestParameters(new JwtPayload({ sub: 'u1' }), {});
             const querier = sync_rules.getBucketParameterQuerier(test_utils.querierOptions(parameters)).querier;
             const buckets = await querier.queryDynamicBucketDescriptions({
                 async getParameterSets(lookups) {
-                    expect(lookups).toEqual([ScopedParameterLookup.direct({ lookupName: 'by_workspace', queryId: '1' }, ['u1'])]);
+                    expect(lookups).toEqual([ScopedParameterLookup.direct(parameterLookupScope('by_workspace', '1'), ['u1'])]);
                     const parameter_sets = await checkpoint.getParameterSets(lookups);
                     expect(parameter_sets).toEqual([{ workspace_id: 'workspace1' }]);
                     return parameter_sets;
@@ -408,7 +421,7 @@ bucket_definitions:
             });
             expect(buckets).toEqual([
                 {
-                    bucket: bucketRequest(syncRules, 'by_workspace["workspace1"]'),
+                    bucket: bucketRequest(syncRules, 'by_workspace["workspace1"]').bucket,
                     priority: 3,
                     definition: 'by_workspace',
                     inclusion_reasons: ['default']
@@ -428,7 +441,6 @@ bucket_definitions:
     test('save and load parameters with dynamic global buckets', async () => {
         const env_7 = { stack: [], error: void 0, hasError: false };
         try {
-            const WORKSPACE_TABLE = test_utils.makeTestTable('workspace');
             const factory = __addDisposableResource(env_7, await generateStorageFactory(), true);
             const syncRules = await factory.updateSyncRules(updateSyncRulesFromYaml(`
 bucket_definitions:
@@ -437,47 +449,48 @@ bucket_definitions:
         - SELECT id as workspace_id FROM workspace WHERE
           workspace.visibility = 'public'
       data: []
-    `));
+    `, {
+                storageVersion
+            }));
             const sync_rules = syncRules.parsed(test_utils.PARSE_OPTIONS).hydratedSyncRules();
             const bucketStorage = factory.getInstance(syncRules);
-            await bucketStorage.startBatch(test_utils.BATCH_OPTIONS, async (batch) => {
-                await batch.save({
-                    sourceTable: WORKSPACE_TABLE,
-                    tag: storage.SaveOperationTag.INSERT,
-                    after: {
-                        id: 'workspace1',
-                        visibility: 'public'
-                    },
-                    afterReplicaId: test_utils.rid('workspace1')
-                });
-                await batch.save({
-                    sourceTable: WORKSPACE_TABLE,
-                    tag: storage.SaveOperationTag.INSERT,
-                    after: {
-                        id: 'workspace2',
-                        visibility: 'private'
-                    },
-                    afterReplicaId: test_utils.rid('workspace2')
-                });
-                await batch.save({
-                    sourceTable: WORKSPACE_TABLE,
-                    tag: storage.SaveOperationTag.INSERT,
-                    after: {
-                        id: 'workspace3',
-                        visibility: 'public'
-                    },
-                    afterReplicaId: test_utils.rid('workspace3')
-                });
-                await batch.commit('1/1');
+            const writer = __addDisposableResource(env_7, await bucketStorage.createWriter(test_utils.BATCH_OPTIONS), true);
+            const workspaceTable = await test_utils.resolveTestTable(writer, 'workspace', undefined, config);
+            await writer.markAllSnapshotDone('1/1');
+            await writer.save({
+                sourceTable: workspaceTable,
+                tag: storage.SaveOperationTag.INSERT,
+                after: {
+                    id: 'workspace1',
+                    visibility: 'public'
+                },
+                afterReplicaId: test_utils.rid('workspace1')
+            });
+            await writer.save({
+                sourceTable: workspaceTable,
+                tag: storage.SaveOperationTag.INSERT,
+                after: {
+                    id: 'workspace2',
+                    visibility: 'private'
+                },
+                afterReplicaId: test_utils.rid('workspace2')
+            });
+            await writer.save({
+                sourceTable: workspaceTable,
+                tag: storage.SaveOperationTag.INSERT,
+                after: {
+                    id: 'workspace3',
+                    visibility: 'public'
+                },
+                afterReplicaId: test_utils.rid('workspace3')
             });
+            await writer.commit('1/1');
             const checkpoint = await bucketStorage.getCheckpoint();
             const parameters = new RequestParameters(new JwtPayload({ sub: 'unknown' }), {});
             const querier = sync_rules.getBucketParameterQuerier(test_utils.querierOptions(parameters)).querier;
             const buckets = await querier.queryDynamicBucketDescriptions({
                 async getParameterSets(lookups) {
-                    expect(lookups).toEqual([
-                        ScopedParameterLookup.direct({ lookupName: 'by_public_workspace', queryId: '1' }, [])
-                    ]);
+                    expect(lookups).toEqual([ScopedParameterLookup.direct(parameterLookupScope('by_public_workspace', '1'), [])]);
                     const parameter_sets = await checkpoint.getParameterSets(lookups);
                     parameter_sets.sort((a, b) => JSON.stringify(a).localeCompare(JSON.stringify(b)));
                     expect(parameter_sets).toEqual([{ workspace_id: 'workspace1' }, { workspace_id: 'workspace3' }]);
@@ -487,13 +500,13 @@ bucket_definitions:
             buckets.sort((a, b) => a.bucket.localeCompare(b.bucket));
             expect(buckets).toEqual([
                 {
-                    bucket: bucketRequest(syncRules, 'by_public_workspace["workspace1"]'),
+                    bucket: bucketRequest(syncRules, 'by_public_workspace["workspace1"]').bucket,
                     priority: 3,
                     definition: 'by_public_workspace',
                     inclusion_reasons: ['default']
                 },
                 {
-                    bucket: bucketRequest(syncRules, 'by_public_workspace["workspace3"]'),
+                    bucket: bucketRequest(syncRules, 'by_public_workspace["workspace3"]').bucket,
                     priority: 3,
                     definition: 'by_public_workspace',
                     inclusion_reasons: ['default']
@@ -513,7 +526,6 @@ bucket_definitions:
     test('multiple parameter queries', async () => {
         const env_8 = { stack: [], error: void 0, hasError: false };
         try {
-            const WORKSPACE_TABLE = test_utils.makeTestTable('workspace');
             const factory = __addDisposableResource(env_8, await generateStorageFactory(), true);
             const syncRules = await factory.updateSyncRules(updateSyncRulesFromYaml(`
 bucket_definitions:
@@ -524,50 +536,53 @@ bucket_definitions:
         - SELECT id as workspace_id FROM workspace WHERE
             workspace.user_id = token_parameters.user_id
       data: []
-    `));
+    `, {
+                storageVersion
+            }));
             const sync_rules = syncRules.parsed(test_utils.PARSE_OPTIONS).hydratedSyncRules();
             const bucketStorage = factory.getInstance(syncRules);
-            await bucketStorage.startBatch(test_utils.BATCH_OPTIONS, async (batch) => {
-                await batch.save({
-                    sourceTable: WORKSPACE_TABLE,
-                    tag: storage.SaveOperationTag.INSERT,
-                    after: {
-                        id: 'workspace1',
-                        visibility: 'public'
-                    },
-                    afterReplicaId: test_utils.rid('workspace1')
-                });
-                await batch.save({
-                    sourceTable: WORKSPACE_TABLE,
-                    tag: storage.SaveOperationTag.INSERT,
-                    after: {
-                        id: 'workspace2',
-                        visibility: 'private'
-                    },
-                    afterReplicaId: test_utils.rid('workspace2')
-                });
-                await batch.save({
-                    sourceTable: WORKSPACE_TABLE,
-                    tag: storage.SaveOperationTag.INSERT,
-                    after: {
-                        id: 'workspace3',
-                        user_id: 'u1',
-                        visibility: 'private'
-                    },
-                    afterReplicaId: test_utils.rid('workspace3')
-                });
-                await batch.save({
-                    sourceTable: WORKSPACE_TABLE,
-                    tag: storage.SaveOperationTag.INSERT,
-                    after: {
-                        id: 'workspace4',
-                        user_id: 'u2',
-                        visibility: 'private'
-                    },
-                    afterReplicaId: test_utils.rid('workspace4')
-                });
-                await batch.commit('1/1');
+            const writer = __addDisposableResource(env_8, await bucketStorage.createWriter(test_utils.BATCH_OPTIONS), true);
+            const workspaceTable = await test_utils.resolveTestTable(writer, 'workspace', undefined, config);
+            await writer.markAllSnapshotDone('1/1');
+            await writer.save({
+                sourceTable: workspaceTable,
+                tag: storage.SaveOperationTag.INSERT,
+                after: {
+                    id: 'workspace1',
+                    visibility: 'public'
+                },
+                afterReplicaId: test_utils.rid('workspace1')
             });
+            await writer.save({
+                sourceTable: workspaceTable,
+                tag: storage.SaveOperationTag.INSERT,
+                after: {
+                    id: 'workspace2',
+                    visibility: 'private'
+                },
+                afterReplicaId: test_utils.rid('workspace2')
+            });
+            await writer.save({
+                sourceTable: workspaceTable,
+                tag: storage.SaveOperationTag.INSERT,
+                after: {
+                    id: 'workspace3',
+                    user_id: 'u1',
+                    visibility: 'private'
+                },
+                afterReplicaId: test_utils.rid('workspace3')
+            });
+            await writer.save({
+                sourceTable: workspaceTable,
+                tag: storage.SaveOperationTag.INSERT,
+                after: {
+                    id: 'workspace4',
+                    user_id: 'u2',
+                    visibility: 'private'
+                },
+                afterReplicaId: test_utils.rid('workspace4')
+            });
+            await writer.commit('1/1');
             const checkpoint = await bucketStorage.getCheckpoint();
             const parameters = new RequestParameters(new JwtPayload({ sub: 'u1' }), {});
             // Test intermediate values - could be moved to sync_rules.test.ts
@@ -584,15 +599,15 @@ bucket_definitions:
                 }
             })).map((e) => e.bucket);
             expect(foundLookups).toEqual([
-                ScopedParameterLookup.direct({ lookupName: 'by_workspace', queryId: '1' }, []),
-                ScopedParameterLookup.direct({ lookupName: 'by_workspace', queryId: '2' }, ['u1'])
+                ScopedParameterLookup.direct(parameterLookupScope('by_workspace', '1'), []),
+                ScopedParameterLookup.direct(parameterLookupScope('by_workspace', '2'), ['u1'])
             ]);
             parameter_sets.sort((a, b) => JSON.stringify(a).localeCompare(JSON.stringify(b)));
             expect(parameter_sets).toEqual([{ workspace_id: 'workspace1' }, { workspace_id: 'workspace3' }]);
             buckets.sort();
             expect(buckets).toEqual([
-                bucketRequest(syncRules, 'by_workspace["workspace1"]'),
-                bucketRequest(syncRules, 'by_workspace["workspace3"]')
+                bucketRequest(syncRules, 'by_workspace["workspace1"]').bucket,
+                bucketRequest(syncRules, 'by_workspace["workspace3"]').bucket
             ]);
         }
         catch (e_8) {
@@ -615,22 +630,26 @@ bucket_definitions:
     parameters:
       - SELECT group_id FROM test WHERE id1 = token_parameters.user_id OR id2 = token_parameters.user_id
     data: []
-    `));
+    `, {
+                storageVersion
+            }));
             const bucketStorage = factory.getInstance(syncRules);
-            await bucketStorage.startBatch(test_utils.BATCH_OPTIONS, async (batch) => {
-                await batch.save({
-                    sourceTable: TEST_TABLE,
-                    tag: storage.SaveOperationTag.INSERT,
-                    after: {
-                        id: 't2',
-                        id1: 'user3',
-                        id2: 'user4',
-                        group_id: 'group2a'
-                    },
-                    afterReplicaId: test_utils.rid('t2')
-                });
-                await batch.truncate([TEST_TABLE]);
+            const writer = __addDisposableResource(env_9, await bucketStorage.createWriter(test_utils.BATCH_OPTIONS), true);
+            const testTable = await test_utils.resolveTestTable(writer, 'test', ['id'], config);
+            await writer.markAllSnapshotDone('1/1');
+            await writer.save({
+                sourceTable: testTable,
+                tag: storage.SaveOperationTag.INSERT,
+                after: {
+                    id: 't2',
+                    id1: 'user3',
+                    id2: 'user4',
+                    group_id: 'group2a'
+                },
+                afterReplicaId: test_utils.rid('t2')
             });
+            await writer.truncate([testTable]);
+            await writer.flush();
             const checkpoint = await bucketStorage.getCheckpoint();
             const parameters = await checkpoint.getParameterSets([ScopedParameterLookup.direct(MYBUCKET_1, ['user1'])]);
             expect(parameters).toEqual([]);
@@ -656,7 +675,9 @@ bucket_definitions:
         - SELECT id as workspace_id FROM workspace WHERE
           workspace."userId" = token_parameters.user_id
       data: []
-    `));
+    `, {
+                storageVersion
+            }));
             const syncBucketStorage = bucketStorageFactory.getInstance(syncRules);
             const parsedSchema1 = syncBucketStorage.getParsedSyncRules({
                 defaultSchema: 'public'
@@ -699,24 +720,22 @@ streams:
       WHERE data.foo = param.bar AND param.baz = auth.user_id()
     `));
             const bucketStorage = factory.getInstance(syncRules);
-            await bucketStorage.startBatch(test_utils.BATCH_OPTIONS, async (batch) => {
-                await batch.save({
-                    sourceTable: TEST_TABLE,
-                    tag: storage.SaveOperationTag.INSERT,
-                    after: {
-                        baz: 'baz',
-                        bar: 'bar'
-                    },
-                    afterReplicaId: test_utils.rid('t1')
-                });
-                await batch.commit('1/1');
+            const writer = __addDisposableResource(env_11, await bucketStorage.createWriter(test_utils.BATCH_OPTIONS), true);
+            const testTable = await test_utils.resolveTestTable(writer, 'test', ['id'], config);
+            await writer.markAllSnapshotDone('1/1');
+            await writer.save({
+                sourceTable: testTable,
+                tag: storage.SaveOperationTag.INSERT,
+                after: {
+                    baz: 'baz',
+                    bar: 'bar'
+                },
+                afterReplicaId: test_utils.rid('t1')
             });
+            await writer.commit('1/1');
             const checkpoint = await bucketStorage.getCheckpoint();
             const parameters = await checkpoint.getParameterSets([
-                ScopedParameterLookup.direct({
-                    lookupName: 'lookup',
-                    queryId: '0'
-                }, ['baz'])
+                ScopedParameterLookup.direct(parameterLookupScope('lookup', '0'), ['baz'])
             ]);
             expect(parameters).toEqual([
                 {