@powersync/service-core 1.20.5 → 1.22.0

package/src/util/env.ts

@@ -13,7 +13,7 @@ export const env = utils.collectEnvironmentVariables({
   POWERSYNC_CONFIG_B64: utils.type.string.optional(),
   /**
    * @deprecated use POWERSYNC_SYNC_CONFIG_B64 instead.
-   * Base64 encoded contents of sync rules YAML
+   * Base64 encoded contents of sync config YAML
    */
   POWERSYNC_SYNC_RULES_B64: utils.type.string.optional(),
   /**

package/src/util/protocol-types.ts

@@ -77,7 +77,7 @@ export const StreamingSyncRequest = t.object({
   raw_data: t.boolean.optional(),
 
   /**
-   * Client parameters to be passed to the sync rules.
+   * Client parameters to be passed to the sync config.
    */
   parameters: t.record(t.any).optional(),
 

package/src/util/util-index.ts

@@ -17,6 +17,7 @@ export * from './config/collectors/config-collector.js';
 export * from './config/collectors/impl/base64-config-collector.js';
 export * from './config/collectors/impl/fallback-config-collector.js';
 export * from './config/collectors/impl/filesystem-config-collector.js';
+export * from './config/collectors/impl/yaml-env.js';
 
 export * from './config/sync-rules/impl/base64-sync-rules-collector.js';
 export * from './config/sync-rules/impl/filesystem-sync-rules-collector.js';

package/src/util/utils.ts

@@ -39,6 +39,14 @@ export function escapeIdentifier(identifier: string) {
   return `"${identifier.replace(/"/g, '""').replace(/\./g, '"."')}"`;
 }
 
+/**
+ *  Sanitized name of the entity in the format of "{schema}.{entity name}"
+ *  Suitable for safe use in Postgres queries and in log output.
+ */
+export function qualifiedName(ref: sync_rules.SourceTableRef) {
+  return `${escapeIdentifier(ref.schema)}.${escapeIdentifier(ref.name)}`;
+}
+
 export function hashData(type: string, id: string, data: string): number {
   const hash = crypto.createHash('sha256');
   hash.update(`put.${type}.${id}.${data}`);

package/test/src/auth.test.ts

@@ -1,9 +1,17 @@
 import { StaticSupabaseKeyCollector } from '@/index.js';
+import { configFile } from '@powersync/service-types';
 import * as jose from 'jose';
 import { describe, expect, test } from 'vitest';
 import { CachedKeyCollector } from '../../src/auth/CachedKeyCollector.js';
 import { KeyResult } from '../../src/auth/KeyCollector.js';
-import { KeySpec } from '../../src/auth/KeySpec.js';
+import {
+  EC_ALGORITHMS,
+  HS_ALGORITHMS,
+  KeySpec,
+  OKP_ALGORITHMS,
+  RSA_ALGORITHMS,
+  SUPPORTED_ALGORITHMS
+} from '../../src/auth/KeySpec.js';
 import { KeyStore } from '../../src/auth/KeyStore.js';
 import { RemoteJWKSCollector } from '../../src/auth/RemoteJWKSCollector.js';
 import { StaticKeyCollector } from '../../src/auth/StaticKeyCollector.js';
@@ -52,6 +60,47 @@ const privateKeyECDSA: jose.JWK = {
   alg: 'ES256'
 };
 
+const EC_ALGORITHM_CURVES = [
+  ['ES256', 'P-256'],
+  ['ES384', 'P-384'],
+  ['ES512', 'P-521']
+] satisfies [string, string][];
+
+const EDDSA_CURVES = ['Ed25519', 'Ed448'];
+
+function roundTripJwkThroughPowerSyncConfig(key: jose.JWK): jose.JWK {
+  const encoded = configFile.strictJwks.encode({
+    keys: [key as configFile.StrictJwk]
+  });
+
+  const decoded = configFile.strictJwks.decode(encoded);
+  return decoded.keys[0] as jose.JWK;
+}
+
+async function signAndVerifyWithKey(alg: string, key: jose.JWK, signKey: jose.KeyLike | Uint8Array) {
+  const parsedKey = roundTripJwkThroughPowerSyncConfig(key);
+  expect(parsedKey).toEqual(key);
+
+  const keys = await StaticKeyCollector.importKeys([parsedKey]);
+  const store = new KeyStore(keys);
+
+  const signedJwt = await new jose.SignJWT({ claim: alg })
+    .setProtectedHeader({ alg, kid: key.kid })
+    .setSubject('f1')
+    .setIssuedAt()
+    .setIssuer('tester')
+    .setAudience('tests')
+    .setExpirationTime('5m')
+    .sign(signKey);
+
+  const verified = await store.verifyJwt(signedJwt, {
+    defaultAudiences: ['tests'],
+    maxAge: '6m'
+  });
+
+  expect(verified.parsedPayload.claim).toEqual(alg);
+}
+
 describe('JWT Auth', () => {
   test('KeyStore basics', async () => {
     const keys = await StaticKeyCollector.importKeys([sharedKey]);
@@ -208,6 +257,65 @@ describe('JWT Auth', () => {
     ).rejects.toThrow('Unexpected token algorithm HS256');
   });
 
+  describe('supported JWT algorithms', () => {
+    test('covers every declared supported algorithm', () => {
+      const testedAlgorithms = new Set([
+        ...HS_ALGORITHMS,
+        ...RSA_ALGORITHMS,
+        ...EC_ALGORITHM_CURVES.map(([alg]) => alg),
+        ...OKP_ALGORITHMS
+      ]);
+
+      expect([...testedAlgorithms].sort()).toEqual([...SUPPORTED_ALGORITHMS].sort());
+    });
+
+    test.each(HS_ALGORITHMS)('verifies %s tokens', async (alg) => {
+      const secret = await jose.generateSecret(alg);
+      const key = await jose.exportJWK(secret);
+      key.kid = `test-${alg}`;
+      key.alg = alg;
+
+      await signAndVerifyWithKey(alg, key, secret);
+    });
+
+    test.each(RSA_ALGORITHMS)('verifies %s tokens', async (alg) => {
+      const { privateKey, publicKey } = await jose.generateKeyPair(alg);
+      const key = await jose.exportJWK(publicKey);
+      key.kid = `test-${alg}`;
+      key.alg = alg;
+      key.use = 'sig';
+
+      await signAndVerifyWithKey(alg, key, privateKey);
+    });
+
+    test.each(EC_ALGORITHM_CURVES)('verifies %s tokens with curve %s', async (alg, crv) => {
+      expect(EC_ALGORITHMS).toContain(alg);
+
+      const { privateKey, publicKey } = await jose.generateKeyPair(alg);
+      const key = await jose.exportJWK(publicKey);
+      key.kid = `test-${alg}`;
+      key.alg = alg;
+      key.use = 'sig';
+
+      expect(key.crv).toEqual(crv);
+      await signAndVerifyWithKey(alg, key, privateKey);
+    });
+
+    test.each(EDDSA_CURVES)('verifies EdDSA tokens with curve %s', async (crv) => {
+      const alg = 'EdDSA';
+      expect(OKP_ALGORITHMS).toContain(alg);
+
+      const { privateKey, publicKey } = await jose.generateKeyPair(alg, { crv });
+      const key = await jose.exportJWK(publicKey);
+      key.kid = `test-${alg}-${crv}`;
+      key.alg = alg;
+      key.use = 'sig';
+
+      expect(key.crv).toEqual(crv);
+      await signAndVerifyWithKey(alg, key, privateKey);
+    });
+  });
+
   test('key selection for key with kid', async () => {
     const keys = await StaticKeyCollector.importKeys([publicKeyRSA, sharedKey, sharedKey2]);
     const store = new KeyStore(keys);
@@ -376,6 +484,17 @@ describe('JWT Auth', () => {
           }
         })
     ).toThrowError('IPs in this range are not supported');
+
+    // `URL.hostname` exposes IPv6 literals wrapped in brackets; ensure they are
+    // handled like other direct-IP cases.
+    expect(
+      () =>
+        new RemoteJWKSCollector('https://[::1]/.well-known/jwks.json', {
+          lookupOptions: {
+            reject_ip_ranges: ['local']
+          }
+        })
+    ).toThrowError('IPs in this range are not supported');
   });
 
   test('http not blocking local IPs', async () => {

package/test/src/diagnostics.test.ts

@@ -0,0 +1,155 @@
+import { DiagnosticsOptions, getSyncRulesStatus } from '@/api/diagnostics.js';
+import { RouteAPI, SlotWalBudgetInfo } from '@/api/RouteAPI.js';
+import { BucketStorageFactory, PersistedSyncRules, storage } from '@/index.js';
+import { SqlSyncRules } from '@powersync/service-sync-rules';
+import { describe, expect, test } from 'vitest';
+
+const GB = 1024 * 1024 * 1024;
+
+const MINIMAL_SYNC_RULES = `
+bucket_definitions:
+  global:
+    data:
+      - SELECT id FROM test_table
+`;
+
+function makeSyncRulesContent(overrides?: { slot_name?: string }): storage.PersistedSyncRulesContent {
+  // We don't implement the entire interface correctly here - just enough to test the diagnostics logic.
+  return {
+    id: 1,
+    slot_name: overrides?.slot_name ?? 'test_slot',
+    sync_rules_content: MINIMAL_SYNC_RULES,
+    compiled_plan: null,
+    active: true,
+    storageVersion: 1,
+    last_checkpoint_lsn: 'some_lsn',
+    last_fatal_error: null,
+    last_fatal_error_ts: null,
+    last_keepalive_ts: new Date(),
+    last_checkpoint_ts: new Date(),
+    parsed(options?: any) {
+      const syncRules = SqlSyncRules.fromYaml(MINIMAL_SYNC_RULES, {
+        ...options,
+        defaultSchema: 'public'
+      });
+      return {
+        syncConfigWithErrors: syncRules
+      } as PersistedSyncRules;
+    },
+    lock() {
+      throw new Error('Not implemented in mock');
+    },
+    current_lock: null,
+    logger: null as any,
+    asUpdateOptions: null as any,
+    getStorageConfig: null as any
+  } as storage.PersistedSyncRulesContent;
+}
+
+function makeBucketStorage() {
+  return {
+    getInstance() {
+      return {
+        async getStatus() {
+          return {
+            snapshot_done: true,
+            checkpoint_lsn: 'some_lsn',
+            active: true
+          };
+        }
+      };
+    }
+  } as unknown as BucketStorageFactory;
+}
+
+function makeRouteAPI(walBudget?: SlotWalBudgetInfo | undefined): RouteAPI {
+  return {
+    getParseSyncRulesOptions() {
+      return { defaultSchema: 'public' };
+    },
+    async getSourceConfig() {
+      return { tag: 'test', id: 'test', type: 'postgresql' };
+    },
+    async getConnectionStatus() {
+      return { connected: true };
+    },
+    async getDebugTablesInfo() {
+      return [];
+    },
+    async getReplicationLagBytes() {
+      return 0;
+    },
+    ...(walBudget !== undefined
+      ? {
+          async getSlotWalBudget() {
+            return walBudget;
+          }
+        }
+      : {})
+  } as unknown as RouteAPI;
+}
+
+const OPTIONS: DiagnosticsOptions = {
+  live_status: true,
+  check_connection: true,
+  include_content: false
+};
+
+describe('getSyncRulesStatus WAL budget warnings', () => {
+  test('warns when WAL budget is at 40%', async () => {
+    const api = makeRouteAPI({
+      wal_status: 'extended',
+      safe_wal_size: 4 * GB,
+      max_slot_wal_keep_size: 10 * GB
+    });
+    const result = await getSyncRulesStatus(makeBucketStorage(), api, makeSyncRulesContent(), OPTIONS);
+    const walWarnings = result!.errors.filter((e) => e.message.includes('WAL budget'));
+    expect(walWarnings).toHaveLength(1);
+    expect(walWarnings[0].level).toBe('warning');
+    expect(walWarnings[0].message).toContain('40%');
+  });
+
+  test('no warning when WAL budget is at 80%', async () => {
+    const api = makeRouteAPI({
+      wal_status: 'reserved',
+      safe_wal_size: 8 * GB,
+      max_slot_wal_keep_size: 10 * GB
+    });
+    const result = await getSyncRulesStatus(makeBucketStorage(), api, makeSyncRulesContent(), OPTIONS);
+    const walWarnings = result!.errors.filter((e) => e.message.includes('WAL budget'));
+    expect(walWarnings).toHaveLength(0);
+  });
+
+  test('clamps negative safe_wal_size to 0%', async () => {
+    const api = makeRouteAPI({
+      wal_status: 'unreserved',
+      safe_wal_size: -2.4 * GB,
+      max_slot_wal_keep_size: 1 * 1024 * 1024 // 1MB
+    });
+    const result = await getSyncRulesStatus(makeBucketStorage(), api, makeSyncRulesContent(), OPTIONS);
+    const walWarnings = result!.errors.filter((e) => e.message.includes('WAL budget'));
+    expect(walWarnings).toHaveLength(1);
+    expect(walWarnings[0].message).toContain('0%');
+    expect(walWarnings[0].message).not.toMatch(/-\d+%/);
+  });
+
+  test('no WAL budget error when slot status is lost', async () => {
+    const api = makeRouteAPI({
+      wal_status: 'lost'
+    });
+    const result = await getSyncRulesStatus(makeBucketStorage(), api, makeSyncRulesContent(), OPTIONS);
+    const walErrors = result!.errors.filter(
+      (e) => e.message.includes('WAL budget') || e.message.includes('PSYNC_S1146')
+    );
+    expect(walErrors).toHaveLength(0);
+  });
+
+  test('no WAL error when getSlotWalBudget is not defined', async () => {
+    const api = makeRouteAPI();
+    const result = await getSyncRulesStatus(makeBucketStorage(), api, makeSyncRulesContent(), OPTIONS);
+    const walErrors = result!.errors.filter(
+      (e) => e.message.includes('WAL budget') || e.message.includes('PSYNC_S1146')
+    );
+    expect(walErrors).toHaveLength(0);
+  });
+});

package/test/src/routes/error-handler.integration.test.ts

@@ -0,0 +1,275 @@
+import { errors } from '@powersync/lib-services-framework';
+import Fastify, { FastifyInstance } from 'fastify';
+import { Readable } from 'node:stream';
+import * as zlib from 'node:zlib';
+import { afterEach, beforeEach, describe, expect, it } from 'vitest';
+import { registerFastifyErrorHandler } from '../../../src/routes/route-register.js';
+
+describe('Fastify error handler', () => {
+  let app: FastifyInstance;
+
+  beforeEach(() => {
+    app = Fastify();
+    registerFastifyErrorHandler(app);
+  });
+
+  afterEach(async () => {
+    await app.close();
+  });
+
+  describe('errors thrown in route before sending a response', () => {
+    it('returns a JSON error body with no content-encoding when none was set', async () => {
+      app.get('/boom', async () => {
+        throw new errors.ServiceError({
+          status: 503,
+          code: 'PSYNC_S2003' as any,
+          description: 'Service unavailable'
+        });
+      });
+      await app.ready();
+
+      const response = await app.inject({ method: 'GET', url: '/boom' });
+
+      expect(response.statusCode).toBe(503);
+      expect(response.headers['content-type']).toMatch(/application\/json/);
+      expect(response.headers['content-encoding']).toBeUndefined();
+      expect(JSON.parse(response.payload)).toMatchObject({
+        error: { code: 'PSYNC_S2003', status: 503 }
+      });
+    });
+
+    it('gzip-encodes the error body when content-encoding=gzip was set before the throw', async () => {
+      app.get('/boom', async (_request, reply) => {
+        reply.header('content-encoding', 'gzip');
+        throw new Error('kaboom');
+      });
+      await app.ready();
+
+      const response = await app.inject({ method: 'GET', url: '/boom' });
+
+      expect(response.statusCode).toBe(500);
+      expect(response.headers['content-encoding']).toBe('gzip');
+      const decoded = zlib.gunzipSync(response.rawPayload).toString('utf8');
+      expect(JSON.parse(decoded).error.code).toBe('PSYNC_S2001');
+    });
+
+    it('zstd-encodes the error body when content-encoding=zstd was set before the throw', async () => {
+      app.get('/boom', async (_request, reply) => {
+        reply.header('content-encoding', 'zstd');
+        throw new Error('kaboom');
+      });
+      await app.ready();
+
+      const response = await app.inject({ method: 'GET', url: '/boom' });
+
+      expect(response.statusCode).toBe(500);
+      expect(response.headers['content-encoding']).toBe('zstd');
+      const decoded = zlib.zstdDecompressSync(response.rawPayload).toString('utf8');
+      expect(JSON.parse(decoded).error.code).toBe('PSYNC_S2001');
+    });
+  });
+
+  describe('errors after responding with a stream, before any data is sent', () => {
+    it('still returns a JSON error response with no encoding', async () => {
+      app.get('/stream', async (_request, reply) => {
+        const stream = new Readable({
+          read() {
+            process.nextTick(() => this.destroy(new Error('pre-data failure')));
+          }
+        });
+        reply.header('content-type', 'application/x-ndjson');
+        return reply.send(stream);
+      });
+      await app.ready();
+
+      const response = await app.inject({ method: 'GET', url: '/stream' });
+
+      expect(response.statusCode).toBe(500);
+      expect(response.headers['content-encoding']).toBeUndefined();
+      expect(response.headers['content-type']).toMatch(/application\/json/);
+      expect(JSON.parse(response.payload).error.code).toBe('PSYNC_S2001');
+    });
+
+    it('still returns a gzip-encoded JSON error response when encoding was set first', async () => {
+      app.get('/stream', async (_request, reply) => {
+        reply.header('content-encoding', 'gzip');
+        reply.header('content-type', 'application/x-ndjson');
+        const stream = new Readable({
+          read() {
+            process.nextTick(() => this.destroy(new Error('pre-data failure')));
+          }
+        });
+        return reply.send(stream);
+      });
+      await app.ready();
+
+      const response = await app.inject({ method: 'GET', url: '/stream' });
+
+      expect(response.statusCode).toBe(500);
+      expect(response.headers['content-encoding']).toBe('gzip');
+      const decoded = zlib.gunzipSync(response.rawPayload).toString('utf8');
+      expect(JSON.parse(decoded).error.code).toBe('PSYNC_S2001');
+    });
+  });
+
+  describe('errors after a stream has sent data', () => {
+    it('lets fastify tear the response down without raising an uncaught exception', async () => {
+      app.get('/stream', async (_request, reply) => {
+        let chunks = 0;
+        const stream = new Readable({
+          read() {
+            if (chunks++ === 0) {
+              this.push('first chunk\n');
+            } else {
+              this.destroy(new Error('mid-stream failure'));
+            }
+          }
+        });
+        reply.header('content-type', 'application/x-ndjson');
+        return reply.send(stream);
+      });
+      await app.ready();
+
+      const uncaught: Error[] = [];
+      const onUncaught = (err: Error) => uncaught.push(err);
+      const onUnhandled = (err: any) => uncaught.push(err);
+      process.on('uncaughtException', onUncaught);
+      process.on('unhandledRejection', onUnhandled);
+
+      try {
+        await expect(app.inject({ method: 'GET', url: '/stream' })).rejects.toThrow(/destroyed/);
+        await new Promise((resolve) => setImmediate(resolve));
+      } finally {
+        process.off('uncaughtException', onUncaught);
+        process.off('unhandledRejection', onUnhandled);
+      }
+
+      expect(uncaught).toEqual([]);
+    });
+  });
+
+  describe('handler inheritance into child scopes', () => {
+    it('handles errors thrown in routes registered inside a child scope', async () => {
+      await app.register(async (child) => {
+        child.get('/boom', async () => {
+          throw new Error('child scope failure');
+        });
+      });
+      await app.ready();
+
+      const response = await app.inject({ method: 'GET', url: '/boom' });
+
+      expect(response.statusCode).toBe(500);
+      expect(response.headers['content-type']).toMatch(/application\/json/);
+      const body = JSON.parse(response.payload);
+      expect(body.error?.code).toBe('PSYNC_S2001');
+    });
+  });
+
+  describe('built-in Fastify errors', () => {
+    it('preserves the 400 status code for an invalid JSON body', async () => {
+      app.post('/echo', async (request) => ({ received: request.body }));
+      await app.ready();
+
+      const response = await app.inject({
+        method: 'POST',
+        url: '/echo',
+        headers: { 'content-type': 'application/json' },
+        payload: '{ not json'
+      });
+
+      expect(response.statusCode).toBe(400);
+      const body = JSON.parse(response.payload);
+      expect(body.error.status).toBe(400);
+      expect(body.error.code).toBe('FST_ERR_CTP_INVALID_JSON_BODY');
+    });
+
+    it('preserves the 400 status code for an empty JSON body', async () => {
+      app.post('/echo', async (request) => ({ received: request.body }));
+      await app.ready();
+
+      const response = await app.inject({
+        method: 'POST',
+        url: '/echo',
+        headers: { 'content-type': 'application/json' },
+        payload: ''
+      });
+
+      expect(response.statusCode).toBe(400);
+      const body = JSON.parse(response.payload);
+      expect(body.error.status).toBe(400);
+      expect(body.error.code).toBe('FST_ERR_CTP_EMPTY_JSON_BODY');
+    });
+
+    it('preserves the 400 status code for a schema validation failure', async () => {
+      app.post(
+        '/schema',
+        {
+          schema: {
+            body: {
+              type: 'object',
+              required: ['name'],
+              properties: { name: { type: 'string' } }
+            }
+          }
+        },
+        async () => ({ ok: true })
+      );
+      await app.ready();
+
+      const response = await app.inject({
+        method: 'POST',
+        url: '/schema',
+        headers: { 'content-type': 'application/json' },
+        payload: JSON.stringify({})
+      });
+
+      expect(response.statusCode).toBe(400);
+      const body = JSON.parse(response.payload);
+      expect(body.error.status).toBe(400);
+      expect(body.error.code).toBe('FST_ERR_VALIDATION');
+    });
+
+    it('preserves the 413 status code when the body exceeds the limit', async () => {
+      const tinyApp = Fastify({ bodyLimit: 16 });
+      registerFastifyErrorHandler(tinyApp);
+      tinyApp.post('/echo', async (request) => ({ received: request.body }));
+      await tinyApp.ready();
+
+      try {
+        const response = await tinyApp.inject({
+          method: 'POST',
+          url: '/echo',
+          headers: { 'content-type': 'application/json' },
+          payload: JSON.stringify({ data: 'x'.repeat(64) })
+        });
+
+        expect(response.statusCode).toBe(413);
+        const body = JSON.parse(response.payload);
+        expect(body.error.status).toBe(413);
+        expect(body.error.code).toBe('FST_ERR_CTP_BODY_TOO_LARGE');
+      } finally {
+        await tinyApp.close();
+      }
+    });
+
+    it('preserves the 415 status code for an unsupported media type', async () => {
+      app.post('/json-only', async (request) => ({ received: request.body }));
+      // Drop the default text/plain parser so non-JSON content types are rejected.
+      app.removeContentTypeParser('text/plain');
+      await app.ready();
+
+      const response = await app.inject({
+        method: 'POST',
+        url: '/json-only',
+        headers: { 'content-type': 'text/plain' },
+        payload: 'hello'
+      });
+
+      expect(response.statusCode).toBe(415);
+      const body = JSON.parse(response.payload);
+      expect(body.error.status).toBe(415);
+      expect(body.error.code).toBe('FST_ERR_CTP_INVALID_MEDIA_TYPE');
+    });
+  });
+});

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

@@ -1,6 +1,12 @@
 import { BasicRouterRequest, Context, JwtPayload, SyncRulesBucketStorage } from '@/index.js';
-import { RouterResponse, ServiceError, logger } from '@powersync/lib-services-framework';
-import { DEFAULT_HYDRATION_STATE, SqlSyncRules } from '@powersync/service-sync-rules';
+import { logger, RouterResponse, ServiceError } from '@powersync/lib-services-framework';
+import {
+  DEFAULT_HYDRATION_STATE,
+  HydrateSyncConfigParams,
+  nodeSqlite,
+  SqlSyncRules
+} from '@powersync/service-sync-rules';
+import * as sqlite from 'node:sqlite';
 import { Readable, Writable } from 'stream';
 import { pipeline } from 'stream/promises';
 import { describe, expect, it } from 'vitest';
@@ -10,6 +16,11 @@ import { DEFAULT_PARAM_LOGGING_FORMAT_OPTIONS, limitParamsForLogging } from '../
 import { mockServiceContext } from './mocks.js';
 
 describe('Stream Route', () => {
+  const defaultHydrationOptions: HydrateSyncConfigParams = {
+    hydrationState: DEFAULT_HYDRATION_STATE,
+    sqlite: nodeSqlite(sqlite)
+  };
+
   describe('compressed stream', () => {
     it('handles missing sync rules', async () => {
       const context: Context = {
@@ -45,7 +56,7 @@ describe('Stream Route', () => {
 
       const storage = {
         getParsedSyncRules() {
-          return new SqlSyncRules('bucket_definitions: {}').hydrate({ hydrationState: DEFAULT_HYDRATION_STATE });
+          return new SqlSyncRules('bucket_definitions: {}').hydrate(defaultHydrationOptions);
         },
         watchCheckpointChanges: async function* (options) {
           throw new Error('Simulated storage error');
@@ -83,7 +94,7 @@ describe('Stream Route', () => {
     it('logs the application metadata', async () => {
       const storage = {
         getParsedSyncRules() {
-          return new SqlSyncRules('bucket_definitions: {}').hydrate({ hydrationState: DEFAULT_HYDRATION_STATE });
+          return new SqlSyncRules('bucket_definitions: {}').hydrate(defaultHydrationOptions);
         },
         watchCheckpointChanges: async function* (options) {
           throw new Error('Simulated storage error');