@powersync/service-module-mongodb-storage 0.17.0 → 0.18.1

package/src/storage/implementation/v3/models.ts

@@ -1,15 +1,25 @@
-import { InternalOpId, SerializedSyncPlan, SyncRuleState } from '@powersync/service-core';
-import { BucketDefinitionId, ParameterIndexId } from '@powersync/service-sync-rules';
+import {
+  InternalOpId,
+  PersistedDefinitionMapping,
+  SerializedSyncPlan,
+  SyncRuleState,
+  deserializeParameterLookup as deserializeParameterLookupCore
+} from '@powersync/service-core';
+import {
+  BucketDefinitionId,
+  ParameterIndexId,
+  ScopedParameterLookup,
+  SqliteJsonValue
+} from '@powersync/service-sync-rules';
 import * as bson from 'bson';
-import { BucketDataDoc, BucketKey } from '../common/BucketDataDoc.js';
 import {
-  BucketDataDocumentBase,
   BucketDataKey,
   BucketParameterDocumentBase,
   BucketStateDocumentBase,
   CurrentBucket,
+  OpType,
   ReplicaId,
-  SourceTableDocument,
+  SourceTableDocumentSnapshotStatus,
   SourceTableKey,
   SyncRuleCheckpointFields,
   SyncRuleDocumentBase,
@@ -19,7 +29,7 @@ import {
 /**
  * Embedded in sync_rules.sync_configs.
  */
-export interface SyncRuleConfigStateV3 extends SyncRuleCheckpointFields<bigint | null> {
+export interface SyncRuleConfigStateV3 extends SyncRuleCheckpointFields {
   _id: bson.ObjectId;
 
   /**
@@ -47,6 +57,31 @@ export interface ReplicationStreamDocumentV3 extends SyncRuleDocumentBase {
    * but the model allows multiple configs in any state.
    */
   sync_configs: SyncRuleConfigStateV3[];
+
+  /**
+   * The monotonic head of the stream's op sequence: the highest op id persisted to bucket data,
+   * whether or not yet covered by a checkpoint.
+   *
+   * This is shared across all sync configs of the stream (they share the global op sequence).
+   * It is never cleared, only `$max`-advanced. A newly-appended config that replicates nothing
+   * adopts this value as its checkpoint rather than starting at 0.
+   *
+   * Stored as a mongo Long, nullable.
+   */
+  last_persisted_op?: bigint | null;
+
+  /**
+   * The stream's replication position: all source changes up to this LSN have been processed,
+   * and the resulting ops persisted. Replication resumes from here.
+   *
+   * Like {@link last_persisted_op}, this is shared across all sync configs of the stream -
+   * per-config last_checkpoint_lsn values are consistency markers, not replication positions.
+   *
+   * Set via setResumeLsn() (snapshot start, and per-batch progress during streaming), and
+   * advanced on every commit/keepalive - including checkpoint-blocked ones, since commit
+   * flushes first and blocking only delays consistency markers, not data persistence.
+   */
+  resume_lsn?: string | null;
 }
 
 /**
@@ -70,16 +105,7 @@ export interface SyncConfigDefinition {
   content: string;
   serialized_plan?: SerializedSyncPlan | null;
 
-  rule_mapping: {
-    /**
-     * Map of uniqueName -> id, unique per replication stream.
-     */
-    definitions: Record<string, string>;
-    /**
-     * Map of (lookupName, queryId) -> id, unique per replication stream.
-     */
-    parameter_indexes: Record<string, string>;
-  };
+  rule_mapping: PersistedDefinitionMapping;
 }
 
 export interface CurrentBucketV3 extends CurrentBucket {
@@ -108,50 +134,26 @@ export interface BucketParameterDocumentV3 extends BucketParameterDocumentBase<S
 
 export type BucketDataKeyV3 = BucketDataKey;
 
-export interface BucketDataDocumentV3 extends BucketDataDocumentBase {
-  _id: BucketDataKeyV3;
-}
-
-export function serializeBucketDataV3(document: BucketDataDoc): BucketDataDocumentV3 {
-  const { bucketKey, o } = document;
-  return {
-    _id: {
-      b: bucketKey.bucket,
-      o: o
-    },
-    // List fields directly, so that we don't accidentally persist any unknown fields
-    op: document.op,
-    source_table: document.source_table,
-    source_key: document.source_key,
-    table: document.table,
-    row_id: document.row_id,
-    checksum: document.checksum,
-    data: document.data,
-    target_op: document.target_op
-  };
-}
-
-export function loadBucketDataDocumentV3(
-  context: Pick<BucketKey, 'replicationStreamId' | 'definitionId'>,
-  doc: BucketDataDocumentV3
-): BucketDataDoc {
-  const { _id, ...rest } = doc;
-  return {
-    bucketKey: {
-      ...context,
-      bucket: _id.b
-    },
-    o: _id.o,
-    ...rest
-  };
-}
-
 export function taggedBucketParameterDocumentToV3(document: TaggedBucketParameterDocument): BucketParameterDocumentV3 {
   const { index: _index, ...rest } = document;
   return rest as BucketParameterDocumentV3;
 }
 
-export interface SourceTableDocumentV3 extends SourceTableDocument {
+export interface ReplicaIdColumn {
+  name: string;
+  type_oid?: number;
+  type?: string;
+}
+
+export interface SourceTableDocumentV3 {
+  _id: bson.ObjectId;
+  connection_id: number;
+  relation_id: number | string | undefined;
+  schema_name: string;
+  table_name: string;
+  replica_id_columns: ReplicaIdColumn[];
+  snapshot_done: boolean;
+  snapshot_status: SourceTableDocumentSnapshotStatus | undefined;
   bucket_data_source_ids: BucketDefinitionId[];
   parameter_lookup_source_ids: ParameterIndexId[];
   latest_pending_delete?: InternalOpId | undefined;
@@ -162,3 +164,39 @@ export interface BucketStateDocumentV3 extends BucketStateDocumentBase {
     d: BucketDefinitionId;
   };
 }
+
+export interface BucketOperation {
+  o: bigint;
+  op: OpType;
+  source_table?: bson.ObjectId;
+  source_key?: ReplicaId;
+  table?: string;
+  row_id?: string;
+  checksum: bigint;
+  data: string | null;
+}
+
+export interface BucketDataDocumentV3 {
+  _id: BucketDataKey;
+  min_op: bigint;
+  checksum: bigint;
+  count: number;
+  size: number;
+  target_op?: bigint | null;
+  ops: BucketOperation[];
+}
+
+export function serializeParameterLookup(lookup: ScopedParameterLookup): bson.Binary {
+  return new bson.Binary(bson.serialize({ l: lookup.values.slice(2) }));
+}
+
+export function deserializeParameterLookup(lookup: bson.Binary, indexId: ParameterIndexId): SqliteJsonValue[] {
+  return [indexId, '', ...deserializeParameterLookupCore(lookup)];
+}
+
+export function taggedBucketParameterDocumentToTagged(
+  document: TaggedBucketParameterDocument
+): BucketParameterDocumentV3 {
+  const { index: _index, ...rest } = document;
+  return rest as BucketParameterDocumentV3;
+}

package/src/storage/implementation/v3/source-table-utils.ts

@@ -0,0 +1,392 @@
+import { ReplicationAssertionError } from '@powersync/lib-services-framework';
+import { BucketDefinitionMapping, ColumnDescriptor, storage } from '@powersync/service-core';
+import {
+  BucketDataSource,
+  BucketDefinitionId,
+  HydratedSyncConfig,
+  MatchingSources,
+  ParameterIndexId,
+  ParameterIndexLookupCreator,
+  SourceTableRef
+} from '@powersync/service-sync-rules';
+import * as bson from 'bson';
+import { ReplicaIdColumn, SourceTableDocumentV3 } from './models.js';
+
+export interface SourceTableIdentity {
+  schema: string;
+  name: string;
+  objectId: number | string | undefined;
+  replicaIdColumns: ReplicaIdColumn[];
+}
+
+export interface SourceTableMembershipIds {
+  bucketDataSourceIds: BucketDefinitionId[];
+  parameterLookupSourceIds: ParameterIndexId[];
+}
+
+export interface SourceTableDesiredResolution {
+  bucketSourceById: Map<BucketDefinitionId, BucketDataSource>;
+  parameterLookupSourceById: Map<ParameterIndexId, ParameterIndexLookupCreator>;
+  triggersEvent: boolean;
+}
+
+export interface SourceTableReconciliationContext {
+  connectionId: number;
+  connectionTag: string;
+  identity: SourceTableIdentity;
+  storeCurrentData: boolean;
+  syncConfig: HydratedSyncConfig;
+  mapping: BucketDefinitionMapping;
+  desired: SourceTableDesiredResolution;
+}
+
+export interface SourceTableReconciliationPlan {
+  /** Retained source tables, with memberships narrowed to the desired set. */
+  tables: storage.SourceTable[];
+  /** Membership narrowing to persist for retained snapshot-incomplete docs. */
+  narrowingUpdates: SourceTableMembershipUpdate[];
+  /**
+   * Memberships for a new source-table doc covering desired ids no existing doc covers,
+   * or null if no new doc is needed. Empty memberships indicate an event-only table.
+   */
+  newTableMemberships: SourceTableMembershipIds | null;
+  /** Identity-overlapping docs that conflict with the current identity and must be dropped. */
+  dropDocs: SourceTableDocumentV3[];
+}
+
+export interface SourceTableMembershipUpdate {
+  id: bson.ObjectId;
+  memberships: SourceTableMembershipIds;
+}
+
+export interface NewSourceTable {
+  doc: SourceTableDocumentV3;
+  table: storage.SourceTable;
+}
+
+export function sourceTableDesiredResolution(
+  syncConfig: HydratedSyncConfig,
+  ref: SourceTableRef,
+  mapping: BucketDefinitionMapping
+): SourceTableDesiredResolution {
+  const matchingSources = syncConfig.getMatchingSources(ref);
+  return {
+    bucketSourceById: new Map(
+      matchingSources.bucketDataSources.map((source) => [mapping.bucketSourceId(source), source] as const)
+    ),
+    parameterLookupSourceById: new Map(
+      matchingSources.parameterLookupSources.map((source) => [mapping.parameterLookupId(source), source] as const)
+    ),
+    triggersEvent: syncConfig.tableTriggersEvent(ref)
+  };
+}
+
+export function planSourceTableReconciliation(
+  candidateDocs: SourceTableDocumentV3[],
+  context: SourceTableReconciliationContext
+): SourceTableReconciliationPlan {
+  return new SourceTableReconciliationPlanner(context).plan(candidateDocs);
+}
+
+function sameStringArray(left: string[], right: string[]) {
+  return left.length == right.length && left.every((value, index) => value == right[index]);
+}
+
+function matchingSourcesFor(
+  desired: SourceTableDesiredResolution,
+  memberships: SourceTableMembershipIds
+): MatchingSources {
+  return {
+    bucketDataSources: memberships.bucketDataSourceIds.map((id) => desired.bucketSourceById.get(id)!),
+    parameterLookupSources: memberships.parameterLookupSourceIds.map((id) => desired.parameterLookupSourceById.get(id)!)
+  };
+}
+
+function intersectMembershipIds(
+  doc: SourceTableDocumentV3,
+  desired: SourceTableDesiredResolution
+): SourceTableMembershipIds {
+  return {
+    bucketDataSourceIds: doc.bucket_data_source_ids.filter((id) => desired.bucketSourceById.has(id)),
+    parameterLookupSourceIds: doc.parameter_lookup_source_ids.filter((id) => desired.parameterLookupSourceById.has(id))
+  };
+}
+
+function hasMembershipIds(memberships: SourceTableMembershipIds) {
+  return memberships.bucketDataSourceIds.length > 0 || memberships.parameterLookupSourceIds.length > 0;
+}
+
+function sameMembershipIds(doc: SourceTableDocumentV3, memberships: SourceTableMembershipIds) {
+  return (
+    sameStringArray(doc.bucket_data_source_ids, memberships.bucketDataSourceIds) &&
+    sameStringArray(doc.parameter_lookup_source_ids, memberships.parameterLookupSourceIds)
+  );
+}
+
+class SourceTableReconciliationPlanner {
+  private readonly coveredBucketDataSourceIds = new Set<string>();
+  private readonly coveredParameterLookupSourceIds = new Set<string>();
+  private readonly retainedDocIds = new Set<string>();
+  private readonly tables: storage.SourceTable[] = [];
+  private readonly narrowingUpdates: SourceTableMembershipUpdate[] = [];
+  private retainedEventOnlyTable = false;
+
+  constructor(private readonly context: SourceTableReconciliationContext) {}
+
+  plan(candidateDocs: SourceTableDocumentV3[]): SourceTableReconciliationPlan {
+    const { identity } = this.context;
+    for (const doc of candidateDocs) {
+      if (matchingSourceTableIdentity(doc, identity)) {
+        this.retainDoc(doc);
+      }
+    }
+
+    return {
+      tables: this.tables,
+      narrowingUpdates: this.narrowingUpdates,
+      newTableMemberships: this.newTableMemberships(),
+      // Non-retained overlapping docs represent renames / relation-id changes /
+      // replica-identity changes. Same-identity stale docs are retained in production.
+      dropDocs: candidateDocs.filter(
+        (doc) => !this.retainedDocIds.has(doc._id.toHexString()) && !matchingSourceTableIdentity(doc, identity)
+      )
+    };
+  }
+
+  private retainDoc(doc: SourceTableDocumentV3) {
+    const memberships = intersectMembershipIds(doc, this.context.desired);
+    const coversDesiredMembership = hasMembershipIds(memberships);
+    const coversEventOnlyTable =
+      !this.desiredHasMembership() && this.context.desired.triggersEvent && !this.retainedEventOnlyTable;
+
+    this.recordCoverage(doc, memberships);
+    this.planNarrowingUpdate(doc, memberships, coversDesiredMembership, coversEventOnlyTable);
+
+    if (coversDesiredMembership || coversEventOnlyTable) {
+      this.retainedEventOnlyTable ||= coversEventOnlyTable;
+      this.retainedDocIds.add(doc._id.toHexString());
+      this.tables.push(this.sourceTableFor(doc, memberships));
+    }
+  }
+
+  private desiredHasMembership() {
+    const { desired } = this.context;
+    return desired.bucketSourceById.size > 0 || desired.parameterLookupSourceById.size > 0;
+  }
+
+  private recordCoverage(doc: SourceTableDocumentV3, memberships: SourceTableMembershipIds) {
+    this.addCoverage(doc, 'bucket data source', this.coveredBucketDataSourceIds, memberships.bucketDataSourceIds);
+    this.addCoverage(
+      doc,
+      'parameter lookup source',
+      this.coveredParameterLookupSourceIds,
+      memberships.parameterLookupSourceIds
+    );
+  }
+
+  // Membership sets must be pairwise disjoint across the docs of one physical table:
+  // each desired id is covered by exactly one doc, so each definition receives each
+  // row exactly once. The algorithm maintains this (new docs only get uncovered ids,
+  // narrowing only removes ids) - overlap means the persisted state is corrupt.
+  private addCoverage(doc: SourceTableDocumentV3, kind: string, covered: Set<string>, ids: string[]) {
+    const { schema, name } = this.context.identity;
+    for (const id of ids) {
+      if (covered.has(id)) {
+        throw new ReplicationAssertionError(
+          `Source table ${doc._id} duplicates coverage of ${kind} ${id} for ${schema}.${name}`
+        );
+      }
+      covered.add(id);
+    }
+  }
+
+  private planNarrowingUpdate(
+    doc: SourceTableDocumentV3,
+    memberships: SourceTableMembershipIds,
+    coversDesiredMembership: boolean,
+    coversEventOnlyTable: boolean
+  ) {
+    const shouldNarrow =
+      (coversDesiredMembership || coversEventOnlyTable) && !doc.snapshot_done && !sameMembershipIds(doc, memberships);
+
+    if (!shouldNarrow) {
+      return;
+    }
+
+    this.narrowingUpdates.push({
+      id: doc._id,
+      memberships
+    });
+  }
+
+  private newTableMemberships(): SourceTableMembershipIds | null {
+    const { desired } = this.context;
+    const uncovered: SourceTableMembershipIds = {
+      bucketDataSourceIds: [...desired.bucketSourceById.keys()].filter(
+        (id) => !this.coveredBucketDataSourceIds.has(id)
+      ),
+      parameterLookupSourceIds: [...desired.parameterLookupSourceById.keys()].filter(
+        (id) => !this.coveredParameterLookupSourceIds.has(id)
+      )
+    };
+    if (hasMembershipIds(uncovered) || (desired.triggersEvent && this.tables.length == 0)) {
+      return uncovered;
+    }
+    return null;
+  }
+
+  private sourceTableFor(doc: SourceTableDocumentV3, memberships: SourceTableMembershipIds): storage.SourceTable {
+    const { connectionTag, syncConfig, mapping, desired, storeCurrentData } = this.context;
+    const table = sourceTableFromDocument(
+      doc,
+      connectionTag,
+      syncConfig,
+      mapping,
+      matchingSourcesFor(desired, memberships),
+      memberships
+    );
+    table.storeCurrentData = storeCurrentData;
+    return table;
+  }
+}
+
+function sameReplicaIdColumns(left: ReplicaIdColumn[] | undefined, right: ReplicaIdColumn[]) {
+  return (
+    left != null &&
+    left.length == right.length &&
+    left.every(
+      (column, index) =>
+        column.name == right[index].name && column.type == right[index].type && column.type_oid == right[index].type_oid
+    )
+  );
+}
+
+function matchingSourceTableIdentity(doc: SourceTableDocumentV3, identity: SourceTableIdentity) {
+  return (
+    doc.schema_name == identity.schema &&
+    doc.table_name == identity.name &&
+    (identity.objectId == null || doc.relation_id == identity.objectId) &&
+    sameReplicaIdColumns(doc.replica_id_columns, identity.replicaIdColumns)
+  );
+}
+
+export function overlappingSourceTableFilter(
+  connectionId: number,
+  identity: Pick<SourceTableIdentity, 'schema' | 'name' | 'objectId'>
+): Record<string, unknown> {
+  const clauses = [{ schema_name: identity.schema, table_name: identity.name }] as Record<string, unknown>[];
+  if (identity.objectId != null) {
+    clauses.push({ relation_id: identity.objectId });
+  }
+
+  return {
+    connection_id: connectionId,
+    $or: clauses
+  };
+}
+
+export function createNewSourceTable(
+  id: bson.ObjectId,
+  memberships: SourceTableMembershipIds,
+  context: SourceTableReconciliationContext
+): NewSourceTable {
+  const { connectionId, connectionTag, identity, syncConfig, mapping, desired, storeCurrentData } = context;
+  const doc: SourceTableDocumentV3 = {
+    _id: id,
+    connection_id: connectionId,
+    relation_id: identity.objectId,
+    schema_name: identity.schema,
+    table_name: identity.name,
+    replica_id_columns: identity.replicaIdColumns,
+    snapshot_done: false,
+    snapshot_status: undefined,
+    bucket_data_source_ids: memberships.bucketDataSourceIds,
+    parameter_lookup_source_ids: memberships.parameterLookupSourceIds
+  };
+  const table = sourceTableFromDocument(
+    doc,
+    connectionTag,
+    syncConfig,
+    mapping,
+    matchingSourcesFor(desired, memberships),
+    memberships
+  );
+  table.storeCurrentData = storeCurrentData;
+
+  return { doc, table };
+}
+
+export function designateEventCarrier(tables: storage.SourceTable[], triggersEvent: boolean) {
+  if (!triggersEvent) {
+    return;
+  }
+
+  const eventCarrier = tables.find((table) => table.snapshotComplete) ?? tables[0];
+  for (const table of tables) {
+    table.syncEvent = table === eventCarrier;
+  }
+}
+
+function sourceTableMembershipsFromDocument(
+  doc: SourceTableDocumentV3,
+  syncConfig: HydratedSyncConfig,
+  mapping: BucketDefinitionMapping
+): MatchingSources {
+  const bucketDataSourceIds = new Set(doc.bucket_data_source_ids);
+  const parameterLookupSourceIds = new Set(doc.parameter_lookup_source_ids);
+
+  return {
+    bucketDataSources: syncConfig.bucketDataSources.filter((source) =>
+      bucketDataSourceIds.has(mapping.bucketSourceId(source))
+    ),
+    parameterLookupSources: syncConfig.bucketParameterLookupSources.filter((source) =>
+      parameterLookupSourceIds.has(mapping.parameterLookupId(source))
+    )
+  };
+}
+
+export function sourceTableFromDocument(
+  doc: SourceTableDocumentV3,
+  connectionTag: string,
+  syncConfig: HydratedSyncConfig,
+  mapping: BucketDefinitionMapping,
+  memberships?: MatchingSources,
+  membershipIds?: SourceTableMembershipIds
+): storage.SourceTable {
+  const resolvedMemberships = memberships ?? sourceTableMembershipsFromDocument(doc, syncConfig, mapping);
+  const resolvedMembershipIds = membershipIds ?? {
+    bucketDataSourceIds: resolvedMemberships.bucketDataSources.map((source) => mapping.bucketSourceId(source)),
+    parameterLookupSourceIds: resolvedMemberships.parameterLookupSources.map((source) =>
+      mapping.parameterLookupId(source)
+    )
+  };
+  const table = new storage.SourceTable({
+    id: doc._id,
+    ref: {
+      connectionTag,
+      schema: doc.schema_name,
+      name: doc.table_name
+    },
+    objectId: doc.relation_id,
+    replicaIdColumns: doc.replica_id_columns!.map(
+      (c) => ({ name: c.name, typeId: c.type_oid, type: c.type }) satisfies ColumnDescriptor
+    ),
+    snapshotComplete: doc.snapshot_done,
+    bucketDataSources: resolvedMemberships.bucketDataSources,
+    parameterLookupSources: resolvedMemberships.parameterLookupSources,
+    bucketDataSourceIds: new Set(resolvedMembershipIds.bucketDataSourceIds),
+    parameterLookupSourceIds: new Set(resolvedMembershipIds.parameterLookupSourceIds)
+  });
+  table.syncData = table.bucketDataSources.length > 0;
+  table.syncParameters = table.parameterLookupSources.length > 0;
+  table.syncEvent = syncConfig.tableTriggersEvent(table.ref);
+  table.snapshotStatus =
+    doc.snapshot_status == null
+      ? undefined
+      : {
+          lastKey: doc.snapshot_status.last_key?.buffer ?? null,
+          totalEstimatedCount: doc.snapshot_status.total_estimated_count,
+          replicatedCount: doc.snapshot_status.replicated_count
+        };
+  return table;
+}

package/src/storage/storage-index.ts

@@ -1,17 +1,25 @@
 export * as test_utils from '../utils/test-utils.js';
 export * from '../utils/util.js';
-export * from './implementation/BucketDefinitionMapping.js';
 export * from './implementation/common/PersistedBatch.js';
 export * from './implementation/createMongoSyncBucketStorage.js';
 export * from './implementation/db.js';
 export * from './implementation/models.js';
 export * from './implementation/MongoIdSequence.js';
-export * from './implementation/MongoPersistedSyncRules.js';
-export * from './implementation/MongoPersistedSyncRulesContent.js';
+export * from './implementation/MongoParsedSyncConfigSet.js';
+export * from './implementation/MongoPersistedReplicationStream.js';
 export * from './implementation/MongoStorageProvider.js';
 export * from './implementation/MongoSyncRulesLock.js';
 export * from './implementation/OperationBatch.js';
 export * from './implementation/v1/models.js';
-export * from './implementation/v3/models.js';
+export { loadBucketDataDocument, serializeBucketData } from './implementation/v3/bucket-format.js';
+export {
+  BucketDataDocumentV3,
+  BucketOperation,
+  RecordedLookupV3,
+  ReplicationStreamDocumentV3,
+  SyncConfigDefinition,
+  SyncRuleConfigStateV3,
+  taggedBucketParameterDocumentToTagged
+} from './implementation/v3/models.js';
 export * from './MongoBucketStorage.js';
 export * from './MongoReportStorage.js';

package/src/utils/test-utils.ts

@@ -7,8 +7,7 @@ import { PowerSyncMongo } from '../storage/implementation/db.js';
 export type MongoTestStorageOptions = {
   url: string;
   isCI: boolean;
-  internalOptions?: MongoBucketStorageOptions;
-};
+} & Omit<MongoBucketStorageOptions, 'replicationStreamNamePrefix'>;
 
 export function mongoTestStorageFactoryGenerator(factoryOptions: MongoTestStorageOptions) {
   return {
@@ -27,7 +26,11 @@ export function mongoTestStorageFactoryGenerator(factoryOptions: MongoTestStorag
         await db.clear();
       }
 
-      return new MongoBucketStorage(db, { slot_name_prefix: 'test_' }, factoryOptions.internalOptions);
+      return new MongoBucketStorage(db, {
+        replicationStreamNamePrefix: 'test_',
+        checksumOptions: factoryOptions.checksumOptions,
+        supportsMultipleSyncConfigs: factoryOptions.supportsMultipleSyncConfigs
+      });
     },
     tableIdStrings: false
   };

package/src/utils/util.ts

@@ -26,9 +26,9 @@ export function idPrefixFilter<T>(prefix: Partial<T>, rest: (keyof T)[]): mongo.
   return filter;
 }
 
-export function generateSlotName(prefix: string, sync_rules_id: number) {
+export function generateReplicationStreamName(prefix: string, replicationStreamId: number) {
   const slot_suffix = crypto.randomBytes(2).toString('hex');
-  return `${prefix}${sync_rules_id}_${slot_suffix}`;
+  return `${prefix}${replicationStreamId}_${slot_suffix}`;
 }
 
 /**
@@ -141,6 +141,7 @@ export async function retryOnMongoMaxTimeMSExpired<T>(
   }
 ): Promise<T> {
   let retryCount = 0;
+  // Retry indefinitely on MaxTimeMSExpired errors with exponential backoff.
   while (true) {
     if (options.signal?.aborted) {
       throw new ReplicationAbortedError(options.abortMessage ?? 'Aborted MongoDB operation', options.signal.reason);