@powersync/service-core-tests 0.0.0-dev-20260225160713 → 0.0.0-dev-20260511080634

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

@@ -1,60 +1,8 @@
-var __addDisposableResource = (this && this.__addDisposableResource) || function (env, value, async) {
-    if (value !== null && value !== void 0) {
-        if (typeof value !== "object" && typeof value !== "function") throw new TypeError("Object expected.");
-        var dispose, inner;
-        if (async) {
-            if (!Symbol.asyncDispose) throw new TypeError("Symbol.asyncDispose is not defined.");
-            dispose = value[Symbol.asyncDispose];
-        }
-        if (dispose === void 0) {
-            if (!Symbol.dispose) throw new TypeError("Symbol.dispose is not defined.");
-            dispose = value[Symbol.dispose];
-            if (async) inner = dispose;
-        }
-        if (typeof dispose !== "function") throw new TypeError("Object not disposable.");
-        if (inner) dispose = function() { try { inner.call(this); } catch (e) { return Promise.reject(e); } };
-        env.stack.push({ value: value, dispose: dispose, async: async });
-    }
-    else if (async) {
-        env.stack.push({ async: true });
-    }
-    return value;
-};
-var __disposeResources = (this && this.__disposeResources) || (function (SuppressedError) {
-    return function (env) {
-        function fail(e) {
-            env.error = env.hasError ? new SuppressedError(e, env.error, "An error was suppressed during disposal.") : e;
-            env.hasError = true;
-        }
-        var r, s = 0;
-        function next() {
-            while (r = env.stack.pop()) {
-                try {
-                    if (!r.async && s === 1) return s = 0, env.stack.push(r), Promise.resolve().then(next);
-                    if (r.dispose) {
-                        var result = r.dispose.call(r.value);
-                        if (r.async) return s |= 2, Promise.resolve(result).then(next, function(e) { fail(e); return next(); });
-                    }
-                    else s |= 1;
-                }
-                catch (e) {
-                    fail(e);
-                }
-            }
-            if (s === 1) return env.hasError ? Promise.reject(env.error) : Promise.resolve();
-            if (env.hasError) throw env.error;
-        }
-        return next();
-    };
-})(typeof SuppressedError === "function" ? SuppressedError : function (error, suppressed, message) {
-    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 { RequestParameters, ScopedParameterLookup } from '@powersync/service-sync-rules';
+import { CURRENT_STORAGE_VERSION, JwtPayload, storage, updateSyncRulesFromYaml } from '@powersync/service-core';
+import { RequestParameters } 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';
 /**
  * @example
  * ```TypeScript
@@ -65,130 +13,123 @@ 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;
     test('save and load parameters', async () => {
-        const env_1 = { stack: [], error: void 0, hasError: false };
-        try {
-            const factory = __addDisposableResource(env_1, await generateStorageFactory(), true);
-            const syncRules = await factory.updateSyncRules(updateSyncRulesFromYaml(`
+        await using factory = await generateStorageFactory();
+        const syncRules = await factory.updateSyncRules(updateSyncRulesFromYaml(`
 bucket_definitions:
   mybucket:
     parameters:
       - SELECT group_id FROM test WHERE id1 = token_parameters.user_id OR id2 = token_parameters.user_id
     data: []
-    `));
-            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 checkpoint = await bucketStorage.getCheckpoint();
-            const parameters = await checkpoint.getParameterSets([ScopedParameterLookup.direct(MYBUCKET_1, ['user1'])]);
-            expect(parameters).toEqual([
-                {
-                    group_id: 'group1a'
-                }
-            ]);
-        }
-        catch (e_1) {
-            env_1.error = e_1;
-            env_1.hasError = true;
-        }
-        finally {
-            const result_1 = __disposeResources(env_1);
-            if (result_1)
-                await result_1;
-        }
+    `, {
+            storageVersion
+        }));
+        const bucketStorage = factory.getInstance(syncRules);
+        const sync_rules = syncRules.parsed(test_utils.PARSE_OPTIONS).hydratedSyncRules();
+        await using writer = await bucketStorage.createWriter(test_utils.BATCH_OPTIONS);
+        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 = new RequestParameters(new JwtPayload({ sub: 'user1' }), {});
+        const querier = sync_rules.getBucketParameterQuerier(test_utils.querierOptions(parameters)).querier;
+        const buckets = await querier.queryDynamicBucketDescriptions({
+            async getParameterSets(lookups) {
+                expect(lookups.map((l) => l.indexKey)).toEqual([['user1']]);
+                const parameter_sets = await checkpoint.getParameterSets(lookups, 1000);
+                expect(parameter_sets).toEqual([{ group_id: 'group1a' }]);
+                return parameter_sets;
+            }
+        });
+        expect(buckets.map((b) => b.bucket)).toEqual([bucketRequest(syncRules, 'mybucket["group1a"]').bucket]);
     });
     test('it should use the latest version', async () => {
-        const env_2 = { stack: [], error: void 0, hasError: false };
-        try {
-            const factory = __addDisposableResource(env_2, await generateStorageFactory(), true);
-            const syncRules = await factory.updateSyncRules(updateSyncRulesFromYaml(`
+        await using factory = await generateStorageFactory();
+        const syncRules = await factory.updateSyncRules(updateSyncRulesFromYaml(`
 bucket_definitions:
   mybucket:
     parameters:
       - SELECT group_id FROM test WHERE id = token_parameters.user_id
     data: []
-    `));
-            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 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');
-            });
-            const checkpoint2 = await bucketStorage.getCheckpoint();
-            const parameters = await checkpoint2.getParameterSets([ScopedParameterLookup.direct(MYBUCKET_1, ['user1'])]);
-            expect(parameters).toEqual([
-                {
-                    group_id: 'group2'
-                }
-            ]);
-            // Use the checkpoint to get older data if relevant
-            const parameters2 = await checkpoint1.getParameterSets([ScopedParameterLookup.direct(MYBUCKET_1, ['user1'])]);
-            expect(parameters2).toEqual([
-                {
-                    group_id: 'group1'
-                }
-            ]);
-        }
-        catch (e_2) {
-            env_2.error = e_2;
-            env_2.hasError = true;
-        }
-        finally {
-            const result_2 = __disposeResources(env_2);
-            if (result_2)
-                await result_2;
-        }
+    `, {
+            storageVersion
+        }));
+        const bucketStorage = factory.getInstance(syncRules);
+        const sync_rules = syncRules.parsed(test_utils.PARSE_OPTIONS).hydratedSyncRules();
+        await using writer = await bucketStorage.createWriter(test_utils.BATCH_OPTIONS);
+        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 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 = new RequestParameters(new JwtPayload({ sub: 'user1' }), {});
+        const querier = sync_rules.getBucketParameterQuerier(test_utils.querierOptions(parameters)).querier;
+        const buckets1 = await querier.queryDynamicBucketDescriptions({
+            async getParameterSets(lookups) {
+                expect(lookups.map((l) => l.indexKey)).toEqual([['user1']]);
+                const parameter_sets = await checkpoint1.getParameterSets(lookups, 1000);
+                expect(parameter_sets).toEqual([{ group_id: 'group1' }]);
+                return parameter_sets;
+            }
+        });
+        expect(buckets1.map((b) => b.bucket)).toEqual([bucketRequest(syncRules, 'mybucket["group1"]').bucket]);
+        const buckets2 = await querier.queryDynamicBucketDescriptions({
+            async getParameterSets(lookups) {
+                expect(lookups.map((l) => l.indexKey)).toEqual([['user1']]);
+                const parameter_sets = await checkpoint2.getParameterSets(lookups, 1000);
+                expect(parameter_sets).toEqual([{ group_id: 'group2' }]);
+                return parameter_sets;
+            }
+        });
+        expect(buckets2.map((b) => b.bucket)).toEqual([bucketRequest(syncRules, 'mybucket["group2"]').bucket]);
     });
     test('it should use the latest version after updates', async () => {
-        const env_3 = { stack: [], error: void 0, hasError: false };
-        try {
-            const factory = __addDisposableResource(env_3, await generateStorageFactory(), true);
-            const syncRules = await factory.updateSyncRules(updateSyncRulesFromYaml(`
+        await using factory = await generateStorageFactory();
+        const syncRules = await factory.updateSyncRules(updateSyncRulesFromYaml(`
 bucket_definitions:
   mybucket:
     parameters:
@@ -196,326 +137,293 @@ bucket_definitions:
         FROM todos
         WHERE list_id IN token_parameters.list_id
     data: []
-    `));
-            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');
-            });
-            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');
-            });
-            // 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`
-            const checkpoint = await bucketStorage.getCheckpoint();
-            const parameters = await checkpoint.getParameterSets([
-                ScopedParameterLookup.direct(MYBUCKET_1, ['list1']),
-                ScopedParameterLookup.direct(MYBUCKET_1, ['list2'])
-            ]);
-            expect(parameters.sort((a, b) => a.todo_id.localeCompare(b.todo_id))).toEqual([
-                {
-                    todo_id: 'todo1'
-                },
-                {
-                    todo_id: 'todo2'
-                }
-            ]);
-        }
-        catch (e_3) {
-            env_3.error = e_3;
-            env_3.hasError = true;
-        }
-        finally {
-            const result_3 = __disposeResources(env_3);
-            if (result_3)
-                await result_3;
-        }
+    `, { storageVersion }));
+        const bucketStorage = factory.getInstance(syncRules);
+        const sync_rules = syncRules.parsed(test_utils.PARSE_OPTIONS).hydratedSyncRules();
+        await using writer = await bucketStorage.createWriter(test_utils.BATCH_OPTIONS);
+        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 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`
+        const checkpoint = await bucketStorage.getCheckpoint();
+        const parameters = new RequestParameters(new JwtPayload({ sub: 'u1', parameters: { list_id: ['list1', 'list2'] } }), {});
+        const querier = sync_rules.getBucketParameterQuerier(test_utils.querierOptions(parameters)).querier;
+        const buckets = await querier.queryDynamicBucketDescriptions({
+            async getParameterSets(lookups) {
+                expect(lookups.map((l) => JSON.stringify(l.indexKey)).sort()).toEqual(['["list1"]', '["list2"]']);
+                const parameter_sets = await checkpoint.getParameterSets(lookups, 1000);
+                expect(parameter_sets.sort((a, b) => a.todo_id.localeCompare(b.todo_id))).toEqual([
+                    { todo_id: 'todo1' },
+                    { todo_id: 'todo2' }
+                ]);
+                return parameter_sets;
+            }
+        });
+        expect(buckets.map((b) => b.bucket).sort()).toEqual([
+            bucketRequest(syncRules, 'mybucket["todo1"]').bucket,
+            bucketRequest(syncRules, 'mybucket["todo2"]').bucket
+        ]);
     });
     test('save and load parameters with different number types', async () => {
-        const env_4 = { stack: [], error: void 0, hasError: false };
-        try {
-            const factory = __addDisposableResource(env_4, await generateStorageFactory(), true);
-            const syncRules = await factory.updateSyncRules(updateSyncRulesFromYaml(`
+        await using factory = await generateStorageFactory();
+        const syncRules = await factory.updateSyncRules(updateSyncRulesFromYaml(`
 bucket_definitions:
   mybucket:
     parameters:
       - SELECT group_id FROM test WHERE n1 = token_parameters.n1 and f2 = token_parameters.f2 and f3 = token_parameters.f3
     data: []
-    `));
-            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');
+    `, {
+            storageVersion
+        }));
+        const bucketStorage = factory.getInstance(syncRules);
+        const sync_rules = syncRules.parsed(test_utils.PARSE_OPTIONS).hydratedSyncRules();
+        await using writer = await bucketStorage.createWriter(test_utils.BATCH_OPTIONS);
+        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 checkpoint = await bucketStorage.getCheckpoint();
+        const testQuery = async (jwtParameters, expectedParameterSets) => {
+            const parameters = new RequestParameters(new JwtPayload({ sub: 'u1', parameters: jwtParameters }), {});
+            const querier = sync_rules.getBucketParameterQuerier(test_utils.querierOptions(parameters)).querier;
+            return await querier.queryDynamicBucketDescriptions({
+                async getParameterSets(lookups) {
+                    const parameter_sets = await checkpoint.getParameterSets(lookups, 1000);
+                    expect(parameter_sets).toEqual(expectedParameterSets);
+                    return parameter_sets;
+                }
             });
-            const TEST_PARAMS = { group_id: 'group1' };
-            const checkpoint = await bucketStorage.getCheckpoint();
-            const parameters1 = await checkpoint.getParameterSets([
-                ScopedParameterLookup.direct(MYBUCKET_1, [314n, 314, 3.14])
-            ]);
-            expect(parameters1).toEqual([TEST_PARAMS]);
-            const parameters2 = await checkpoint.getParameterSets([
-                ScopedParameterLookup.direct(MYBUCKET_1, [314, 314n, 3.14])
-            ]);
-            expect(parameters2).toEqual([TEST_PARAMS]);
-            const parameters3 = await checkpoint.getParameterSets([ScopedParameterLookup.direct(MYBUCKET_1, [314n, 314, 3])]);
-            expect(parameters3).toEqual([]);
-        }
-        catch (e_4) {
-            env_4.error = e_4;
-            env_4.hasError = true;
-        }
-        finally {
-            const result_4 = __disposeResources(env_4);
-            if (result_4)
-                await result_4;
-        }
+        };
+        expect(await testQuery({ n1: 314n, f2: 314, f3: 3.14 }, [{ group_id: 'group1' }])).toMatchObject([
+            { bucket: bucketRequest(syncRules, 'mybucket["group1"]').bucket }
+        ]);
+        expect(await testQuery({ n1: 314, f2: 314n, f3: 3.14 }, [{ group_id: 'group1' }])).toMatchObject([
+            { bucket: bucketRequest(syncRules, 'mybucket["group1"]').bucket }
+        ]);
+        expect(await testQuery({ n1: 314n, f2: 314, f3: 3 }, [])).toEqual([]);
     });
     test('save and load parameters with large numbers', async () => {
-        const env_5 = { stack: [], error: void 0, hasError: false };
-        try {
-            // This ensures serialization / deserialization of "current_data" is done correctly.
-            // This specific case tested here cannot happen with postgres in practice, but we still
-            // test this to ensure correct deserialization.
-            const factory = __addDisposableResource(env_5, await generateStorageFactory(), true);
-            const syncRules = await factory.updateSyncRules(updateSyncRulesFromYaml(`
+        // This ensures serialization / deserialization of "current_data" is done correctly.
+        // This specific case tested here cannot happen with postgres in practice, but we still
+        // test this to ensure correct deserialization.
+        await using factory = await generateStorageFactory();
+        const syncRules = await factory.updateSyncRules(updateSyncRulesFromYaml(`
 bucket_definitions:
   mybucket:
     parameters:
       - SELECT group_id FROM test WHERE n1 = token_parameters.n1
     data: []
-    `));
-            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 TEST_PARAMS = { group_id: 'group1' };
-            const checkpoint = await bucketStorage.getCheckpoint();
-            const parameters1 = await checkpoint.getParameterSets([
-                ScopedParameterLookup.direct(MYBUCKET_1, [1152921504606846976n])
-            ]);
-            expect(parameters1).toEqual([TEST_PARAMS]);
-        }
-        catch (e_5) {
-            env_5.error = e_5;
-            env_5.hasError = true;
-        }
-        finally {
-            const result_5 = __disposeResources(env_5);
-            if (result_5)
-                await result_5;
-        }
+    `, {
+            storageVersion
+        }));
+        const bucketStorage = factory.getInstance(syncRules);
+        const sync_rules = syncRules.parsed(test_utils.PARSE_OPTIONS).hydratedSyncRules();
+        await using writer = await bucketStorage.createWriter(test_utils.BATCH_OPTIONS);
+        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 checkpoint = await bucketStorage.getCheckpoint();
+        const n1 = 1152921504606846976n;
+        const parameters = new RequestParameters(new JwtPayload({ sub: 'u1', parameters: { n1 } }), {});
+        const querier = sync_rules.getBucketParameterQuerier(test_utils.querierOptions(parameters)).querier;
+        const buckets = await querier.queryDynamicBucketDescriptions({
+            getParameterSets: async (lookups) => {
+                expect(lookups.map((l) => l.indexKey)).toEqual([[n1]]);
+                const parameter_sets = await checkpoint.getParameterSets(lookups, 1000);
+                expect(parameter_sets).toEqual([{ group_id: 'group1' }]);
+                return parameter_sets;
+            }
+        });
+        expect(buckets.map((b) => b.bucket)).toEqual([bucketRequest(syncRules, 'mybucket["group1"]').bucket]);
     });
     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(`
+        await using factory = await generateStorageFactory();
+        const syncRules = await factory.updateSyncRules(updateSyncRulesFromYaml(`
 bucket_definitions:
     by_workspace:
       parameters:
         - SELECT id as workspace_id FROM workspace WHERE
           workspace."userId" = token_parameters.user_id
       data: []
-    `));
-            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 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'])]);
-                    const parameter_sets = await checkpoint.getParameterSets(lookups);
-                    expect(parameter_sets).toEqual([{ workspace_id: 'workspace1' }]);
-                    return parameter_sets;
-                }
-            });
-            expect(buckets).toEqual([
-                {
-                    bucket: bucketRequest(syncRules, 'by_workspace["workspace1"]'),
-                    priority: 3,
-                    definition: 'by_workspace',
-                    inclusion_reasons: ['default']
-                }
-            ]);
-        }
-        catch (e_6) {
-            env_6.error = e_6;
-            env_6.hasError = true;
-        }
-        finally {
-            const result_6 = __disposeResources(env_6);
-            if (result_6)
-                await result_6;
-        }
+    `, {
+            storageVersion
+        }));
+        const sync_rules = syncRules.parsed(test_utils.PARSE_OPTIONS).hydratedSyncRules();
+        const bucketStorage = factory.getInstance(syncRules);
+        await using writer = await bucketStorage.createWriter(test_utils.BATCH_OPTIONS);
+        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.map((l) => l.indexKey)).toEqual([['u1']]);
+                const parameter_sets = await checkpoint.getParameterSets(lookups, 1000);
+                expect(parameter_sets).toEqual([{ workspace_id: 'workspace1' }]);
+                return parameter_sets;
+            }
+        });
+        expect(buckets).toEqual([
+            {
+                bucket: bucketRequest(syncRules, 'by_workspace["workspace1"]').bucket,
+                priority: 3,
+                definition: 'by_workspace',
+                inclusion_reasons: ['default']
+            }
+        ]);
     });
     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(`
+        await using factory = await generateStorageFactory();
+        const syncRules = await factory.updateSyncRules(updateSyncRulesFromYaml(`
 bucket_definitions:
     by_public_workspace:
       parameters:
         - SELECT id as workspace_id FROM workspace WHERE
           workspace.visibility = 'public'
       data: []
-    `));
-            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 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' }, [])
-                    ]);
-                    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' }]);
-                    return parameter_sets;
-                }
-            });
-            buckets.sort((a, b) => a.bucket.localeCompare(b.bucket));
-            expect(buckets).toEqual([
-                {
-                    bucket: bucketRequest(syncRules, 'by_public_workspace["workspace1"]'),
-                    priority: 3,
-                    definition: 'by_public_workspace',
-                    inclusion_reasons: ['default']
-                },
-                {
-                    bucket: bucketRequest(syncRules, 'by_public_workspace["workspace3"]'),
-                    priority: 3,
-                    definition: 'by_public_workspace',
-                    inclusion_reasons: ['default']
-                }
-            ]);
-        }
-        catch (e_7) {
-            env_7.error = e_7;
-            env_7.hasError = true;
-        }
-        finally {
-            const result_7 = __disposeResources(env_7);
-            if (result_7)
-                await result_7;
-        }
+    `, {
+            storageVersion
+        }));
+        const sync_rules = syncRules.parsed(test_utils.PARSE_OPTIONS).hydratedSyncRules();
+        const bucketStorage = factory.getInstance(syncRules);
+        await using writer = await bucketStorage.createWriter(test_utils.BATCH_OPTIONS);
+        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.map((l) => l.indexKey)).toEqual([[]]);
+                const parameter_sets = await checkpoint.getParameterSets(lookups, 1000);
+                parameter_sets.sort((a, b) => JSON.stringify(a).localeCompare(JSON.stringify(b)));
+                expect(parameter_sets).toEqual([{ workspace_id: 'workspace1' }, { workspace_id: 'workspace3' }]);
+                return parameter_sets;
+            }
+        });
+        buckets.sort((a, b) => a.bucket.localeCompare(b.bucket));
+        expect(buckets).toEqual([
+            {
+                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,
+                priority: 3,
+                definition: 'by_public_workspace',
+                inclusion_reasons: ['default']
+            }
+        ]);
     });
     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(`
+        await using factory = await generateStorageFactory();
+        const syncRules = await factory.updateSyncRules(updateSyncRulesFromYaml(`
 bucket_definitions:
     by_workspace:
       parameters:
@@ -524,171 +432,152 @@ bucket_definitions:
         - SELECT id as workspace_id FROM workspace WHERE
             workspace.user_id = token_parameters.user_id
       data: []
-    `));
-            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 checkpoint = await bucketStorage.getCheckpoint();
-            const parameters = new RequestParameters(new JwtPayload({ sub: 'u1' }), {});
-            // Test intermediate values - could be moved to sync_rules.test.ts
-            const querier = sync_rules.getBucketParameterQuerier(test_utils.querierOptions(parameters)).querier;
-            // Test final values - the important part
-            const foundLookups = [];
-            const parameter_sets = [];
-            const buckets = (await querier.queryDynamicBucketDescriptions({
-                async getParameterSets(lookups) {
-                    foundLookups.push(...lookups);
-                    const output = await checkpoint.getParameterSets(lookups);
-                    parameter_sets.push(...output);
-                    return output;
-                }
-            })).map((e) => e.bucket);
-            expect(foundLookups).toEqual([
-                ScopedParameterLookup.direct({ lookupName: 'by_workspace', queryId: '1' }, []),
-                ScopedParameterLookup.direct({ lookupName: 'by_workspace', queryId: '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"]')
-            ]);
-        }
-        catch (e_8) {
-            env_8.error = e_8;
-            env_8.hasError = true;
-        }
-        finally {
-            const result_8 = __disposeResources(env_8);
-            if (result_8)
-                await result_8;
-        }
+    `, {
+            storageVersion
+        }));
+        const sync_rules = syncRules.parsed(test_utils.PARSE_OPTIONS).hydratedSyncRules();
+        const bucketStorage = factory.getInstance(syncRules);
+        await using writer = await bucketStorage.createWriter(test_utils.BATCH_OPTIONS);
+        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
+        const querier = sync_rules.getBucketParameterQuerier(test_utils.querierOptions(parameters)).querier;
+        // Test final values - the important part
+        const foundLookups = [];
+        const parameter_sets = [];
+        const buckets = (await querier.queryDynamicBucketDescriptions({
+            async getParameterSets(lookups) {
+                foundLookups.push(...lookups);
+                const output = await checkpoint.getParameterSets(lookups, 1000);
+                parameter_sets.push(...output);
+                return output;
+            }
+        })).map((e) => e.bucket);
+        // Not testing the scope anymore - the exact format depends on storage version
+        expect(foundLookups.map((l) => l.indexKey)).toEqual([[], ['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"]').bucket,
+            bucketRequest(syncRules, 'by_workspace["workspace3"]').bucket
+        ]);
     });
     test('truncate parameters', async () => {
-        const env_9 = { stack: [], error: void 0, hasError: false };
-        try {
-            const factory = __addDisposableResource(env_9, await generateStorageFactory(), true);
-            const syncRules = await factory.updateSyncRules(updateSyncRulesFromYaml(`
+        await using factory = await generateStorageFactory();
+        const syncRules = await factory.updateSyncRules(updateSyncRulesFromYaml(`
 bucket_definitions:
   mybucket:
     parameters:
       - SELECT group_id FROM test WHERE id1 = token_parameters.user_id OR id2 = token_parameters.user_id
     data: []
-    `));
-            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 checkpoint = await bucketStorage.getCheckpoint();
-            const parameters = await checkpoint.getParameterSets([ScopedParameterLookup.direct(MYBUCKET_1, ['user1'])]);
-            expect(parameters).toEqual([]);
-        }
-        catch (e_9) {
-            env_9.error = e_9;
-            env_9.hasError = true;
-        }
-        finally {
-            const result_9 = __disposeResources(env_9);
-            if (result_9)
-                await result_9;
-        }
+    `, {
+            storageVersion
+        }));
+        const bucketStorage = factory.getInstance(syncRules);
+        const sync_rules = syncRules.parsed(test_utils.PARSE_OPTIONS).hydratedSyncRules();
+        await using writer = await bucketStorage.createWriter(test_utils.BATCH_OPTIONS);
+        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 = new RequestParameters(new JwtPayload({ sub: 'user1' }), {});
+        const querier = sync_rules.getBucketParameterQuerier(test_utils.querierOptions(parameters)).querier;
+        const buckets = await querier.queryDynamicBucketDescriptions({
+            async getParameterSets(lookups) {
+                expect(lookups.map((l) => l.indexKey)).toEqual([['user1']]);
+                const parameter_sets = await checkpoint.getParameterSets(lookups, 1000);
+                expect(parameter_sets).toEqual([]);
+                return parameter_sets;
+            }
+        });
+        expect(buckets).toEqual([]);
     });
     test('invalidate cached parsed sync rules', async () => {
-        const env_10 = { stack: [], error: void 0, hasError: false };
-        try {
-            const bucketStorageFactory = __addDisposableResource(env_10, await generateStorageFactory(), true);
-            const syncRules = await bucketStorageFactory.updateSyncRules(updateSyncRulesFromYaml(`
+        await using bucketStorageFactory = await generateStorageFactory();
+        const syncRules = await bucketStorageFactory.updateSyncRules(updateSyncRulesFromYaml(`
 bucket_definitions:
     by_workspace:
       parameters:
         - SELECT id as workspace_id FROM workspace WHERE
           workspace."userId" = token_parameters.user_id
       data: []
-    `));
-            const syncBucketStorage = bucketStorageFactory.getInstance(syncRules);
-            const parsedSchema1 = syncBucketStorage.getParsedSyncRules({
-                defaultSchema: 'public'
-            });
-            const parsedSchema2 = syncBucketStorage.getParsedSyncRules({
-                defaultSchema: 'public'
-            });
-            // These should be cached, this will be the same instance
-            expect(parsedSchema2).equals(parsedSchema1);
-            expect(parsedSchema1.getSourceTables()[0].schema).equals('public');
-            const parsedSchema3 = syncBucketStorage.getParsedSyncRules({
-                defaultSchema: 'databasename'
-            });
-            // The cache should not be used
-            expect(parsedSchema3).not.equals(parsedSchema2);
-            expect(parsedSchema3.getSourceTables()[0].schema).equals('databasename');
-        }
-        catch (e_10) {
-            env_10.error = e_10;
-            env_10.hasError = true;
-        }
-        finally {
-            const result_10 = __disposeResources(env_10);
-            if (result_10)
-                await result_10;
-        }
+    `, {
+            storageVersion
+        }));
+        const syncBucketStorage = bucketStorageFactory.getInstance(syncRules);
+        const parsedSchema1 = syncBucketStorage.getParsedSyncRules({
+            defaultSchema: 'public'
+        });
+        const parsedSchema2 = syncBucketStorage.getParsedSyncRules({
+            defaultSchema: 'public'
+        });
+        // These should be cached, this will be the same instance
+        expect(parsedSchema2).equals(parsedSchema1);
+        expect(parsedSchema1.getSourceTables()[0].schema).equals('public');
+        const parsedSchema3 = syncBucketStorage.getParsedSyncRules({
+            defaultSchema: 'databasename'
+        });
+        // The cache should not be used
+        expect(parsedSchema3).not.equals(parsedSchema2);
+        expect(parsedSchema3.getSourceTables()[0].schema).equals('databasename');
     });
     test('sync streams smoke test', async () => {
-        const env_11 = { stack: [], error: void 0, hasError: false };
-        try {
-            const factory = __addDisposableResource(env_11, await generateStorageFactory(), true);
-            const syncRules = await factory.updateSyncRules(updateSyncRulesFromYaml(`
+        await using factory = await generateStorageFactory();
+        const syncRules = await factory.updateSyncRules(updateSyncRulesFromYaml(`
 config:
   edition: 3
 
@@ -698,41 +587,201 @@ streams:
       SELECT data.* FROM test AS data, test AS param
       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 bucketStorage = factory.getInstance(syncRules);
+        const sync_rules = syncRules.parsed(test_utils.PARSE_OPTIONS).hydratedSyncRules();
+        await using writer = await bucketStorage.createWriter(test_utils.BATCH_OPTIONS);
+        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 = new RequestParameters(new JwtPayload({ sub: 'baz' }), {});
+        const querier = sync_rules.getBucketParameterQuerier({
+            ...test_utils.querierOptions(parameters),
+            streams: {
+                stream: [
+                    {
+                        priorityOverride: null,
+                        parameters: null,
+                        opaque_id: 123
+                    }
+                ]
+            }
+        }).querier;
+        const buckets = await querier.queryDynamicBucketDescriptions({
+            async getParameterSets(lookups) {
+                expect(lookups.map((l) => l.indexKey)).toEqual([['baz']]);
+                const parameter_sets = await checkpoint.getParameterSets(lookups, 1000);
+                expect(parameter_sets).toEqual([{ '0': 'bar' }]);
+                return parameter_sets;
+            }
+        });
+        console.log('whatabuckets', buckets);
+        expect(buckets).toHaveLength(1);
+        expect(buckets).toMatchObject([
+            {
+                bucket: expect.stringMatching(/stream.*\["bar"\]$/),
+                definition: 'stream',
+                inclusion_reasons: [{ subscription: 123 }],
+                priority: 3
+            }
+        ]);
+    });
+    test('respects parameter limit', async () => {
+        await using factory = await generateStorageFactory();
+        const syncRules = await factory.updateSyncRules(updateSyncRulesFromYaml(`
+config:
+  edition: 3
+
+streams:
+  a:
+    auto_subscribe: true
+    query: SELECT * FROM a WHERE id IN (SELECT id FROM b)
+    `, {
+            storageVersion
+        }));
+        const bucketStorage = factory.getInstance(syncRules);
+        const sync_rules = syncRules.parsed(test_utils.PARSE_OPTIONS).hydratedSyncRules();
+        await using writer = await bucketStorage.createWriter(test_utils.BATCH_OPTIONS);
+        const testTable = await test_utils.resolveTestTable(writer, 'b', ['id'], config);
+        await writer.markAllSnapshotDone('1/1');
+        for (let i = 0; i < 10; i++) {
+            await writer.save({
+                sourceTable: testTable,
+                tag: storage.SaveOperationTag.INSERT,
+                after: {
+                    id: `t${i}`
+                },
+                afterReplicaId: test_utils.rid(`t${i}`)
             });
-            const checkpoint = await bucketStorage.getCheckpoint();
-            const parameters = await checkpoint.getParameterSets([
-                ScopedParameterLookup.direct({
-                    lookupName: 'lookup',
-                    queryId: '0'
-                }, ['baz'])
-            ]);
-            expect(parameters).toEqual([
-                {
-                    '0': 'bar'
-                }
-            ]);
-        }
-        catch (e_11) {
-            env_11.error = e_11;
-            env_11.hasError = true;
-        }
-        finally {
-            const result_11 = __disposeResources(env_11);
-            if (result_11)
-                await result_11;
         }
+        await writer.commit('1/1');
+        const checkpoint = await bucketStorage.getCheckpoint();
+        const parameters = new RequestParameters(new JwtPayload({ sub: 'u' }), {});
+        const querier = sync_rules.getBucketParameterQuerier(test_utils.querierOptions(parameters)).querier;
+        await expect(querier.queryDynamicBucketDescriptions({
+            async getParameterSets(lookups) {
+                const parameter_sets = await checkpoint.getParameterSets(lookups, 5);
+                return parameter_sets;
+            }
+        })).rejects.toThrow('Too many parameter results (limit was 5)');
+    });
+    test('sync streams store multiple parameter outputs for a single source row and lookup', async () => {
+        await using factory = await generateStorageFactory();
+        const syncRules = await factory.updateSyncRules(updateSyncRulesFromYaml(`
+config:
+  edition: 3
+streams:
+  chat:
+    auto_subscribe: true
+    query: |
+      SELECT a.*
+      FROM a, b, json_each(b.x) x, json_each(b.y) y
+      WHERE a.x = x.value AND y.value = auth.user_id()
+    `));
+        const bucketStorage = factory.getInstance(syncRules);
+        const sync_rules = syncRules.parsed(test_utils.PARSE_OPTIONS).hydratedSyncRules();
+        await using writer = await bucketStorage.createWriter(test_utils.BATCH_OPTIONS);
+        const tableB = await test_utils.resolveTestTable(writer, 'b', ['id'], config);
+        const firstState = {
+            id: 'id0',
+            x: JSON.stringify(['x1', 'x2']),
+            y: JSON.stringify(['y1', 'y2'])
+        };
+        const secondState = {
+            id: 'id0',
+            x: JSON.stringify(['x2']),
+            y: JSON.stringify(['y1', 'y2'])
+        };
+        const thirdState = {
+            id: 'id0',
+            x: JSON.stringify(['x2']),
+            y: JSON.stringify(['y2'])
+        };
+        const replicaId = test_utils.rid('id0');
+        await writer.markAllSnapshotDone('1/1');
+        await writer.save({
+            sourceTable: tableB,
+            tag: storage.SaveOperationTag.INSERT,
+            after: firstState,
+            afterReplicaId: replicaId
+        });
+        await writer.commit('1/1');
+        let checkpoint = await bucketStorage.getCheckpoint();
+        const parameters = new RequestParameters(new JwtPayload({ sub: 'y1' }), {});
+        const querier = sync_rules.getBucketParameterQuerier({
+            ...test_utils.querierOptions(parameters)
+        }).querier;
+        let buckets = await querier.queryDynamicBucketDescriptions({
+            async getParameterSets(lookups) {
+                expect(lookups.map((l) => l.indexKey)).toEqual([['y1']]);
+                const parameter_sets = await checkpoint.getParameterSets(lookups, 1000);
+                expect(parameter_sets).toEqual([{ '0': 'x1' }, { '0': 'x2' }]);
+                return parameter_sets;
+            }
+        });
+        expect(buckets).toMatchObject([
+            {
+                bucket: expect.stringMatching(/chat.*\["x1"\]$/),
+                definition: 'chat',
+                inclusion_reasons: ['default'],
+                priority: 3
+            },
+            {
+                bucket: expect.stringMatching(/chat.*\["x2"\]$/),
+                definition: 'chat',
+                inclusion_reasons: ['default'],
+                priority: 3
+            }
+        ]);
+        // Make the x2 bucket inaccessible
+        await writer.save({
+            sourceTable: tableB,
+            tag: storage.SaveOperationTag.UPDATE,
+            before: firstState,
+            after: secondState,
+            beforeReplicaId: replicaId,
+            afterReplicaId: replicaId
+        });
+        await writer.commit('1/2');
+        checkpoint = await bucketStorage.getCheckpoint();
+        buckets = await querier.queryDynamicBucketDescriptions({
+            async getParameterSets(lookups) {
+                expect(lookups.map((l) => l.indexKey)).toEqual([['y1']]);
+                const parameter_sets = await checkpoint.getParameterSets(lookups, 1000);
+                expect(parameter_sets).toEqual([{ '0': 'x2' }]);
+                return parameter_sets;
+            }
+        });
+        expect(buckets.map((bkt) => bkt.bucket)).toStrictEqual([expect.stringContaining('x2')]);
+        // Second update, remove user from inputs
+        await writer.save({
+            sourceTable: tableB,
+            tag: storage.SaveOperationTag.UPDATE,
+            before: secondState,
+            after: thirdState,
+            beforeReplicaId: replicaId,
+            afterReplicaId: replicaId
+        });
+        await writer.commit('1/3');
+        checkpoint = await bucketStorage.getCheckpoint();
+        buckets = await querier.queryDynamicBucketDescriptions({
+            async getParameterSets(lookups) {
+                expect(lookups.map((l) => l.indexKey)).toEqual([['y1']]);
+                const parameter_sets = await checkpoint.getParameterSets(lookups, 1000);
+                expect(parameter_sets).toHaveLength(0);
+                return parameter_sets;
+            }
+        });
+        expect(buckets).toHaveLength(0);
     });
 }
 //# sourceMappingURL=register-data-storage-parameter-tests.js.map