@powersync/service-module-mongodb-storage 0.16.0 → 0.18.0

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

@@ -0,0 +1,38 @@
+import { BucketDataDoc } from '../common/BucketDataDoc.js';
+
+export const DEFAULT_MAX_DOC_SIZE_BYTES = 1024 * 1024; // 1MB
+
+/**
+ * Split an array of bucket data operations into chunks where each chunk's
+ * total data size stays close to `maxDocSizeBytes`.
+ *
+ * The threshold is a target, not a hard ceiling — a single operation whose
+ * `data` field exceeds the limit is placed in its own chunk and is NOT split.
+ */
+export function chunkBucketData(
+  operations: BucketDataDoc[],
+  maxDocSizeBytes = DEFAULT_MAX_DOC_SIZE_BYTES
+): BucketDataDoc[][] {
+  const chunks: BucketDataDoc[][] = [];
+  let currentChunk: BucketDataDoc[] = [];
+  let currentSize = 0;
+
+  for (const op of operations) {
+    const opSize = op.data?.length ?? 0;
+
+    if (currentSize + opSize > maxDocSizeBytes && currentChunk.length > 0) {
+      chunks.push(currentChunk);
+      currentChunk = [];
+      currentSize = 0;
+    }
+
+    currentChunk.push(op);
+    currentSize += opSize;
+  }
+
+  if (currentChunk.length > 0) {
+    chunks.push(currentChunk);
+  }
+
+  return chunks;
+}

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

@@ -1,19 +1,113 @@
-import { InternalOpId } from '@powersync/service-core';
+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 { BucketDefinitionId, ParameterIndexId } from '../BucketDefinitionMapping.js';
-import { BucketDataDoc, BucketKey } from '../common/BucketDataDoc.js';
 import {
-  BucketDataDocumentBase,
   BucketDataKey,
   BucketParameterDocumentBase,
   BucketStateDocumentBase,
   CurrentBucket,
+  OpType,
   ReplicaId,
-  SourceTableDocument,
+  SourceTableDocumentSnapshotStatus,
   SourceTableKey,
+  SyncRuleCheckpointFields,
+  SyncRuleDocumentBase,
   TaggedBucketParameterDocument
 } from '../models.js';
 
+/**
+ * Embedded in sync_rules.sync_configs.
+ */
+export interface SyncRuleConfigStateV3 extends SyncRuleCheckpointFields {
+  _id: bson.ObjectId;
+
+  /**
+   * If false, we cannot create any checkpoints.
+   */
+  snapshot_done: boolean;
+
+  state: SyncRuleState;
+}
+
+/**
+ * Represents the state of a replication stream, in the sync_rules collection.
+ *
+ * Differences from V1:
+ * 1. The static config is moved into a separate sync_configs collection.
+ * 2. The same replication stream may be shared by multiple sync config instances.
+ */
+export interface ReplicationStreamDocumentV3 extends SyncRuleDocumentBase {
+  storage_version: number;
+
+  /**
+   * These contain the checkpoint/state per sync config.
+   *
+   * In common cases we'd have one active config or one active + one processing config,
+   * 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;
+}
+
+/**
+ * Static sync config definition.
+ *
+ * This should be treated as immutable - we don't update this after initial creation.
+ */
+export interface SyncConfigDefinition {
+  _id: bson.ObjectId;
+  created_at: Date;
+  storage_version: number;
+  /**
+   * The related SyncRuleDocumentV3.
+   *
+   * Note that a specific sync config definition never moves between replication streams. Instead, we can create a new copy for the new replication stream.
+   *
+   * When terminating a specific sync config definition, we remove the reference from replication stream -> sync config, but this reference here remains as a historical record.
+   */
+  replication_stream_id: number;
+
+  content: string;
+  serialized_plan?: SerializedSyncPlan | null;
+
+  rule_mapping: PersistedDefinitionMapping;
+}
+
 export interface CurrentBucketV3 extends CurrentBucket {
   def: BucketDefinitionId;
 }
@@ -40,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;
@@ -94,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';