@powersync/service-core 1.13.4 → 1.15.0

package/test/src/sync/BucketChecksumState.test.ts

@@ -1,16 +1,25 @@
 import {
   BucketChecksum,
   BucketChecksumState,
+  BucketChecksumStateOptions,
   BucketChecksumStateStorage,
   CHECKPOINT_INVALIDATE_ALL,
   ChecksumMap,
   InternalOpId,
+  ReplicationCheckpoint,
+  StreamingSyncRequest,
   SyncContext,
   WatchFilterEvent
 } from '@/index.js';
 import { JSONBig } from '@powersync/service-jsonbig';
-import { RequestParameters, SqliteJsonRow, ParameterLookup, SqlSyncRules } from '@powersync/service-sync-rules';
-import { describe, expect, test } from 'vitest';
+import {
+  SqliteJsonRow,
+  ParameterLookup,
+  SqlSyncRules,
+  RequestJwtPayload,
+  BucketSource
+} from '@powersync/service-sync-rules';
+import { describe, expect, test, beforeEach } from 'vitest';
 
 describe('BucketChecksumState', () => {
   // Single global[] bucket.
@@ -54,6 +63,9 @@ bucket_definitions:
     maxDataFetchConcurrency: 10
   });
 
+  const syncRequest: StreamingSyncRequest = {};
+  const tokenPayload: RequestJwtPayload = { sub: '' };
+
   test('global bucket with update', async () => {
     const storage = new MockBucketChecksumStateStorage();
     // Set intial state
@@ -61,22 +73,27 @@ bucket_definitions:
 
     const state = new BucketChecksumState({
       syncContext,
-      syncParams: new RequestParameters({ sub: '' }, {}),
-      syncRules: SYNC_RULES_GLOBAL,
+      syncRequest,
+      tokenPayload,
+      syncRules: {
+        syncRules: SYNC_RULES_GLOBAL,
+        version: 1
+      },
       bucketStorage: storage
     });
 
     const line = (await state.buildNextCheckpointLine({
-      base: { checkpoint: 1n, lsn: '1' },
+      base: storage.makeCheckpoint(1n),
       writeCheckpoint: null,
       update: CHECKPOINT_INVALIDATE_ALL
     }))!;
     line.advance();
     expect(line.checkpointLine).toEqual({
       checkpoint: {
-        buckets: [{ bucket: 'global[]', checksum: 1, count: 1, priority: 3 }],
+        buckets: [{ bucket: 'global[]', checksum: 1, count: 1, priority: 3, subscriptions: [{ default: 0 }] }],
         last_op_id: '1',
-        write_checkpoint: undefined
+        write_checkpoint: undefined,
+        streams: [{ name: 'global', is_default: true, errors: [] }]
       }
     });
     expect(line.bucketsToFetch).toEqual([
@@ -97,7 +114,7 @@ bucket_definitions:
 
     // Now we get a new line
     const line2 = (await state.buildNextCheckpointLine({
-      base: { checkpoint: 2n, lsn: '2' },
+      base: storage.makeCheckpoint(2n),
       writeCheckpoint: null,
       update: {
         updatedDataBuckets: new Set(['global[]']),
@@ -110,7 +127,7 @@ bucket_definitions:
     expect(line2.checkpointLine).toEqual({
       checkpoint_diff: {
         removed_buckets: [],
-        updated_buckets: [{ bucket: 'global[]', checksum: 2, count: 2, priority: 3 }],
+        updated_buckets: [{ bucket: 'global[]', checksum: 2, count: 2, priority: 3, subscriptions: [{ default: 0 }] }],
         last_op_id: '2',
         write_checkpoint: undefined
       }
@@ -128,24 +145,28 @@ bucket_definitions:
 
     const state = new BucketChecksumState({
       syncContext,
+      tokenPayload,
       // Client sets the initial state here
-      initialBucketPositions: [{ name: 'global[]', after: 1n }],
-      syncParams: new RequestParameters({ sub: '' }, {}),
-      syncRules: SYNC_RULES_GLOBAL,
+      syncRequest: { buckets: [{ name: 'global[]', after: '1' }] },
+      syncRules: {
+        syncRules: SYNC_RULES_GLOBAL,
+        version: 1
+      },
       bucketStorage: storage
     });
 
     const line = (await state.buildNextCheckpointLine({
-      base: { checkpoint: 1n, lsn: '1' },
+      base: storage.makeCheckpoint(1n),
       writeCheckpoint: null,
       update: CHECKPOINT_INVALIDATE_ALL
     }))!;
     line.advance();
     expect(line.checkpointLine).toEqual({
       checkpoint: {
-        buckets: [{ bucket: 'global[]', checksum: 1, count: 1, priority: 3 }],
+        buckets: [{ bucket: 'global[]', checksum: 1, count: 1, priority: 3, subscriptions: [{ default: 0 }] }],
         last_op_id: '1',
-        write_checkpoint: undefined
+        write_checkpoint: undefined,
+        streams: [{ name: 'global', is_default: true, errors: [] }]
       }
     });
     expect(line.bucketsToFetch).toEqual([
@@ -166,24 +187,29 @@ bucket_definitions:
 
     const state = new BucketChecksumState({
       syncContext,
-      syncParams: new RequestParameters({ sub: '' }, {}),
-      syncRules: SYNC_RULES_GLOBAL_TWO,
+      tokenPayload,
+      syncRequest,
+      syncRules: {
+        syncRules: SYNC_RULES_GLOBAL_TWO,
+        version: 2
+      },
       bucketStorage: storage
     });
 
     const line = (await state.buildNextCheckpointLine({
-      base: { checkpoint: 1n, lsn: '1' },
+      base: storage.makeCheckpoint(1n),
       writeCheckpoint: null,
       update: CHECKPOINT_INVALIDATE_ALL
     }))!;
     expect(line.checkpointLine).toEqual({
       checkpoint: {
         buckets: [
-          { bucket: 'global[1]', checksum: 1, count: 1, priority: 3 },
-          { bucket: 'global[2]', checksum: 1, count: 1, priority: 3 }
+          { bucket: 'global[1]', checksum: 1, count: 1, priority: 3, subscriptions: [{ default: 0 }] },
+          { bucket: 'global[2]', checksum: 1, count: 1, priority: 3, subscriptions: [{ default: 0 }] }
         ],
         last_op_id: '1',
-        write_checkpoint: undefined
+        write_checkpoint: undefined,
+        streams: [{ name: 'global', is_default: true, errors: [] }]
       }
     });
     expect(line.bucketsToFetch).toEqual([
@@ -202,7 +228,7 @@ bucket_definitions:
     storage.updateTestChecksum({ bucket: 'global[2]', checksum: 2, count: 2 });
 
     const line2 = (await state.buildNextCheckpointLine({
-      base: { checkpoint: 2n, lsn: '2' },
+      base: storage.makeCheckpoint(2n),
       writeCheckpoint: null,
       update: {
         ...CHECKPOINT_INVALIDATE_ALL,
@@ -214,8 +240,8 @@ bucket_definitions:
       checkpoint_diff: {
         removed_buckets: [],
         updated_buckets: [
-          { bucket: 'global[1]', checksum: 2, count: 2, priority: 3 },
-          { bucket: 'global[2]', checksum: 2, count: 2, priority: 3 }
+          { bucket: 'global[1]', checksum: 2, count: 2, priority: 3, subscriptions: [{ default: 0 }] },
+          { bucket: 'global[2]', checksum: 2, count: 2, priority: 3, subscriptions: [{ default: 0 }] }
         ],
         last_op_id: '2',
         write_checkpoint: undefined
@@ -231,26 +257,30 @@ bucket_definitions:
 
     const state = new BucketChecksumState({
       syncContext,
+      tokenPayload,
       // Client sets the initial state here
-      initialBucketPositions: [{ name: 'something_here[]', after: 1n }],
-      syncParams: new RequestParameters({ sub: '' }, {}),
-      syncRules: SYNC_RULES_GLOBAL,
+      syncRequest: { buckets: [{ name: 'something_here[]', after: '1' }] },
+      syncRules: {
+        syncRules: SYNC_RULES_GLOBAL,
+        version: 1
+      },
       bucketStorage: storage
     });
 
     storage.updateTestChecksum({ bucket: 'global[]', checksum: 1, count: 1 });
 
     const line = (await state.buildNextCheckpointLine({
-      base: { checkpoint: 1n, lsn: '1' },
+      base: storage.makeCheckpoint(1n),
       writeCheckpoint: null,
       update: CHECKPOINT_INVALIDATE_ALL
     }))!;
     line.advance();
     expect(line.checkpointLine).toEqual({
       checkpoint: {
-        buckets: [{ bucket: 'global[]', checksum: 1, count: 1, priority: 3 }],
+        buckets: [{ bucket: 'global[]', checksum: 1, count: 1, priority: 3, subscriptions: [{ default: 0 }] }],
         last_op_id: '1',
-        write_checkpoint: undefined
+        write_checkpoint: undefined,
+        streams: [{ name: 'global', is_default: true, errors: [] }]
       }
     });
     expect(line.bucketsToFetch).toEqual([
@@ -272,8 +302,12 @@ bucket_definitions:
 
     const state = new BucketChecksumState({
       syncContext,
-      syncParams: new RequestParameters({ sub: '' }, {}),
-      syncRules: SYNC_RULES_GLOBAL_TWO,
+      tokenPayload,
+      syncRequest,
+      syncRules: {
+        syncRules: SYNC_RULES_GLOBAL_TWO,
+        version: 1
+      },
       bucketStorage: storage
     });
 
@@ -281,7 +315,7 @@ bucket_definitions:
     // storage.filter = state.checkpointFilter;
 
     const line = await state.buildNextCheckpointLine({
-      base: { checkpoint: 1n, lsn: '1' },
+      base: storage.makeCheckpoint(1n),
       writeCheckpoint: null,
       update: CHECKPOINT_INVALIDATE_ALL
     });
@@ -293,7 +327,7 @@ bucket_definitions:
     storage.updateTestChecksum({ bucket: 'global[2]', checksum: 2, count: 2 });
 
     const line2 = (await state.buildNextCheckpointLine({
-      base: { checkpoint: 2n, lsn: '2' },
+      base: storage.makeCheckpoint(2n),
       writeCheckpoint: null,
       update: {
         ...CHECKPOINT_INVALIDATE_ALL,
@@ -309,7 +343,7 @@ bucket_definitions:
         removed_buckets: [],
         updated_buckets: [
           // This does not include global[2], since it was not invalidated.
-          { bucket: 'global[1]', checksum: 2, count: 2, priority: 3 }
+          { bucket: 'global[1]', checksum: 2, count: 2, priority: 3, subscriptions: [{ default: 0 }] }
         ],
         last_op_id: '2',
         write_checkpoint: undefined
@@ -324,8 +358,12 @@ bucket_definitions:
 
     const state = new BucketChecksumState({
       syncContext,
-      syncParams: new RequestParameters({ sub: '' }, {}),
-      syncRules: SYNC_RULES_GLOBAL_TWO,
+      tokenPayload,
+      syncRequest,
+      syncRules: {
+        syncRules: SYNC_RULES_GLOBAL_TWO,
+        version: 2
+      },
       bucketStorage: storage
     });
 
@@ -337,7 +375,7 @@ bucket_definitions:
     storage.updateTestChecksum({ bucket: 'global[2]', checksum: 1, count: 1 });
 
     const line = await state.buildNextCheckpointLine({
-      base: { checkpoint: 1n, lsn: '1' },
+      base: storage.makeCheckpoint(1n),
       writeCheckpoint: null,
       update: CHECKPOINT_INVALIDATE_ALL
     });
@@ -348,7 +386,7 @@ bucket_definitions:
     storage.updateTestChecksum({ bucket: 'global[2]', checksum: 2, count: 2 });
 
     const line2 = (await state.buildNextCheckpointLine({
-      base: { checkpoint: 2n, lsn: '2' },
+      base: storage.makeCheckpoint(2n),
       writeCheckpoint: null,
       // Invalidate the state - will re-check all buckets
       update: CHECKPOINT_INVALIDATE_ALL
@@ -357,8 +395,8 @@ bucket_definitions:
       checkpoint_diff: {
         removed_buckets: [],
         updated_buckets: [
-          { bucket: 'global[1]', checksum: 2, count: 2, priority: 3 },
-          { bucket: 'global[2]', checksum: 2, count: 2, priority: 3 }
+          { bucket: 'global[1]', checksum: 2, count: 2, priority: 3, subscriptions: [{ default: 0 }] },
+          { bucket: 'global[2]', checksum: 2, count: 2, priority: 3, subscriptions: [{ default: 0 }] }
         ],
         last_op_id: '2',
         write_checkpoint: undefined
@@ -378,13 +416,17 @@ bucket_definitions:
 
     const state = new BucketChecksumState({
       syncContext,
-      syncParams: new RequestParameters({ sub: '' }, {}),
-      syncRules: SYNC_RULES_GLOBAL_TWO,
+      tokenPayload,
+      syncRequest,
+      syncRules: {
+        syncRules: SYNC_RULES_GLOBAL_TWO,
+        version: 2
+      },
       bucketStorage: storage
     });
 
     const line = (await state.buildNextCheckpointLine({
-      base: { checkpoint: 3n, lsn: '3' },
+      base: storage.makeCheckpoint(3n),
       writeCheckpoint: null,
       update: CHECKPOINT_INVALIDATE_ALL
     }))!;
@@ -392,11 +434,12 @@ bucket_definitions:
     expect(line.checkpointLine).toEqual({
       checkpoint: {
         buckets: [
-          { bucket: 'global[1]', checksum: 3, count: 3, priority: 3 },
-          { bucket: 'global[2]', checksum: 3, count: 3, priority: 3 }
+          { bucket: 'global[1]', checksum: 3, count: 3, priority: 3, subscriptions: [{ default: 0 }] },
+          { bucket: 'global[2]', checksum: 3, count: 3, priority: 3, subscriptions: [{ default: 0 }] }
         ],
         last_op_id: '3',
-        write_checkpoint: undefined
+        write_checkpoint: undefined,
+        streams: [{ name: 'global', is_default: true, errors: [] }]
       }
     });
     expect(line.bucketsToFetch).toEqual([
@@ -426,7 +469,7 @@ bucket_definitions:
     storage.updateTestChecksum({ bucket: 'global[1]', checksum: 4, count: 4 });
 
     const line2 = (await state.buildNextCheckpointLine({
-      base: { checkpoint: 4n, lsn: '4' },
+      base: storage.makeCheckpoint(4n),
       writeCheckpoint: null,
       update: {
         ...CHECKPOINT_INVALIDATE_ALL,
@@ -443,7 +486,8 @@ bucket_definitions:
             bucket: 'global[1]',
             checksum: 4,
             count: 4,
-            priority: 3
+            priority: 3,
+            subscriptions: [{ default: 0 }]
           }
         ],
         last_op_id: '4',
@@ -479,32 +523,49 @@ bucket_definitions:
 
     const state = new BucketChecksumState({
       syncContext,
-      syncParams: new RequestParameters({ sub: 'u1' }, {}),
-      syncRules: SYNC_RULES_DYNAMIC,
+      tokenPayload: { sub: 'u1' },
+      syncRequest,
+      syncRules: {
+        syncRules: SYNC_RULES_DYNAMIC,
+        version: 1
+      },
       bucketStorage: storage
     });
 
-    storage.getParameterSets = async (
-      checkpoint: InternalOpId,
-      lookups: ParameterLookup[]
-    ): Promise<SqliteJsonRow[]> => {
-      expect(checkpoint).toEqual(1n);
-      expect(lookups).toEqual([ParameterLookup.normalized('by_project', '1', ['u1'])]);
-      return [{ id: 1 }, { id: 2 }];
-    };
-
     const line = (await state.buildNextCheckpointLine({
-      base: { checkpoint: 1n, lsn: '1' },
+      base: storage.makeCheckpoint(1n, (lookups) => {
+        expect(lookups).toEqual([ParameterLookup.normalized('by_project', '1', ['u1'])]);
+        return [{ id: 1 }, { id: 2 }];
+      }),
       writeCheckpoint: null,
       update: CHECKPOINT_INVALIDATE_ALL
     }))!;
     expect(line.checkpointLine).toEqual({
       checkpoint: {
         buckets: [
-          { bucket: 'by_project[1]', checksum: 1, count: 1, priority: 3 },
-          { bucket: 'by_project[2]', checksum: 1, count: 1, priority: 3 }
+          {
+            bucket: 'by_project[1]',
+            checksum: 1,
+            count: 1,
+            priority: 3,
+            subscriptions: [{ default: 0 }]
+          },
+          {
+            bucket: 'by_project[2]',
+            checksum: 1,
+            count: 1,
+            priority: 3,
+            subscriptions: [{ default: 0 }]
+          }
         ],
         last_op_id: '1',
+        streams: [
+          {
+            is_default: true,
+            name: 'by_project',
+            errors: []
+          }
+        ],
         write_checkpoint: undefined
       }
     });
@@ -531,18 +592,12 @@ bucket_definitions:
     line.updateBucketPosition({ bucket: 'by_project[1]', nextAfter: 1n, hasMore: false });
     line.updateBucketPosition({ bucket: 'by_project[2]', nextAfter: 1n, hasMore: false });
 
-    storage.getParameterSets = async (
-      checkpoint: InternalOpId,
-      lookups: ParameterLookup[]
-    ): Promise<SqliteJsonRow[]> => {
-      expect(checkpoint).toEqual(2n);
-      expect(lookups).toEqual([ParameterLookup.normalized('by_project', '1', ['u1'])]);
-      return [{ id: 1 }, { id: 2 }, { id: 3 }];
-    };
-
     // Now we get a new line
     const line2 = (await state.buildNextCheckpointLine({
-      base: { checkpoint: 2n, lsn: '2' },
+      base: storage.makeCheckpoint(2n, (lookups) => {
+        expect(lookups).toEqual([ParameterLookup.normalized('by_project', '1', ['u1'])]);
+        return [{ id: 1 }, { id: 2 }, { id: 3 }];
+      }),
       writeCheckpoint: null,
       update: {
         invalidateDataBuckets: false,
@@ -555,13 +610,245 @@ bucket_definitions:
     expect(line2.checkpointLine).toEqual({
       checkpoint_diff: {
         removed_buckets: [],
-        updated_buckets: [{ bucket: 'by_project[3]', checksum: 1, count: 1, priority: 3 }],
+        updated_buckets: [
+          {
+            bucket: 'by_project[3]',
+            checksum: 1,
+            count: 1,
+            priority: 3,
+            subscriptions: [{ default: 0 }]
+          }
+        ],
         last_op_id: '2',
         write_checkpoint: undefined
       }
     });
     expect(line2.getFilteredBucketPositions()).toEqual(new Map([['by_project[3]', 0n]]));
   });
+
+  describe('streams', () => {
+    let source: { -readonly [P in keyof BucketSource]: BucketSource[P] };
+    let storage: MockBucketChecksumStateStorage;
+
+    function checksumState(source: string | boolean, options?: Partial<BucketChecksumStateOptions>) {
+      if (typeof source == 'boolean') {
+        source = `
+streams:
+  stream:
+    auto_subscribe: ${source}
+    query: SELECT * FROM assets WHERE id IN ifnull(subscription.parameter('ids'), '["default"]');
+
+config:
+  edition: 2
+`;
+      }
+
+      const rules = SqlSyncRules.fromYaml(source, {
+        defaultSchema: 'public'
+      });
+
+      return new BucketChecksumState({
+        syncContext,
+        syncRequest,
+        tokenPayload,
+        syncRules: { syncRules: rules, version: 1 },
+        bucketStorage: storage,
+        ...options
+      });
+    }
+
+    beforeEach(() => {
+      storage = new MockBucketChecksumStateStorage();
+      storage.updateTestChecksum({ bucket: '1#stream|0["default"]', checksum: 1, count: 1 });
+      storage.updateTestChecksum({ bucket: '1#stream|0["a"]', checksum: 1, count: 1 });
+      storage.updateTestChecksum({ bucket: '1#stream|0["b"]', checksum: 1, count: 1 });
+    });
+
+    test('includes defaults', async () => {
+      const state = checksumState(true);
+      const line = await state.buildNextCheckpointLine({
+        base: storage.makeCheckpoint(1n),
+        writeCheckpoint: null,
+        update: CHECKPOINT_INVALIDATE_ALL
+      })!;
+      line?.advance();
+      expect(line?.checkpointLine).toEqual({
+        checkpoint: {
+          buckets: [
+            { bucket: '1#stream|0["default"]', checksum: 1, count: 1, priority: 3, subscriptions: [{ default: 0 }] }
+          ],
+          last_op_id: '1',
+          write_checkpoint: undefined,
+          streams: [{ name: 'stream', is_default: true, errors: [] }]
+        }
+      });
+    });
+
+    test('can exclude defaults', async () => {
+      const state = checksumState(true, { syncRequest: { streams: { include_defaults: false, subscriptions: [] } } });
+
+      const line = await state.buildNextCheckpointLine({
+        base: storage.makeCheckpoint(1n),
+        writeCheckpoint: null,
+        update: CHECKPOINT_INVALIDATE_ALL
+      })!;
+      line?.advance();
+      expect(line?.checkpointLine).toEqual({
+        checkpoint: {
+          buckets: [],
+          last_op_id: '1',
+          write_checkpoint: undefined,
+          streams: []
+        }
+      });
+    });
+
+    test('custom subscriptions', async () => {
+      const state = checksumState(true, {
+        syncRequest: {
+          streams: {
+            subscriptions: [
+              { stream: 'stream', parameters: { ids: '["a"]' }, override_priority: null },
+              { stream: 'stream', parameters: { ids: '["b"]' }, override_priority: 1 }
+            ]
+          }
+        }
+      });
+
+      const line = await state.buildNextCheckpointLine({
+        base: storage.makeCheckpoint(1n),
+        writeCheckpoint: null,
+        update: CHECKPOINT_INVALIDATE_ALL
+      })!;
+      line?.advance();
+      expect(line?.checkpointLine).toEqual({
+        checkpoint: {
+          buckets: [
+            { bucket: '1#stream|0["a"]', checksum: 1, count: 1, priority: 3, subscriptions: [{ sub: 0 }] },
+            { bucket: '1#stream|0["b"]', checksum: 1, count: 1, priority: 1, subscriptions: [{ sub: 1 }] },
+            { bucket: '1#stream|0["default"]', checksum: 1, count: 1, priority: 3, subscriptions: [{ default: 0 }] }
+          ],
+          last_op_id: '1',
+          write_checkpoint: undefined,
+          streams: [{ name: 'stream', is_default: true, errors: [] }]
+        }
+      });
+    });
+
+    test('overlap between custom subscriptions', async () => {
+      const state = checksumState(false, {
+        syncRequest: {
+          streams: {
+            subscriptions: [
+              { stream: 'stream', parameters: { ids: '["a", "b"]' }, override_priority: null },
+              { stream: 'stream', parameters: { ids: '["b"]' }, override_priority: 1 }
+            ]
+          }
+        }
+      });
+
+      const line = await state.buildNextCheckpointLine({
+        base: storage.makeCheckpoint(1n),
+        writeCheckpoint: null,
+        update: CHECKPOINT_INVALIDATE_ALL
+      })!;
+      line?.advance();
+      expect(line?.checkpointLine).toEqual({
+        checkpoint: {
+          buckets: [
+            { bucket: '1#stream|0["a"]', checksum: 1, count: 1, priority: 3, subscriptions: [{ sub: 0 }] },
+            { bucket: '1#stream|0["b"]', checksum: 1, count: 1, priority: 1, subscriptions: [{ sub: 0 }, { sub: 1 }] }
+          ],
+          last_op_id: '1',
+          write_checkpoint: undefined,
+          streams: [{ name: 'stream', is_default: false, errors: [] }]
+        }
+      });
+    });
+
+    test('overlap between default and custom subscription', async () => {
+      const state = checksumState(true, {
+        syncRequest: {
+          streams: {
+            subscriptions: [{ stream: 'stream', parameters: { ids: '["a", "default"]' }, override_priority: 1 }]
+          }
+        }
+      });
+
+      const line = await state.buildNextCheckpointLine({
+        base: storage.makeCheckpoint(1n),
+        writeCheckpoint: null,
+        update: CHECKPOINT_INVALIDATE_ALL
+      })!;
+      line?.advance();
+      expect(line?.checkpointLine).toEqual({
+        checkpoint: {
+          buckets: [
+            { bucket: '1#stream|0["a"]', checksum: 1, count: 1, priority: 1, subscriptions: [{ sub: 0 }] },
+            {
+              bucket: '1#stream|0["default"]',
+              checksum: 1,
+              count: 1,
+              priority: 1,
+              subscriptions: [{ sub: 0 }, { default: 0 }]
+            }
+          ],
+          last_op_id: '1',
+          write_checkpoint: undefined,
+          streams: [{ name: 'stream', is_default: true, errors: [] }]
+        }
+      });
+    });
+
+    test('reports errors', async () => {
+      const state = checksumState(true, {
+        syncRequest: {
+          streams: {
+            subscriptions: [
+              { stream: 'stream', parameters: { ids: '["a", "b"]' }, override_priority: 1 },
+              { stream: 'stream', parameters: { ids: 'invalid json' }, override_priority: null }
+            ]
+          }
+        }
+      });
+
+      const line = await state.buildNextCheckpointLine({
+        base: storage.makeCheckpoint(1n),
+        writeCheckpoint: null,
+        update: CHECKPOINT_INVALIDATE_ALL
+      })!;
+      line?.advance();
+      expect(line?.checkpointLine).toEqual({
+        checkpoint: {
+          buckets: [
+            { bucket: '1#stream|0["a"]', checksum: 1, count: 1, priority: 1, subscriptions: [{ sub: 0 }] },
+            { bucket: '1#stream|0["b"]', checksum: 1, count: 1, priority: 1, subscriptions: [{ sub: 0 }] },
+            {
+              bucket: '1#stream|0["default"]',
+              checksum: 1,
+              count: 1,
+              priority: 3,
+              subscriptions: [{ default: 0 }]
+            }
+          ],
+          last_op_id: '1',
+          write_checkpoint: undefined,
+          streams: [
+            {
+              name: 'stream',
+              is_default: true,
+              errors: [
+                {
+                  message: 'Error evaluating bucket ids: Unexpected token \'i\', "invalid json" is not valid JSON',
+                  subscription: 1
+                }
+              ]
+            }
+          ]
+        }
+      });
+    });
+  });
 });
 
 class MockBucketChecksumStateStorage implements BucketChecksumStateStorage {
@@ -595,7 +882,19 @@ class MockBucketChecksumStateStorage implements BucketChecksumStateStorage {
     );
   }
 
-  async getParameterSets(checkpoint: InternalOpId, lookups: ParameterLookup[]): Promise<SqliteJsonRow[]> {
-    throw new Error('Method not implemented.');
+  makeCheckpoint(
+    opId: InternalOpId,
+    parameters?: (lookups: ParameterLookup[]) => SqliteJsonRow[]
+  ): ReplicationCheckpoint {
+    return {
+      checkpoint: opId,
+      lsn: String(opId),
+      getParameterSets: async (lookups: ParameterLookup[]) => {
+        if (parameters == null) {
+          throw new Error(`getParametersSets not defined for checkpoint ${opId}`);
+        }
+        return parameters(lookups);
+      }
+    };
   }
 }