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

package/dist/types/types.d.ts

@@ -1,5 +1,7 @@
 import * as service_types from '@powersync/service-types';
 import * as t from 'ts-codec';
+export declare const MongoStorageReadPreference: t.Union<t.Codec<"primary" | "primaryPreferred" | "secondary" | "secondaryPreferred", "primary" | "primaryPreferred" | "secondary" | "secondaryPreferred", string, t.CodecProps>, t.LiteralCodec<"nearest">>;
+export type MongoStorageReadPreference = t.Encoded<typeof MongoStorageReadPreference>;
 export declare const MongoStorageConfig: t.Intersection<t.Codec<{
     type: "mongodb";
     uri: string;
@@ -14,7 +16,16 @@ export declare const MongoStorageConfig: t.Intersection<t.Codec<{
     username?: string | undefined;
     password?: string | undefined;
     reject_ip_ranges?: string[] | undefined;
-}, string, t.CodecProps>, t.ObjectCodec<{}>>;
+}, string, t.CodecProps>, t.ObjectCodec<{
+    /**
+     * Read preference for bulk checksum and bucket data reads.
+     *
+     * If unset, MongoDB driver defaults are used for backwards compatibility.
+     *
+     * This is an experimental option, and may be removed in a future release.
+     */
+    bulk_read_preference: t.OptionalCodec<t.Codec<"primary" | "primaryPreferred" | "secondary" | "secondaryPreferred" | "nearest", "primary" | "primaryPreferred" | "secondary" | "secondaryPreferred" | "nearest", string, t.CodecProps>>;
+}>>;
 export type MongoStorageConfig = t.Encoded<typeof MongoStorageConfig>;
 export type MongoStorageConfigDecoded = t.Decoded<typeof MongoStorageConfig>;
 export declare function isMongoStorageConfig(config: service_types.configFile.GenericStorageConfig): config is MongoStorageConfig;

package/dist/types/types.js

@@ -1,7 +1,20 @@
 import * as lib_mongo from '@powersync/lib-service-mongodb';
 import * as t from 'ts-codec';
+export const MongoStorageReadPreference = t
+    .literal('primary')
+    .or(t.literal('primaryPreferred'))
+    .or(t.literal('secondary'))
+    .or(t.literal('secondaryPreferred'))
+    .or(t.literal('nearest'));
 export const MongoStorageConfig = lib_mongo.BaseMongoConfig.and(t.object({
-// Add any mongo specific storage settings here in future
+    /**
+     * Read preference for bulk checksum and bucket data reads.
+     *
+     * If unset, MongoDB driver defaults are used for backwards compatibility.
+     *
+     * This is an experimental option, and may be removed in a future release.
+     */
+    bulk_read_preference: MongoStorageReadPreference.optional()
 }));
 export function isMongoStorageConfig(config) {
     return config.type == lib_mongo.MONGO_CONNECTION_TYPE;

package/dist/types/types.js.map

@@ -1 +1 @@
-{"version":3,"file":"types.js","sourceRoot":"","sources":["../../src/types/types.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,SAAS,MAAM,gCAAgC,CAAC;AAE5D,OAAO,KAAK,CAAC,MAAM,UAAU,CAAC;AAE9B,MAAM,CAAC,MAAM,kBAAkB,GAAG,SAAS,CAAC,eAAe,CAAC,GAAG,CAC7D,CAAC,CAAC,MAAM,CAAC;AACP,yDAAyD;CAC1D,CAAC,CACH,CAAC;AAKF,MAAM,UAAU,oBAAoB,CAClC,MAAqD;IAErD,OAAO,MAAM,CAAC,IAAI,IAAI,SAAS,CAAC,qBAAqB,CAAC;AACxD,CAAC"}
+{"version":3,"file":"types.js","sourceRoot":"","sources":["../../src/types/types.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,SAAS,MAAM,gCAAgC,CAAC;AAE5D,OAAO,KAAK,CAAC,MAAM,UAAU,CAAC;AAE9B,MAAM,CAAC,MAAM,0BAA0B,GAAG,CAAC;KACxC,OAAO,CAAC,SAAS,CAAC;KAClB,EAAE,CAAC,CAAC,CAAC,OAAO,CAAC,kBAAkB,CAAC,CAAC;KACjC,EAAE,CAAC,CAAC,CAAC,OAAO,CAAC,WAAW,CAAC,CAAC;KAC1B,EAAE,CAAC,CAAC,CAAC,OAAO,CAAC,oBAAoB,CAAC,CAAC;KACnC,EAAE,CAAC,CAAC,CAAC,OAAO,CAAC,SAAS,CAAC,CAAC,CAAC;AAI5B,MAAM,CAAC,MAAM,kBAAkB,GAAG,SAAS,CAAC,eAAe,CAAC,GAAG,CAC7D,CAAC,CAAC,MAAM,CAAC;IACP;;;;;;OAMG;IACH,oBAAoB,EAAE,0BAA0B,CAAC,QAAQ,EAAE;CAC5D,CAAC,CACH,CAAC;AAKF,MAAM,UAAU,oBAAoB,CAClC,MAAqD;IAErD,OAAO,MAAM,CAAC,IAAI,IAAI,SAAS,CAAC,qBAAqB,CAAC;AACxD,CAAC"}

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@powersync/service-module-mongodb-storage",
   "repository": "https://github.com/powersync-ja/powersync-service",
-  "version": "0.18.0",
+  "version": "0.18.2",
   "license": "FSL-1.1-ALv2",
   "type": "module",
   "publishConfig": {
@@ -17,15 +17,15 @@
     "lru-cache": "^10.2.2",
     "ts-codec": "^1.3.0",
     "uuid": "^14.0.0",
-    "@powersync/lib-service-mongodb": "0.6.27",
-    "@powersync/lib-services-framework": "0.9.6",
-    "@powersync/service-core": "1.23.0",
+    "@powersync/lib-service-mongodb": "0.6.28",
+    "@powersync/lib-services-framework": "0.9.7",
+    "@powersync/service-core": "1.23.2",
     "@powersync/service-jsonbig": "0.17.13",
-    "@powersync/service-sync-rules": "0.38.0",
-    "@powersync/service-types": "0.16.0"
+    "@powersync/service-sync-rules": "0.38.1",
+    "@powersync/service-types": "0.16.1"
   },
   "devDependencies": {
-    "@powersync/service-core-tests": "0.17.0"
+    "@powersync/service-core-tests": "0.17.1"
   },
   "scripts": {
     "build": "tsc -b",

package/src/storage/MongoBucketStorage.ts

@@ -34,7 +34,9 @@ export interface MongoBucketStorageOptions {
    * Prefix for replication stream name and Postgres logical replication slot name.
    */
   replicationStreamNamePrefix: string;
+  readPreference?: mongo.ReadPreference;
   checksumOptions?: Omit<MongoChecksumOptions, 'storageConfig'>;
+  checksumCacheTtlMs?: number;
   /**
    * Reuse a compatible active replication stream by appending a new sync config.
    *
@@ -91,6 +93,8 @@ export class MongoBucketStorage extends storage.BucketStorageFactory {
       undefined,
       {
         checksumOptions: this.options.checksumOptions,
+        readPreference: this.options.readPreference,
+        checksumCacheTtlMs: this.options.checksumCacheTtlMs,
         storageConfig
       }
     );
@@ -458,9 +462,9 @@ export class MongoBucketStorage extends storage.BucketStorageFactory {
       },
       [...existingConfigDocs, syncConfigDoc]
     );
-    if (updateOptions.lock) {
-      await stream.lock(session);
-    }
+    // The stream already exists, so an active replication job may already hold the stream lock.
+    // Deployment only persists the appended sync config; replication job locking is handled by
+    // the replicator.
     return stream;
   }
 

package/src/storage/implementation/MongoBucketBatch.ts

@@ -107,7 +107,7 @@ export abstract class MongoBucketBatch
   private hooks: storage.StorageHooks | undefined;
   private clearedError = false;
 
-  private tracer: PerformanceTracer<'storage' | 'evaluate'>;
+  protected tracer: PerformanceTracer<'storage' | 'evaluate'>;
 
   /**
    * Last written op, if any. This may not reflect a consistent checkpoint.
@@ -198,14 +198,18 @@ export abstract class MongoBucketBatch
     const batch = this.batch;
     let last_op: InternalOpId | null = null;
     let resumeBatch: OperationBatch | null = null;
+    let clearedError = false;
 
     using _ = this.tracer.span('storage', 'flush');
 
     await this.hooks?.beforeBatchFlush?.(this);
 
     await this.withReplicationTransaction(`Flushing ${batch?.length ?? 0} ops`, async (session, opSeq) => {
+      clearedError = false;
       if (batch != null) {
-        resumeBatch = await this.replicateBatch(session, batch, opSeq, options);
+        const result = await this.replicateBatch(session, batch, opSeq, options);
+        resumeBatch = result.resumeBatch;
+        clearedError ||= result.clearedError;
       }
 
       if (this.write_checkpoint_batch.length > 0) {
@@ -217,6 +221,10 @@ export abstract class MongoBucketBatch
       last_op = opSeq.last();
     });
 
+    if (clearedError) {
+      this.clearedError = true;
+    }
+
     // null if done, set if we need another flush
     this.batch = resumeBatch;
 
@@ -235,7 +243,7 @@ export abstract class MongoBucketBatch
     batch: OperationBatch,
     op_seq: MongoIdSequence,
     options?: storage.BucketBatchCommitOptions
-  ): Promise<OperationBatch | null> {
+  ): Promise<{ resumeBatch: OperationBatch | null; clearedError: boolean }> {
     let sizes: Map<string, number> | undefined = undefined;
     using _ = this.tracer.span('storage', 'replicate_batch');
     // Only look up current_data sizes if the batch stores current_data and at least one
@@ -340,12 +348,17 @@ export abstract class MongoBucketBatch
       }
     }
 
-    if (didFlush) {
+    const clearedError = didFlush && !this.clearedError;
+    if (clearedError) {
+      // No need to clear an error more than once per batch, since an error would always result in restarting the batch.
       using _ = this.tracer.span('storage', 'clear_error');
-      await this.clearError();
+      await this.clearError(this.session);
     }
 
-    return resumeBatch?.hasData() ? resumeBatch : null;
+    return {
+      resumeBatch: resumeBatch?.hasData() ? resumeBatch : null,
+      clearedError
+    };
   }
 
   private saveOperation(
@@ -899,12 +912,7 @@ export abstract class MongoBucketBatch
     return copy;
   }
 
-  protected async clearError(): Promise<void> {
-    // No need to clear an error more than once per batch, since an error would always result in restarting the batch.
-    if (this.clearedError) {
-      return;
-    }
-
+  protected async clearError(session: mongo.ClientSession): Promise<void> {
     await this.db.sync_rules.updateOne(
       {
         _id: this.replicationStreamId
@@ -914,9 +922,11 @@ export abstract class MongoBucketBatch
           last_fatal_error: null,
           last_fatal_error_ts: null
         }
+      },
+      {
+        session
       }
     );
-    this.clearedError = true;
   }
 
   /**

package/src/storage/implementation/MongoChecksums.ts

@@ -1,3 +1,4 @@
+import { mongo } from '@powersync/lib-service-mongodb';
 import {
   addPartialChecksums,
   bson,
@@ -13,7 +14,9 @@ import {
 } from '@powersync/service-core';
 import type { VersionedPowerSyncMongo } from './db.js';
 
+import { ServiceAssertionError } from '@powersync/lib-services-framework';
 import { BucketDefinitionId } from '@powersync/service-sync-rules';
+import { setSessionSnapshotTime } from '../../utils/util.js';
 import { StorageConfig } from './models.js';
 
 export interface FetchPartialBucketChecksumByDefinition {
@@ -43,14 +46,40 @@ export interface MongoChecksumOptions {
    */
   operationBatchLimit?: number;
 
+  checksumCacheTtlMs?: number;
+
   storageConfig: StorageConfig;
 }
 
+/**
+ * Read options used in requests to the cache, used to construct a session.
+ *
+ * readConcern is always 'snapshot'.
+ */
+interface MongoChecksumCacheReadContext {
+  /**
+   * (Optional) Specify a specific Timestamp for the snapshot read.
+   */
+  snapshotTime?: mongo.Timestamp;
+
+  /**
+   * Read preference. Use undefined for the default,
+   */
+  readPreference: mongo.ReadPreference | undefined;
+}
+
+/**
+ * Read options passed into individual methods.
+ */
+export interface MongoChecksumSessionContext {
+  readOptions: Pick<mongo.CommandOperationOptions, 'session' | 'readPreference' | 'readConcern'>;
+}
+
 const DEFAULT_BUCKET_BATCH_LIMIT = 200;
 export const DEFAULT_OPERATION_BATCH_LIMIT = 50_000;
 
 export abstract class MongoChecksums {
-  private _cache: ChecksumCache | undefined;
+  private _cache: ChecksumCache<MongoChecksumCacheReadContext> | undefined;
   protected readonly storageConfig: StorageConfig;
 
   constructor(
@@ -66,10 +95,11 @@ export abstract class MongoChecksums {
    *
    * This means the cache only allocates memory once it is used for the first time.
    */
-  private get cache(): ChecksumCache {
-    this._cache ??= new ChecksumCache({
-      fetchChecksums: (batch) => {
-        return this.computePartialChecksums(batch);
+  private get cache(): ChecksumCache<MongoChecksumCacheReadContext> {
+    this._cache ??= new ChecksumCache<MongoChecksumCacheReadContext>({
+      ttlMs: this.options.checksumCacheTtlMs,
+      fetchChecksums: (batch, context) => {
+        return this.computePartialChecksums(batch, context);
       }
     });
     return this._cache;
@@ -79,8 +109,12 @@ export abstract 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: BucketChecksumRequest[]): Promise<ChecksumMap> {
-    return this.cache.getChecksumMap(checkpoint, buckets);
+  async getChecksums(
+    checkpoint: InternalOpId,
+    buckets: BucketChecksumRequest[],
+    options: MongoChecksumCacheReadContext
+  ): Promise<ChecksumMap> {
+    return this.cache.getChecksumMap(checkpoint, buckets, options);
   }
 
   clearCache() {
@@ -96,11 +130,39 @@ export abstract class MongoChecksums {
    * As long as data is compacted regularly, this should be fast. Large buckets without pre-compacted bucket_state
    * can be slow.
    */
-  private async computePartialChecksums(batch: FetchPartialBucketChecksum[]): Promise<PartialChecksumMap> {
+  private async computePartialChecksums(
+    batch: FetchPartialBucketChecksum[],
+    context: MongoChecksumCacheReadContext | undefined
+  ): Promise<PartialChecksumMap> {
     if (batch.length == 0) {
       return new Map();
     }
-    const preStates = await this.fetchPreStates(batch);
+
+    if (context == null) {
+      throw new ServiceAssertionError(`context is required`);
+    }
+
+    const { snapshotTime, readPreference } = context;
+    return this.db.client.withSession({ snapshot: true }, async (session) => {
+      if (snapshotTime != null) {
+        setSessionSnapshotTime(session, snapshotTime);
+      }
+      return this.computePartialChecksumsWithSession(batch, {
+        readOptions: {
+          // This is set on the session, but we set it on each operation as well just in case
+          readConcern: 'snapshot',
+          readPreference,
+          session
+        }
+      });
+    });
+  }
+
+  private async computePartialChecksumsWithSession(
+    batch: FetchPartialBucketChecksum[],
+    context: MongoChecksumSessionContext
+  ): Promise<PartialChecksumMap> {
+    const preStates = await this.fetchPreStates(batch, context);
 
     const mappedRequests = batch.map((request) => {
       let start = request.start;
@@ -116,7 +178,7 @@ export abstract class MongoChecksums {
       };
     });
 
-    const queriedChecksums = await this.computePartialChecksumsDirect(mappedRequests);
+    const queriedChecksums = await this.computePartialChecksumsDirect(mappedRequests, context);
 
     return new Map<string, PartialOrFullChecksum>(
       batch.map((request) => {
@@ -142,19 +204,22 @@ export abstract class MongoChecksums {
    * For large buckets, this can be slow, but should not time out as the underlying queries are performed in
    * smaller batches.
    */
-  public async computePartialChecksumsDirect(batch: FetchPartialBucketChecksum[]): Promise<PartialChecksumMap> {
+  private async computePartialChecksumsDirect(
+    batch: FetchPartialBucketChecksum[],
+    context: MongoChecksumSessionContext
+  ): Promise<PartialChecksumMap> {
     // Limit the number of buckets we query for at a time.
     const bucketBatchLimit = this.options?.bucketBatchLimit ?? DEFAULT_BUCKET_BATCH_LIMIT;
 
     if (batch.length <= bucketBatchLimit) {
       // Single batch - no need for splitting the batch and merging results
-      return await this.computePartialChecksumsInternal(batch);
+      return await this.computePartialChecksumsInternal(batch, context);
     }
     // Split the batch and merge results
     let results = new Map<string, PartialOrFullChecksum>();
     for (let i = 0; i < batch.length; i += bucketBatchLimit) {
       const bucketBatch = batch.slice(i, i + bucketBatchLimit);
-      const batchResults = await this.computePartialChecksumsInternal(bucketBatch);
+      const batchResults = await this.computePartialChecksumsInternal(bucketBatch, context);
       for (let r of batchResults.values()) {
         results.set(r.bucket, r);
       }
@@ -169,10 +234,14 @@ export abstract class MongoChecksums {
    *
    * `batch` must be limited to DEFAULT_BUCKET_BATCH_LIMIT buckets before calling this.
    */
-  protected abstract computePartialChecksumsInternal(batch: FetchPartialBucketChecksum[]): Promise<PartialChecksumMap>;
+  protected abstract computePartialChecksumsInternal(
+    batch: FetchPartialBucketChecksum[],
+    context: MongoChecksumSessionContext
+  ): Promise<PartialChecksumMap>;
 
   protected abstract fetchPreStates(
-    batch: FetchPartialBucketChecksum[]
+    batch: FetchPartialBucketChecksum[],
+    context: MongoChecksumSessionContext
   ): Promise<Map<string, { opId: InternalOpId; checksum: BucketChecksum }>>;
 }
 

package/src/storage/implementation/MongoCompactor.ts

@@ -120,7 +120,7 @@ export abstract class MongoCompactor {
   /**
    * Compact buckets by converting operations into MOVE and/or CLEAR operations.
    *
-   * See /docs/compacting-operations.md for details.
+   * See /docs/storage/compacting-operations.md for details.
    */
   async compact() {
     if (this.buckets) {

package/src/storage/implementation/MongoParameterCompactor.ts

@@ -16,7 +16,7 @@ type ParameterCompactionReadDocument = {
  *
  * This scans through the entire collection to find data to compact.
  *
- * For background, see the `/docs/parameters-lookups.md` file.
+ * For background, see the `/docs/storage/parameter-lookups.md` file.
  */
 export class MongoParameterCompactor {
   constructor(

package/src/storage/implementation/MongoPersistedSyncConfigContent.ts

@@ -69,7 +69,8 @@ export class MongoPersistedSyncConfigContentV1 extends MongoPersistedSyncConfigC
       replicationStreamName: doc.slot_name ?? `powersync_${doc._id}`,
       storageVersion: doc.storage_version ?? storage.LEGACY_STORAGE_VERSION,
       mapping: new SingleSyncConfigBucketDefinitionMapping(),
-      syncConfigId: null
+      syncConfigId: null,
+      syncConfigState: doc.state
     });
   }
 
@@ -98,7 +99,8 @@ export class MongoPersistedSyncConfigContentV3 extends MongoPersistedSyncConfigC
       replicationStreamName: doc.slot_name ?? `powersync_${doc._id}`,
       storageVersion: doc.storage_version,
       mapping: SingleSyncConfigBucketDefinitionMapping.fromPersistedMapping(config.rule_mapping),
-      syncConfigId: config._id
+      syncConfigId: config._id,
+      syncConfigState: state.state
     });
   }
 

package/src/storage/implementation/MongoStorageProvider.ts

@@ -38,8 +38,18 @@ export class MongoStorageProvider implements storage.StorageProvider {
     await client.connect();
 
     const database = new PowerSyncMongo(client, { database: resolvedConfig.storage.database });
+    const readPreference =
+      decodedConfig.bulk_read_preference == null
+        ? undefined
+        : new lib_mongo.mongo.ReadPreference(decodedConfig.bulk_read_preference, undefined, {
+            // maxStalenessSeconds is relevant for all modes except 'primary'.
+            // 90 is the minimum value.
+            maxStalenessSeconds: decodedConfig.bulk_read_preference == 'primary' ? undefined : 90
+          });
     const syncStorageFactory = new MongoBucketStorage(database, {
       replicationStreamNamePrefix: resolvedConfig.slot_name_prefix,
+      readPreference,
+      checksumCacheTtlMs: resolvedConfig.api_parameters.bucket_count_cache_ttl_minutes * 60_000,
       // Right now, only MongoDB source databases supports incremental reprocessing.
       // Remove this filter when we support it for other source databases.
       // This assumes a single source connection - revisit if we ever support multiple connections.

package/src/storage/implementation/MongoSyncBucketStorage.ts

@@ -40,6 +40,8 @@ import { MongoWriteCheckpointAPI } from './MongoWriteCheckpointAPI.js';
 
 export interface MongoSyncBucketStorageOptions {
   checksumOptions?: Omit<MongoChecksumOptions, 'storageConfig'>;
+  readPreference?: mongo.ReadPreference;
+  checksumCacheTtlMs?: number;
   storageConfig: StorageConfig;
 }
 
@@ -80,6 +82,7 @@ export abstract class MongoSyncBucketStorage
   private writeCheckpointAPI: MongoWriteCheckpointAPI;
   public readonly logger: Logger;
   public readonly storageConfig: StorageConfig;
+  public readonly readPreference: mongo.ReadPreference | undefined;
   #storageInitialized = false;
 
   constructor(
@@ -92,6 +95,7 @@ export abstract class MongoSyncBucketStorage
   ) {
     super();
     this.storageConfig = options.storageConfig;
+    this.readPreference = options.readPreference;
     this.db = factory.db.versioned(this.storageConfig);
     this.checksums = this.createMongoChecksums(options);
     this.writeCheckpointAPI = new MongoWriteCheckpointAPI({
@@ -130,8 +134,8 @@ export abstract class MongoSyncBucketStorage
     this.writeCheckpointAPI.setWriteCheckpointMode(mode);
   }
 
-  createManagedWriteCheckpoint(checkpoint: storage.ManagedWriteCheckpointOptions): Promise<bigint> {
-    return this.writeCheckpointAPI.createManagedWriteCheckpoint(checkpoint);
+  createManagedWriteCheckpoints(checkpoints: storage.ManagedWriteCheckpointOptions[]): Promise<Map<string, bigint>> {
+    return this.writeCheckpointAPI.createManagedWriteCheckpoints(checkpoints);
   }
 
   lastWriteCheckpoint(filters: storage.SyncStorageLastWriteCheckpointFilters): Promise<bigint | null> {
@@ -247,24 +251,30 @@ export abstract class MongoSyncBucketStorage
   }
 
   protected abstract getBucketDataBatchImpl(
-    checkpoint: utils.InternalOpId,
+    checkpoint: MongoReplicationCheckpoint,
     dataBuckets: storage.BucketDataRequest[],
     options?: storage.BucketDataBatchOptions
   ): AsyncIterable<storage.SyncBucketDataChunk>;
 
   async *getBucketDataBatch(
-    checkpoint: utils.InternalOpId,
+    checkpoint: storage.ReplicationCheckpoint,
     dataBuckets: storage.BucketDataRequest[],
     options?: storage.BucketDataBatchOptions
   ): AsyncIterable<storage.SyncBucketDataChunk> {
-    yield* this.getBucketDataBatchImpl(checkpoint, dataBuckets, options);
+    yield* this.getBucketDataBatchImpl(checkpoint as MongoReplicationCheckpoint, dataBuckets, options);
   }
 
   async getChecksums(
-    checkpoint: utils.InternalOpId,
-    buckets: storage.BucketChecksumRequest[]
+    checkpoint: storage.ReplicationCheckpoint,
+    buckets: storage.BucketChecksumRequest[],
+    options?: storage.BucketChecksumOptions
   ): Promise<utils.ChecksumMap> {
-    return this.checksums.getChecksums(checkpoint, buckets);
+    const mongoCheckpoint = checkpoint as MongoReplicationCheckpoint;
+    const snapshotTime = mongoCheckpoint.snapshotTime; // May be undefined in tests
+    return this.checksums.getChecksums(checkpoint.checkpoint, buckets, {
+      snapshotTime,
+      readPreference: options?.requestHint == 'bulk' ? this.readPreference : undefined
+    });
   }
 
   clearChecksumCache() {

package/src/storage/implementation/MongoWriteCheckpointAPI.ts

@@ -26,30 +26,77 @@ export class MongoWriteCheckpointAPI implements storage.WriteCheckpointAPI {
     this._mode = mode;
   }
 
-  async createManagedWriteCheckpoint(checkpoint: storage.ManagedWriteCheckpointOptions): Promise<bigint> {
+  async createManagedWriteCheckpoints(
+    checkpoints: storage.ManagedWriteCheckpointOptions[]
+  ): Promise<Map<string, bigint>> {
     if (this.writeCheckpointMode !== storage.WriteCheckpointMode.MANAGED) {
       throw new framework.ServiceAssertionError(
         `Attempting to create a managed Write Checkpoint when the current Write Checkpoint mode is set to "${this.writeCheckpointMode}"`
       );
     }
 
-    const { user_id, heads: lsns } = checkpoint;
-    const doc = await this.db.write_checkpoints.findOneAndUpdate(
-      {
-        user_id: user_id
-      },
-      {
-        $set: {
-          lsns,
-          processed_at_lsn: null
+    const uniqueCheckpoints = [...new Map(checkpoints.map((checkpoint) => [checkpoint.user_id, checkpoint])).values()];
+    if (uniqueCheckpoints.length == 0) {
+      return new Map();
+    }
+
+    if (uniqueCheckpoints.length == 1) {
+      // For the common case of a single checkpoint, we can do this in a single request.
+      const { user_id, heads: lsns } = uniqueCheckpoints[0];
+      const doc = await this.db.write_checkpoints.findOneAndUpdate(
+        {
+          user_id
         },
-        $inc: {
-          client_id: 1n
+        {
+          $set: {
+            lsns,
+            processed_at_lsn: null
+          },
+          $inc: {
+            client_id: 1n
+          }
+        },
+        { upsert: true, returnDocument: 'after' }
+      );
+
+      return new Map([[doc!.user_id, doc!.client_id]]);
+    }
+
+    // For more than one checkpoint, this gives a constant 2 requests
+    await this.db.write_checkpoints.bulkWrite(
+      uniqueCheckpoints.map(({ user_id, heads: lsns }) => ({
+        updateOne: {
+          filter: { user_id },
+          update: {
+            $set: {
+              lsns,
+              processed_at_lsn: null
+            },
+            $inc: {
+              client_id: 1n
+            }
+          },
+          upsert: true
         }
-      },
-      { upsert: true, returnDocument: 'after' }
+      }))
     );
-    return doc!.client_id;
+
+    const userIds = uniqueCheckpoints.map((checkpoint) => checkpoint.user_id);
+    const docs = await this.db.write_checkpoints
+      .find(
+        {
+          user_id: { $in: userIds }
+        },
+        {
+          projection: {
+            user_id: 1,
+            client_id: 1
+          }
+        }
+      )
+      .toArray();
+
+    return new Map(docs.map((doc) => [doc.user_id, doc.client_id]));
   }
 
   async lastWriteCheckpoint(filters: storage.LastWriteCheckpointFilters): Promise<bigint | null> {

package/src/storage/implementation/db.ts

@@ -195,7 +195,14 @@ export class PowerSyncMongo {
    * This is used in a similar way to the Postgres NOTIFY functionality.
    */
   async notifyCheckpoint() {
-    await this.checkpoint_events.insertOne({} as any, { forceServerObjectId: true });
+    await this.checkpoint_events.insertOne({} as any, {
+      forceServerObjectId: true,
+      // No correctness issue if this write is missed / rolled back.
+      // It could cause some sync delays, that will resolve in at most a minute, but no consistency issues.
+      writeConcern: {
+        w: 1
+      }
+    });
   }
 
   /**