@powersync/service-core-tests 0.15.4 → 0.16.0

package/src/tests/register-data-storage-parameter-tests.ts

@@ -1,9 +1,14 @@
 import { CURRENT_STORAGE_VERSION, JwtPayload, storage, updateSyncRulesFromYaml } from '@powersync/service-core';
-import { RequestParameters, ScopedParameterLookup, SqliteJsonRow } from '@powersync/service-sync-rules';
+import {
+  ParameterIndexLookupCreator,
+  RequestParameters,
+  ScopedParameterLookup,
+  SqliteJsonRow,
+  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
@@ -18,7 +23,6 @@ import { parameterLookupScope } from './util.js';
 export function registerDataStorageParameterTests(config: storage.TestStorageConfig) {
   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();
@@ -37,6 +41,7 @@ bucket_definitions:
       )
     );
     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);
@@ -69,12 +74,20 @@ 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 () => {
@@ -94,6 +107,7 @@ bucket_definitions:
       )
     );
     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);
@@ -121,20 +135,30 @@ 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;
       }
-    ]);
+    });
+    expect(buckets1.map((b) => b.bucket)).toEqual([bucketRequest(syncRules, 'mybucket["group1"]').bucket]);
 
-    // 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'
+    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 () => {
@@ -154,6 +178,7 @@ bucket_definitions:
       )
     );
     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);
@@ -197,18 +222,29 @@ 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'])
-    ]);
+    const parameters = new RequestParameters(
+      new JwtPayload({ sub: 'u1', parameters: { list_id: ['list1', 'list2'] } }),
+      {}
+    );
+    const querier = sync_rules.getBucketParameterQuerier(test_utils.querierOptions(parameters)).querier;
 
-    expect(parameters.sort((a, b) => (a.todo_id as string).localeCompare(b.todo_id as string))).toEqual([
-      {
-        todo_id: 'todo1'
-      },
-      {
-        todo_id: 'todo2'
+    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 as string).localeCompare(b.todo_id as string))).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
     ]);
   });
 
@@ -229,6 +265,7 @@ bucket_definitions:
       )
     );
     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);
@@ -248,20 +285,31 @@ bucket_definitions:
 
     await writer.commit('1/1');
 
-    const TEST_PARAMS = { group_id: 'group1' };
-
     const checkpoint = await bucketStorage.getCheckpoint();
+    const testQuery = async (jwtParameters: Record<string, any>, expectedParameterSets: SqliteJsonRow[]) => {
+      const parameters = new RequestParameters(new JwtPayload({ sub: 'u1', parameters: jwtParameters }), {});
+      const querier = sync_rules.getBucketParameterQuerier(test_utils.querierOptions(parameters)).querier;
 
-    const parameters1 = await checkpoint.getParameterSets([
-      ScopedParameterLookup.direct(MYBUCKET_1, [314n, 314, 3.14])
+      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 () => {
@@ -285,6 +333,7 @@ bucket_definitions:
       )
     );
     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);
@@ -315,14 +364,23 @@ bucket_definitions:
 
     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 () => {
@@ -342,7 +400,7 @@ bucket_definitions:
         }
       )
     );
-    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);
@@ -366,10 +424,10 @@ bucket_definitions:
 
     const buckets = await querier.queryDynamicBucketDescriptions({
       async getParameterSets(lookups) {
-        expect(lookups).toEqual([ScopedParameterLookup.direct(parameterLookupScope('by_workspace', '1'), ['u1'])]);
+        expect(lookups.map((l) => l.indexKey)).toEqual([['u1']]);
 
-        const parameter_sets = await checkpoint.getParameterSets(lookups);
-        expect(parameter_sets).toEqual([{ workspace_id: 'workspace1' }]);
+        const parameter_sets = await checkpoint.getParameterSets(lookups, 1000);
+        expect(parameter_sets).toEqual([{ lookup: lookups[0], rows: [{ workspace_id: 'workspace1' }] }]);
         return parameter_sets;
       }
     });
@@ -400,7 +458,7 @@ bucket_definitions:
         }
       )
     );
-    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);
@@ -446,11 +504,15 @@ bucket_definitions:
 
     const buckets = await querier.queryDynamicBucketDescriptions({
       async getParameterSets(lookups) {
-        expect(lookups).toEqual([ScopedParameterLookup.direct(parameterLookupScope('by_public_workspace', '1'), [])]);
+        expect(lookups.map((l) => l.indexKey)).toEqual([[]]);
 
-        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' }]);
+        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;
       }
     });
@@ -490,7 +552,7 @@ bucket_definitions:
         }
       )
     );
-    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);
@@ -554,16 +616,17 @@ bucket_definitions:
       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' }]);
 
@@ -591,6 +654,7 @@ bucket_definitions:
       )
     );
     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);
@@ -611,9 +675,19 @@ bucket_definitions:
     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 parameters = await checkpoint.getParameterSets([ScopedParameterLookup.direct(MYBUCKET_1, ['user1'])]);
-    expect(parameters).toEqual([]);
+    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 () => {
@@ -671,6 +745,7 @@ streams:
     `)
     );
     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);
@@ -688,13 +763,390 @@ 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([
       {
-        '0': 'bar'
+        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([{ 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: string): ParameterIndexLookupCreator {
+      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"\]$/)
     ]);
   });
 }