@powersync/service-core 1.20.0 → 1.20.1

package/src/storage/SyncRulesBucketStorage.ts

@@ -1,5 +1,10 @@
 import { Logger, ObserverClient } from '@powersync/lib-services-framework';
-import { HydratedSyncRules, ScopedParameterLookup, SqliteJsonRow } from '@powersync/service-sync-rules';
+import {
+  BucketDataSource,
+  HydratedSyncRules,
+  ScopedParameterLookup,
+  SqliteJsonRow
+} from '@powersync/service-sync-rules';
 import * as util from '../util/util-index.js';
 import { BucketStorageBatch, FlushedResult, SaveUpdate } from './BucketStorageBatch.js';
 import { BucketStorageFactory } from './BucketStorageFactory.js';
@@ -103,7 +108,7 @@ export interface SyncRulesBucketStorage
    */
   getBucketDataBatch(
     checkpoint: util.InternalOpId,
-    dataBuckets: Map<string, util.InternalOpId>,
+    dataBuckets: BucketDataRequest[],
     options?: BucketDataBatchOptions
   ): AsyncIterable<SyncBucketDataChunk>;
 
@@ -115,7 +120,7 @@ export interface SyncRulesBucketStorage
    * This may be slow, depending on the size of the buckets.
    * The checksums are cached internally to compensate for this, but does not cover all cases.
    */
-  getChecksums(checkpoint: util.InternalOpId, buckets: string[]): Promise<util.ChecksumMap>;
+  getChecksums(checkpoint: util.InternalOpId, buckets: BucketChecksumRequest[]): Promise<util.ChecksumMap>;
 
   /**
    * Clear checksum cache. Primarily intended for tests.
@@ -127,6 +132,16 @@ export interface SyncRulesBucketStorageListener {
   batchStarted: (batch: BucketStorageBatch) => void;
 }
 
+export interface BucketDataRequest {
+  bucket: string;
+  start: util.InternalOpId;
+  source: BucketDataSource;
+}
+export interface BucketChecksumRequest {
+  bucket: string;
+  source: BucketDataSource;
+}
+
 export interface SyncRuleStatus {
   checkpoint_lsn: string | null;
   active: boolean;

package/src/sync/BucketChecksumState.ts

@@ -7,7 +7,8 @@ import {
   QuerierError,
   RequestedStream,
   RequestParameters,
-  ResolvedBucket
+  ResolvedBucket,
+  mergeBuckets
 } from '@powersync/service-sync-rules';
 
 import * as storage from '../storage/storage-index.js';
@@ -137,20 +138,20 @@ export class BucketChecksumState {
       }
 
       // Re-check updated buckets only
-      let checksumLookups: string[] = [];
+      let checksumLookups: storage.BucketChecksumRequest[] = [];
 
       let newChecksums = new Map<string, util.BucketChecksum>();
-      for (let bucket of bucketDescriptionMap.keys()) {
-        if (!updatedBuckets.has(bucket)) {
-          const existing = this.lastChecksums.get(bucket);
+      for (let desc of bucketDescriptionMap.values()) {
+        if (!updatedBuckets.has(desc.bucket)) {
+          const existing = this.lastChecksums.get(desc.bucket);
           if (existing == null) {
             // If this happens, it means updatedBuckets did not correctly include all new buckets
-            throw new ServiceAssertionError(`Existing checksum not found for bucket ${bucket}`);
+            throw new ServiceAssertionError(`Existing checksum not found for bucket ${desc.bucket}`);
           }
           // Bucket is not specifically updated, and we have a previous checksum
-          newChecksums.set(bucket, existing);
+          newChecksums.set(desc.bucket, existing);
         } else {
-          checksumLookups.push(bucket);
+          checksumLookups.push({ bucket: desc.bucket, source: desc.source });
         }
       }
 
@@ -163,12 +164,12 @@ export class BucketChecksumState {
       checksumMap = newChecksums;
     } else {
       // Re-check all buckets
-      const bucketList = [...bucketDescriptionMap.keys()];
+      const bucketList = [...bucketDescriptionMap.values()].map((b) => ({ bucket: b.bucket, source: b.source }));
       checksumMap = await storage.getChecksums(base.checkpoint, bucketList);
     }
 
     // Subset of buckets for which there may be new data in this batch.
-    let bucketsToFetch: BucketDescription[];
+    let bucketsToFetch: ResolvedBucket[];
 
     let checkpointLine: util.StreamingSyncCheckpointDiff | util.StreamingSyncCheckpoint;
 
@@ -207,10 +208,7 @@ export class BucketChecksumState {
         ...this.parameterState.translateResolvedBucket(bucketDescriptionMap.get(e.bucket)!, streamNameToIndex)
       }));
       bucketsToFetch = [...generateBucketsToFetch].map((b) => {
-        return {
-          priority: bucketDescriptionMap.get(b)!.priority,
-          bucket: b
-        };
+        return bucketDescriptionMap.get(b)!;
       });
 
       deferredLog = () => {
@@ -265,7 +263,7 @@ export class BucketChecksumState {
           totalParamResults
         );
       };
-      bucketsToFetch = allBuckets.map((b) => ({ bucket: b.bucket, priority: b.priority }));
+      bucketsToFetch = allBuckets;
 
       const subscriptions: util.StreamDescription[] = [];
       const streamNameToIndex = new Map<string, number>();
@@ -342,17 +340,17 @@ export class BucketChecksumState {
         deferredLog();
       },
 
-      getFilteredBucketPositions: (buckets?: BucketDescription[]): Map<string, util.InternalOpId> => {
+      getFilteredBucketPositions: (buckets?: ResolvedBucket[]): storage.BucketDataRequest[] => {
         if (!hasAdvanced) {
           throw new ServiceAssertionError('Call line.advance() before getFilteredBucketPositions()');
         }
         buckets ??= bucketsToFetch;
-        const filtered = new Map<string, util.InternalOpId>();
+        const filtered: storage.BucketDataRequest[] = [];
 
         for (let bucket of buckets) {
           const state = this.bucketDataPositions.get(bucket.bucket);
           if (state) {
-            filtered.set(bucket.bucket, state.start_op_id);
+            filtered.push({ bucket: bucket.bucket, start: state.start_op_id, source: bucket.source });
           }
         }
         return filtered;
@@ -660,7 +658,7 @@ export class BucketParameterState {
 
 export interface CheckpointLine {
   checkpointLine: util.StreamingSyncCheckpointDiff | util.StreamingSyncCheckpoint;
-  bucketsToFetch: BucketDescription[];
+  bucketsToFetch: ResolvedBucket[];
 
   /**
    * Call when a checkpoint line is being sent to a client, to update the internal state.
@@ -672,7 +670,7 @@ export interface CheckpointLine {
    *
    * @param bucketsToFetch List of buckets to fetch - either this.bucketsToFetch, or a subset of it. Defaults to this.bucketsToFetch.
    */
-  getFilteredBucketPositions(bucketsToFetch?: BucketDescription[]): Map<string, util.InternalOpId>;
+  getFilteredBucketPositions(bucketsToFetch?: ResolvedBucket[]): storage.BucketDataRequest[];
 
   /**
    * Update the position of bucket data the client has, after it was sent to the client.
@@ -762,32 +760,3 @@ function limitedBuckets(buckets: string[] | { bucket: string }[], limit: number)
   const limited = buckets.slice(0, limit);
   return `${JSON.stringify(limited)}...`;
 }
-
-/**
- * Resolves duplicate buckets in the given array, merging the inclusion reasons for duplicate.
- *
- * It's possible for duplicates to occur when a stream has multiple subscriptions, consider e.g.
- *
- * ```
- * sync_streams:
- *  assets_by_category:
- *    query: select * from assets where category in (request.parameters() -> 'categories')
- * ```
- *
- * Here, a client might subscribe once with `{"categories": [1]}` and once with `{"categories": [1, 2]}`. Since each
- * subscription is evaluated independently, this would lead to three buckets, with a duplicate `assets_by_category[1]`
- * bucket.
- */
-function mergeBuckets(buckets: ResolvedBucket[]): ResolvedBucket[] {
-  const byBucketId: Record<string, ResolvedBucket> = {};
-
-  for (const bucket of buckets) {
-    if (Object.hasOwn(byBucketId, bucket.bucket)) {
-      byBucketId[bucket.bucket].inclusion_reasons.push(...bucket.inclusion_reasons);
-    } else {
-      byBucketId[bucket.bucket] = structuredClone(bucket);
-    }
-  }
-
-  return Object.values(byBucketId);
-}

package/src/sync/sync.ts

@@ -1,5 +1,11 @@
 import { JSONBig, JsonContainer } from '@powersync/service-jsonbig';
-import { BucketDescription, BucketPriority, HydratedSyncRules, SqliteJsonValue } from '@powersync/service-sync-rules';
+import {
+  BucketDescription,
+  BucketPriority,
+  HydratedSyncRules,
+  ResolvedBucket,
+  SqliteJsonValue
+} from '@powersync/service-sync-rules';
 
 import { AbortError } from 'ix/aborterror.js';
 
@@ -179,7 +185,7 @@ async function* streamResponseInner(
       // receive a sync complete message after the synchronization is done (which happens in the last
       // bucketDataInBatches iteration). Without any batch, the line is missing and clients might not complete their
       // sync properly.
-      const priorityBatches: [BucketPriority | null, BucketDescription[]][] = bucketsByPriority;
+      const priorityBatches: [BucketPriority | null, ResolvedBucket[]][] = bucketsByPriority;
       if (priorityBatches.length == 0) {
         priorityBatches.push([null, []]);
       }
@@ -257,7 +263,7 @@ interface BucketDataRequest {
   /** Contains current bucket state. Modified by the request as data is sent. */
   checkpointLine: CheckpointLine;
   /** Subset of checkpointLine.bucketsToFetch, filtered by priority. */
-  bucketsToFetch: BucketDescription[];
+  bucketsToFetch: ResolvedBucket[];
   /** Whether data lines should be encoded in a legacy format where {@link util.OplogEntry.data} is a nested object. */
   legacyDataLines: boolean;
   /** Signals that the connection was aborted and that streaming should stop ASAP. */

package/src/sync/util.ts

@@ -183,6 +183,16 @@ export function settledPromise<T>(promise: Promise<T>): Promise<PromiseSettledRe
   );
 }
 
+export function unsettledPromise<T>(settled: Promise<PromiseSettledResult<T>>): Promise<T> {
+  return settled.then((result) => {
+    if (result.status === 'fulfilled') {
+      return Promise.resolve(result.value);
+    } else {
+      return Promise.reject(result.reason);
+    }
+  });
+}
+
 export type MapOrSet<T> = Map<T, any> | Set<T>;
 
 /**

package/test/src/checksum_cache.test.ts

@@ -1,7 +1,9 @@
 import { ChecksumCache, FetchChecksums, FetchPartialBucketChecksum } from '@/storage/ChecksumCache.js';
 import { addChecksums, BucketChecksum, InternalOpId, PartialChecksum } from '@/util/util-index.js';
+import { BucketDataSource } from '@powersync/service-sync-rules';
 import * as crypto from 'node:crypto';
 import { describe, expect, it } from 'vitest';
+import { removeSource } from './utils.js';
 
 /**
  * Create a deterministic BucketChecksum based on the bucket name and checkpoint for testing purposes.
@@ -67,6 +69,12 @@ describe('checksum cache', function () {
     return new ChecksumCache({ fetchChecksums: fetch });
   };
 
+  const DUMMY_SOURCE: BucketDataSource = null as any;
+
+  function removeLookupSources(lookups: FetchPartialBucketChecksum[]) {
+    return lookups.map((b) => removeSource(b));
+  }
+
   it('should handle a sequential lookups (a)', async function () {
     let lookups: FetchPartialBucketChecksum[][] = [];
     const cache = factory(async (batch) => {
@@ -74,13 +82,13 @@ describe('checksum cache', function () {
       return fetchTestChecksums(batch);
     });
 
-    expect(await cache.getChecksums(123n, ['test'])).toEqual([TEST_123]);
+    expect(await cache.getChecksums(123n, [{ bucket: 'test', source: DUMMY_SOURCE }])).toEqual([TEST_123]);
 
-    expect(await cache.getChecksums(1234n, ['test'])).toEqual([TEST_1234]);
+    expect(await cache.getChecksums(1234n, [{ bucket: 'test', source: DUMMY_SOURCE }])).toEqual([TEST_1234]);
 
-    expect(await cache.getChecksums(123n, ['test2'])).toEqual([TEST2_123]);
+    expect(await cache.getChecksums(123n, [{ bucket: 'test2', source: DUMMY_SOURCE }])).toEqual([TEST2_123]);
 
-    expect(lookups).toEqual([
+    expect(lookups.map(removeLookupSources)).toMatchObject([
       [{ bucket: 'test', end: 123n }],
       // This should use the previous lookup
       [{ bucket: 'test', start: 123n, end: 1234n }],
@@ -96,13 +104,13 @@ describe('checksum cache', function () {
       return fetchTestChecksums(batch);
     });
 
-    expect(await cache.getChecksums(123n, ['test2'])).toEqual([TEST2_123]);
+    expect(await cache.getChecksums(123n, [{ bucket: 'test2', source: DUMMY_SOURCE }])).toEqual([TEST2_123]);
 
-    expect(await cache.getChecksums(1234n, ['test'])).toEqual([TEST_1234]);
+    expect(await cache.getChecksums(1234n, [{ bucket: 'test', source: DUMMY_SOURCE }])).toEqual([TEST_1234]);
 
-    expect(await cache.getChecksums(123n, ['test'])).toEqual([TEST_123]);
+    expect(await cache.getChecksums(123n, [{ bucket: 'test', source: DUMMY_SOURCE }])).toEqual([TEST_123]);
 
-    expect(lookups).toEqual([
+    expect(lookups.map(removeLookupSources)).toEqual([
       // With this order, there is no option for a partial lookup
       [{ bucket: 'test2', end: 123n }],
       [{ bucket: 'test', end: 1234n }],
@@ -117,16 +125,16 @@ describe('checksum cache', function () {
       return fetchTestChecksums(batch);
     });
 
-    const p1 = cache.getChecksums(123n, ['test']);
-    const p2 = cache.getChecksums(1234n, ['test']);
-    const p3 = cache.getChecksums(123n, ['test2']);
+    const p1 = cache.getChecksums(123n, [{ bucket: 'test', source: DUMMY_SOURCE }]);
+    const p2 = cache.getChecksums(1234n, [{ bucket: 'test', source: DUMMY_SOURCE }]);
+    const p3 = cache.getChecksums(123n, [{ bucket: 'test2', source: DUMMY_SOURCE }]);
 
     expect(await p1).toEqual([TEST_123]);
     expect(await p2).toEqual([TEST_1234]);
     expect(await p3).toEqual([TEST2_123]);
 
     // Concurrent requests, so we can't do a partial lookup for 123 -> 1234
-    expect(lookups).toEqual([
+    expect(lookups.map(removeLookupSources)).toEqual([
       [{ bucket: 'test', end: 123n }],
       [{ bucket: 'test', end: 1234n }],
       [{ bucket: 'test2', end: 123n }]
@@ -140,15 +148,15 @@ describe('checksum cache', function () {
       return fetchTestChecksums(batch);
     });
 
-    const p1 = cache.getChecksums(123n, ['test']);
-    const p2 = cache.getChecksums(123n, ['test']);
+    const p1 = cache.getChecksums(123n, [{ bucket: 'test', source: DUMMY_SOURCE }]);
+    const p2 = cache.getChecksums(123n, [{ bucket: 'test', source: DUMMY_SOURCE }]);
 
     expect(await p1).toEqual([TEST_123]);
 
     expect(await p2).toEqual([TEST_123]);
 
     // The lookup should be deduplicated, even though it's in progress
-    expect(lookups).toEqual([[{ bucket: 'test', end: 123n }]]);
+    expect(lookups.map(removeLookupSources)).toEqual([[{ bucket: 'test', end: 123n }]]);
   });
 
   it('should handle serial + concurrent lookups', async function () {
@@ -158,15 +166,15 @@ describe('checksum cache', function () {
       return fetchTestChecksums(batch);
     });
 
-    expect(await cache.getChecksums(123n, ['test'])).toEqual([TEST_123]);
+    expect(await cache.getChecksums(123n, [{ bucket: 'test', source: DUMMY_SOURCE }])).toEqual([TEST_123]);
 
-    const p2 = cache.getChecksums(1234n, ['test']);
-    const p3 = cache.getChecksums(1234n, ['test']);
+    const p2 = cache.getChecksums(1234n, [{ bucket: 'test', source: DUMMY_SOURCE }]);
+    const p3 = cache.getChecksums(1234n, [{ bucket: 'test', source: DUMMY_SOURCE }]);
 
     expect(await p2).toEqual([TEST_1234]);
     expect(await p3).toEqual([TEST_1234]);
 
-    expect(lookups).toEqual([
+    expect(lookups.map(removeLookupSources)).toEqual([
       [{ bucket: 'test', end: 123n }],
       // This lookup is deduplicated
       [{ bucket: 'test', start: 123n, end: 1234n }]
@@ -180,9 +188,14 @@ describe('checksum cache', function () {
       return fetchTestChecksums(batch);
     });
 
-    expect(await cache.getChecksums(123n, ['test', 'test2'])).toEqual([TEST_123, TEST2_123]);
+    expect(
+      await cache.getChecksums(123n, [
+        { bucket: 'test', source: DUMMY_SOURCE },
+        { bucket: 'test2', source: DUMMY_SOURCE }
+      ])
+    ).toEqual([TEST_123, TEST2_123]);
 
-    expect(lookups).toEqual([
+    expect(lookups.map(removeLookupSources)).toEqual([
       [
         // Both lookups in the same request
         { bucket: 'test', end: 123n },
@@ -198,10 +211,15 @@ describe('checksum cache', function () {
       return fetchTestChecksums(batch);
     });
 
-    expect(await cache.getChecksums(123n, ['test'])).toEqual([TEST_123]);
-    expect(await cache.getChecksums(123n, ['test', 'test2'])).toEqual([TEST_123, TEST2_123]);
+    expect(await cache.getChecksums(123n, [{ bucket: 'test', source: DUMMY_SOURCE }])).toEqual([TEST_123]);
+    expect(
+      await cache.getChecksums(123n, [
+        { bucket: 'test', source: DUMMY_SOURCE },
+        { bucket: 'test2', source: DUMMY_SOURCE }
+      ])
+    ).toEqual([TEST_123, TEST2_123]);
 
-    expect(lookups).toEqual([
+    expect(lookups.map(removeLookupSources)).toEqual([
       // Request 1
       [{ bucket: 'test', end: 123n }],
       // Request 2
@@ -216,13 +234,19 @@ describe('checksum cache', function () {
       return fetchTestChecksums(batch);
     });
 
-    const a = cache.getChecksums(123n, ['test', 'test2']);
-    const b = cache.getChecksums(123n, ['test2', 'test3']);
+    const a = cache.getChecksums(123n, [
+      { bucket: 'test', source: DUMMY_SOURCE },
+      { bucket: 'test2', source: DUMMY_SOURCE }
+    ]);
+    const b = cache.getChecksums(123n, [
+      { bucket: 'test2', source: DUMMY_SOURCE },
+      { bucket: 'test3', source: DUMMY_SOURCE }
+    ]);
 
     expect(await a).toEqual([TEST_123, TEST2_123]);
     expect(await b).toEqual([TEST2_123, TEST3_123]);
 
-    expect(lookups).toEqual([
+    expect(lookups.map(removeLookupSources)).toEqual([
       // Request A
       [
         { bucket: 'test', end: 123n },
@@ -240,9 +264,9 @@ describe('checksum cache', function () {
       return fetchTestChecksums(batch);
     });
 
-    expect(await cache.getChecksums(123n, ['test'])).toEqual([TEST_123]);
+    expect(await cache.getChecksums(123n, [{ bucket: 'test', source: DUMMY_SOURCE }])).toEqual([TEST_123]);
 
-    expect(await cache.getChecksums(125n, ['test'])).toEqual([
+    expect(await cache.getChecksums(125n, [{ bucket: 'test', source: DUMMY_SOURCE }])).toEqual([
       {
         bucket: 'test',
         checksum: -1865121912,
@@ -250,14 +274,14 @@ describe('checksum cache', function () {
       }
     ]);
 
-    expect(await cache.getChecksums(124n, ['test'])).toEqual([
+    expect(await cache.getChecksums(124n, [{ bucket: 'test', source: DUMMY_SOURCE }])).toEqual([
       {
         bucket: 'test',
         checksum: 1887460431,
         count: 124
       }
     ]);
-    expect(lookups).toEqual([
+    expect(lookups.map(removeLookupSources)).toEqual([
       [{ bucket: 'test', end: 123n }],
       [{ bucket: 'test', start: 123n, end: 125n }],
       [{ bucket: 'test', start: 123n, end: 124n }]
@@ -275,19 +299,31 @@ describe('checksum cache', function () {
       return fetchTestChecksums(batch);
     });
 
-    const a = cache.getChecksums(123n, ['test', 'test2']);
-    const b = cache.getChecksums(123n, ['test2', 'test3']);
+    const a = cache.getChecksums(123n, [
+      { bucket: 'test', source: DUMMY_SOURCE },
+      { bucket: 'test2', source: DUMMY_SOURCE }
+    ]);
+    const b = cache.getChecksums(123n, [
+      { bucket: 'test2', source: DUMMY_SOURCE },
+      { bucket: 'test3', source: DUMMY_SOURCE }
+    ]);
 
     await expect(a).rejects.toEqual(TEST_ERROR);
     await expect(b).rejects.toEqual(TEST_ERROR);
 
-    const a2 = cache.getChecksums(123n, ['test', 'test2']);
-    const b2 = cache.getChecksums(123n, ['test2', 'test3']);
+    const a2 = cache.getChecksums(123n, [
+      { bucket: 'test', source: DUMMY_SOURCE },
+      { bucket: 'test2', source: DUMMY_SOURCE }
+    ]);
+    const b2 = cache.getChecksums(123n, [
+      { bucket: 'test2', source: DUMMY_SOURCE },
+      { bucket: 'test3', source: DUMMY_SOURCE }
+    ]);
 
     expect(await a2).toEqual([TEST_123, TEST2_123]);
     expect(await b2).toEqual([TEST2_123, TEST3_123]);
 
-    expect(lookups).toEqual([
+    expect(lookups.map(removeLookupSources)).toEqual([
       // Request A (fails)
       [
         { bucket: 'test', end: 123n },
@@ -311,11 +347,15 @@ describe('checksum cache', function () {
       return fetchTestChecksums(batch.filter((b) => b.bucket != 'test'));
     });
 
-    expect(await cache.getChecksums(123n, ['test'])).toEqual([{ bucket: 'test', checksum: 0, count: 0 }]);
-    expect(await cache.getChecksums(123n, ['test', 'test2'])).toEqual([
-      { bucket: 'test', checksum: 0, count: 0 },
-      TEST2_123
+    expect(await cache.getChecksums(123n, [{ bucket: 'test', source: DUMMY_SOURCE }])).toEqual([
+      { bucket: 'test', checksum: 0, count: 0 }
     ]);
+    expect(
+      await cache.getChecksums(123n, [
+        { bucket: 'test', source: DUMMY_SOURCE },
+        { bucket: 'test2', source: DUMMY_SOURCE }
+      ])
+    ).toEqual([{ bucket: 'test', checksum: 0, count: 0 }, TEST2_123]);
   });
 
   it('should handle missing checksums (b)', async function () {
@@ -325,8 +365,10 @@ describe('checksum cache', function () {
       return fetchTestChecksums(batch.filter((b) => b.bucket != 'test' || b.end != 123n));
     });
 
-    expect(await cache.getChecksums(123n, ['test'])).toEqual([{ bucket: 'test', checksum: 0, count: 0 }]);
-    expect(await cache.getChecksums(1234n, ['test'])).toEqual([
+    expect(await cache.getChecksums(123n, [{ bucket: 'test', source: DUMMY_SOURCE }])).toEqual([
+      { bucket: 'test', checksum: 0, count: 0 }
+    ]);
+    expect(await cache.getChecksums(1234n, [{ bucket: 'test', source: DUMMY_SOURCE }])).toEqual([
       {
         bucket: 'test',
         checksum: 1597020602,
@@ -334,7 +376,10 @@ describe('checksum cache', function () {
       }
     ]);
 
-    expect(lookups).toEqual([[{ bucket: 'test', end: 123n }], [{ bucket: 'test', start: 123n, end: 1234n }]]);
+    expect(lookups.map(removeLookupSources)).toEqual([
+      [{ bucket: 'test', end: 123n }],
+      [{ bucket: 'test', start: 123n, end: 1234n }]
+    ]);
   });
 
   it('should use maxSize', async function () {
@@ -347,8 +392,8 @@ describe('checksum cache', function () {
       maxSize: 2
     });
 
-    expect(await cache.getChecksums(123n, ['test'])).toEqual([TEST_123]);
-    expect(await cache.getChecksums(124n, ['test'])).toEqual([
+    expect(await cache.getChecksums(123n, [{ bucket: 'test', source: DUMMY_SOURCE }])).toEqual([TEST_123]);
+    expect(await cache.getChecksums(124n, [{ bucket: 'test', source: DUMMY_SOURCE }])).toEqual([
       {
         bucket: 'test',
         checksum: 1887460431,
@@ -356,30 +401,30 @@ describe('checksum cache', function () {
       }
     ]);
 
-    expect(await cache.getChecksums(125n, ['test'])).toEqual([
+    expect(await cache.getChecksums(125n, [{ bucket: 'test', source: DUMMY_SOURCE }])).toEqual([
       {
         bucket: 'test',
         checksum: -1865121912,
         count: 125
       }
     ]);
-    expect(await cache.getChecksums(126n, ['test'])).toEqual([
+    expect(await cache.getChecksums(126n, [{ bucket: 'test', source: DUMMY_SOURCE }])).toEqual([
       {
         bucket: 'test',
         checksum: -1720007310,
         count: 126
       }
     ]);
-    expect(await cache.getChecksums(124n, ['test'])).toEqual([
+    expect(await cache.getChecksums(124n, [{ bucket: 'test', source: DUMMY_SOURCE }])).toEqual([
       {
         bucket: 'test',
         checksum: 1887460431,
         count: 124
       }
     ]);
-    expect(await cache.getChecksums(123n, ['test'])).toEqual([TEST_123]);
+    expect(await cache.getChecksums(123n, [{ bucket: 'test', source: DUMMY_SOURCE }])).toEqual([TEST_123]);
 
-    expect(lookups).toEqual([
+    expect(lookups.map(removeLookupSources)).toEqual([
       [{ bucket: 'test', end: 123n }],
       [{ bucket: 'test', start: 123n, end: 124n }],
       [{ bucket: 'test', start: 124n, end: 125n }],
@@ -400,10 +445,10 @@ describe('checksum cache', function () {
       maxSize: 2
     });
 
-    const p3 = cache.getChecksums(123n, ['test3']);
-    const p4 = cache.getChecksums(123n, ['test4']);
-    const p1 = cache.getChecksums(123n, ['test']);
-    const p2 = cache.getChecksums(123n, ['test2']);
+    const p3 = cache.getChecksums(123n, [{ bucket: 'test3', source: DUMMY_SOURCE }]);
+    const p4 = cache.getChecksums(123n, [{ bucket: 'test4', source: DUMMY_SOURCE }]);
+    const p1 = cache.getChecksums(123n, [{ bucket: 'test', source: DUMMY_SOURCE }]);
+    const p2 = cache.getChecksums(123n, [{ bucket: 'test2', source: DUMMY_SOURCE }]);
 
     expect(await p1).toEqual([TEST_123]);
     expect(await p2).toEqual([TEST2_123]);
@@ -417,7 +462,7 @@ describe('checksum cache', function () {
     ]);
 
     // The lookup should be deduplicated, even though it's in progress
-    expect(lookups).toEqual([
+    expect(lookups.map(removeLookupSources)).toEqual([
       [{ bucket: 'test3', end: 123n }],
       [{ bucket: 'test4', end: 123n }],
       [{ bucket: 'test', end: 123n }],
@@ -434,7 +479,7 @@ describe('checksum cache', function () {
       return fetchTestChecksums(batch);
     });
 
-    expect(await cache.getChecksums(123n, ['test'])).toEqual([TEST_123]);
-    expect(await cache.getChecksums(1234n, ['test'])).toEqual([TEST_1234]);
+    expect(await cache.getChecksums(123n, [{ bucket: 'test', source: DUMMY_SOURCE }])).toEqual([TEST_123]);
+    expect(await cache.getChecksums(1234n, [{ bucket: 'test', source: DUMMY_SOURCE }])).toEqual([TEST_1234]);
   });
 });