@powersync/service-module-mongodb-storage 0.0.0-dev-20260803144812 → 0.0.0-dev-20260929095716

package/src/storage/implementation/MongoWriteBatch.ts

@@ -0,0 +1,172 @@
+import { mongo } from '@powersync/lib-service-mongodb';
+
+/**
+ * Explicitly groups writes with no intervening reads or result dependencies.
+ * Callers retain responsibility for transaction and ordering boundaries.
+ *
+ * On MongoDB 8.0+, this uses the client-level bulkWrite API.
+ *
+ * On MongoDB earlier versions, this uses the the collection-level bulkWrite API, or individual operations.
+ * This is less efficient, but produces the same results.
+ */
+export class MongoWriteBatch {
+  private readonly operations: mongo.AnyClientBulkWriteModel<mongo.Document>[] = [];
+  private readonly deleteChecks: { index: number; check: (count: number) => void }[] = [];
+  private readonly fallback: (() => Promise<unknown>)[] = [];
+
+  private readonly ordered: boolean;
+
+  constructor(
+    private readonly client: mongo.MongoClient,
+    private readonly supportsClientBulkWrite: boolean,
+    private readonly session: mongo.ClientSession | undefined,
+    options: { ordered: boolean }
+  ) {
+    this.ordered = options.ordered;
+  }
+
+  /**
+   * Perform a collection-level bulkWrite.
+   *
+   * On MongoDB 8.0+, these operations join the client-level bulkWrite with the batch's ordering.
+   * The driver may split commands to respect server batch limits.
+   *
+   * On earlier MongoDB versions, this always uses an unordered collection-level bulkWrite.
+   * Operations within this collection bulk must therefore be independent of their order.
+   */
+  bulkWriteUnordered<T extends mongo.Document>(
+    collection: mongo.Collection<T>,
+    operations: mongo.AnyBulkWriteOperation<T>[]
+  ): void {
+    if (operations.length === 0) return;
+    if (!this.supportsClientBulkWrite) {
+      this.fallback.push(() => collection.bulkWrite(operations, { ordered: false, session: this.session }));
+      return;
+    }
+    for (const operation of operations) {
+      // Collection and client models contain the same operation fields, with a
+      // different envelope. Keep the schema checked at the collection boundary.
+      const [name, model] = Object.entries(operation)[0];
+      this.operations.push({ ...model, name, namespace: collection.namespace });
+    }
+  }
+
+  insertOne<T extends mongo.Document>(collection: mongo.Collection<T>, document: mongo.OptionalUnlessRequiredId<T>) {
+    if (!this.supportsClientBulkWrite) {
+      this.fallback.push(() => collection.insertOne(document, { session: this.session }));
+      return;
+    }
+    this.addModel<T>({ name: 'insertOne', namespace: collection.namespace, document: document as mongo.OptionalId<T> });
+  }
+
+  insertMany<T extends mongo.Document>(
+    collection: mongo.Collection<T>,
+    documents: mongo.OptionalUnlessRequiredId<T>[]
+  ) {
+    if (documents.length === 0) return;
+    if (!this.supportsClientBulkWrite) {
+      this.fallback.push(() => collection.insertMany(documents, { session: this.session }));
+      return;
+    }
+    for (const document of documents) {
+      this.addModel<T>({
+        name: 'insertOne',
+        namespace: collection.namespace,
+        document: document as mongo.OptionalId<T>
+      });
+    }
+  }
+
+  deleteMany<T extends mongo.Document>(
+    collection: mongo.Collection<T>,
+    filter: mongo.Filter<T>,
+    checkDeletedCount?: (count: number) => void
+  ) {
+    if (checkDeletedCount) {
+      // Client-bulk results are checked after all writes execute. A failed
+      // invariant must roll back the entire batch, not leave later writes visible.
+      if (!this.session?.inTransaction()) throw new Error('Checked deletes require a transaction');
+    }
+    if (!this.supportsClientBulkWrite) {
+      this.fallback.push(async () => {
+        const result = await collection.deleteMany(filter, { session: this.session });
+        checkDeletedCount?.(result.deletedCount);
+      });
+      return;
+    }
+    if (checkDeletedCount) {
+      this.deleteChecks.push({ index: this.operations.length, check: checkDeletedCount });
+    }
+    this.addModel<T>({ name: 'deleteMany', namespace: collection.namespace, filter });
+  }
+
+  updateOne<T extends mongo.Document>(
+    collection: mongo.Collection<T>,
+    filter: mongo.Filter<T>,
+    update: mongo.UpdateFilter<T> | mongo.Document[],
+    options: Pick<mongo.UpdateOptions, 'upsert' | 'arrayFilters'> = {}
+  ) {
+    if (!this.supportsClientBulkWrite) {
+      this.fallback.push(() => collection.updateOne(filter, update, { ...options, session: this.session }));
+      return;
+    }
+    this.addModel({ name: 'updateOne', namespace: collection.namespace, filter, update, ...options });
+  }
+
+  updateMany<T extends mongo.Document>(
+    collection: mongo.Collection<T>,
+    filter: mongo.Filter<T>,
+    update: mongo.UpdateFilter<T> | mongo.Document[],
+    options: Pick<mongo.UpdateOptions, 'upsert' | 'arrayFilters'> = {}
+  ) {
+    if (!this.supportsClientBulkWrite) {
+      this.fallback.push(() => collection.updateMany(filter, update, { ...options, session: this.session }));
+      return;
+    }
+    this.addModel({ name: 'updateMany', namespace: collection.namespace, filter, update, ...options });
+  }
+
+  private addModel<T extends mongo.Document>(operation: mongo.AnyClientBulkWriteModel<T>) {
+    // The collection-specific methods validate the schema before erasing it here.
+    this.operations.push(operation as unknown as mongo.AnyClientBulkWriteModel<mongo.Document>);
+  }
+
+  /**
+   * Execute the queued writes.
+   *
+   * On MongoDB 8.0+, this uses the client-level bulkWrite API, typically resulting in a single command.
+   * The command may be split if there are a large number of operations.
+   *
+   * On earlier MongoDB versions, this executes each queued operation individually.
+   *
+   * If no operations were queued, this is a no-op.
+   */
+  async execute(): Promise<void> {
+    if (!this.supportsClientBulkWrite) {
+      // Sessions cannot execute concurrent operations within a transaction.
+      for (const write of this.fallback) await write();
+      return;
+    }
+    if (this.operations.length === 0) return;
+
+    try {
+      const result = await this.client.bulkWrite(this.operations, {
+        session: this.session,
+        ordered: this.ordered,
+        verboseResults: this.deleteChecks.length > 0
+      });
+      for (const { index, check } of this.deleteChecks) {
+        const deleted = result.deleteResults?.get(index);
+        if (deleted == null) throw new Error('Missing client bulk delete result');
+        check(deleted.deletedCount);
+      }
+    } catch (error) {
+      // The driver wraps command failures without copying their error labels.
+      // Preserve withTransaction's retry handling for e.g. write conflicts.
+      if (error instanceof mongo.MongoClientBulkWriteError && error.cause instanceof mongo.MongoError) {
+        throw error.cause;
+      }
+      throw error;
+    }
+  }
+}

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,56 +349,59 @@ 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) {
         const replicationLag = Math.round((Date.now() - options.oldestUncommittedChange.getTime()) / 1000);
 
         this.logger.info(
-          `Flushed ${this.bucketDataCount} + ${this.bucketParameters.length} + ${
+          `Flushed: ${this.bucketDataCount} ops, ${this.bucketParameters.length} index entries, ${
             this.currentDataCount
-          } updates, ${Math.round(this.currentSize / 1024)}kb in ${duration}ms. Last op_id: ${this.debugLastOpId}. Replication lag: ${replicationLag}s`,
+          } records. ${Math.round(this.currentSize / 1024)}kb in ${duration}ms. Last op_id: ${this.debugLastOpId}. Replication lag: ${replicationLag}s`,
           {
             flushed: {
               duration: duration,
               size: this.currentSize,
-              bucket_data_count: this.bucketDataCount,
-              parameter_data_count: this.bucketParameters.length,
-              current_data_count: this.currentDataCount,
+              bucket_ops_count: this.bucketDataCount,
+              parameter_indexes_count: this.bucketParameters.length,
+              source_records_count: this.currentDataCount,
               replication_lag_seconds: replicationLag
             }
           }
         );
       } else {
         this.logger.info(
-          `Flushed ${this.bucketDataCount} + ${this.bucketParameters.length} + ${
+          `Flushed: ${this.bucketDataCount} ops, ${this.bucketParameters.length} index entries, ${
             this.currentDataCount
-          } updates, ${Math.round(this.currentSize / 1024)}kb in ${duration}ms. Last op_id: ${this.debugLastOpId}`,
+          } records. ${Math.round(this.currentSize / 1024)}kb in ${duration}ms. Last op_id: ${this.debugLastOpId}`,
           {
             flushed: {
               duration: duration,
               size: this.currentSize,
-              bucket_data_count: this.bucketDataCount,
-              parameter_data_count: this.bucketParameters.length,
-              current_data_count: this.currentDataCount
+              bucket_ops_count: this.bucketDataCount,
+              parameter_indexes_count: this.bucketParameters.length,
+              source_records_count: this.currentDataCount
             }
           }
         );
@@ -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);
   }