@powersync/service-module-mongodb-storage 0.0.0-dev-20260225160713 → 0.0.0-dev-20260313100403

package/src/storage/implementation/MongoChecksums.ts

@@ -2,6 +2,7 @@ import * as lib_mongo from '@powersync/lib-service-mongodb';
 import {
   addPartialChecksums,
   bson,
+  BucketChecksumRequest,
   BucketChecksum,
   ChecksumCache,
   ChecksumMap,
@@ -12,7 +13,7 @@ import {
   PartialChecksumMap,
   PartialOrFullChecksum
 } from '@powersync/service-core';
-import { PowerSyncMongo } from './db.js';
+import { VersionedPowerSyncMongo } from './db.js';
 import { StorageConfig } from './models.js';
 
 /**
@@ -49,7 +50,7 @@ export class MongoChecksums {
   private readonly storageConfig: StorageConfig;
 
   constructor(
-    private db: PowerSyncMongo,
+    private db: VersionedPowerSyncMongo,
     private group_id: number,
     private options: MongoChecksumOptions
   ) {
@@ -74,7 +75,7 @@ export class MongoChecksums {
    * Calculate checksums, utilizing the cache for partial checkums, and querying the remainder from
    * the database (bucket_state + bucket_data).
    */
-  async getChecksums(checkpoint: InternalOpId, buckets: string[]): Promise<ChecksumMap> {
+  async getChecksums(checkpoint: InternalOpId, buckets: BucketChecksumRequest[]): Promise<ChecksumMap> {
     return this.cache.getChecksumMap(checkpoint, buckets);
   }
 
@@ -298,6 +299,7 @@ export class MongoChecksums {
           const req = requests.get(bucket);
           requests.set(bucket, {
             bucket,
+            source: req!.source,
             start: doc.last_op,
             end: req!.end
           });

package/src/storage/implementation/MongoCompactor.ts

@@ -9,7 +9,7 @@ import {
   utils
 } from '@powersync/service-core';
 
-import { PowerSyncMongo } from './db.js';
+import { VersionedPowerSyncMongo } from './db.js';
 import { BucketDataDocument, BucketDataKey, BucketStateDocument } from './models.js';
 import { MongoSyncBucketStorage } from './MongoSyncBucketStorage.js';
 import { cacheKey } from './OperationBatch.js';
@@ -85,19 +85,19 @@ export class MongoCompactor {
 
   constructor(
     private storage: MongoSyncBucketStorage,
-    private db: PowerSyncMongo,
-    options?: MongoCompactOptions
+    private db: VersionedPowerSyncMongo,
+    options: MongoCompactOptions
   ) {
     this.group_id = storage.group_id;
-    this.idLimitBytes = (options?.memoryLimitMB ?? DEFAULT_MEMORY_LIMIT_MB) * 1024 * 1024;
-    this.moveBatchLimit = options?.moveBatchLimit ?? DEFAULT_MOVE_BATCH_LIMIT;
-    this.moveBatchQueryLimit = options?.moveBatchQueryLimit ?? DEFAULT_MOVE_BATCH_QUERY_LIMIT;
-    this.clearBatchLimit = options?.clearBatchLimit ?? DEFAULT_CLEAR_BATCH_LIMIT;
-    this.minBucketChanges = options?.minBucketChanges ?? DEFAULT_MIN_BUCKET_CHANGES;
-    this.minChangeRatio = options?.minChangeRatio ?? DEFAULT_MIN_CHANGE_RATIO;
-    this.maxOpId = options?.maxOpId ?? 0n;
-    this.buckets = options?.compactBuckets;
-    this.signal = options?.signal;
+    this.idLimitBytes = (options.memoryLimitMB ?? DEFAULT_MEMORY_LIMIT_MB) * 1024 * 1024;
+    this.moveBatchLimit = options.moveBatchLimit ?? DEFAULT_MOVE_BATCH_LIMIT;
+    this.moveBatchQueryLimit = options.moveBatchQueryLimit ?? DEFAULT_MOVE_BATCH_QUERY_LIMIT;
+    this.clearBatchLimit = options.clearBatchLimit ?? DEFAULT_CLEAR_BATCH_LIMIT;
+    this.minBucketChanges = options.minBucketChanges ?? DEFAULT_MIN_BUCKET_CHANGES;
+    this.minChangeRatio = options.minChangeRatio ?? DEFAULT_MIN_CHANGE_RATIO;
+    this.maxOpId = options.maxOpId ?? 0n;
+    this.buckets = options.compactBuckets;
+    this.signal = options.signal;
   }
 
   /**
@@ -662,6 +662,7 @@ export class MongoCompactor {
       buckets.map((bucket) => {
         return {
           bucket,
+          source: {} as any,
           end: this.maxOpId
         };
       })

package/src/storage/implementation/MongoParameterCompactor.ts

@@ -1,8 +1,8 @@
+import { mongo } from '@powersync/lib-service-mongodb';
 import { logger } from '@powersync/lib-services-framework';
 import { bson, CompactOptions, InternalOpId } from '@powersync/service-core';
 import { LRUCache } from 'lru-cache';
-import { PowerSyncMongo } from './db.js';
-import { mongo } from '@powersync/lib-service-mongodb';
+import { VersionedPowerSyncMongo } from './db.js';
 import { BucketParameterDocument } from './models.js';
 
 /**
@@ -14,7 +14,7 @@ import { BucketParameterDocument } from './models.js';
  */
 export class MongoParameterCompactor {
   constructor(
-    private db: PowerSyncMongo,
+    private db: VersionedPowerSyncMongo,
     private group_id: number,
     private checkpoint: InternalOpId,
     private options: CompactOptions

package/src/storage/implementation/MongoPersistedSyncRulesContent.ts

@@ -1,9 +1,8 @@
 import { mongo } from '@powersync/lib-service-mongodb';
 import { storage } from '@powersync/service-core';
 import { MongoSyncRulesLock } from './MongoSyncRulesLock.js';
-import { PowerSyncMongo } from './db.js';
+import { PowerSyncMongo, VersionedPowerSyncMongo } from './db.js';
 import { getMongoStorageConfig, SyncRuleDocument } from './models.js';
-import { ErrorCode, ServiceError } from '@powersync/lib-services-framework';
 
 export class MongoPersistedSyncRulesContent extends storage.PersistedSyncRulesContent {
   public current_lock: MongoSyncRulesLock | null = null;
@@ -29,18 +28,11 @@ export class MongoPersistedSyncRulesContent extends storage.PersistedSyncRulesCo
   }
 
   getStorageConfig() {
-    const storageConfig = getMongoStorageConfig(this.storageVersion);
-    if (storageConfig == null) {
-      throw new ServiceError(
-        ErrorCode.PSYNC_S1005,
-        `Unsupported storage version ${this.storageVersion} for sync rules ${this.id}`
-      );
-    }
-    return storageConfig;
+    return getMongoStorageConfig(this.storageVersion);
   }
 
   async lock() {
-    const lock = await MongoSyncRulesLock.createLock(this.db, this);
+    const lock = await MongoSyncRulesLock.createLock(this.db.versioned(this.getStorageConfig()), this);
     this.current_lock = lock;
     return lock;
   }

package/src/storage/implementation/MongoSyncBucketStorage.ts

@@ -31,7 +31,7 @@ import { LRUCache } from 'lru-cache';
 import * as timers from 'timers/promises';
 import { idPrefixFilter, mapOpEntry, readSingleBatch, setSessionSnapshotTime } from '../../utils/util.js';
 import { MongoBucketStorage } from '../MongoBucketStorage.js';
-import { PowerSyncMongo } from './db.js';
+import { VersionedPowerSyncMongo } from './db.js';
 import {
   BucketDataDocument,
   BucketDataKey,
@@ -44,6 +44,7 @@ import { MongoBucketBatch } from './MongoBucketBatch.js';
 import { MongoChecksumOptions, MongoChecksums } from './MongoChecksums.js';
 import { MongoCompactor } from './MongoCompactor.js';
 import { MongoParameterCompactor } from './MongoParameterCompactor.js';
+import { MongoPersistedSyncRulesContent } from './MongoPersistedSyncRulesContent.js';
 import { MongoWriteCheckpointAPI } from './MongoWriteCheckpointAPI.js';
 
 export interface MongoSyncBucketStorageOptions {
@@ -66,7 +67,7 @@ export class MongoSyncBucketStorage
   extends BaseObserver<storage.SyncRulesBucketStorageListener>
   implements storage.SyncRulesBucketStorage
 {
-  private readonly db: PowerSyncMongo;
+  private readonly db: VersionedPowerSyncMongo;
   readonly checksums: MongoChecksums;
 
   private parsedSyncRulesCache: { parsed: HydratedSyncRules; options: storage.ParseSyncRulesOptions } | undefined;
@@ -75,13 +76,13 @@ export class MongoSyncBucketStorage
   constructor(
     public readonly factory: MongoBucketStorage,
     public readonly group_id: number,
-    private readonly sync_rules: storage.PersistedSyncRulesContent,
+    private readonly sync_rules: MongoPersistedSyncRulesContent,
     public readonly slot_name: string,
     writeCheckpointMode: storage.WriteCheckpointMode | undefined,
     options: MongoSyncBucketStorageOptions
   ) {
     super();
-    this.db = factory.db;
+    this.db = factory.db.versioned(sync_rules.getStorageConfig());
     this.checksums = new MongoChecksums(this.db, this.group_id, {
       ...options.checksumOptions,
       storageConfig: options?.storageConfig
@@ -166,10 +167,7 @@ export class MongoSyncBucketStorage
     });
   }
 
-  async startBatch(
-    options: storage.StartBatchOptions,
-    callback: (batch: storage.BucketStorageBatch) => Promise<void>
-  ): Promise<storage.FlushedResult | null> {
+  async createWriter(options: storage.CreateWriterOptions): Promise<storage.BucketStorageBatch> {
     const doc = await this.db.sync_rules.findOne(
       {
         _id: this.group_id
@@ -178,7 +176,7 @@ export class MongoSyncBucketStorage
     );
     const checkpoint_lsn = doc?.last_checkpoint_lsn ?? null;
 
-    await using batch = new MongoBucketBatch({
+    const writer = new MongoBucketBatch({
       logger: options.logger,
       db: this.db,
       syncRules: this.sync_rules.parsed(options).hydratedSyncRules(),
@@ -186,21 +184,26 @@ export class MongoSyncBucketStorage
       slotName: this.slot_name,
       lastCheckpointLsn: checkpoint_lsn,
       resumeFromLsn: maxLsn(checkpoint_lsn, doc?.snapshot_lsn),
-      noCheckpointBeforeLsn: doc?.no_checkpoint_before ?? options.zeroLSN,
       keepaliveOp: doc?.keepalive_op ? BigInt(doc.keepalive_op) : null,
       storeCurrentData: options.storeCurrentData,
       skipExistingRows: options.skipExistingRows ?? false,
       markRecordUnavailable: options.markRecordUnavailable
     });
-    this.iterateListeners((cb) => cb.batchStarted?.(batch));
-
-    await callback(batch);
-    await batch.flush();
-    if (batch.last_flushed_op != null) {
-      return { flushed_op: batch.last_flushed_op };
-    } else {
-      return null;
-    }
+    this.iterateListeners((cb) => cb.batchStarted?.(writer));
+    return writer;
+  }
+
+  /**
+   * @deprecated Use `createWriter()` with `await using` instead.
+   */
+  async startBatch(
+    options: storage.CreateWriterOptions,
+    callback: (batch: storage.BucketStorageBatch) => Promise<void>
+  ): Promise<storage.FlushedResult | null> {
+    await using writer = await this.createWriter(options);
+    await callback(writer);
+    await writer.flush();
+    return writer.last_flushed_op != null ? { flushed_op: writer.last_flushed_op } : null;
   }
 
   async resolveTable(options: storage.ResolveTableOptions): Promise<storage.ResolveTableResult> {
@@ -372,19 +375,20 @@ export class MongoSyncBucketStorage
 
   async *getBucketDataBatch(
     checkpoint: utils.InternalOpId,
-    dataBuckets: Map<string, InternalOpId>,
+    dataBuckets: storage.BucketDataRequest[],
     options?: storage.BucketDataBatchOptions
   ): AsyncIterable<storage.SyncBucketDataChunk> {
-    if (dataBuckets.size == 0) {
+    if (dataBuckets.length == 0) {
       return;
     }
     let filters: mongo.Filter<BucketDataDocument>[] = [];
+    const bucketMap = new Map(dataBuckets.map((request) => [request.bucket, request.start]));
 
     if (checkpoint == null) {
       throw new ServiceAssertionError('checkpoint is null');
     }
     const end = checkpoint;
-    for (let [name, start] of dataBuckets.entries()) {
+    for (let { bucket: name, start } of dataBuckets) {
       filters.push({
         _id: {
           $gt: {
@@ -477,7 +481,7 @@ export class MongoSyncBucketStorage
         }
 
         if (start == null) {
-          const startOpId = dataBuckets.get(bucket);
+          const startOpId = bucketMap.get(bucket);
           if (startOpId == null) {
             throw new ServiceAssertionError(`data for unexpected bucket: ${bucket}`);
           }
@@ -519,7 +523,10 @@ export class MongoSyncBucketStorage
     }
   }
 
-  async getChecksums(checkpoint: utils.InternalOpId, buckets: string[]): Promise<utils.ChecksumMap> {
+  async getChecksums(
+    checkpoint: utils.InternalOpId,
+    buckets: storage.BucketChecksumRequest[]
+  ): Promise<utils.ChecksumMap> {
     return this.checksums.getChecksums(checkpoint, buckets);
   }
 
@@ -576,7 +583,7 @@ export class MongoSyncBucketStorage
   async clear(options?: storage.ClearStorageOptions): Promise<void> {
     while (true) {
       if (options?.signal?.aborted) {
-        throw new ReplicationAbortedError('Aborted clearing data');
+        throw new ReplicationAbortedError('Aborted clearing data', options.signal.reason);
       }
       try {
         await this.clearIteration();
@@ -631,7 +638,7 @@ export class MongoSyncBucketStorage
       { maxTimeMS: lib_mongo.db.MONGO_CLEAR_OPERATION_TIMEOUT_MS }
     );
 
-    await this.db.current_data.deleteMany(
+    await this.db.common_current_data.deleteMany(
       {
         _id: idPrefixFilter<SourceKey>({ g: this.group_id }, ['t', 'k'])
       },

package/src/storage/implementation/MongoSyncRulesLock.ts

@@ -2,7 +2,7 @@ import crypto from 'crypto';
 
 import { ErrorCode, logger, ServiceError } from '@powersync/lib-services-framework';
 import { storage } from '@powersync/service-core';
-import { PowerSyncMongo } from './db.js';
+import { PowerSyncMongo, VersionedPowerSyncMongo } from './db.js';
 
 /**
  * Manages a lock on a sync rules document, so that only one process
@@ -12,7 +12,7 @@ export class MongoSyncRulesLock implements storage.ReplicationLock {
   private readonly refreshInterval: NodeJS.Timeout;
 
   static async createLock(
-    db: PowerSyncMongo,
+    db: VersionedPowerSyncMongo,
     sync_rules: storage.PersistedSyncRulesContent
   ): Promise<MongoSyncRulesLock> {
     const lockId = crypto.randomBytes(8).toString('hex');
@@ -52,7 +52,7 @@ export class MongoSyncRulesLock implements storage.ReplicationLock {
   }
 
   constructor(
-    private db: PowerSyncMongo,
+    private db: VersionedPowerSyncMongo,
     public sync_rules_id: number,
     private lock_id: string
   ) {

package/src/storage/implementation/MongoWriteCheckpointAPI.ts

@@ -1,16 +1,16 @@
 import { mongo } from '@powersync/lib-service-mongodb';
 import * as framework from '@powersync/lib-services-framework';
 import { GetCheckpointChangesOptions, InternalOpId, storage } from '@powersync/service-core';
-import { PowerSyncMongo } from './db.js';
+import { PowerSyncMongo, VersionedPowerSyncMongo } from './db.js';
 
 export type MongoCheckpointAPIOptions = {
-  db: PowerSyncMongo;
+  db: VersionedPowerSyncMongo;
   mode: storage.WriteCheckpointMode;
   sync_rules_id: number;
 };
 
 export class MongoWriteCheckpointAPI implements storage.WriteCheckpointAPI {
-  readonly db: PowerSyncMongo;
+  readonly db: VersionedPowerSyncMongo;
   private _mode: storage.WriteCheckpointMode;
 
   constructor(options: MongoCheckpointAPIOptions) {
@@ -166,7 +166,7 @@ export class MongoWriteCheckpointAPI implements storage.WriteCheckpointAPI {
 }
 
 export async function batchCreateCustomWriteCheckpoints(
-  db: PowerSyncMongo,
+  db: VersionedPowerSyncMongo,
   session: mongo.ClientSession,
   checkpoints: storage.CustomWriteCheckpointOptions[],
   opId: InternalOpId

package/src/storage/implementation/OperationBatch.ts

@@ -2,6 +2,7 @@ import { ToastableSqliteRow } from '@powersync/service-sync-rules';
 import * as bson from 'bson';
 
 import { storage } from '@powersync/service-core';
+import { mongoTableId } from '../storage-index.js';
 
 /**
  * Maximum number of operations in a batch.
@@ -86,8 +87,8 @@ export class RecordOperation {
     const beforeId = record.beforeReplicaId ?? record.afterReplicaId;
     this.afterId = afterId;
     this.beforeId = beforeId;
-    this.internalBeforeKey = cacheKey(record.sourceTable.id, beforeId);
-    this.internalAfterKey = afterId ? cacheKey(record.sourceTable.id, afterId) : null;
+    this.internalBeforeKey = cacheKey(mongoTableId(record.sourceTable.id), beforeId);
+    this.internalAfterKey = afterId ? cacheKey(mongoTableId(record.sourceTable.id), afterId) : null;
 
     this.estimatedSize = estimateRowSize(record.before) + estimateRowSize(record.after);
   }

package/src/storage/implementation/PersistedBatch.ts

@@ -5,9 +5,9 @@ import * as bson from 'bson';
 
 import { Logger, logger as defaultLogger } from '@powersync/lib-services-framework';
 import { InternalOpId, storage, utils } from '@powersync/service-core';
-import { currentBucketKey, MAX_ROW_SIZE } from './MongoBucketBatch.js';
+import { currentBucketKey, EMPTY_DATA, MAX_ROW_SIZE } from './MongoBucketBatch.js';
 import { MongoIdSequence } from './MongoIdSequence.js';
-import { PowerSyncMongo } from './db.js';
+import { PowerSyncMongo, VersionedPowerSyncMongo } from './db.js';
 import {
   BucketDataDocument,
   BucketParameterDocument,
@@ -16,7 +16,7 @@ import {
   CurrentDataDocument,
   SourceKey
 } from './models.js';
-import { replicaIdToSubkey } from '../../utils/util.js';
+import { mongoTableId, replicaIdToSubkey } from '../../utils/util.js';
 
 /**
  * Maximum size of operations we write in a single transaction.
@@ -63,6 +63,7 @@ export class PersistedBatch {
   currentSize = 0;
 
   constructor(
+    private db: VersionedPowerSyncMongo,
     private group_id: number,
     writtenSize: number,
     options?: { logger?: Logger }
@@ -132,7 +133,7 @@ export class PersistedBatch {
               o: op_id
             },
             op: 'PUT',
-            source_table: options.table.id,
+            source_table: mongoTableId(options.table.id),
             source_key: options.sourceKey,
             table: k.table,
             row_id: k.id,
@@ -159,7 +160,7 @@ export class PersistedBatch {
               o: op_id
             },
             op: 'REMOVE',
-            source_table: options.table.id,
+            source_table: mongoTableId(options.table.id),
             source_key: options.sourceKey,
             table: bd.table,
             row_id: bd.id,
@@ -208,7 +209,7 @@ export class PersistedBatch {
             _id: op_id,
             key: {
               g: this.group_id,
-              t: sourceTable.id,
+              t: mongoTableId(sourceTable.id),
               k: sourceKey
             },
             lookup: binLookup,
@@ -230,7 +231,7 @@ export class PersistedBatch {
             _id: op_id,
             key: {
               g: this.group_id,
-              t: sourceTable.id,
+              t: mongoTableId(sourceTable.id),
               k: sourceKey
             },
             lookup: lookup,
@@ -243,7 +244,7 @@ export class PersistedBatch {
     }
   }
 
-  deleteCurrentData(id: SourceKey) {
+  hardDeleteCurrentData(id: SourceKey) {
     const op: mongo.AnyBulkWriteOperation<CurrentDataDocument> = {
       deleteOne: {
         filter: { _id: id }
@@ -253,12 +254,41 @@ export class PersistedBatch {
     this.currentSize += 50;
   }
 
+  /**
+   * Mark a current_data document as soft deleted, to delete on the next commit.
+   *
+   * If softDeleteCurrentData is not enabled, this falls back to a hard delete.
+   */
+  softDeleteCurrentData(id: SourceKey, checkpointGreaterThan: bigint) {
+    if (!this.db.storageConfig.softDeleteCurrentData) {
+      this.hardDeleteCurrentData(id);
+      return;
+    }
+    const op: mongo.AnyBulkWriteOperation<CurrentDataDocument> = {
+      updateOne: {
+        filter: { _id: id },
+        update: {
+          $set: {
+            data: EMPTY_DATA,
+            buckets: [],
+            lookups: [],
+            pending_delete: checkpointGreaterThan
+          }
+        },
+        upsert: true
+      }
+    };
+    this.currentData.push(op);
+    this.currentSize += 50;
+  }
+
   upsertCurrentData(id: SourceKey, values: Partial<CurrentDataDocument>) {
     const op: mongo.AnyBulkWriteOperation<CurrentDataDocument> = {
       updateOne: {
         filter: { _id: id },
         update: {
-          $set: values
+          $set: values,
+          $unset: { pending_delete: 1 }
         },
         upsert: true
       }
@@ -276,7 +306,8 @@ export class PersistedBatch {
     );
   }
 
-  async flush(db: PowerSyncMongo, session: mongo.ClientSession, options?: storage.BucketBatchCommitOptions) {
+  async flush(session: mongo.ClientSession, options?: storage.BucketBatchCommitOptions) {
+    const db = this.db;
     const startAt = performance.now();
     let flushedSomething = false;
     if (this.bucketData.length > 0) {
@@ -297,7 +328,7 @@ export class PersistedBatch {
     }
     if (this.currentData.length > 0) {
       flushedSomething = true;
-      await db.current_data.bulkWrite(this.currentData, {
+      await db.common_current_data.bulkWrite(this.currentData, {
         session,
         // may update and delete data within the same batch - order matters
         ordered: true

package/src/storage/implementation/db.ts

@@ -10,13 +10,16 @@ import {
   CheckpointEventDocument,
   ClientConnectionDocument,
   CurrentDataDocument,
+  CurrentDataDocumentV3,
   CustomWriteCheckpointDocument,
   IdSequenceDocument,
   InstanceDocument,
   SourceTableDocument,
+  StorageConfig,
   SyncRuleDocument,
   WriteCheckpointDocument
 } from './models.js';
+import { ServiceAssertionError } from '@powersync/lib-services-framework';
 
 export interface PowerSyncMongoOptions {
   /**
@@ -27,6 +30,7 @@ export interface PowerSyncMongoOptions {
 
 export class PowerSyncMongo {
   readonly current_data: mongo.Collection<CurrentDataDocument>;
+  readonly v3_current_data: mongo.Collection<CurrentDataDocumentV3>;
   readonly bucket_data: mongo.Collection<BucketDataDocument>;
   readonly bucket_parameters: mongo.Collection<BucketParameterDocument>;
   readonly op_id_sequence: mongo.Collection<IdSequenceDocument>;
@@ -51,7 +55,8 @@ export class PowerSyncMongo {
     });
     this.db = db;
 
-    this.current_data = db.collection<CurrentDataDocument>('current_data');
+    this.current_data = db.collection('current_data');
+    this.v3_current_data = db.collection('v3_current_data');
     this.bucket_data = db.collection('bucket_data');
     this.bucket_parameters = db.collection('bucket_parameters');
     this.op_id_sequence = db.collection('op_id_sequence');
@@ -66,11 +71,16 @@ export class PowerSyncMongo {
     this.connection_report_events = this.db.collection('connection_report_events');
   }
 
+  versioned(storageConfig: StorageConfig) {
+    return new VersionedPowerSyncMongo(this, storageConfig);
+  }
+
   /**
    * Clear all collections.
    */
   async clear() {
     await this.current_data.deleteMany({});
+    await this.v3_current_data.deleteMany({});
     await this.bucket_data.deleteMany({});
     await this.bucket_parameters.deleteMany({});
     await this.op_id_sequence.deleteMany({});
@@ -171,6 +181,124 @@ export class PowerSyncMongo {
       { name: 'dirty_count' }
     );
   }
+
+  async initializeStorageVersion(storageConfig: StorageConfig) {
+    if (storageConfig.softDeleteCurrentData) {
+      // Initialize the v3_current_data collection, which is used for the new storage version.
+      // No-op if this already exists
+      await this.v3_current_data.createIndex(
+        {
+          '_id.g': 1,
+          pending_delete: 1
+        },
+        {
+          partialFilterExpression: { pending_delete: { $exists: true } },
+          name: 'pending_delete'
+        }
+      );
+    }
+  }
+}
+
+/**
+ * This is similar to PowerSyncMongo, but blocks access to certain collections based on the storage version.
+ */
+export class VersionedPowerSyncMongo {
+  readonly client: mongo.MongoClient;
+  readonly db: mongo.Db;
+
+  readonly storageConfig: StorageConfig;
+  #upstream: PowerSyncMongo;
+
+  constructor(upstream: PowerSyncMongo, storageConfig: StorageConfig) {
+    this.#upstream = upstream;
+    this.client = upstream.client;
+    this.db = upstream.db;
+    this.storageConfig = storageConfig;
+  }
+
+  /**
+   * Uses either `current_data` or `v3_current_data` collection based on the storage version.
+   *
+   * Use in places where it does not matter which version is used.
+   */
+  get common_current_data(): mongo.Collection<CurrentDataDocument> {
+    if (this.storageConfig.softDeleteCurrentData) {
+      return this.#upstream.v3_current_data;
+    } else {
+      return this.#upstream.current_data;
+    }
+  }
+
+  get v1_current_data() {
+    if (this.storageConfig.softDeleteCurrentData) {
+      throw new ServiceAssertionError(
+        'current_data collection should not be used when softDeleteCurrentData is enabled'
+      );
+    }
+    return this.#upstream.current_data;
+  }
+
+  get v3_current_data() {
+    if (!this.storageConfig.softDeleteCurrentData) {
+      throw new ServiceAssertionError(
+        'v3_current_data collection should not be used when softDeleteCurrentData is disabled'
+      );
+    }
+    return this.#upstream.v3_current_data;
+  }
+
+  get bucket_data() {
+    return this.#upstream.bucket_data;
+  }
+
+  get bucket_parameters() {
+    return this.#upstream.bucket_parameters;
+  }
+
+  get op_id_sequence() {
+    return this.#upstream.op_id_sequence;
+  }
+
+  get sync_rules() {
+    return this.#upstream.sync_rules;
+  }
+
+  get source_tables() {
+    return this.#upstream.source_tables;
+  }
+
+  get custom_write_checkpoints() {
+    return this.#upstream.custom_write_checkpoints;
+  }
+
+  get write_checkpoints() {
+    return this.#upstream.write_checkpoints;
+  }
+
+  get instance() {
+    return this.#upstream.instance;
+  }
+
+  get locks() {
+    return this.#upstream.locks;
+  }
+
+  get bucket_state() {
+    return this.#upstream.bucket_state;
+  }
+
+  get checkpoint_events() {
+    return this.#upstream.checkpoint_events;
+  }
+
+  get connection_report_events() {
+    return this.#upstream.connection_report_events;
+  }
+
+  notifyCheckpoint() {
+    return this.#upstream.notifyCheckpoint();
+  }
 }
 
 export function createPowerSyncMongo(config: MongoStorageConfig, options?: lib_mongo.MongoConnectionOptions) {