@powersync/service-module-mongodb 0.20.1 → 0.21.1

package/src/api/MongoRouteAPIAdapter.ts

@@ -8,10 +8,12 @@ import { logger } from '@powersync/lib-services-framework';
 import { CheckpointImplementation } from '../replication/checkpoints/CheckpointImplementation.js';
 import { createCheckpointImplementation } from '../replication/checkpoints/create-checkpoint-implementation.js';
 import { MongoManager } from '../replication/MongoManager.js';
-import { constructAfterRecord } from '../replication/MongoRelation.js';
 import { CHECKPOINTS_COLLECTION, detectDocumentDb } from '../replication/replication-utils.js';
 import * as types from '../types/types.js';
 import { escapeRegExp } from '../utils.js';
+import { inferCollectionSchema } from './infer-collection-schema.js';
+
+const SCHEMA_INFERENCE_CONCURRENCY = 4;
 
 export class MongoRouteAPIAdapter implements api.RouteAPI {
   protected client: mongo.MongoClient;
@@ -21,6 +23,7 @@ export class MongoRouteAPIAdapter implements api.RouteAPI {
   defaultSchema: string;
 
   private checkpointImplementation: CheckpointImplementation | null = null;
+  private documentDbDetection: Promise<boolean> | null = null;
 
   constructor(protected config: types.ResolvedConnectionConfig) {
     const manager = new MongoManager(config);
@@ -206,9 +209,18 @@ export class MongoRouteAPIAdapter implements api.RouteAPI {
     return checkpointImplementation.createReplicationHead(callback);
   }
 
+  private isDocumentDb(): Promise<boolean> {
+    // Share in-flight detection and cache its result for this adapter's lifetime.
+    return (this.documentDbDetection ??= detectDocumentDb(this.db).catch((error) => {
+      // Allow a later request to retry after a transient connection error.
+      this.documentDbDetection = null;
+      throw error;
+    }));
+  }
+
   private async getCheckpointImplementation(): Promise<CheckpointImplementation> {
     if (this.checkpointImplementation == null) {
-      const isDocumentDb = await detectDocumentDb(this.db);
+      const isDocumentDb = await this.isDocumentDb();
       this.checkpointImplementation = createCheckpointImplementation(isDocumentDb, {
         client: this.client,
         db: this.db,
@@ -226,32 +238,38 @@ export class MongoRouteAPIAdapter implements api.RouteAPI {
   }
 
   async getConnectionSchema(): Promise<service_types.DatabaseSchema[]> {
-    const sampleSize = 50;
-
+    const isDocumentDb = await this.isDocumentDb();
     const databases = await this.db.admin().listDatabases({ nameOnly: true });
     const filteredDatabases = databases.databases.filter((db) => {
       return !['local', 'admin', 'config'].includes(db.name);
     });
-    const databaseSchemas = await Promise.all(
-      filteredDatabases.map(async (db) => {
-        /**
-         * Filtering the list of database with `authorizedDatabases: true`
-         * does not produce the full list of databases under some circumstances.
-         * This catches any potential auth errors.
-         */
-        let collections: mongo.CollectionInfo[];
-        try {
-          collections = await this.client.db(db.name).listCollections().toArray();
-        } catch (e) {
-          if (lib_mongo.isMongoServerError(e) && e.codeName == 'Unauthorized') {
-            // Ignore databases we're not authorized to query
-            return null;
-          }
-          throw e;
+    const databaseSchemas: service_types.DatabaseSchema[] = [];
+    for (const db of filteredDatabases) {
+      /**
+       * Filtering the list of database with `authorizedDatabases: true`
+       * does not produce the full list of databases under some circumstances.
+       * This catches any potential auth errors.
+       */
+      let collections: mongo.CollectionInfo[];
+      try {
+        collections = await this.client.db(db.name).listCollections().toArray();
+      } catch (e) {
+        if (lib_mongo.isMongoServerError(e) && e.codeName == 'Unauthorized') {
+          // Ignore databases we're not authorized to query
+          continue;
         }
+        throw e;
+      }
 
-        let tables: service_types.TableSchema[] = [];
-        for (let collection of collections) {
+      const tables: (service_types.TableSchema | undefined)[] = new Array(collections.length);
+      const pendingCollections = collections.entries();
+      let failed = false;
+      const inferCollections = async () => {
+        // Reading from the iterator automatically manages the queue
+        for (const [index, collection] of pendingCollections) {
+          if (failed) {
+            return;
+          }
           if ([CHECKPOINTS_COLLECTION].includes(collection.name)) {
             continue;
           }
@@ -264,121 +282,45 @@ export class MongoRouteAPIAdapter implements api.RouteAPI {
             continue;
           }
           try {
-            const sampleDocuments = await this.db
-              .collection(collection.name)
-              .aggregate([{ $sample: { size: sampleSize } }])
-              .toArray();
-
-            if (sampleDocuments.length > 0) {
-              const columns = this.getColumnsFromDocuments(sampleDocuments);
-
-              tables.push({
-                name: collection.name,
-                // Since documents are sampled in a random order, we need to sort
-                // to get a consistent order
-                columns: columns.sort((a, b) => a.name.localeCompare(b.name))
-              });
-            } else {
-              tables.push({
-                name: collection.name,
-                columns: []
-              });
-            }
+            const columns = await inferCollectionSchema(
+              this.client.db(db.name).collection(collection.name),
+              isDocumentDb
+            );
+            // Preserve collection order even when queries finish out of order.
+            tables[index] = { name: collection.name, columns };
           } catch (e) {
             if (lib_mongo.isMongoServerError(e) && e.codeName == 'Unauthorized') {
               // Ignore collections we're not authorized to query
               continue;
             }
+            // Fail the whole request on unexpected errors: the response cannot indicate
+            // partial results, so omitting a collection would make an incomplete schema
+            // appear complete and could produce an incorrect generated client schema.
+            failed = true;
             throw e;
           }
         }
-
-        return {
-          name: db.name,
-          tables: tables
-        } satisfies service_types.DatabaseSchema;
-      })
-    );
-    return databaseSchemas.filter((schema) => !!schema);
-  }
-
-  private getColumnsFromDocuments(documents: mongo.BSON.Document[]) {
-    let columns = new Map<string, { sqliteType: sync_rules.ExpressionType; bsonTypes: Set<string> }>();
-    for (const document of documents) {
-      const parsed = constructAfterRecord(document);
-      for (const key in parsed) {
-        const value = parsed[key];
-        const type = sync_rules.sqliteTypeOf(value);
-        const sqliteType = sync_rules.ExpressionType.fromTypeText(type);
-        let entry = columns.get(key);
-        if (entry == null) {
-          entry = { sqliteType, bsonTypes: new Set() };
-          columns.set(key, entry);
-        } else {
-          entry.sqliteType = entry.sqliteType.or(sqliteType);
-        }
-        const bsonType = this.getBsonType(document[key]);
-        if (bsonType != null) {
-          entry.bsonTypes.add(bsonType);
-        }
-      }
-    }
-    return [...columns.entries()].map(([key, value]) => {
-      const internal_type = value.bsonTypes.size == 0 ? '' : [...value.bsonTypes].join(' | ');
-      return {
-        name: key,
-        type: internal_type,
-        sqlite_type: value.sqliteType.typeFlags,
-        internal_type,
-        pg_type: internal_type
       };
-    });
-  }
 
-  private getBsonType(data: any): string | null {
-    if (data == null) {
-      // null or undefined
-      return 'Null';
-    } else if (typeof data == 'string') {
-      return 'String';
-    } else if (typeof data == 'number') {
-      if (Number.isInteger(data)) {
-        return 'Integer';
-      } else {
-        return 'Double';
+      // Each worker holds only schema metadata, with a bounded number of source queries.
+      const workers = Array.from(
+        { length: Math.min(SCHEMA_INFERENCE_CONCURRENCY, collections.length) },
+        inferCollections
+      );
+      try {
+        await Promise.all(workers);
+      } catch (e) {
+        // Finish in-flight queries before rejecting the request. Workers stop taking
+        // new collections as soon as one encounters a non-authorization error.
+        await Promise.allSettled(workers);
+        throw e;
       }
-    } else if (typeof data == 'bigint') {
-      return 'Long';
-    } else if (typeof data == 'boolean') {
-      return 'Boolean';
-    } else if (data instanceof mongo.ObjectId) {
-      return 'ObjectId';
-    } else if (data instanceof mongo.UUID) {
-      return 'UUID';
-    } else if (data instanceof Date) {
-      return 'Date';
-    } else if (data instanceof mongo.Timestamp) {
-      return 'Timestamp';
-    } else if (data instanceof mongo.Binary) {
-      return 'Binary';
-    } else if (data instanceof mongo.Long) {
-      return 'Long';
-    } else if (data instanceof RegExp) {
-      return 'RegExp';
-    } else if (data instanceof mongo.MinKey) {
-      return 'MinKey';
-    } else if (data instanceof mongo.MaxKey) {
-      return 'MaxKey';
-    } else if (data instanceof mongo.Decimal128) {
-      return 'Decimal';
-    } else if (Array.isArray(data)) {
-      return 'Array';
-    } else if (data instanceof Uint8Array) {
-      return 'Binary';
-    } else if (typeof data == 'object') {
-      return 'Object';
-    } else {
-      return null;
+
+      databaseSchemas.push({
+        name: db.name,
+        tables: tables.filter((table) => table != null)
+      });
     }
+    return databaseSchemas;
   }
 }

package/src/api/infer-collection-schema.ts

@@ -0,0 +1,127 @@
+import { mongo } from '@powersync/lib-service-mongodb';
+import { ExpressionType } from '@powersync/service-sync-rules';
+import { TableSchema } from '@powersync/service-types';
+
+// Match the types exposed after BSON deserialization and conversion to sync rules values.
+const BSON_TYPES: Record<string, { name: string; sqliteType: ExpressionType }> = {
+  int: { name: 'Integer', sqliteType: ExpressionType.INTEGER },
+  long: { name: 'Long', sqliteType: ExpressionType.INTEGER },
+  double: { name: 'Double', sqliteType: ExpressionType.REAL },
+  decimal: { name: 'Decimal', sqliteType: ExpressionType.TEXT },
+  string: { name: 'String', sqliteType: ExpressionType.TEXT },
+  symbol: { name: 'String', sqliteType: ExpressionType.TEXT },
+  bool: { name: 'Boolean', sqliteType: ExpressionType.INTEGER },
+  objectId: { name: 'ObjectId', sqliteType: ExpressionType.TEXT },
+  uuid: { name: 'UUID', sqliteType: ExpressionType.TEXT },
+  binData: { name: 'Binary', sqliteType: ExpressionType.BLOB },
+  date: { name: 'Date', sqliteType: ExpressionType.TEXT },
+  timestamp: { name: 'Timestamp', sqliteType: ExpressionType.INTEGER },
+  regex: { name: 'RegExp', sqliteType: ExpressionType.TEXT },
+  object: { name: 'Object', sqliteType: ExpressionType.TEXT },
+  array: { name: 'Array', sqliteType: ExpressionType.TEXT },
+  javascript: { name: 'Object', sqliteType: ExpressionType.TEXT },
+  javascriptWithScope: { name: 'Object', sqliteType: ExpressionType.TEXT },
+  dbPointer: { name: 'Object', sqliteType: ExpressionType.TEXT },
+  null: { name: 'Null', sqliteType: ExpressionType.NONE },
+  undefined: { name: 'Null', sqliteType: ExpressionType.NONE },
+  minKey: { name: 'MinKey', sqliteType: ExpressionType.NONE },
+  maxKey: { name: 'MaxKey', sqliteType: ExpressionType.NONE }
+};
+
+/**
+ * Infer top-level fields without transferring sampled document values to the service.
+ * Memory on the service scales with the inferred schema, not the size of those values.
+ */
+export async function inferCollectionSchema(
+  collection: mongo.Collection,
+  isDocumentDb: boolean
+): Promise<TableSchema['columns']> {
+  const fields = await collection
+    .aggregate<{ _id: string; types: string[] }>(
+      [
+        // Keep this first so MongoDB can use its random cursor on large collections.
+        { $sample: { size: 50 } },
+        {
+          $project: {
+            _id: 0,
+            fields: {
+              $map: {
+                input: { $objectToArray: '$$ROOT' },
+                as: 'field',
+                in: {
+                  name: '$$field.k',
+                  type: {
+                    $let: {
+                      vars: { bsonType: { $type: '$$field.v' } },
+                      in: {
+                        $switch: {
+                          branches: [
+                            {
+                              case: { $eq: ['$$bsonType', 'double'] },
+                              // Whole-number doubles are replicated as SQLite integers.
+                              then: { $cond: [{ $eq: [{ $mod: ['$$field.v', 1] }, 0] }, 'int', 'double'] }
+                            },
+                            {
+                              case: { $eq: ['$$bsonType', 'binData'] },
+                              then: {
+                                $cond: [
+                                  // BinData compares by length, then subtype, then bytes. Only
+                                  // 16-byte values of subtype 4 fall within this UUID range.
+                                  // This works without transferring binary values or requiring
+                                  // the newer MongoDB binary conversion operators.
+                                  // https://www.mongodb.com/docs/manual/reference/bson-type-comparison-order/#bindata
+                                  {
+                                    $and: [
+                                      { $gte: ['$$field.v', new mongo.UUID('00000000-0000-0000-0000-000000000000')] },
+                                      { $lte: ['$$field.v', new mongo.UUID('ffffffff-ffff-ffff-ffff-ffffffffffff')] }
+                                    ]
+                                  },
+                                  'uuid',
+                                  'binData'
+                                ]
+                              }
+                            }
+                          ],
+                          default: '$$bsonType'
+                        }
+                      }
+                    }
+                  }
+                }
+              }
+            }
+          }
+        },
+        // Discard values before unwinding so large documents aren't duplicated per field.
+        { $unwind: '$fields' },
+        { $group: { _id: '$fields.name', types: { $addToSet: '$fields.type' } } }
+      ],
+      {
+        // Bound execution per collection below the default 60-second socket timeout
+        // so MongoDB can return a query timeout before the connection times out.
+        maxTimeMS: 30_000,
+        // Small collections can require $sample to sort full documents. Disable
+        // disk spill explicitly so concurrent schema queries fail at the memory
+        // limit without adding temporary-file I/O on the source database.
+        allowDiskUse: false,
+        // Field names are case-sensitive even when the collection's default collation isn't.
+        // DocumentDB rejects the collation option, including simple collation.
+        ...(isDocumentDb ? {} : { collation: { locale: 'simple' } })
+      }
+    )
+    .toArray();
+
+  return fields
+    .map(({ _id: name, types }) => {
+      let sqliteType = ExpressionType.NONE;
+      const bsonTypes = new Set<string>();
+      for (const type of types) {
+        const inferred = BSON_TYPES[type];
+        sqliteType = sqliteType.or(inferred.sqliteType);
+        bsonTypes.add(inferred.name);
+      }
+      const internal_type = [...bsonTypes].sort().join(' | ');
+      return { name, type: internal_type, sqlite_type: sqliteType.typeFlags, internal_type, pg_type: internal_type };
+    })
+    .sort((a, b) => a.name.localeCompare(b.name));
+}

package/src/replication/ChangeStream.ts

@@ -213,7 +213,7 @@ export class ChangeStream {
     this.isDocumentDb = await detectDocumentDb(this.defaultDb);
     if (this.isDocumentDb) {
       this.logger.warn(
-        'Azure DocumentDB support is experimental. APIs and behavior may change, and long-term stability is not yet guaranteed.'
+        'Azure DocumentDB support is in alpha. APIs and behavior may change, and long-term stability is not yet guaranteed.'
       );
     }
     this._checkpointImplementation = createCheckpointImplementation(this.isDocumentDb, {
@@ -595,9 +595,6 @@ export class ChangeStream {
     return rawChangeStream(watchDb, pipeline, {
       batchSize: options.batchSize ?? this.snapshotChunkLength,
       maxAwaitTimeMS,
-      // maxAwaitTimeMS can be 0 for probe-style streams that do not want an idle wait.
-      // In that case there is no client-side wait to emulate for DocumentDB.
-      clientSideMaxAwaitTimeMS: this.isDocumentDb && maxAwaitTimeMS > 0,
       maxTimeMS: this.changeStreamTimeout,
 
       signal: options.signal,
@@ -633,6 +630,7 @@ export class ChangeStream {
         // We get a complete postimage for every change, so we don't need to store the current data.
         storeCurrentData: false,
         hooks: this.storageHooks,
+        signal: this.abortSignal,
         tracer
       },
       async (batch) => {

package/src/replication/MongoSnapshotter.ts

@@ -212,6 +212,7 @@ export class MongoSnapshotter {
       defaultSchema: this.defaultDb.databaseName,
       storeCurrentData: false,
       skipExistingRows: true,
+      signal: this.abortSignal,
       tracer: new PerformanceTracer('MongoDB initial snapshot setup')
     });
     if (snapshotLsn == null) {
@@ -345,10 +346,10 @@ export class MongoSnapshotter {
       return;
     }
 
-    // Populate the cache _after_ initial replication, but _before_ we switch to this replication stream.
+    // Compact storage _after_ initial replication, but _before_ we switch to this replication stream.
     // Keeping snapshot_done false until this completes makes this resumable after interruption.
     // No checkpoint exists yet - storage defaults to its highest persisted op id.
-    await this.storage.populatePersistentChecksumCache({
+    await this.storage.compactInitialReplication({
       signal: this.abortSignal
     });
 
@@ -361,7 +362,8 @@ export class MongoSnapshotter {
       zeroLSN: MongoLSN.ZERO.comparable,
       defaultSchema: this.defaultDb.databaseName,
       storeCurrentData: false,
-      skipExistingRows: true
+      skipExistingRows: true,
+      signal: this.abortSignal
     });
 
     // The checkpoint here is a marker - we need to replicate up to at least this
@@ -391,6 +393,7 @@ export class MongoSnapshotter {
       storeCurrentData: false,
       skipExistingRows: true,
       hooks: this.storageHooks,
+      signal: this.abortSignal,
       tracer: new PerformanceTracer('MongoDB snapshot table')
     });
     // Get fresh table info, in case it was updated while queuing.
@@ -782,9 +785,6 @@ export class MongoSnapshotter {
     return rawChangeStream(watchDb, pipeline, {
       batchSize: options.batchSize ?? this.snapshotChunkLength,
       maxAwaitTimeMS,
-      // maxAwaitTimeMS can be 0 for probe-style streams that do not want an idle wait.
-      // In that case there is no client-side wait to emulate for DocumentDB.
-      clientSideMaxAwaitTimeMS: this.isDocumentDb && maxAwaitTimeMS > 0,
       maxTimeMS: this.changeStreamTimeout,
       signal: options.signal,
       logger: this.logger,

package/src/replication/RawChangeStream.ts

@@ -6,14 +6,8 @@ import {
   ReplicationAssertionError
 } from '@powersync/lib-services-framework';
 import { PerformanceTracer } from '@powersync/service-core';
-import { performance } from 'node:perf_hooks';
-import { setTimeout as delay } from 'node:timers/promises';
 import { ChangeStreamInvalidatedError } from './ChangeStream.js';
 
-// Keep the DocumentDB idle-poll workaround from adding the full maxAwaitTimeMS
-// as local latency when an update arrives just after an empty batch.
-const CLIENT_SIDE_MAX_AWAIT_TIME_MS_DELAY_CAP_MS = 1_000;
-
 export interface RawChangeStreamOptions {
   signal?: AbortSignal;
 
@@ -21,21 +15,12 @@ export interface RawChangeStreamOptions {
    * How long to wait for new data per batch (max time for long-polling).
    * This is sent as maxTimeMS for the getMore command.
    *
-   * A value of 0 is allowed for probe-style streams that do not want an idle
-   * wait; in that case PowerSync also skips the local empty-batch delay.
+   * A value of 0 removes the explicit await limit and leaves the server's
+   * default awaitData behavior in effect; it does not make getMore return
+   * immediately. Snapshot probes use 0 for this purpose.
    */
   maxAwaitTimeMS: number;
 
-  /**
-   * Also enforce maxAwaitTimeMS on the client for empty getMore batches.
-   *
-   * Azure DocumentDB currently returns idle getMore calls before maxTimeMS. When
-   * this is enabled, empty batches are delayed locally (capped at 1s) to avoid
-   * tight polling. We still send maxTimeMS so this remains compatible with
-   * servers that handle maxAwaitTimeMS correctly.
-   */
-  clientSideMaxAwaitTimeMS?: boolean;
-
   /**
    * Timeout for the initial aggregate command.
    */
@@ -230,17 +215,12 @@ async function* rawChangeStreamInner(
       options.signal?.throwIfAborted();
 
       using commandSpan = options.tracer?.span('changestream', 'getmore');
-      const getMoreStartedAt = performance.now();
       const getMoreCommand: mongo.Document = {
         getMore: cursorId,
         collection: nsCollection,
         batchSize: batchSizer.next(),
         maxTimeMS: options.maxAwaitTimeMS
       };
-      // Azure DocumentDB currently returns empty getMore batches before
-      // maxTimeMS expires. Keep maxTimeMS for forward compatibility with the
-      // server-side behavior, and when client-side mode is enabled, enforce the
-      // capped idle wait locally for empty batches below.
       const getMoreResult: mongo.Document = await db.command(getMoreCommand, { session, raw: true }).catch((e) => {
         if (isMongoServerError(e) && e.codeName == 'CursorKilled') {
           // This may be due to the killCursors command issued when aborting.
@@ -268,13 +248,6 @@ async function* rawChangeStreamInner(
         // postBatchResumeToken is returned in MongoDB 4.0.7 and later, and we support 6.0+
         throw new ReplicationAssertionError(`postBatchResumeToken from aggregate response`);
       }
-      if (options.clientSideMaxAwaitTimeMS && nextBatch.length == 0) {
-        const remainingMaxAwaitTimeMS = Math.ceil(options.maxAwaitTimeMS - (performance.now() - getMoreStartedAt));
-        if (remainingMaxAwaitTimeMS > 0) {
-          const clientSideDelayMs = Math.min(remainingMaxAwaitTimeMS, CLIENT_SIDE_MAX_AWAIT_TIME_MS_DELAY_CAP_MS);
-          await delay(clientSideDelayMs, undefined, { signal: options.signal });
-        }
-      }
       yield {
         events: nextBatch,
         resumeToken: cursor.postBatchResumeToken,

package/src/types/types.ts

@@ -67,11 +67,11 @@ export interface NormalizedMongoConnectionConfig {
 export const MongoConnectionConfig = service_types.configFile.DataSourceConfig.and(lib_mongo.BaseMongoConfig).and(
   t.object({
     // Replication specific settings
-    post_images: t.literal('off').or(t.literal('auto_configure')).or(t.literal('read_only')).optional(),
+    post_images: service_types.enumLiteral('off', 'auto_configure', 'read_only').optional(),
     /**
      * Interval in seconds between source connection heartbeats. Null or omitted defaults to 60 seconds.
      */
-    heartbeat_interval_seconds: t.number.or(t.Null).optional()
+    heartbeat_interval_seconds: service_types.orNull(t.number).optional()
   })
 );
 

package/test/src/change_stream.test.ts

@@ -622,6 +622,79 @@ bucket_definitions:
     expect(data).toMatchObject([test_utils.putOp('test_data', { id: test_id, description: 'test1' })]);
   });
 
+  test.runIf(storageVersion >= 3)(
+    'does not resnapshot an unchanged event definition during incremental reprocessing',
+    async (testContext) => {
+      const eventDefinition = `
+event_definitions:
+  checkpoint_requests:
+    payloads:
+      - SELECT user_id, checkpoint, client_id, CASE WHEN checkpoint_requested_at IS NULL THEN true ELSE false END AS is_legacy FROM checkpoints
+`;
+      const syncConfig = (deploymentComment: string) => `
+config:
+  edition: 3
+  storage_version: 3
+  # ${deploymentComment}
+
+${eventDefinition}
+streams:
+  global:
+    auto_subscribe: true
+    queries:
+      - SELECT *, _id AS id FROM lists
+      - SELECT *, _id AS id FROM todos
+`;
+
+      let replicationStreamId: number;
+      {
+        await using context = await openContext();
+        const firstStorage = await context.updateSyncRules(syncConfig('initial deployment'));
+        if (
+          !('incrementalReprocessing' in firstStorage.storageConfig) ||
+          firstStorage.storageConfig.incrementalReprocessing !== true
+        ) {
+          testContext.skip('storage does not support incremental reprocessing');
+        }
+
+        const { db } = context;
+        await db.collection('lists').insertOne({ name: 'list' });
+        await db.collection('todos').insertOne({ description: 'todo' });
+        await db.collection('checkpoints').insertOne({
+          user_id: 'user-1',
+          checkpoint: 1n,
+          client_id: 'client-1',
+          checkpoint_requested_at: null
+        });
+
+        replicationStreamId = firstStorage.replicationStreamId;
+        await context.replicateSnapshot();
+        context.startStreaming();
+        await context.getCheckpoint();
+      }
+
+      const resnapshottedCollections: string[] = [];
+      await using context = await openContext({
+        doNotClear: true,
+        streamOptions: {
+          snapshotHooks: {
+            beforeSnapshotStarted: async (table) => {
+              resnapshottedCollections.push(table.name);
+            }
+          }
+        }
+      });
+
+      const processingStorage = await context.updateSyncRules(syncConfig('redeployed without behavioral changes'));
+      expect(processingStorage.replicationStreamId).toBe(replicationStreamId);
+      expect(await context.factory.getDeployingSyncConfig()).not.toBeNull();
+
+      await context.replicateSnapshot();
+
+      expect(resnapshottedCollections).toEqual([]);
+    }
+  );
+
   test('coalesces standalone checkpoints when backlog is buffered', async () => {
     await using context = await openContext();
     await context.updateSyncRules(BASIC_SYNC_RULES);

package/test/src/documentdb_mode.test.ts

@@ -759,8 +759,7 @@ bucket_definitions:
     expect(JSON.parse(lastOp.data as string)).toMatchObject({ description: 'after_keepalive' });
   });
 
-  // Skipped until Azure DocumentDB ships the server-side getMore maxAwaitTimeMS fix.
-  test.skip('respects maxAwaitTimeMS for idle getMore calls in documentDbMode', async () => {
+  test('respects maxAwaitTimeMS for idle getMore calls in documentDbMode', async () => {
     const maxAwaitTimeMS = 2_000;
 
     await using context = await openContext({