@powersync/service-core 1.27.1 → 1.28.0

package/test/src/routes/mocks.ts

@@ -11,9 +11,13 @@ import {
   SyncContext,
   SyncRulesBucketStorage
 } from '@/index.js';
+import { SyncConfigEngine } from '@/system/SyncConfigEngine.js';
 import { MeterProvider } from '@opentelemetry/sdk-metrics';
 
-export function mockServiceContext(storage: Partial<SyncRulesBucketStorage> | null) {
+export function mockServiceContext(
+  storage: Partial<SyncRulesBucketStorage> | null,
+  overrideMetricsEngine?: MetricsEngine
+) {
   // This is very incomplete - just enough to get the current tests passing.
 
   const storageEngine: StorageEngine = {
@@ -28,21 +32,28 @@ export function mockServiceContext(storage: Partial<SyncRulesBucketStorage> | nu
     } as Partial<BucketStorageFactory>
   } as any;
 
-  const meterProvider = new MeterProvider({
-    readers: []
-  });
-  const meter = meterProvider.getMeter('powersync-tests');
-  const metricsEngine = new MetricsEngine({
-    disable_telemetry_sharing: true,
-    factory: new OpenTelemetryMetricsFactory(meter)
-  });
-  createCoreAPIMetrics(metricsEngine);
+  let metricsEngine = overrideMetricsEngine;
+  if (metricsEngine == null) {
+    const meterProvider = new MeterProvider({
+      readers: []
+    });
+    const meter = meterProvider.getMeter('powersync-tests');
+    metricsEngine = new MetricsEngine({
+      disable_telemetry_sharing: true,
+      factory: new OpenTelemetryMetricsFactory(meter)
+    });
+    createCoreAPIMetrics(metricsEngine);
+  }
+  let routeAPI: RouteAPI | undefined;
   const service_context: Partial<ServiceContext> = {
+    configuration: {
+      sync_rules: { present: false, exit_on_error: true }
+    } as ServiceContext['configuration'],
     syncContext: new SyncContext({ maxBuckets: 1, maxDataFetchConcurrency: 1, maxParameterQueryResults: 1 }),
     eventsEngine: new EventsEngine(),
     routerEngine: {
       getAPI() {
-        return {
+        return (routeAPI ??= {
           getParseSyncRulesOptions() {
             return { defaultSchema: 'public' };
           },
@@ -67,7 +78,7 @@ export function mockServiceContext(storage: Partial<SyncRulesBucketStorage> | nu
           async getDebugTablesInfo() {
             return [];
           }
-        } satisfies Partial<RouteAPI> as unknown as RouteAPI;
+        } satisfies Partial<RouteAPI> as unknown as RouteAPI);
       },
       addStopHandler() {
         return () => {};
@@ -76,11 +87,13 @@ export function mockServiceContext(storage: Partial<SyncRulesBucketStorage> | nu
     storageEngine,
     metricsEngine: metricsEngine,
     // Not used
-    configuration: null as any,
     lifeCycleEngine: null as any,
     migrations: null as any,
     replicationEngine: null as any,
     serviceMode: null as any
   };
+  service_context.syncConfigEngine = new SyncConfigEngine(service_context.configuration!.sync_rules, () =>
+    service_context.routerEngine!.getAPI()
+  );
   return service_context as ServiceContext;
 }

package/test/src/routes/stream-disconnect.integration.test.ts

@@ -0,0 +1,129 @@
+import { CHECKPOINT_INVALIDATE_ALL, ContextProvider, JwtPayload, SyncRulesBucketStorage } from '@/index.js';
+import { DEFAULT_HYDRATION_STATE, nodeSqlite, parseSyncConfig } from '@powersync/service-sync-rules';
+import { APIMetric } from '@powersync/service-types';
+import Fastify from 'fastify';
+import * as http from 'node:http';
+import * as sqlite from 'node:sqlite';
+import { describe, expect, it, onTestFinished } from 'vitest';
+import { syncStreamed } from '../../../src/routes/endpoints/sync-stream.js';
+import { registerFastifyErrorHandler, registerFastifyRoutes } from '../../../src/routes/route-register.js';
+import { recordingMetricsEngine } from '../recording-metrics.js';
+import { mockServiceContext } from './mocks.js';
+
+// Use real HTTP disconnects to verify that transport teardown isn't counted as a stream error.
+describe('Sync stream client disconnect', () => {
+  /** A stream still writing operations when the client disconnects, as on an initial sync. */
+  function busyStorage() {
+    return {
+      getParsedSyncRules: () =>
+        parseSyncConfig(
+          `
+config:
+  edition: 3
+streams:
+  global:
+    auto_subscribe: true
+    query: SELECT * FROM test
+`,
+          { defaultSchema: 'public' }
+        ).config.hydrate({ hydrationState: DEFAULT_HYDRATION_STATE, sqlite: nodeSqlite(sqlite) }),
+      getChecksums: async (_checkpoint, buckets) =>
+        new Map(buckets.map(({ bucket }) => [bucket, { bucket, checksum: 1, count: 100_000 }])),
+      getBucketDataBatch: async function* (_checkpoint, buckets) {
+        // Bounded so an abort that fails to stop the stream cannot run away.
+        for (let batch = 0; batch < 100; batch++) {
+          yield {
+            chunkData: {
+              bucket: buckets[0].bucket,
+              data: Array.from({ length: 1000 }, () => ({ op: 'PUT' })),
+              has_more: true,
+              after: `${batch * 1000}`,
+              next_after: `${(batch + 1) * 1000}`
+            },
+            targetOp: null
+          };
+        }
+        yield { hasMore: true };
+      },
+      watchCheckpointChanges: async function* ({ signal }) {
+        yield {
+          base: { checkpoint: 1n, lsn: '1', getParameterSets: async () => [] },
+          writeCheckpoint: null,
+          update: CHECKPOINT_INVALIDATE_ALL
+        };
+        await new Promise<void>((resolve) => signal.addEventListener('abort', () => resolve(), { once: true }));
+      }
+    } as Partial<SyncRulesBucketStorage>;
+  }
+
+  async function abortClientMidStream(acceptEncoding: string) {
+    const recorder = recordingMetricsEngine('stream-disconnect-test');
+    onTestFinished(() => recorder.shutdown());
+    const service_context = mockServiceContext(busyStorage(), recorder.engine);
+    const contextProvider: ContextProvider = async (_request, options) => ({
+      logger: options.logger,
+      service_context,
+      token_payload: new JwtPayload({
+        exp: Date.now() / 1000 + 10_000,
+        iat: Date.now() / 1000 - 10_000,
+        sub: 'test-user'
+      })
+    });
+
+    const app = Fastify();
+    registerFastifyErrorHandler(app);
+    registerFastifyRoutes(app, contextProvider, [{ ...syncStreamed, authorize: async () => ({ authorized: true }) }]);
+
+    try {
+      const address = await app.listen({ port: 0, host: '127.0.0.1' });
+      const url = new URL(syncStreamed.path, address);
+
+      await new Promise<void>((resolve, reject) => {
+        const clientRequest = http.request(
+          {
+            host: url.hostname,
+            port: url.port,
+            path: url.pathname,
+            method: 'POST',
+            headers: { 'content-type': 'application/json', 'accept-encoding': acceptEncoding }
+          },
+          (clientResponse) => {
+            clientResponse.once('data', () => {
+              clientRequest.destroy();
+              resolve();
+            });
+            clientResponse.on('error', () => {});
+          }
+        );
+        clientRequest.on('error', (error) => reject(error));
+        clientRequest.end(JSON.stringify({ raw_data: true }));
+      });
+
+      // Wait for afterSend to record the close.
+      await expect
+        .poll(() =>
+          recorder.seriesValue(APIMetric.SYNC_CONNECTIONS, {
+            outcome: 'ok',
+            close_reason: 'client_closed',
+            transport: 'http_stream'
+          })
+        )
+        .toBe(1);
+
+      expect(await recorder.seriesValue(APIMetric.SYNC_CONNECTIONS, { outcome: 'error' })).toBeUndefined();
+      expect(await recorder.seriesValue(APIMetric.SYNC_CONNECTIONS, {})).toBe(1);
+      expect(await recorder.seriesValue(APIMetric.CONCURRENT_CONNECTIONS, {})).toBe(0);
+    } finally {
+      await app.close();
+    }
+  }
+
+  it('counts a real client hangup as an ok close', async () => {
+    await abortClientMidStream('identity');
+  });
+
+  it('counts a real client hangup on a compressed response as an ok close', async () => {
+    // Gzip adds a separate teardown path.
+    await abortClientMidStream('gzip');
+  });
+});

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

@@ -7,20 +7,23 @@ import {
   streamResponse,
   SyncRulesBucketStorage
 } from '@/index.js';
-import { logger, RouterResponse, ServiceError } from '@powersync/lib-services-framework';
+import { ErrorCode, logger, RouterResponse, ServiceError } from '@powersync/lib-services-framework';
 import {
   DEFAULT_HYDRATION_STATE,
   HydrateSyncConfigParams,
   nodeSqlite,
+  parseSyncConfig,
   SqlSyncRules
 } from '@powersync/service-sync-rules';
+import { APIMetric } from '@powersync/service-types';
 import * as sqlite from 'node:sqlite';
 import { Readable, Writable } from 'stream';
 import { pipeline } from 'stream/promises';
-import { describe, expect, it, vi } from 'vitest';
+import { describe, expect, it, onTestFinished, vi } from 'vitest';
 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 { recordingMetricsEngine } from '../recording-metrics.js';
 import { mockServiceContext } from './mocks.js';
 
 describe('Stream Route', () => {
@@ -189,120 +192,210 @@ describe('Stream Route', () => {
         DEFAULT_PARAM_LOGGING_FORMAT_OPTIONS.maxStringLength
       );
     });
+
+    // Fail the stream before reporting a client disconnect.
+    const runClientDisconnectAfter = async (streamError: Error) => {
+      const recorder = recordingMetricsEngine('stream-route-test');
+      onTestFinished(() => recorder.shutdown());
+      const storage = {
+        getParsedSyncRules() {
+          return parseSyncConfig('config:\n  edition: 3\nstreams: {}', {
+            defaultSchema: 'public'
+          }).config.hydrate(defaultHydrationOptions);
+        },
+        watchCheckpointChanges: async function* (options) {
+          throw streamError;
+        }
+      } as Partial<SyncRulesBucketStorage>;
+
+      const context: Context = {
+        logger: logger,
+        service_context: mockServiceContext(storage, recorder.engine),
+        token_payload: new JwtPayload({
+          exp: new Date().getTime() / 1000 + 10000,
+          iat: new Date().getTime() / 1000 - 10000,
+          sub: 'test-user'
+        })
+      };
+      const request: BasicRouterRequest = { headers: {}, hostname: '', protocol: 'http' };
+
+      const response = await (syncStreamed.handler({ context, params: {}, request }) as Promise<RouterResponse>);
+      await drainWithTimeout(response.data as Readable).catch((error) => error);
+      await response.afterSend({ clientClosed: true });
+      expect(await recorder.seriesValue(APIMetric.SYNC_CONNECTIONS, {})).toBe(1);
+      expect(await recorder.seriesValue(APIMetric.CONCURRENT_CONNECTIONS, {})).toBe(0);
+      return recorder;
+    };
+
+    it('keeps a genuine mid-stream failure as an error even when the client then disconnects', async () => {
+      const recorder = await runClientDisconnectAfter(new Error('Simulated storage error'));
+
+      expect(
+        await recorder.seriesValue(APIMetric.SYNC_CONNECTIONS, {
+          outcome: 'error',
+          close_reason: 'stream_error',
+          error_code: 'other',
+          transport: 'http_stream'
+        })
+      ).toEqual(1);
+      expect(
+        await recorder.seriesValue(APIMetric.SYNC_CONNECTIONS, {
+          outcome: 'ok',
+          close_reason: 'client_closed',
+          transport: 'http_stream'
+        })
+      ).toBeUndefined();
+    });
+
+    it('reports the PowerSync code for a ServiceError mid-stream', async () => {
+      const recorder = await runClientDisconnectAfter(
+        new ServiceError({ status: 500, code: ErrorCode.PSYNC_S2305, description: 'Too many buckets' })
+      );
+
+      expect(
+        await recorder.seriesValue(APIMetric.SYNC_CONNECTIONS, {
+          outcome: 'error',
+          close_reason: 'stream_error',
+          error_code: ErrorCode.PSYNC_S2305,
+          transport: 'http_stream'
+        })
+      ).toEqual(1);
+    });
   });
 
-  it('closes after a data fetch error while waiting for a new checkpoint', async () => {
-    // After 1,000 operations, the sync stream concurrently calls next() on the
-    // checkpoint watcher. This test then fails the next data fetch without
-    // producing another checkpoint. Before the fix, awaiting watcher.return()
-    // during cleanup queued it behind that pending next(), leaving the response
-    // open until an unrelated checkpoint was written.
-    const syncRules = SqlSyncRules.fromYaml(
-      `
+  it.each([false, true])(
+    'closes after a data fetch error while waiting for a new checkpoint (cleanupFails=%s)',
+    async (cleanupFails) => {
+      // After 1,000 operations, the sync stream concurrently calls next() on the
+      // checkpoint watcher. This test then fails the next data fetch without
+      // producing another checkpoint. Before the fix, awaiting watcher.return()
+      // during cleanup queued it behind that pending next(), leaving the response
+      // open until an unrelated checkpoint was written.
+      const syncRules = parseSyncConfig(
+        `
 bucket_definitions:
   global:
     data: []
       `,
-      { defaultSchema: 'public' }
-    ).config.hydrate(defaultHydrationOptions);
-
-    let checkpointWatcherAborted = false;
-    let dataFetches = 0;
-    const storage = {
-      watchCheckpointChanges: async function* ({ signal }) {
-        yield {
-          base: {
-            checkpoint: 1n,
-            lsn: '1',
-            getParameterSets: async () => []
-          },
-          writeCheckpoint: null,
-          update: CHECKPOINT_INVALIDATE_ALL
-        };
-
-        await new Promise<void>((_resolve, reject) => {
-          // There is intentionally no next checkpoint: cleanup must abort this
-          // pending wait rather than wait for it to complete naturally.
-          signal.addEventListener(
-            'abort',
-            () => {
-              checkpointWatcherAborted = true;
-              reject(new Error('Checkpoint watcher aborted'));
+        { defaultSchema: 'public' }
+      ).config.hydrate(defaultHydrationOptions);
+
+      let checkpointWatcherAborted = false;
+      let checkpointWatcherClosed = false;
+      const cleanupError = new Error('Checkpoint watcher cleanup failed');
+      let dataFetches = 0;
+      const storage = {
+        watchCheckpointChanges: async function* ({ signal }) {
+          try {
+            yield {
+              base: {
+                checkpoint: 1n,
+                lsn: '1',
+                getParameterSets: async () => []
+              },
+              writeCheckpoint: null,
+              update: CHECKPOINT_INVALIDATE_ALL
+            };
+
+            await new Promise<void>((_resolve, reject) => {
+              // There is intentionally no next checkpoint: cleanup must abort this
+              // pending wait rather than wait for it to complete naturally.
+              signal.addEventListener(
+                'abort',
+                () => {
+                  checkpointWatcherAborted = true;
+                  reject(signal.reason);
+                },
+                { once: true }
+              );
+            });
+          } finally {
+            await new Promise<void>((resolve) => setImmediate(resolve));
+            checkpointWatcherClosed = true;
+            if (cleanupFails) throw cleanupError;
+          }
+        },
+        getChecksums: async (_checkpoint, buckets) =>
+          new Map(buckets.map(({ bucket }) => [bucket, { bucket, checksum: 1, count: 1000 }])),
+        getBucketDataBatch: async function* () {
+          if (dataFetches++ > 0) {
+            throw new Error('Simulated data fetch failure');
+          }
+
+          yield {
+            chunkData: {
+              bucket: 'global[]',
+              data: Array.from({ length: 1000 }, () => ({ op: 'PUT' })),
+              has_more: true,
+              after: '0',
+              next_after: '1000'
             },
-            { once: true }
-          );
-        });
-      },
-      getChecksums: async (_checkpoint, buckets) =>
-        new Map(buckets.map(({ bucket }) => [bucket, { bucket, checksum: 1, count: 1000 }])),
-      getBucketDataBatch: async function* () {
-        if (dataFetches++ > 0) {
-          throw new Error('Simulated data fetch failure');
+            targetOp: null
+          };
+          yield { hasMore: true };
         }
-
-        yield {
-          chunkData: {
-            bucket: 'global[]',
-            data: Array.from({ length: 1000 }, () => ({ op: 'PUT' })),
-            has_more: true,
-            after: '0',
-            next_after: '1000'
-          },
-          targetOp: null
-        };
-        yield { hasMore: true };
-      }
-    } as Partial<SyncRulesBucketStorage>;
-    const serviceContext = mockServiceContext(storage);
-    const controller = new AbortController();
-    const checkpointLogger = logger.child({});
-    const checkpointLogSpy = vi.spyOn(checkpointLogger, 'info');
-
-    const response = (async () => {
-      for await (const _line of streamResponse({
-        syncContext: serviceContext.syncContext,
-        bucketStorage: storage as SyncRulesBucketStorage,
-        syncRules,
-        params: { client_id: 'test-client', raw_data: true },
-        token: new JwtPayload({ sub: 'test-user', exp: Date.now() / 1000 + 10_000 }),
-        tracker: new RequestTracker(serviceContext.metricsEngine),
-        isEncodingAsBson: false,
-        signal: controller.signal,
-        logger: checkpointLogger
-      })) {
-        // Consume the response until the simulated data fetch error is propagated.
+      } as Partial<SyncRulesBucketStorage>;
+      const serviceContext = mockServiceContext(storage);
+      const controller = new AbortController();
+      const checkpointLogger = logger.child({});
+      const checkpointLogSpy = vi.spyOn(checkpointLogger, 'info');
+
+      const response = (async () => {
+        for await (const _line of streamResponse({
+          syncContext: serviceContext.syncContext,
+          bucketStorage: storage as SyncRulesBucketStorage,
+          syncRules,
+          params: { client_id: 'test-client', raw_data: true },
+          token: new JwtPayload({ sub: 'test-user', exp: Date.now() / 1000 + 10_000 }),
+          tracker: new RequestTracker(serviceContext.metricsEngine),
+          isEncodingAsBson: false,
+          signal: controller.signal,
+          logger: checkpointLogger
+        })) {
+          // Consume the response until the simulated data fetch error is propagated.
+        }
+      })();
+
+      let timeout: NodeJS.Timeout | undefined;
+      const outcome = await Promise.race([
+        response.then(
+          () => new Error('Sync stream unexpectedly completed'),
+          (error) => error
+        ),
+        new Promise((resolve) => {
+          timeout = setTimeout(() => resolve(new Error('Sync stream did not close')), 500);
+        })
+      ]);
+      clearTimeout(timeout);
+
+      // Capture this before aborting below, which would set it regardless of the stream cleanup.
+      const abortedByCleanup = checkpointWatcherAborted;
+
+      controller.abort();
+      await response.catch(() => {});
+
+      expect(outcome).toBeInstanceOf(Error);
+      if (cleanupFails) {
+        expect(outcome).toBeInstanceOf(AggregateError);
+        expect((outcome as AggregateError).errors).toEqual([
+          expect.objectContaining({ message: 'Simulated data fetch failure' }),
+          cleanupError
+        ]);
+        expect((outcome as AggregateError).cause).toMatchObject({ message: 'Simulated data fetch failure' });
+      } else {
+        expect((outcome as Error).message).toContain('Simulated data fetch failure');
       }
-    })();
-
-    let timeout: NodeJS.Timeout | undefined;
-    const outcome = await Promise.race([
-      response.then(
-        () => new Error('Sync stream unexpectedly completed'),
-        (error) => error
-      ),
-      new Promise((resolve) => {
-        timeout = setTimeout(() => resolve(new Error('Sync stream did not close')), 500);
-      })
-    ]);
-    clearTimeout(timeout);
-
-    // Capture this before aborting below, which would set it regardless of the stream cleanup.
-    const abortedByCleanup = checkpointWatcherAborted;
-
-    controller.abort();
-    await response.catch(() => {});
-
-    expect(outcome).toBeInstanceOf(Error);
-    expect((outcome as Error).message).toContain('Simulated data fetch failure');
-    expect(abortedByCleanup).toBe(true);
-    expect(checkpointLogSpy).toHaveBeenCalledWith('checkpoint_interrupted: 1', {
-      checkpoint: 1n,
-      user_id: 'test-user',
-      operations_synced: 1000,
-      data_synced_bytes: 0,
-      ms: expect.any(Object)
-    });
-  });
+      expect(checkpointWatcherClosed).toBe(true);
+      expect(abortedByCleanup).toBe(true);
+      expect(checkpointLogSpy).toHaveBeenCalledWith('checkpoint_interrupted: 1', {
+        checkpoint: 1n,
+        user_id: 'test-user',
+        operations_synced: 1000,
+        data_synced_bytes: 0,
+        ms: expect.any(Object)
+      });
+    }
+  );
 });
 
 export async function drainWithTimeout(readable: Readable, ms = 2_000) {

package/test/src/routes/sync-rules.test.ts

@@ -17,7 +17,6 @@ describe('sync-rules routes', () => {
       updateSyncRules: vi.fn(async () => ({ replicationStreamName: 'new_slot' }))
     };
     // Deploying through the API requires the sync config to not be set in the service config.
-    (service_context as any).configuration = { sync_rules: { present: false } };
 
     return {
       logger: logger,
@@ -79,6 +78,25 @@ describe('sync-rules routes', () => {
   });
 
   describe('deploy', () => {
+    it.each([
+      {
+        inputState: 'invalid YAML',
+        configuration: { present: true, content: 'streams: [', exit_on_error: false }
+      },
+      { inputState: 'unavailable input', configuration: { present: true, exit_on_error: false } }
+    ])(
+      'blocks deployment when a config is supplied regardless of the load result: $inputState',
+      async ({ configuration }) => {
+        const context = makeContext();
+        // Configured mode disables API deployment even if its YAML is rejected or unavailable.
+        context.service_context.configuration.sync_rules = configuration;
+        await expect(deploySyncRules.handler({ context, params: { content: '' }, request })).rejects.toMatchObject({
+          message: expect.stringContaining('Sync config API disabled')
+        });
+        expect(context.service_context.storageEngine.activeBucketStorage.updateSyncRules).not.toHaveBeenCalled();
+      }
+    );
+
     it('logs that bucket_definitions are deprecated', async () => {
       const warnSpy = vi.spyOn(logger, 'warn');
 

package/test/src/source_table_config.test.ts

@@ -1,6 +1,6 @@
 import { isCompatible, parsePersistedSyncConfigContent, updateSyncRulesFromConfig } from '@/storage/storage-index.js';
 import { logger } from '@powersync/lib-services-framework';
-import { PrecompiledSyncConfig, SqlSyncRules } from '@powersync/service-sync-rules';
+import { PrecompiledSyncConfig, parseSyncConfig } from '@powersync/service-sync-rules';
 import { describe, expect, test } from 'vitest';
 
 const CONFIGURED = /* yaml */ `
@@ -17,7 +17,7 @@ const CONFIGURED = /* yaml */ `
 
 describe('source-table options', () => {
   test('preserves filters through compiled storage', () => {
-    const parsed = SqlSyncRules.fromYaml(CONFIGURED, { defaultSchema: 'app' });
+    const parsed = parseSyncConfig(CONFIGURED, { defaultSchema: 'app' });
     const update = updateSyncRulesFromConfig(parsed);
     const restored = parsePersistedSyncConfigContent({
       content: CONFIGURED,
@@ -31,7 +31,7 @@ describe('source-table options', () => {
   });
   test('reports invalid expressions before storage', () => {
     expect(() =>
-      SqlSyncRules.fromYaml(CONFIGURED.replace('$$doc.active', '$doc.active'), {
+      parseSyncConfig(CONFIGURED.replace('$$doc.active', '$doc.active'), {
         defaultSchema: 'app'
       })
     ).toThrow('Expected a source field');
@@ -49,7 +49,7 @@ describe('source-table options', () => {
         orders:
           query: SELECT * FROM orders
     `;
-    const parsed = SqlSyncRules.fromYaml(yaml, { defaultSchema: 'app', throwOnError: false });
+    const parsed = parseSyncConfig(yaml, { defaultSchema: 'app', throwOnError: false });
     expect(parsed.errors).toContainEqual(
       expect.objectContaining({ type: 'fatal', message: expect.stringContaining(message) })
     );
@@ -72,7 +72,7 @@ describe('source-table options', () => {
 
   test('keeps valid filters on a partial plan with an unrelated SQL error', () => {
     const yaml = CONFIGURED.replace('SELECT * FROM orders', 'SELECT FROM');
-    const parsed = SqlSyncRules.fromYaml(yaml, { defaultSchema: 'app', throwOnError: false });
+    const parsed = parseSyncConfig(yaml, { defaultSchema: 'app', throwOnError: false });
     expect(parsed.errors.some((error) => error.type === 'fatal')).toBe(true);
     const update = updateSyncRulesFromConfig(parsed);
     expect(update.config.plan!.plan.sourceTableConfig).toEqual({
@@ -80,7 +80,7 @@ describe('source-table options', () => {
     });
   });
   test('requires replacement processing when filters change or are removed', () => {
-    const deploy = (yaml: string) => updateSyncRulesFromConfig(SqlSyncRules.fromYaml(yaml, { defaultSchema: 'app' }));
+    const deploy = (yaml: string) => updateSyncRulesFromConfig(parseSyncConfig(yaml, { defaultSchema: 'app' }));
     const first = deploy(CONFIGURED);
     const same = deploy(CONFIGURED.replace('SELECT *', 'SELECT id'));
     const changed = deploy(CONFIGURED.replace('true', 'false'));
@@ -95,7 +95,7 @@ describe('source-table options', () => {
     expect(isCompatible([first.config.plan], removed.config, logger)).toBe(false);
   });
   test('requires replacement processing when saved source-table options no longer validate', () => {
-    const update = updateSyncRulesFromConfig(SqlSyncRules.fromYaml(CONFIGURED, { defaultSchema: 'app' }));
+    const update = updateSyncRulesFromConfig(parseSyncConfig(CONFIGURED, { defaultSchema: 'app' }));
     const existing = structuredClone(update.config.plan!);
     // A saved expression can become unsupported after a module or version change.
     Object.assign(existing.plan.sourceTableConfig!.orders!, { mongodb_filter_expression: { $unsupported: [] } });