@powersync/service-core 1.19.2 → 1.20.1

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]);
   });
 });

package/test/src/config.test.ts

@@ -69,6 +69,7 @@ describe('Config', () => {
 
     expect(config.api_parameters.max_buckets_per_connection).toBe(1);
   });
+
   it('should throw YAML validation error for invalid base64 config', {}, async () => {
     const yamlConfig = /* yaml */ `
       # PowerSync config
@@ -86,4 +87,118 @@ describe('Config', () => {
       })
     ).rejects.toThrow(/YAML Error:[\s\S]*Attempting to substitute environment variable INVALID_VAR/);
   });
+
+  it('should resolve inline sync config', async () => {
+    const yamlConfig = /* yaml */ `
+      # PowerSync config
+      replication:
+        connections: []
+      storage:
+        type: mongodb
+      sync_config:
+        content: |
+          config:
+            edition: 2
+          streams:
+            a:
+              query: SELECT * FROM users
+    `;
+
+    const collector = new CompoundConfigCollector();
+
+    const result = await collector.collectConfig({
+      config_base64: Buffer.from(yamlConfig, 'utf-8').toString('base64')
+    });
+
+    expect(result.sync_rules).toEqual({
+      present: true,
+      exit_on_error: true,
+      content: expect.stringContaining('edition: 2')
+    });
+  });
+
+  it('should still resolve inline sync rules', async () => {
+    const yamlConfig = /* yaml */ `
+      # PowerSync config
+      replication:
+        connections: []
+      storage:
+        type: mongodb
+      sync_rules:
+        content: |
+          config:
+            edition: 2
+          streams:
+            a:
+              query: SELECT * FROM users
+    `;
+
+    const collector = new CompoundConfigCollector();
+
+    const result = await collector.collectConfig({
+      config_base64: Buffer.from(yamlConfig, 'utf-8').toString('base64')
+    });
+
+    expect(result.sync_rules).toEqual({
+      present: true,
+      exit_on_error: true,
+      content: expect.stringContaining('edition: 2')
+    });
+  });
+
+  it('should resolve base64 sync config', async () => {
+    const yamlConfig = /* yaml */ `
+      # PowerSync config
+      replication:
+        connections: []
+      storage:
+        type: mongodb
+    `;
+    const yamlSyncConfig = /* yaml */ `
+      config:
+        edition: 2
+      streams:
+        a:
+          query: SELECT * FROM users
+    `;
+
+    const collector = new CompoundConfigCollector();
+
+    const result = await collector.collectConfig({
+      config_base64: Buffer.from(yamlConfig, 'utf-8').toString('base64'),
+      sync_config_base64: Buffer.from(yamlSyncConfig, 'utf-8').toString('base64')
+    });
+
+    expect(result.sync_rules).toEqual({
+      present: true,
+      exit_on_error: true,
+      content: expect.stringContaining('edition: 2')
+    });
+  });
+
+  it('should not allow both sync_config and sync_rules', async () => {
+    const yamlConfig = /* yaml */ `
+      # PowerSync config
+      replication:
+        connections: []
+      storage:
+        type: mongodb
+      sync_config:
+        content: |
+          config:
+            edition: 2
+      sync_rules:
+        content: |
+          config:
+            edition: 2
+    `;
+
+    const collector = new CompoundConfigCollector();
+
+    await expect(
+      collector.collectConfig({
+        config_base64: Buffer.from(yamlConfig, 'utf-8').toString('base64')
+      })
+    ).rejects.toThrow(/Both `sync_config` and `sync_rules` are present/);
+  });
 });

package/test/src/routes/admin.test.ts

@@ -0,0 +1,48 @@
+import { BasicRouterRequest, Context, JwtPayload } from '@/index.js';
+import { logger } from '@powersync/lib-services-framework';
+import { describe, expect, it } from 'vitest';
+import { validate } from '../../../src/routes/endpoints/admin.js';
+import { mockServiceContext } from './mocks.js';
+
+describe('admin routes', () => {
+  describe('validate', () => {
+    it('reports errors with source location', async () => {
+      const context: Context = {
+        logger: logger,
+        service_context: mockServiceContext(null),
+        token_payload: new JwtPayload({
+          sub: '',
+          exp: 0,
+          iat: 0
+        })
+      };
+
+      const request: BasicRouterRequest = {
+        headers: {},
+        hostname: '',
+        protocol: 'http'
+      };
+
+      const response = await validate.handler({
+        context,
+        params: {
+          sync_rules: `
+bucket_definitions:
+  missing_table:
+    data:
+      - SELECT * FROM missing_table
+`
+        },
+        request
+      });
+
+      expect(response.errors).toEqual([
+        expect.objectContaining({
+          level: 'warning',
+          location: { start_offset: 70, end_offset: 83 },
+          message: 'Table public.missing_table not found'
+        })
+      ]);
+    });
+  });
+});

package/test/src/routes/mocks.ts

@@ -41,8 +41,29 @@ export function mockServiceContext(storage: Partial<SyncRulesBucketStorage> | nu
         return {
           getParseSyncRulesOptions() {
             return { defaultSchema: 'public' };
+          },
+          async getSourceConfig() {
+            return {
+              tag: 'test_tag',
+              id: 'test_id',
+              type: 'test_type'
+            };
+          },
+          async getConnectionSchema() {
+            return [];
+          },
+          async getConnectionStatus() {
+            return {
+              id: 'test_id',
+              uri: 'http://example.org/',
+              connected: true,
+              errors: []
+            };
+          },
+          async getDebugTablesInfo() {
+            return [];
           }
-        } as Partial<RouteAPI>;
+        } satisfies Partial<RouteAPI> as unknown as RouteAPI;
       },
       addStopHandler() {
         return () => {};

package/test/src/routes/stream.test.ts

@@ -8,6 +8,7 @@ import winston from 'winston';
 import { syncStreamed } from '../../../src/routes/endpoints/sync-stream.js';
 import { DEFAULT_PARAM_LOGGING_FORMAT_OPTIONS, limitParamsForLogging } from '../../../src/util/param-logging.js';
 import { mockServiceContext } from './mocks.js';
+import { DEFAULT_HYDRATION_STATE } from '@powersync/service-sync-rules';
 
 describe('Stream Route', () => {
   describe('compressed stream', () => {
@@ -45,7 +46,7 @@ describe('Stream Route', () => {
 
       const storage = {
         getParsedSyncRules() {
-          return new SqlSyncRules('bucket_definitions: {}').hydrate();
+          return new SqlSyncRules('bucket_definitions: {}').hydrate({ hydrationState: DEFAULT_HYDRATION_STATE });
         },
         watchCheckpointChanges: async function* (options) {
           throw new Error('Simulated storage error');
@@ -83,7 +84,7 @@ describe('Stream Route', () => {
     it('logs the application metadata', async () => {
       const storage = {
         getParsedSyncRules() {
-          return new SqlSyncRules('bucket_definitions: {}').hydrate();
+          return new SqlSyncRules('bucket_definitions: {}').hydrate({ hydrationState: DEFAULT_HYDRATION_STATE });
         },
         watchCheckpointChanges: async function* (options) {
           throw new Error('Simulated storage error');