@powersync/service-core 1.26.1 → 1.27.1

package/src/routes/endpoints/socket-route.ts

@@ -16,6 +16,10 @@ export const syncStreamReactive: SocketRouteGenerator = (router) =>
       const { routerEngine, metricsEngine, syncContext } = service_context;
       const streamStart = Date.now();
 
+      // Format client-controlled values before registering connection resources.
+      const formattedAppMetadata = params.app_metadata ? limitParamsForLogging(params.app_metadata) : undefined;
+      const formattedClientParams = params.parameters ? limitParamsForLogging(params.parameters) : undefined;
+
       logger.defaultMeta = {
         ...logger.defaultMeta,
         user_id: context.token_payload!.userIdJson,
@@ -99,13 +103,12 @@ export const syncStreamReactive: SocketRouteGenerator = (router) =>
         tracker.setCompressed(connection.tracker.encoding);
       }
 
-      const formattedAppMetadata = params.app_metadata ? limitParamsForLogging(params.app_metadata) : undefined;
-      logger.info('Sync stream started', {
-        app_metadata: formattedAppMetadata,
-        client_params: params.parameters ? limitParamsForLogging(params.parameters) : undefined
-      });
-
       try {
+        logger.info('Sync stream started', {
+          app_metadata: formattedAppMetadata,
+          client_params: formattedClientParams
+        });
+
         for await (const data of sync.streamResponse({
           syncContext: syncContext,
           bucketStorage: bucketStorage,

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

@@ -2,9 +2,10 @@ import { ErrorCode, errors, router, schema } from '@powersync/lib-services-frame
 import { SqlSyncRules, SyncConfigWithErrors, SyncRulesErrors } from '@powersync/service-sync-rules';
 import type { FastifyPluginAsync } from 'fastify';
 import * as t from 'ts-codec';
+import { assertSourceCapabilities } from '../../api/source-capabilities.js';
 
-import { RouteAPI } from '../../api/RouteAPI.js';
-import { updateSyncRulesFromConfig, updateSyncRulesFromYaml } from '../../storage/BucketStorageFactory.js';
+import { PatternResult, RouteAPI } from '../../api/RouteAPI.js';
+import { logSyncConfigErrors, updateSyncRulesFromConfig } from '../../storage/BucketStorageFactory.js';
 import { authApi } from '../auth.js';
 import { routeDefinition } from '../router.js';
 
@@ -55,6 +56,7 @@ export const deploySyncRules = routeDefinition({
     let syncConfig: SyncConfigWithErrors;
 
     try {
+      // First ensure the SyncConfig parses correctly
       const apiHandler = service_context.routerEngine.getAPI();
       syncConfig = SqlSyncRules.fromYaml(content, {
         ...apiHandler.getParseSyncRulesOptions(),
@@ -70,6 +72,10 @@ export const deploySyncRules = routeDefinition({
       });
     }
 
+    logSyncConfigErrors(syncConfig);
+    // Validate if the current sources support the configuration specified in the sync config
+    await assertSourceCapabilities(service_context.routerEngine.getAPI(), syncConfig.config);
+
     const sync_rules = await storageEngine.activeBucketStorage.updateSyncRules(updateSyncRulesFromConfig(syncConfig));
 
     return {
@@ -176,11 +182,18 @@ export const reprocessSyncRules = routeDefinition({
     }
 
     const sync_rules = active.content;
+    const parsed = SqlSyncRules.fromYaml(sync_rules.sync_rules_content, {
+      ...payload.context.service_context.routerEngine.getAPI().getParseSyncRulesOptions(),
+      schema: undefined,
+      // This sync config already passed validation. But if the rules are not valid anymore due
+      // to a service change, we do want to report the error here.
+      throwOnError: true
+    });
+    logSyncConfigErrors(parsed);
+    await assertSourceCapabilities(payload.context.service_context.routerEngine.getAPI(), parsed.config);
+
     const new_rules = await activeBucketStorage.updateSyncRules(
-      updateSyncRulesFromYaml(sync_rules.sync_rules_content, {
-        // This sync config already passed validation. But if the rules are not valid anymore due
-        // to a service change, we do want to report the error here.
-        validate: true,
+      updateSyncRulesFromConfig(parsed, {
         version_label: sync_rules.version_label,
         forceNewReplicationStream: true
       })
@@ -208,11 +221,31 @@ async function debugSyncRules(apiHandler: RouteAPI, sync_rules: string) {
       // No schema-based validation at this point
       schema: undefined
     });
-    const source_table_patterns = rules.config.getSourceTables();
-    const resolved_tables = await apiHandler.getDebugTablesInfo(source_table_patterns, rules.config);
+    const errors: string[] = [];
+    const warnings = rules.errors.filter((error) => error.type === 'warning').map((error) => error.message);
+    const recordError = (error: any) => {
+      errors.push(...(error instanceof SyncRulesErrors ? error.errors.map((e) => e.message) : [error.message]));
+    };
+    try {
+      const diagnostics = (await apiHandler.validateSourceCapabilities?.(rules.config)) ?? [];
+      for (const diagnostic of diagnostics) {
+        (diagnostic.level === 'fatal' ? errors : warnings).push(diagnostic.message);
+      }
+    } catch (e) {
+      recordError(e);
+    }
+    let resolved_tables: PatternResult[] = [];
+    try {
+      const source_table_patterns = rules.config.getSourceTables();
+      resolved_tables = await apiHandler.getDebugTablesInfo(source_table_patterns, rules.config);
+    } catch (e) {
+      recordError(e);
+    }
 
     return {
-      valid: true,
+      valid: errors.length == 0,
+      ...(warnings.length > 0 ? { warnings } : {}),
+      ...(errors.length > 0 ? { errors } : {}),
       bucket_definitions: rules.config.debugRepresentation(),
       source_tables: resolved_tables,
       data_tables: rules.config.debugGetOutputTables()

package/src/storage/BucketStorageFactory.ts

@@ -117,10 +117,14 @@ export abstract class BucketStorageFactory
    */
   abstract getSystemIdentifier(): Promise<BucketStorageSystemIdentifier>;
 
-  abstract [Symbol.asyncDispose](): PromiseLike<void>;
+  async [Symbol.asyncDispose](): Promise<void> {
+    await this.iterateAsyncListeners(async (listener) => listener.beforeDispose?.());
+  }
 }
 
 export interface BucketStorageFactoryListener {
+  /** Release owned resources before the factory closes its database connections. */
+  beforeDispose: () => Promise<void>;
   syncStorageCreated: (storage: SyncRulesBucketStorage) => void;
   replicationEvent: (event: ReplicationEventPayload) => void;
 }
@@ -177,7 +181,7 @@ export interface UpdateSyncRulesOptions {
   config: {
     yaml: string;
     /**
-     * The serialized sync plan for the sync configuration, or `null` for configurations not using the sync stream
+     * The serialized sync plan for the sync configuration, or `null` for configurations not using the Sync Streams
      * compiler.
      */
     plan: SerializedSyncPlan | null;
@@ -223,14 +227,15 @@ export function updateSyncRulesFromYaml(
   content: string,
   options?: Omit<UpdateSyncRulesOptions, 'config'> & { validate?: boolean }
 ): UpdateSyncRulesOptions {
+  const { validate, ...updateOptions } = options ?? {};
   const config = SqlSyncRules.fromYaml(content, {
     // No schema-based validation at this point
     schema: undefined,
     defaultSchema: options?.defaultSchema ?? 'not_applicable', // Not needed for validation
-    throwOnError: options?.validate ?? false
+    throwOnError: validate ?? false
   });
 
-  return updateSyncRulesFromConfig(config, options);
+  return updateSyncRulesFromConfig(config, updateOptions);
 }
 
 export function updateSyncRulesFromConfig(
@@ -257,7 +262,31 @@ export function updateSyncRulesFromConfig(
   return { config: { yaml: config.content, plan, parsed }, ...options };
 }
 
+/**
+ * Logs the errors and warnings of a parsed sync config
+ *
+ * Call this where a sync config is loaded or deployed, so that operators see these in the service logs and not only
+ * in the diagnostics and validate API responses.
+ *
+ * Fatal errors usually throw during parsing before this is reached. They can reach this when the sync config is parsed
+ * without validation, such as at startup with `exit_on_error: false`.
+ */
+export function logSyncConfigErrors(parsed: SyncConfigWithErrors, log: typeof logger = logger) {
+  for (const error of parsed.errors) {
+    if (error.type == 'warning') {
+      log.warn(`Sync config warning: ${error.message}`);
+    } else {
+      log.error(`Sync config error: ${error.message}`);
+    }
+  }
+}
+
 export interface GetIntanceOptions {
+  /**
+   * The job lease, including a lease acquired during initial configuration.
+   * Required for writing; optional for reading.
+   */
+  replicationLock?: ReplicationLock;
   /**
    * Set to true to skip trigger any events for creating the instance.
    *

package/src/storage/PersistedSyncConfigContent.ts

@@ -10,6 +10,7 @@ import {
   HydrationState,
   nodeSqlite,
   PrecompiledSyncConfig,
+  SourceConnectionMap,
   SqlSyncRules,
   SyncConfigWithErrors,
   versionedHydrationState,
@@ -202,6 +203,8 @@ export interface PersistedSyncConfigContentData {
   readonly version_label?: string;
 }
 export type PersistedSyncConfigId = string;
+
 export interface ParseSyncConfigOptions {
   defaultSchema: string;
+  connections?: SourceConnectionMap;
 }

package/src/storage/StorageProvider.ts

@@ -31,5 +31,8 @@ export interface StorageProvider {
    */
   type: string;
 
+  /**
+   * Creates active storage during storage-engine startup.
+   */
   getStorage(options: GetStorageOptions): Promise<ActiveStorage>;
 }

package/src/storage/StorageVersionConfig.ts

@@ -49,11 +49,6 @@ export const STORAGE_VERSION_4 = 4;
  */
 export const LEGACY_STORAGE_VERSION = STORAGE_VERSION_1;
 
-/**
- * Default storage version for newly persisted replication streams.
- */
-export const CURRENT_STORAGE_VERSION = STORAGE_VERSION_2;
-
 /**
  * All versions that can be loaded.
  *

package/src/storage/SyncRulesBucketStorage.ts

@@ -11,7 +11,7 @@ import * as util from '../util/util-index.js';
 import { BucketStorageBatch, FlushedResult, SaveUpdate } from './BucketStorageBatch.js';
 import { BucketStorageFactory } from './BucketStorageFactory.js';
 import { ParsedSyncConfigSet } from './ParsedSyncConfigSet.js';
-import { ParseSyncConfigOptions } from './PersistedSyncConfigContent.js';
+import type { ParseSyncConfigOptions } from './PersistedSyncConfigContent.js';
 import { SourceEntityDescriptor } from './SourceEntity.js';
 import { SourceTable } from './SourceTable.js';
 import { SourceTableCandidateReconciler } from './SourceTableReconciler.js';
@@ -402,6 +402,8 @@ export interface CompactOptions {
 }
 
 export interface CompactInitialReplicationOptions {
+  /** Internal/testing use: bypass the new-chunk threshold in MongoDB V3/V4 storage. */
+  forceChunkCompaction?: boolean;
   /**
    * Compact data up to this op id.
    *

package/src/storage/implementation/IncrementalReprocessingCompatibility.ts

@@ -1,4 +1,4 @@
-import { CompatibilityContext } from '@powersync/service-sync-rules';
+import { CompatibilityContext, sourceTableConfigsEqual } from '@powersync/service-sync-rules';
 import { Logger } from 'winston';
 import { SerializedSyncPlan, UpdateSyncRulesOptions } from '../BucketStorageFactory.js';
 
@@ -11,8 +11,8 @@ export function isCompatible(
   logger: Logger
 ): boolean {
   if (updateConfig.plan == null) {
-    // Only support sync streams with serialized plans
-    logger.info(`Not using current sync streams - incremental reprocessing not supported`);
+    // Only support Sync Streams with serialized plans
+    logger.info(`Not using current Sync Streams - incremental reprocessing not supported`);
     return false;
   }
 
@@ -23,8 +23,8 @@ export function isCompatible(
   }
 
   if (existingPlans.some((plan) => plan == null)) {
-    // Only support sync streams with serialized plans
-    logger.info(`Existing replication stream not using current sync streams - incremental reprocessing not supported`);
+    // Only support Sync Streams with serialized plans
+    logger.info(`Existing replication stream not using current Sync Streams - incremental reprocessing not supported`);
     return false;
   }
 
@@ -37,5 +37,17 @@ export function isCompatible(
     return false;
   }
 
+  if (
+    existingPlans.some(
+      (existing) =>
+        !sourceTableConfigsEqual(
+          existing!.plan.sourceTableConfig ?? {},
+          updateConfig.plan!.plan.sourceTableConfig ?? {}
+        )
+    )
+  ) {
+    logger.info('Source table configuration changed - incremental reprocessing not supported');
+    return false;
+  }
   return true;
 }

package/src/sync/BucketChecksumState.ts

@@ -89,7 +89,7 @@ export class BucketChecksumState {
    * subscribed to, we keep an index of the stream names to their index in that array.
    *
    * This is used to compress the representation of buckets in `checkpoint` and `checkpoint_diff` lines: For buckets
-   * that are part of sync rules or default streams, we need to include the name of the defining sync rule or definition
+   * that are part of legacy Sync Rules or default streams, we need to include the name of the defining bucket definition or stream
    * yielding that bucket (so that clients can track progress for default streams).
    * But instead of sending the name for each bucket, we use the fact that it's part of the streams array and only send
    * their index, reducing the size of those messages.
@@ -747,7 +747,8 @@ export class BucketParameterState {
         }
       }
     }
-    const allBuckets = [...staticBuckets, ...mergeBuckets(dynamicBuckets)];
+    // A stream can reach the same bucket through both static and dynamic parameters.
+    const allBuckets = mergeBuckets([...staticBuckets, ...dynamicBuckets]);
 
     if (invalidateDataBuckets) {
       return {
@@ -816,7 +817,7 @@ function logCheckpoint(
 }
 
 /**
- * Format a breakdown of dynamic buckets by sync stream or legacy bucket definition.
+ * Format a breakdown of dynamic buckets by Sync Stream or legacy bucket definition.
  *
  * Sorts definitions by count (descending), includes the top 100, and returns both the
  * formatted message string and the counts record suitable for structured log data.
@@ -834,7 +835,7 @@ function formatBucketDefinitionBreakdown(
   const allSorted = Array.from(bucketsByDefinition.entries()).sort((a, b) => b[1] - a[1]);
   const sortedDefinitions = allSorted.slice(0, maxLoggedDefinitions);
 
-  const sourceLabel = bucketSourceType == BucketSourceType.SYNC_STREAM ? 'sync stream' : 'bucket definition';
+  const sourceLabel = bucketSourceType == BucketSourceType.SYNC_STREAM ? 'Sync Stream' : 'bucket definition';
   let message = `\nBuckets by ${sourceLabel}:`;
   const countsByDefinition: Record<string, number> = {};
   for (const [definition, count] of sortedDefinitions) {

package/src/util/param-logging.ts

@@ -18,8 +18,9 @@ export const DEFAULT_PARAM_LOGGING_FORMAT_OPTIONS: ParamLoggingFormatOptions = {
  * Formats potentially arbitrary parameters for logging.
  * This limits the number of keys and strings to a maximum length.
  * A warning key-value is added if the number of keys exceeds the maximum.
- * String values exceeding the maximum length are truncated.
+ * Keys and string values exceeding the maximum length are truncated.
  * Non-String values are stringified, the maximum length is then applied.
+ * Values that cannot be serialized are replaced with a placeholder.
  * @param params - The parameters to format.
  * @param options - The options to use.
  * @default DEFAULT_PARAM_LOGGING_FORMAT_OPTIONS
@@ -41,20 +42,26 @@ export function limitParamsForLogging(
     return value;
   }
 
-  return Object.fromEntries(
-    Object.entries(params).map(([key, value], index) => {
-      if (index == maxKeyCount) {
-        return ['⚠️', 'Additional parameters omitted'];
-      }
+  function formatValue(value: unknown): string {
+    if (typeof value == 'string') {
+      return trimString(value);
+    }
+    try {
+      return trimString(JSON.stringify(value) ?? '[undefined]');
+    } catch {
+      return trimString('[unserializable]');
+    }
+  }
 
-      if (index > maxKeyCount) {
-        return [];
-      }
+  return Object.fromEntries(
+    Object.entries(params)
+      .slice(0, maxKeyCount + 1)
+      .map(([key, value], index) => {
+        if (index == maxKeyCount) {
+          return ['⚠️', 'Additional parameters omitted'];
+        }
 
-      if (typeof value == 'string') {
-        return [key, trimString(value)];
-      }
-      return [key, trimString(JSON.stringify(value))];
-    })
+        return [trimString(key), formatValue(value)];
+      })
   );
 }

package/src/util/protocol-types.ts

@@ -19,7 +19,7 @@ export type BucketRequest = t.Decoded<typeof BucketRequest>;
  */
 export const RequestedStreamSubscription = t.object({
   /**
-   * The defined name of the stream as it appears in sync stream definitions.
+   * The defined name of the stream as it appears in Sync Stream definitions.
    */
   stream: t.string,
   /**
@@ -29,7 +29,7 @@ export const RequestedStreamSubscription = t.object({
   /**
    * Set when the client wishes to re-assign a different priority to this stream.
    *
-   * Streams and sync rules can also assign a default priority, but clients are allowed to override those. This can be
+   * Sync Streams and legacy bucket definitions can also assign a default priority, but clients are allowed to override those. This can be
    * useful when the priority for partial syncs depends on e.g. the current page opened in a client.
    */
   override_priority: orNull(t.number)
@@ -49,7 +49,7 @@ export const StreamSubscriptionRequest = t.object({
   include_defaults: t.boolean.optional(),
 
   /**
-   * An array of sync streams the client has opened explicitly.
+   * An array of Sync Streams the client has opened explicitly.
    */
   subscriptions: t.array(RequestedStreamSubscription)
 });
@@ -253,8 +253,8 @@ export interface BucketChecksum {
 /**
  * The reason a particular bucket is included in a checkpoint.
  *
- * This information allows clients to associate individual buckets with sync streams they're subscribed to. Having that
- * association is useful because it enables clients to track progress for individual sync streams.
+ * This information allows clients to associate individual buckets with Sync Streams they're subscribed to. Having that
+ * association is useful because it enables clients to track progress for individual Sync Streams.
  */
 export type BucketSubscriptionReason = BucketDerivedFromDefaultStream | BucketDerivedFromExplicitSubscription;
 

package/test/src/AbstractReplicator.test.ts

@@ -1,6 +1,9 @@
+import type { RouteAPI } from '@/api/RouteAPI.js';
+import { assertSourceCapabilities } from '@/api/source-capabilities.js';
 import { AbstractReplicationJob } from '@/replication/AbstractReplicationJob.js';
 import { AbstractReplicator, AbstractReplicatorOptions, CreateJobOptions } from '@/replication/AbstractReplicator.js';
 import { PersistedReplicationStream } from '@/storage/PersistedReplicationStream.js';
+import type { ReplicationLock } from '@/storage/ReplicationLock.js';
 import { SyncRulesBucketStorage } from '@/storage/SyncRulesBucketStorage.js';
 import { describe, expect, it, vi } from 'vitest';
 
@@ -45,6 +48,21 @@ class TestReplicator extends AbstractReplicator {
     return (this as any).heartbeatIntervalNanos;
   }
 
+  async runStartupForTest(): Promise<void> {
+    const controller = new AbortController();
+    controller.abort();
+    (this as any).abortController = controller;
+    await (this as any).runLoop();
+  }
+
+  async refreshForTest(configuredLock?: ReplicationLock): Promise<{ replicationJobStarted: boolean }> {
+    (this as any).abortController = new AbortController();
+    return (this as any).refresh({
+      configuredLock,
+      loadedVersionLabel: this.syncRuleProvider.versionLabel
+    });
+  }
+
   shouldHandleStreamForTest(
     replicationStream: PersistedReplicationStream,
     loadedSyncRules: string | undefined,
@@ -54,6 +72,144 @@ class TestReplicator extends AbstractReplicator {
   }
 }
 
+describe('AbstractReplicator startup sync config', () => {
+  it.each([true, false])('respects exit_on_error=%s for unsupported file-loaded filters', async (exitOnError) => {
+    const yaml = /* yaml */ `
+      # sync config fixture.
+      config:
+        edition: 3
+        source_table_options:
+          orders:
+            mongodb_filter_expression: { $eq: ['$$doc.active', true] }
+      streams:
+        orders:
+          query: SELECT * FROM orders
+    `;
+    const configureSyncRules = vi.fn(
+      async (_options: import('@/storage/BucketStorageFactory.js').UpdateSyncRulesOptions) => ({ updated: false })
+    );
+    const replicator = new TestReplicator(async () => {}, {
+      id: 'test',
+      storageEngine: {
+        activeBucketStorage: { configureSyncRules }
+      } as unknown as AbstractReplicatorOptions['storageEngine'],
+      configuration: { connections: [{ type: 'postgresql' }] },
+      syncRuleProvider: { get: async () => yaml, exitOnError, versionLabel: undefined },
+      metricsEngine: {} as AbstractReplicatorOptions['metricsEngine'],
+      rateLimiter: {} as AbstractReplicatorOptions['rateLimiter']
+    });
+    if (exitOnError) {
+      await expect(replicator.runStartupForTest()).rejects.toThrow('only supported by MongoDB sources');
+      expect(configureSyncRules).not.toHaveBeenCalled();
+    } else {
+      await expect(replicator.runStartupForTest()).resolves.toBeUndefined();
+      expect(configureSyncRules).toHaveBeenCalledOnce();
+      expect(configureSyncRules.mock.calls[0][0].config.plan?.errors).toEqual([
+        expect.objectContaining({
+          level: 'fatal',
+          message: expect.stringContaining('only supported by MongoDB sources')
+        })
+      ]);
+    }
+  });
+
+  it.each(
+    [true, false].flatMap((exitOnError) =>
+      (['warning', 'valid', 'unexpected error'] as const).map((result) => ({ exitOnError, result }))
+    )
+  )(
+    'checks source capabilities before persistence: $result, exit_on_error=$exitOnError',
+    async ({ result, exitOnError }) => {
+      const yaml = /* yaml */ `
+        # sync config fixture.
+        config:
+          edition: 3
+        streams:
+          orders:
+            query: SELECT * FROM orders
+      `;
+      const calls: string[] = [];
+      const configureSyncRules = vi.fn(async () => {
+        calls.push('persist');
+        return { updated: false };
+      });
+      const replicator = new TestReplicator(async () => {}, {
+        id: 'test',
+        storageEngine: {
+          activeBucketStorage: { configureSyncRules }
+        } as unknown as AbstractReplicatorOptions['storageEngine'],
+        syncRuleProvider: { get: async () => yaml, exitOnError, versionLabel: undefined },
+        metricsEngine: {} as AbstractReplicatorOptions['metricsEngine'],
+        rateLimiter: {} as AbstractReplicatorOptions['rateLimiter']
+      });
+      replicator.registerSourceCapabilitiesAssertion((config) =>
+        assertSourceCapabilities(
+          {
+            async validateSourceCapabilities() {
+              calls.push('validate');
+              if (result === 'unexpected error') throw new Error('Source validation failed');
+              return result === 'warning' ? [{ level: 'warning', message: 'Missing index' }] : [];
+            }
+          } as unknown as RouteAPI,
+          config
+        )
+      );
+
+      if (result === 'unexpected error' && exitOnError) {
+        await expect(replicator.runStartupForTest()).rejects.toThrow('Source validation failed');
+        expect(calls).toEqual(['validate']);
+      } else {
+        await replicator.runStartupForTest();
+        expect(calls).toEqual(['validate', 'persist']);
+      }
+    }
+  );
+
+  it.each([true, false])('retains source-table options with exit_on_error=%s', async (exitOnError) => {
+    const yaml = /* yaml */ `
+      {
+        config: { edition: 3, source_table_options: { orders: { mongodb_filter_expression: 'disabled' } } },
+        streams: { orders: { query: SELECT * FROM orders } }
+      }
+    `;
+    const configureSyncRules = vi.fn(async () => ({ updated: false }));
+    const replicator = new TestReplicator(async () => {}, {
+      id: 'test',
+      storageEngine: {
+        activeBucketStorage: { configureSyncRules }
+      } as unknown as AbstractReplicatorOptions['storageEngine'],
+      syncRuleProvider: { get: async () => yaml, exitOnError, versionLabel: 'v2' },
+      metricsEngine: {} as AbstractReplicatorOptions['metricsEngine'],
+      rateLimiter: {} as AbstractReplicatorOptions['rateLimiter']
+    });
+
+    await replicator.runStartupForTest();
+
+    expect(configureSyncRules).toHaveBeenCalledExactlyOnceWith(
+      expect.objectContaining({
+        lock: true,
+        version_label: 'v2',
+        config: expect.objectContaining({
+          parsed: expect.objectContaining({
+            errors: [],
+            config: expect.objectContaining({
+              plan: expect.objectContaining({
+                sourceTableConfig: { orders: { mongodb_filter_expression: 'disabled' } }
+              })
+            })
+          }),
+          plan: expect.objectContaining({
+            plan: expect.objectContaining({
+              version: 3,
+              sourceTableConfig: { orders: { mongodb_filter_expression: 'disabled' } }
+            })
+          })
+        })
+      })
+    );
+  });
+});
+
 describe('AbstractReplicator heartbeat interval', () => {
   const options: AbstractReplicatorOptions = {
     id: 'test',