@powersync/service-core-tests 0.15.4 → 0.16.0

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

@@ -1,9 +1,8 @@
 import { CURRENT_STORAGE_VERSION, JwtPayload, storage, updateSyncRulesFromYaml } from '@powersync/service-core';
-import { RequestParameters, ScopedParameterLookup } from '@powersync/service-sync-rules';
+import { RequestParameters, ScopedParameterLookup, UnscopedParameterLookup } from '@powersync/service-sync-rules';
 import { expect, test } from 'vitest';
 import * as test_utils from '../test-utils/test-utils-index.js';
 import { bucketRequest } from '../test-utils/test-utils-index.js';
-import { parameterLookupScope } from './util.js';
 /**
  * @example
  * ```TypeScript
@@ -17,7 +16,6 @@ import { parameterLookupScope } from './util.js';
 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 () => {
         await using factory = await generateStorageFactory();
         const syncRules = await factory.updateSyncRules(updateSyncRulesFromYaml(`
@@ -30,6 +28,7 @@ bucket_definitions:
             storageVersion
         }));
         const bucketStorage = factory.getInstance(syncRules);
+        const sync_rules = syncRules.parsed(test_utils.PARSE_OPTIONS).hydratedSyncConfig();
         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');
@@ -57,12 +56,17 @@ bucket_definitions:
         });
         await writer.commit('1/1');
         const checkpoint = await bucketStorage.getCheckpoint();
-        const parameters = await checkpoint.getParameterSets([ScopedParameterLookup.direct(MYBUCKET_1, ['user1'])]);
-        expect(parameters).toEqual([
-            {
-                group_id: 'group1a'
+        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([{ lookup: lookups[0], rows: [{ 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 () => {
         await using factory = await generateStorageFactory();
@@ -76,6 +80,7 @@ bucket_definitions:
             storageVersion
         }));
         const bucketStorage = factory.getInstance(syncRules);
+        const sync_rules = syncRules.parsed(test_utils.PARSE_OPTIONS).hydratedSyncConfig();
         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');
@@ -101,19 +106,26 @@ bucket_definitions:
         });
         await writer.commit('1/2');
         const checkpoint2 = await bucketStorage.getCheckpoint();
-        const parameters = await checkpoint2.getParameterSets([ScopedParameterLookup.direct(MYBUCKET_1, ['user1'])]);
-        expect(parameters).toEqual([
-            {
-                group_id: 'group2'
+        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([{ lookup: lookups[0], rows: [{ group_id: 'group1' }] }]);
+                return parameter_sets;
             }
-        ]);
-        // 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'
+        });
+        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([{ lookup: lookups[0], rows: [{ 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 () => {
         await using factory = await generateStorageFactory();
@@ -127,6 +139,7 @@ bucket_definitions:
     data: []
     `, { storageVersion }));
         const bucketStorage = factory.getInstance(syncRules);
+        const sync_rules = syncRules.parsed(test_utils.PARSE_OPTIONS).hydratedSyncConfig();
         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');
@@ -165,17 +178,23 @@ bucket_definitions:
         // 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'
+        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 results = await checkpoint.getParameterSets(lookups, 1000);
+                const allRows = results.flatMap(({ rows }) => rows);
+                expect(allRows.sort((a, b) => a.todo_id.localeCompare(b.todo_id))).toEqual([
+                    { todo_id: 'todo1' },
+                    { todo_id: 'todo2' }
+                ]);
+                return results;
             }
+        });
+        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 () => {
@@ -190,6 +209,7 @@ bucket_definitions:
             storageVersion
         }));
         const bucketStorage = factory.getInstance(syncRules);
+        const sync_rules = syncRules.parsed(test_utils.PARSE_OPTIONS).hydratedSyncConfig();
         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');
@@ -206,18 +226,30 @@ bucket_definitions:
             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([
-            ScopedParameterLookup.direct(MYBUCKET_1, [314n, 314, 3.14])
+        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);
+                    if (expectedParameterSets.length == 0) {
+                        expect(parameter_sets).toEqual([]);
+                    }
+                    else {
+                        expect(parameter_sets).toEqual([{ lookup: lookups[0], rows: expectedParameterSets }]);
+                    }
+                    return parameter_sets;
+                }
+            });
+        };
+        expect(await testQuery({ n1: 314n, f2: 314, f3: 3.14 }, [{ group_id: 'group1' }])).toMatchObject([
+            { bucket: bucketRequest(syncRules, 'mybucket["group1"]').bucket }
         ]);
-        expect(parameters1).toEqual([TEST_PARAMS]);
-        const parameters2 = await checkpoint.getParameterSets([
-            ScopedParameterLookup.direct(MYBUCKET_1, [314, 314n, 3.14])
+        expect(await testQuery({ n1: 314, f2: 314n, f3: 3.14 }, [{ group_id: 'group1' }])).toMatchObject([
+            { bucket: bucketRequest(syncRules, 'mybucket["group1"]').bucket }
         ]);
-        expect(parameters2).toEqual([TEST_PARAMS]);
-        const parameters3 = await checkpoint.getParameterSets([ScopedParameterLookup.direct(MYBUCKET_1, [314n, 314, 3])]);
-        expect(parameters3).toEqual([]);
+        expect(await testQuery({ n1: 314n, f2: 314, f3: 3 }, [])).toEqual([]);
     });
     test('save and load parameters with large numbers', async () => {
         // This ensures serialization / deserialization of "current_data" is done correctly.
@@ -234,6 +266,7 @@ bucket_definitions:
             storageVersion
         }));
         const bucketStorage = factory.getInstance(syncRules);
+        const sync_rules = syncRules.parsed(test_utils.PARSE_OPTIONS).hydratedSyncConfig();
         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');
@@ -260,12 +293,19 @@ bucket_definitions:
             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([
-            ScopedParameterLookup.direct(MYBUCKET_1, [1152921504606846976n])
-        ]);
-        expect(parameters1).toEqual([TEST_PARAMS]);
+        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([{ lookup: lookups[0], rows: [{ 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 () => {
         await using factory = await generateStorageFactory();
@@ -279,7 +319,7 @@ bucket_definitions:
     `, {
             storageVersion
         }));
-        const sync_rules = syncRules.parsed(test_utils.PARSE_OPTIONS).hydratedSyncRules();
+        const sync_rules = syncRules.parsed(test_utils.PARSE_OPTIONS).hydratedSyncConfig();
         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);
@@ -299,9 +339,9 @@ bucket_definitions:
         const querier = sync_rules.getBucketParameterQuerier(test_utils.querierOptions(parameters)).querier;
         const buckets = await querier.queryDynamicBucketDescriptions({
             async getParameterSets(lookups) {
-                expect(lookups).toEqual([ScopedParameterLookup.direct(parameterLookupScope('by_workspace', '1'), ['u1'])]);
-                const parameter_sets = await checkpoint.getParameterSets(lookups);
-                expect(parameter_sets).toEqual([{ workspace_id: 'workspace1' }]);
+                expect(lookups.map((l) => l.indexKey)).toEqual([['u1']]);
+                const parameter_sets = await checkpoint.getParameterSets(lookups, 1000);
+                expect(parameter_sets).toEqual([{ lookup: lookups[0], rows: [{ workspace_id: 'workspace1' }] }]);
                 return parameter_sets;
             }
         });
@@ -326,7 +366,7 @@ bucket_definitions:
     `, {
             storageVersion
         }));
-        const sync_rules = syncRules.parsed(test_utils.PARSE_OPTIONS).hydratedSyncRules();
+        const sync_rules = syncRules.parsed(test_utils.PARSE_OPTIONS).hydratedSyncConfig();
         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);
@@ -364,10 +404,13 @@ bucket_definitions:
         const querier = sync_rules.getBucketParameterQuerier(test_utils.querierOptions(parameters)).querier;
         const buckets = await querier.queryDynamicBucketDescriptions({
             async getParameterSets(lookups) {
-                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' }]);
+                expect(lookups.map((l) => l.indexKey)).toEqual([[]]);
+                const parameter_sets = await checkpoint.getParameterSets(lookups, 1000);
+                expect(parameter_sets).toHaveLength(1);
+                const [{ lookup, rows }] = parameter_sets;
+                expect(lookup).toEqual(lookups[0]);
+                rows.sort((a, b) => JSON.stringify(a).localeCompare(JSON.stringify(b)));
+                expect(rows).toEqual([{ workspace_id: 'workspace1' }, { workspace_id: 'workspace3' }]);
                 return parameter_sets;
             }
         });
@@ -401,7 +444,7 @@ bucket_definitions:
     `, {
             storageVersion
         }));
-        const sync_rules = syncRules.parsed(test_utils.PARSE_OPTIONS).hydratedSyncRules();
+        const sync_rules = syncRules.parsed(test_utils.PARSE_OPTIONS).hydratedSyncConfig();
         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);
@@ -455,15 +498,15 @@ bucket_definitions:
         const buckets = (await querier.queryDynamicBucketDescriptions({
             async getParameterSets(lookups) {
                 foundLookups.push(...lookups);
-                const output = await checkpoint.getParameterSets(lookups);
-                parameter_sets.push(...output);
+                const output = await checkpoint.getParameterSets(lookups, 1000);
+                for (const { rows } of output) {
+                    parameter_sets.push(...rows);
+                }
                 return output;
             }
         })).map((e) => e.bucket);
-        expect(foundLookups).toEqual([
-            ScopedParameterLookup.direct(parameterLookupScope('by_workspace', '1'), []),
-            ScopedParameterLookup.direct(parameterLookupScope('by_workspace', '2'), ['u1'])
-        ]);
+        // 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();
@@ -484,6 +527,7 @@ bucket_definitions:
             storageVersion
         }));
         const bucketStorage = factory.getInstance(syncRules);
+        const sync_rules = syncRules.parsed(test_utils.PARSE_OPTIONS).hydratedSyncConfig();
         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');
@@ -501,8 +545,17 @@ bucket_definitions:
         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([]);
+        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 () => {
         await using bucketStorageFactory = await generateStorageFactory();
@@ -546,6 +599,7 @@ streams:
       WHERE data.foo = param.bar AND param.baz = auth.user_id()
     `));
         const bucketStorage = factory.getInstance(syncRules);
+        const sync_rules = syncRules.parsed(test_utils.PARSE_OPTIONS).hydratedSyncConfig();
         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');
@@ -560,13 +614,330 @@ streams:
         });
         await writer.commit('1/1');
         const checkpoint = await bucketStorage.getCheckpoint();
-        const parameters = await checkpoint.getParameterSets([
-            ScopedParameterLookup.direct(parameterLookupScope('lookup', '0'), ['baz'])
+        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([{ lookup: lookups[0], rows: [{ '0': 'bar' }] }]);
+                return parameter_sets;
+            }
+        });
+        expect(buckets).toHaveLength(1);
+        expect(buckets).toMatchObject([
+            {
+                bucket: expect.stringMatching(/stream.*\["bar"\]$/),
+                definition: 'stream',
+                inclusion_reasons: [{ subscription: 123 }],
+                priority: 3
+            }
         ]);
-        expect(parameters).toEqual([
+    });
+    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).hydratedSyncConfig();
+        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}`)
+            });
+        }
+        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).hydratedSyncConfig();
+        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([{ lookup: lookups[0], rows: [{ '0': 'x1' }, { '0': 'x2' }] }]);
+                return parameter_sets;
+            }
+        });
+        expect(buckets).toMatchObject([
+            {
+                bucket: expect.stringMatching(/chat.*\["x1"\]$/),
+                definition: 'chat',
+                inclusion_reasons: ['default'],
+                priority: 3
+            },
             {
-                '0': 'bar'
+                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([{ lookup: lookups[0], rows: [{ '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);
+    });
+    test('can request multiple lookups at once', 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 p IN (SELECT id FROM param_a WHERE u = auth.user_id())
+  b:
+    auto_subscribe: true
+    query: SELECT * FROM b WHERE p IN (SELECT id FROM param_b WHERE u = auth.user_id())
+    `));
+        const bucketStorage = factory.getInstance(syncRules);
+        const parsedSyncRules = syncRules.parsed(test_utils.PARSE_OPTIONS);
+        const hydrationState = parsedSyncRules.hydrationState;
+        const syncConfig = parsedSyncRules.syncConfigWithErrors.config;
+        await using writer = await bucketStorage.createWriter(test_utils.BATCH_OPTIONS);
+        const paramATable = await test_utils.resolveTestTable(writer, 'param_a', ['id'], config, 1);
+        const paramBTable = await test_utils.resolveTestTable(writer, 'param_b', ['id'], config, 2);
+        const replicaId = test_utils.rid('id');
+        // Insert the same row into param_a and param_b
+        await writer.markAllSnapshotDone('1/1');
+        await writer.save({
+            sourceTable: paramATable,
+            tag: storage.SaveOperationTag.INSERT,
+            after: {
+                id: 'id',
+                u: 'user'
+            },
+            afterReplicaId: replicaId
+        });
+        await writer.save({
+            sourceTable: paramBTable,
+            tag: storage.SaveOperationTag.INSERT,
+            after: {
+                id: 'id',
+                u: 'user'
+            },
+            afterReplicaId: replicaId
+        });
+        await writer.commit('1/1');
+        function findParameterOnTable(name) {
+            for (const source of syncConfig.bucketParameterLookupSources) {
+                for (const param of source.getSourceTables()) {
+                    if (param.name == name)
+                        return source;
+                }
+            }
+            throw new Error(`Expected parameter index on ${name}`);
+        }
+        // Run two lookups on separate parameter indexes.
+        const lookupA = ScopedParameterLookup.normalized(hydrationState.getParameterIndexLookupScope(findParameterOnTable('param_a')), UnscopedParameterLookup.normalized(['user']));
+        const lookupB = ScopedParameterLookup.normalized(hydrationState.getParameterIndexLookupScope(findParameterOnTable('param_b')), UnscopedParameterLookup.normalized(['user']));
+        const checkpoint = await bucketStorage.getCheckpoint();
+        const parameterSets = await checkpoint.getParameterSets([lookupA, lookupB], 1000);
+        const expectedRow = { '0': 'id' };
+        let foundLookupA = false, foundLookupB = false;
+        // We should get the same row on both, with information on which lookup contributed which row.
+        for (const { lookup, rows } of parameterSets) {
+            if (lookup === lookupA) {
+                foundLookupA = true;
+                expect(rows).toStrictEqual([expectedRow]);
+            }
+            else if (lookup === lookupB) {
+                foundLookupB = true;
+                expect(rows).toStrictEqual([expectedRow]);
+            }
+            else {
+                throw new Error('unexpected lookup in results');
+            }
+        }
+        expect(foundLookupA).toBeTruthy();
+        expect(foundLookupB).toBeTruthy();
+    });
+    test('sync streams preserve duplicate downstream lookups with different provenance', async () => {
+        await using factory = await generateStorageFactory();
+        const syncRules = await factory.updateSyncRules(updateSyncRulesFromYaml(`
+config:
+  edition: 3
+streams:
+  stream:
+    auto_subscribe: true
+    query: |
+      SELECT a.*
+      FROM a, b, c
+      WHERE a.x = b.x
+        AND a.z = c.z
+        AND b.y = c.y
+        AND c.u = auth.user_id()
+    `, {
+            storageVersion
+        }));
+        const bucketStorage = factory.getInstance(syncRules);
+        const sync_rules = syncRules.parsed(test_utils.PARSE_OPTIONS).hydratedSyncConfig();
+        await using writer = await bucketStorage.createWriter(test_utils.BATCH_OPTIONS);
+        const tableB = await test_utils.resolveTestTable(writer, 'b', ['id'], config, 1);
+        const tableC = await test_utils.resolveTestTable(writer, 'c', ['id'], config, 2);
+        await writer.markAllSnapshotDone('1/1');
+        await writer.save({
+            sourceTable: tableB,
+            tag: storage.SaveOperationTag.INSERT,
+            after: {
+                id: 'b1',
+                y: 'shared-y',
+                x: 'x-from-shared-y'
+            },
+            afterReplicaId: test_utils.rid('b1')
+        });
+        await writer.save({
+            sourceTable: tableC,
+            tag: storage.SaveOperationTag.INSERT,
+            after: {
+                id: 'c1',
+                u: 'user1',
+                y: 'shared-y',
+                z: 'z1'
+            },
+            afterReplicaId: test_utils.rid('c1')
+        });
+        await writer.save({
+            sourceTable: tableC,
+            tag: storage.SaveOperationTag.INSERT,
+            after: {
+                id: 'c2',
+                u: 'user1',
+                y: 'shared-y',
+                z: 'z2'
+            },
+            afterReplicaId: test_utils.rid('c2')
+        });
+        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) {
+                return checkpoint.getParameterSets(lookups, 1000);
+            }
+        });
+        expect(buckets.map((bucket) => bucket.bucket).sort()).toStrictEqual([
+            expect.stringMatching(/stream.*\["x-from-shared-y","z1"\]$/),
+            expect.stringMatching(/stream.*\["x-from-shared-y","z2"\]$/)
         ]);
     });
 }