@powersync/service-module-mongodb-storage 0.20.0 → 0.22.0

package/src/storage/implementation/MongoWriteCheckpointAPI.ts

@@ -1,29 +1,31 @@
-import { mongo } from '@powersync/lib-service-mongodb';
 import * as framework from '@powersync/lib-services-framework';
-import { GetCheckpointChangesOptions, InternalOpId, storage } from '@powersync/service-core';
+import { GetCheckpointChangesOptions, storage } from '@powersync/service-core';
 import { VersionedPowerSyncMongo } from './db.js';
 
 export type MongoCheckpointAPIOptions = {
   db: VersionedPowerSyncMongo;
-  mode: storage.WriteCheckpointMode;
-  sync_rules_id: number;
+  writeCheckpointMode: storage.WriteCheckpointModeConfig;
+  replicationStreamId: number;
 };
 
 export class MongoWriteCheckpointAPI implements storage.WriteCheckpointAPI {
   readonly db: VersionedPowerSyncMongo;
+  readonly replicationStreamId: number;
+
   private _mode: storage.WriteCheckpointMode;
 
   constructor(options: MongoCheckpointAPIOptions) {
     this.db = options.db;
-    this._mode = options.mode;
+    this._mode = options.writeCheckpointMode.mode;
+    this.replicationStreamId = options.replicationStreamId;
   }
 
   get writeCheckpointMode() {
     return this._mode;
   }
 
-  setWriteCheckpointMode(mode: storage.WriteCheckpointMode): void {
-    this._mode = mode;
+  setWriteCheckpointMode(config: storage.WriteCheckpointModeConfig): void {
+    this._mode = config.mode;
   }
 
   async createManagedWriteCheckpoints(
@@ -93,7 +95,8 @@ export class MongoWriteCheckpointAPI implements storage.WriteCheckpointAPI {
             },
             upsert: true
           }
-        }))
+        })),
+        { ordered: false }
       );
 
       const userIds = generatedCheckpoints.map((checkpoint) => checkpoint.user_id);
@@ -178,7 +181,8 @@ export class MongoWriteCheckpointAPI implements storage.WriteCheckpointAPI {
             upsert: true
           }
         };
-      })
+      }),
+      { ordered: false }
     );
 
     // Fetch the final ids separately so stale requests can still return the
@@ -247,6 +251,7 @@ export class MongoWriteCheckpointAPI implements storage.WriteCheckpointAPI {
   }
 
   protected async lastCustomWriteCheckpoint(filters: storage.CustomWriteCheckpointFilters) {
+    // Legacy V1/V2 implementation.
     const { user_id, sync_rules_id } = filters;
     const lastWriteCheckpoint = await this.db.custom_write_checkpoints.findOne({
       user_id,
@@ -301,8 +306,9 @@ export class MongoWriteCheckpointAPI implements storage.WriteCheckpointAPI {
     };
   }
 
-  private async getCustomWriteCheckpointChanges(options: GetCheckpointChangesOptions) {
+  protected async getCustomWriteCheckpointChanges(options: GetCheckpointChangesOptions) {
     const limit = 1000;
+    // Legacy V1/V2 implementation.
     const changes = await this.db.custom_write_checkpoints
       .find(
         {
@@ -332,39 +338,3 @@ export class MongoWriteCheckpointAPI implements storage.WriteCheckpointAPI {
     };
   }
 }
-
-export async function batchCreateCustomWriteCheckpoints(
-  db: VersionedPowerSyncMongo,
-  session: mongo.ClientSession,
-  checkpoints: storage.CustomWriteCheckpointOptions[],
-  opId: InternalOpId
-): Promise<void> {
-  if (checkpoints.length == 0) {
-    return;
-  }
-
-  await db.custom_write_checkpoints.bulkWrite(
-    checkpoints.map((checkpointOptions) => {
-      const set: Record<string, unknown> = {
-        checkpoint: checkpointOptions.checkpoint,
-        sync_rules_id: checkpointOptions.sync_rules_id,
-        op_id: opId
-      };
-      if (checkpointOptions.checkpoint_requested_at != null) {
-        set.checkpoint_requested_at = checkpointOptions.checkpoint_requested_at;
-      }
-
-      return {
-        updateOne: {
-          filter: { user_id: checkpointOptions.user_id, sync_rules_id: checkpointOptions.sync_rules_id },
-          update: {
-            $set: set,
-            ...(checkpointOptions.checkpoint_requested_at == null ? { $unset: { checkpoint_requested_at: 1 } } : {})
-          },
-          upsert: true
-        }
-      };
-    }),
-    { session }
-  );
-}

package/src/storage/implementation/SyncRuleStateUpdate.ts

@@ -2,21 +2,28 @@ import { mongo } from '@powersync/lib-service-mongodb';
 import { storage } from '@powersync/service-core';
 
 /**
- * Update pipeline to update replication stream status, covering all storage versions.
+ * Update pipeline to stop a deploying replication stream, covering all storage versions.
  *
  * Roughly equivalent to:
  *   $set: {
- *     state: state,
- *     'sync_configs.$[].state': state
+ *     state: STOP,
+ *     'sync_configs.$[].state': STOP
  *   }
  *
  * The difference is that this also handles v1 storage cases, where `sync_configs` is not present.
+ *
+ * This can be used for specific use cases:
+ * 1. Stop an existing PROCESSING stream, when it is being replaced by a new PROCESSING one.
+ * 2. Stop an existing ACTIVE or ERRORED stream, when it is being replaced by a new ACTIVE one.
+ *
+ * Do not use this when an ACTIVE stream transitions to ERRORED, and is being replaced by a new PROCESSING one.
+ * In that case, we need to maintain the ERRORED state, which this pipeline does not cover.
  */
-export function syncRuleStateUpdatePipeline(state: storage.SyncRuleState): mongo.Document[] {
+export function stopReplicationStreamPipeline(): mongo.Document[] {
   return [
     {
       $set: {
-        state,
+        state: storage.SyncRuleState.STOP,
         sync_configs: {
           $cond: [
             { $isArray: '$sync_configs' },
@@ -25,7 +32,7 @@ export function syncRuleStateUpdatePipeline(state: storage.SyncRuleState): mongo
                 input: '$sync_configs',
                 as: 'config',
                 in: {
-                  $mergeObjects: ['$$config', { state }]
+                  $mergeObjects: ['$$config', { state: storage.SyncRuleState.STOP }]
                 }
               }
             },

package/src/storage/implementation/common/MongoSyncBucketStorageCheckpoint.ts

@@ -1,9 +1,31 @@
 import { mongo } from '@powersync/lib-service-mongodb';
-import { InternalOpId } from '@powersync/service-core';
+import { InternalOpId, ReplicationCheckpoint } from '@powersync/service-core';
 import * as bson from 'bson';
 
-export interface MongoSyncBucketStorageCheckpoint {
+export interface MongoSyncBucketStorageCheckpoint extends ReplicationCheckpoint {
   checkpoint: InternalOpId;
   snapshotTime: bson.Timestamp;
   clusterTime: mongo.ClusterTime;
+
+  /**
+   * The stream's `parameter_compaction.checkpoint_changes_invalid_before` boundary, read in the
+   * same snapshot as {@link checkpoint} and {@link snapshotTime}.
+   *
+   * Parameter compaction may have deleted parameter entries below this boundary, so checkpoint
+   * change detection cannot enumerate individual lookup changes from a checkpoint below it.
+   *
+   * 0n for streams that have never been compacted.
+   */
+  parameterChangesInvalidBefore: InternalOpId;
+}
+
+/**
+ * MongoDB-specific version of GetCheckpointChangesOptions.
+ *
+ * The next checkpoint carries the snapshot and invalidation boundary that change detection must
+ * be evaluated against. Only `checkpoint` is used from the previous one.
+ */
+export interface MongoGetCheckpointChangesOptions {
+  lastCheckpoint: ReplicationCheckpoint;
+  nextCheckpoint: MongoSyncBucketStorageCheckpoint;
 }

package/src/storage/implementation/common/PersistedBatch.ts

@@ -8,6 +8,7 @@ import { JSONBig } from '@powersync/service-jsonbig';
 import { mongoTableId, replicaIdToSubkey } from '../../../utils/util.js';
 import { currentBucketKey, MAX_ROW_SIZE } from '../MongoBucketBatchShared.js';
 import { MongoIdSequence } from '../MongoIdSequence.js';
+import { MongoWriteBatch } from '../MongoWriteBatch.js';
 import type { VersionedPowerSyncMongo } from '../db.js';
 import { TaggedBucketParameterDocument } from '../models.js';
 import { ObjectStorage } from '../v3/object-storage/ObjectStorage.js';
@@ -65,6 +66,11 @@ export interface PersistedBatchOptions {
   logger?: Logger;
   objectStorage?: ObjectStorage;
   inlineThresholdBytes?: number;
+  /**
+   * Aborts in-flight object storage uploads when replication stops.
+   */
+  signal?: AbortSignal;
+  objectStorageUsageWriterId?: string;
 }
 
 /**
@@ -81,6 +87,8 @@ export abstract class PersistedBatch {
 
   protected readonly objectStorage?: ObjectStorage;
   protected readonly inlineThresholdBytes: number = DEFAULT_INLINE_THRESHOLD_BYTES;
+  protected readonly signal?: AbortSignal;
+  protected readonly objectStorageUsageWriterId?: string;
 
   /**
    * For debug logging only.
@@ -102,6 +110,8 @@ export abstract class PersistedBatch {
     this.currentSize = writtenSize;
     this.logger = options?.logger ?? defaultLogger;
     this.objectStorage = options?.objectStorage;
+    this.signal = options?.signal;
+    this.objectStorageUsageWriterId = options?.objectStorageUsageWriterId;
     if (options?.inlineThresholdBytes != null) {
       this.inlineThresholdBytes = options.inlineThresholdBytes;
     }
@@ -124,7 +134,8 @@ export abstract class PersistedBatch {
       remaining_buckets.set(currentBucketKey(mapped), mapped);
     }
 
-    const dchecksum = BigInt(utils.hashDelete(replicaIdToSubkey(options.table.id, options.sourceKey)));
+    const subkey = this.persistedSubkey(options.table.id, options.sourceKey);
+    const dchecksum = BigInt(utils.hashDelete(subkey));
 
     for (const evaluated of options.evaluated) {
       const definitionId = this.getBucketDefinitionId(evaluated.source);
@@ -159,6 +170,7 @@ export abstract class PersistedBatch {
         bucket: evaluated.bucket,
         sourceTableId: options.table.id,
         sourceKey: options.sourceKey,
+        subkey,
         table: evaluated.table,
         rowId: evaluated.id,
         checksum: BigInt(checksum),
@@ -181,6 +193,7 @@ export abstract class PersistedBatch {
         op_id,
         sourceTableId: options.table.id,
         sourceKey: options.sourceKey,
+        subkey,
         table: bucket.table,
         rowId: bucket.id,
         checksum: dchecksum
@@ -204,19 +217,27 @@ export abstract class PersistedBatch {
 
   protected abstract get currentDataCount(): number;
 
-  protected abstract flushBucketData(session: mongo.ClientSession): Promise<void>;
+  protected abstract queueBucketData(writes: MongoWriteBatch): Promise<void>;
 
-  protected abstract flushBucketParameters(session: mongo.ClientSession): Promise<void>;
+  protected abstract queueBucketParameters(writes: MongoWriteBatch): void;
 
-  protected abstract flushCurrentData(session: mongo.ClientSession): Promise<void>;
+  protected abstract queueCurrentData(writes: MongoWriteBatch): void;
 
-  protected abstract flushBucketStates(session: mongo.ClientSession): Promise<void>;
+  protected abstract queueBucketStates(writes: MongoWriteBatch): void;
 
   protected abstract resetCurrentData(): void;
 
   protected abstract checkDefinitionId(definitionId: BucketDefinitionId | null): BucketDefinitionId;
   protected abstract getBucketDefinitionId(bucketSource: BucketDataSource): BucketDefinitionId;
 
+  /**
+   * New bucket operations persist protocol subkeys during replication. Older
+   * V1 documents may not have one, so sync reads retain a fallback.
+   */
+  protected persistedSubkey(table: storage.SourceTableId, key: storage.ReplicaId): string {
+    return replicaIdToSubkey(table, key);
+  }
+
   protected get bucketDataCount(): number {
     return this.bucketData.length;
   }
@@ -234,17 +255,45 @@ export abstract class PersistedBatch {
         bucket,
         lastOp: op_id,
         incrementCount: 1,
-        incrementBytes: bytes
+        incrementBytes: bytes,
+        incrementChunks: 0
       });
     }
   }
 
+  /**
+   * V3 persists operations in chunks. Keep this separate from incrementBucket:
+   * operation counts are known while evaluating rows, while chunk counts and
+   * exact persisted bytes are only known after the writer has chunked a flush.
+   */
+  protected incrementBucketPersistedChunk(definitionId: BucketDefinitionId, bucket: string, bytes: number) {
+    const key = `${definitionId ?? ''}:${bucket}`;
+    const existingState = this.bucketStates.get(key);
+    if (existingState != null) {
+      existingState.incrementChunks += 1;
+      existingState.incrementBytes += bytes;
+    }
+  }
+
+  /**
+   * V3's compactor calculates byte deltas from persisted chunk metadata.
+   * Replace the writer's per-operation estimate with those exact sizes before
+   * flushing the corresponding bucket state.
+   */
+  protected resetBucketPersistedBytes(definitionId: BucketDefinitionId, bucket: string) {
+    const state = this.bucketStates.get(`${definitionId ?? ''}:${bucket}`);
+    if (state != null) {
+      state.incrementBytes = 0;
+    }
+  }
+
   protected addBucketDataPut(options: {
     op_id: InternalOpId;
     bucketKey: BucketKey;
     bucket: string;
     sourceTableId: storage.SourceTable['id'];
     sourceKey: storage.ReplicaId;
+    subkey: string;
     table: string;
     rowId: string;
     checksum: bigint;
@@ -256,6 +305,7 @@ export abstract class PersistedBatch {
       op: 'PUT',
       source_table: mongoTableId(options.sourceTableId),
       source_key: options.sourceKey,
+      subkey: options.subkey,
       table: options.table,
       row_id: options.rowId,
       checksum: options.checksum,
@@ -268,6 +318,7 @@ export abstract class PersistedBatch {
     bucketKey: BucketKey;
     sourceTableId: storage.SourceTable['id'];
     sourceKey: storage.ReplicaId;
+    subkey: string;
     table: string;
     rowId: string;
     checksum: bigint;
@@ -278,6 +329,7 @@ export abstract class PersistedBatch {
       op: 'REMOVE',
       source_table: mongoTableId(options.sourceTableId),
       source_key: options.sourceKey,
+      subkey: options.subkey,
       table: options.table,
       row_id: options.rowId,
       checksum: options.checksum,
@@ -297,24 +349,27 @@ export abstract class PersistedBatch {
   async flush(session: mongo.ClientSession, options?: storage.BucketBatchCommitOptions) {
     const startAt = performance.now();
     let flushedSomething = false;
+    const writes = this.db.createWriteBatch(session, { ordered: false });
     if (this.bucketDataCount > 0) {
       flushedSomething = true;
-      await this.flushBucketData(session);
+      await this.queueBucketData(writes);
     }
     if (this.bucketParameters.length > 0) {
       flushedSomething = true;
-      await this.flushBucketParameters(session);
+      this.queueBucketParameters(writes);
     }
     if (this.currentDataCount > 0) {
       flushedSomething = true;
-      await this.flushCurrentData(session);
+      this.queueCurrentData(writes);
     }
 
     if (this.bucketStates.size > 0) {
       flushedSomething = true;
-      await this.flushBucketStates(session);
+      this.queueBucketStates(writes);
     }
 
+    await writes.execute();
+
     if (flushedSomething) {
       const duration = Math.round(performance.now() - startAt);
       if (options?.oldestUncommittedChange != null) {
@@ -377,4 +432,5 @@ export interface BucketStateUpdate {
   lastOp: InternalOpId;
   incrementCount: number;
   incrementBytes: number;
+  incrementChunks: number;
 }

package/src/storage/implementation/common/VersionedPowerSyncMongoBase.ts

@@ -58,6 +58,10 @@ export abstract class BaseVersionedPowerSyncMongo {
     return this.upstream.notifyCheckpoint();
   }
 
+  createWriteBatch(session: mongo.ClientSession | undefined, options: { ordered: boolean }) {
+    return this.upstream.createWriteBatch(session, options);
+  }
+
   protected sourceRecordsCollectionName(replicationStreamId: number, sourceTableId: mongo.ObjectId) {
     return this.upstream.sourceRecordsCollectionName(replicationStreamId, sourceTableId);
   }

package/src/storage/implementation/db.ts

@@ -17,6 +17,7 @@ import {
   SyncRuleDocumentBase,
   WriteCheckpointDocument
 } from './models.js';
+import { MongoWriteBatch } from './MongoWriteBatch.js';
 import {
   BucketDataDocumentV1,
   BucketParameterDocument,
@@ -24,8 +25,9 @@ import {
   CurrentDataDocument
 } from './v1/models.js';
 import { VersionedPowerSyncMongoV1 } from './v1/VersionedPowerSyncMongoV1.js';
-import { BucketDataDocumentV3 } from './v3/models.js';
-import { VersionedPowerSyncMongoV3 } from './v3/VersionedPowerSyncMongoV3.js';
+import { BucketDataDocumentV3, CustomCheckpointRequestDocumentV3 } from './v3/models.js';
+import type { CustomCheckpointRequestCollectionSpecifier } from './v3/VersionedPowerSyncMongoV3.js';
+import { OBJECT_STORAGE_USAGE_COLLECTION, VersionedPowerSyncMongoV3 } from './v3/VersionedPowerSyncMongoV3.js';
 
 export interface PowerSyncMongoOptions {
   /**
@@ -53,6 +55,19 @@ export class PowerSyncMongo {
 
   readonly client: mongo.MongoClient;
   readonly db: mongo.Db;
+  private get clientBulkWriteSupport(): boolean {
+    // The driver exposes topology at runtime, but omits this internal property
+    // from its public types. Reuse its handshake results without another command.
+    const client = this.client as mongo.MongoClient & { topology?: { description: mongo.TopologyDescription } };
+    const servers = [...(client.topology?.description.servers.values() ?? [])];
+    // MongoDB 8.0 introduced client bulkWrite at wire version 25. Unknown / mixed-version
+    // topologies use collection writes until all known servers support it.
+    return servers.length > 0 && servers.every((server) => server.maxWireVersion >= 25);
+  }
+
+  createWriteBatch(session: mongo.ClientSession | undefined, options: { ordered: boolean }): MongoWriteBatch {
+    return new MongoWriteBatch(this.client, this.clientBulkWriteSupport, session, options);
+  }
 
   constructor(client: mongo.MongoClient, options?: PowerSyncMongoOptions) {
     this.client = client;
@@ -137,6 +152,20 @@ export class PowerSyncMongo {
     return `source_table_${replicationStreamId}`;
   }
 
+  customCheckpointRequestCollectionName(options: CustomCheckpointRequestCollectionSpecifier) {
+    return `custom_checkpoint_requests_${options.replicationStreamId}_${options.eventId}`;
+  }
+
+  async listCustomCheckpointRequestCollections(
+    replicationStreamId?: number
+  ): Promise<mongo.Collection<CustomCheckpointRequestDocumentV3>[]> {
+    const prefix =
+      replicationStreamId == null
+        ? 'custom_checkpoint_requests_'
+        : `custom_checkpoint_requests_${replicationStreamId}_`;
+    return this.collectionsByPrefix(prefix);
+  }
+
   async listSourceTableCollections(
     replicationStreamId?: number
   ): Promise<mongo.Collection<CommonSourceTableDocument>[]> {
@@ -178,6 +207,10 @@ export class PowerSyncMongo {
     await this.locks.deleteMany({});
     await this.bucket_state.deleteMany({});
     await this.custom_write_checkpoints.deleteMany({});
+    await this.db.collection(OBJECT_STORAGE_USAGE_COLLECTION).deleteMany({});
+    for (const collection of await this.listCustomCheckpointRequestCollections()) {
+      await collection.drop();
+    }
   }
 
   /**

package/src/storage/implementation/models.ts

@@ -74,6 +74,12 @@ export interface BucketDataProperties {
   op: OpType;
   source_table?: bson.ObjectId;
   source_key?: ReplicaId;
+  /**
+   * Stable identifier for the source record in the client protocol.
+   *
+   * This is derived from (source_table, source_key), so persistence is optional but preferred.
+   */
+  subkey?: string;
   table?: string;
   row_id?: string;
   checksum: bigint;
@@ -215,6 +221,34 @@ export interface SyncRuleDocumentBase {
   } | null;
 
   storage_version?: number;
+
+  /** Optional operator-supplied label identifying the sync config version. */
+  version_label?: string | null;
+
+  /**
+   * Incremental parameter compaction state for the replication stream.
+   *
+   * Operation ids are allocated across all parameter indexes of a stream, so this is
+   * stream-level state, shared by all sync configs of the stream.
+   */
+  parameter_compaction?: {
+    /**
+     * The exclusive operation-id boundary through which every parameter index in this stream has
+     * been compacted.
+     */
+    compacted_before: InternalOpId;
+
+    /**
+     * Parameter entries below this boundary may no longer be available for checkpoint change
+     * detection, since compaction may have deleted them.
+     *
+     * This is advanced before the first delete of a compaction pass, while
+     * {@link compacted_before} is only advanced after every delete of the pass completed.
+     * A checkpoint transition starting below this boundary must conservatively invalidate all
+     * parameter buckets, since the individual changes may no longer be available.
+     */
+    checkpoint_changes_invalid_before?: InternalOpId;
+  };
 }
 
 export interface SyncRuleCheckpointFields {

package/src/storage/implementation/v1/MongoBucketBatchV1.ts

@@ -1,3 +1,4 @@
+import { mongo } from '@powersync/lib-service-mongodb';
 import { ReplicationAssertionError } from '@powersync/lib-services-framework';
 import { ColumnDescriptor, InternalOpId, SourceTable, storage } from '@powersync/service-core';
 import { HydratedSyncConfig } from '@powersync/service-sync-rules';
@@ -50,6 +51,43 @@ export class MongoBucketBatchV1 extends MongoBucketBatch {
     // No-op for V1: source records live in a shared collection.
   }
 
+  protected override async batchCreateCustomWriteCheckpoints(
+    session: mongo.ClientSession,
+    opId: InternalOpId
+  ): Promise<void> {
+    // Only the final checkpoint per user/stream is visible after this transaction.
+    const checkpoints = new Map(
+      this.write_checkpoint_batch.map((checkpoint) => [
+        JSON.stringify([checkpoint.sync_rules_id, checkpoint.user_id]),
+        checkpoint
+      ])
+    );
+    await this.db.custom_write_checkpoints.bulkWrite(
+      [...checkpoints.values()].map((checkpointOptions) => {
+        const set: Record<string, unknown> = {
+          checkpoint: checkpointOptions.checkpoint,
+          sync_rules_id: checkpointOptions.sync_rules_id,
+          op_id: opId
+        };
+        if (checkpointOptions.checkpoint_requested_at != null) {
+          set.checkpoint_requested_at = checkpointOptions.checkpoint_requested_at;
+        }
+
+        return {
+          updateOne: {
+            filter: { user_id: checkpointOptions.user_id, sync_rules_id: checkpointOptions.sync_rules_id },
+            update: {
+              $set: set,
+              ...(checkpointOptions.checkpoint_requested_at == null ? { $unset: { checkpoint_requested_at: 1 } } : {})
+            },
+            upsert: true
+          }
+        };
+      }),
+      { session, ordered: false }
+    );
+  }
+
   async resolveTables(options: storage.ResolveTablesOptions): Promise<storage.ResolveTablesResult> {
     const syncRules = options.parsedSyncConfig?.hydratedSyncConfig ?? this.sync_rules;
     const reconcile = options.reconcileSourceTables ?? storage.defaultSourceTableReconciler;
@@ -431,7 +469,9 @@ export class MongoBucketBatchV1 extends MongoBucketBatch {
     const ids = tables.map((table) => mongoTableId(table.id));
 
     await this.withTransaction(async () => {
-      await this.db.sourceTablesV1(this.replicationStreamId).updateMany(
+      const writes = this.db.createWriteBatch(session, { ordered: false });
+      writes.updateMany(
+        this.db.sourceTablesV1(this.replicationStreamId),
         { _id: { $in: ids } },
         {
           $set: {
@@ -440,12 +480,12 @@ export class MongoBucketBatchV1 extends MongoBucketBatch {
           $unset: {
             snapshot_status: 1
           }
-        },
-        { session }
+        }
       );
 
       if (no_checkpoint_before_lsn != null) {
-        await this.db.sync_rules.updateOne(
+        writes.updateOne(
+          this.db.sync_rules,
           {
             _id: this.replicationStreamId
           },
@@ -456,10 +496,10 @@ export class MongoBucketBatchV1 extends MongoBucketBatch {
             $max: {
               no_checkpoint_before: no_checkpoint_before_lsn
             }
-          },
-          { session: this.session }
+          }
         );
       }
+      await writes.execute();
     });
     return tables.map((table) => {
       const copy = table.clone();