@powersync/service-module-mongodb 0.21.0 → 0.21.2

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

@@ -0,0 +1,153 @@
+import * as lib_mongo from '@powersync/lib-service-mongodb';
+import { mongo } from '@powersync/lib-service-mongodb';
+import { ExpressionType } from '@powersync/service-sync-rules';
+import { TableSchema } from '@powersync/service-types';
+
+/**
+ * Server errors that mean this one collection could not be inspected, rather than the
+ * connection being unusable.
+ *
+ * These come from the memory ceiling {@link inferCollectionSchema} imposes on itself by
+ * refusing to spill to disk, and are deterministic per collection. Timeouts are
+ * deliberately excluded: they usually indicate an overloaded source, where degrading
+ * would silently empty the schema of every collection at once.
+ */
+const SCHEMA_INFERENCE_FAILURE_CODES = new Set([
+  // ExceededMemoryLimit - a blocking stage ran out of memory with disk spill disabled.
+  146,
+  // QueryExceededMemoryLimitNoDiskUseAllowed - as above, reported by the sort $sample
+  // uses on collections too small for its random cursor.
+  292
+]);
+
+/**
+ * Whether the error means we could not determine this collection's fields, as opposed to
+ * something that makes the rest of the schema unreliable too.
+ */
+export function isSchemaInferenceFailure(e: unknown): boolean {
+  return lib_mongo.isMongoServerError(e) && SCHEMA_INFERENCE_FAILURE_CODES.has(e.code as number);
+}
+
+// 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/module/MongoModule.ts

@@ -44,8 +44,6 @@ export class MongoModule extends replication.ReplicationModule<types.MongoConnec
     });
   }
 
-  async onInitialized(context: system.ServiceContextContainer): Promise<void> {}
-
   /**
    * Combines base config with normalized connection settings
    */

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,

package/src/replication/MongoRelation.ts

@@ -3,11 +3,14 @@ import { storage } from '@powersync/service-core';
 import { JsonContainer } from '@powersync/service-jsonbig';
 import {
   CompatibilityContext,
+  CompatibilityOption,
   CustomArray,
   CustomObject,
   CustomSqliteValue,
   DateTimeSourceOptions,
   DateTimeValue,
+  SQLITE_FALSE,
+  SQLITE_TRUE,
   SqliteInputRow,
   SqliteInputValue,
   TimeValuePrecision
@@ -127,7 +130,11 @@ function filterJsonData(data: any, context: CompatibilityContext, depth = 0): an
       return data;
     }
   } else if (typeof data == 'boolean') {
-    return data ? 1n : 0n;
+    if (context.isEnabled(CompatibilityOption.fixedBooleanInJson)) {
+      return data;
+    }
+
+    return data ? SQLITE_TRUE : SQLITE_FALSE;
   } else if (typeof data == 'bigint') {
     return data;
   } else if (data instanceof Date) {

package/src/replication/MongoSnapshotter.ts

@@ -785,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/replication/SourceRowConverter.ts

@@ -1,5 +1,5 @@
 import { mongo } from '@powersync/lib-service-mongodb';
-import { applyRowContext, CompatibilityContext, SqliteRow } from '@powersync/service-sync-rules';
+import { applyRowContext, CompatibilityContext, CompatibilityOption, SqliteRow } from '@powersync/service-sync-rules';
 import { bufferToSqlite, DateRenderMode, getDateRenderMode, parseDocumentId } from './bufferToSqlite.js';
 import { constructAfterRecord } from './MongoRelation.js';
 
@@ -46,13 +46,15 @@ export class LegacySourceRowConverter implements SourceRowConverter {
 
 export class DirectSourceRowConverter implements SourceRowConverter {
   private readonly dateRenderMode: DateRenderMode;
+  private readonly fixedBooleansInJson: boolean;
 
   constructor(compatibilityContext: CompatibilityContext) {
     this.dateRenderMode = getDateRenderMode(compatibilityContext);
+    this.fixedBooleansInJson = compatibilityContext.isEnabled(CompatibilityOption.fixedBooleanInJson);
   }
 
   rawToSqliteRow(source: Buffer): { row: SqliteRow; replicaId: any } {
-    const row = bufferToSqlite(source, this.dateRenderMode);
+    const row = bufferToSqlite(source, this.dateRenderMode, this.fixedBooleansInJson);
     const replicaId = parseDocumentId(source).id;
     return { row, replicaId };
   }

package/src/replication/bufferToSqlite.ts

@@ -80,12 +80,16 @@ const SHARED_WRITER = new JsonBufferWriter();
  *
  * @param bytes the source BSON bytes
  * @param dateRenderMode derive using getDateRenderMode(compatibilityContext)
+ * @param fixedBooleansInJson whether to serialize booleans in nested JSON as booleans, derived from compatibility
+ * context.
  *
  * @returns a SqliteRow
  */
-export function bufferToSqlite(bytes: Buffer, dateRenderMode: DateRenderMode): SqliteRow {
+export function bufferToSqlite(bytes: Buffer, dateRenderMode: DateRenderMode, fixedBooleansInJson: boolean): SqliteRow {
   const row: SqliteRow = {};
   const jsonWriter = SHARED_WRITER;
+  const options: SerializeToJsonOptions = { dateRenderMode, fixedBooleans: fixedBooleansInJson };
+
   // BSON documents are length-prefixed and null-terminated. We parse directly
   // from raw bytes, so structural validation happens here rather than in the
   // upstream BSON decoder.
@@ -112,14 +116,14 @@ export function bufferToSqlite(bytes: Buffer, dateRenderMode: DateRenderMode): S
       }
       case BSON_TYPE_ARRAY: {
         jsonWriter.reset();
-        const result = serializeNestedArrayToJson(bytes, offset, 0, jsonWriter, dateRenderMode);
+        const result = serializeNestedArrayToJson(bytes, offset, 0, jsonWriter, options);
         row[key] = jsonWriter.toString();
         offset = result.nextOffset;
         break;
       }
       case BSON_TYPE_DOCUMENT: {
         jsonWriter.reset();
-        const result = serializeNestedObjectToJson(bytes, offset, 0, jsonWriter, dateRenderMode);
+        const result = serializeNestedObjectToJson(bytes, offset, 0, jsonWriter, options);
         row[key] = jsonWriter.toString();
         offset = result.nextOffset;
         break;
@@ -195,7 +199,7 @@ export function bufferToSqlite(bytes: Buffer, dateRenderMode: DateRenderMode): S
       }
       case BSON_TYPE_CODE_WITH_SCOPE: {
         jsonWriter.reset();
-        const nextOffset = writeCodeWithScopeJson(bytes, offset, 0, jsonWriter, dateRenderMode);
+        const nextOffset = writeCodeWithScopeJson(bytes, offset, 0, jsonWriter, options);
         row[key] = jsonWriter.toString();
         offset = nextOffset;
         break;
@@ -437,12 +441,17 @@ function skipBsonValue(bytes: Buffer, offset: number, type: number) {
   }
 }
 
+interface SerializeToJsonOptions {
+  dateRenderMode: DateRenderMode;
+  fixedBooleans: boolean;
+}
+
 function serializeNestedObjectToJson(
   bytes: Buffer,
   offset: number,
   depth: number,
   writer: JsonBufferWriter,
-  dateRenderMode: DateRenderMode
+  options: SerializeToJsonOptions
 ): { nextOffset: number } {
   if (depth > NESTED_DEPTH_LIMIT) {
     throw new Error(`json nested object depth exceeds the limit of ${NESTED_DEPTH_LIMIT}`);
@@ -475,7 +484,7 @@ function serializeNestedObjectToJson(
       type,
       depth,
       writer,
-      dateRenderMode
+      options
     );
     cursor = afterValue;
     // Malformed BSON must fail fast instead of getting the parser stuck on the
@@ -499,7 +508,7 @@ function serializeNestedArrayToJson(
   offset: number,
   depth: number,
   writer: JsonBufferWriter,
-  dateRenderMode: DateRenderMode
+  options: SerializeToJsonOptions
 ): { nextOffset: number } {
   if (depth > NESTED_DEPTH_LIMIT) {
     throw new Error(`json nested object depth exceeds the limit of ${NESTED_DEPTH_LIMIT}`);
@@ -527,7 +536,7 @@ function serializeNestedArrayToJson(
       type,
       depth,
       writer,
-      dateRenderMode
+      options
     );
     cursor = afterValue;
     assertAdvanced(previousCursor, cursor);
@@ -547,7 +556,7 @@ function serializeNestedElementValue(
   type: number,
   depth: number,
   writer: JsonBufferWriter,
-  dateRenderMode: DateRenderMode
+  options: SerializeToJsonOptions
 ): { nextOffset: number; defined: boolean } {
   switch (type) {
     case BSON_TYPE_DOUBLE: // Double
@@ -555,9 +564,9 @@ function serializeNestedElementValue(
     case BSON_TYPE_STRING: // String
       return serializeNestedStringElement(bytes, offset, writer);
     case BSON_TYPE_DOCUMENT: // Embedded document
-      return serializeNestedObjectElement(bytes, offset, depth, writer, dateRenderMode);
+      return serializeNestedObjectElement(bytes, offset, depth, writer, options);
     case BSON_TYPE_ARRAY: // Array
-      return serializeNestedArrayElement(bytes, offset, depth, writer, dateRenderMode);
+      return serializeNestedArrayElement(bytes, offset, depth, writer, options);
     case BSON_TYPE_BINARY: // Binary
       return serializeNestedBinaryElement(bytes, offset, writer);
     case BSON_TYPE_UNDEFINED: // Undefined
@@ -567,11 +576,22 @@ function serializeNestedElementValue(
       writer.writeQuotedHexLower(bytes, offset, 12);
       return { nextOffset: offset + 12, defined: true };
     }
-    case BSON_TYPE_BOOLEAN: // Boolean
-      writer.writeByte(bytes[offset] ? BYTE_ONE : BYTE_ZERO);
+    case BSON_TYPE_BOOLEAN: {
+      // Boolean
+      const value = !!bytes[offset];
+
+      if (options.fixedBooleans) {
+        const str = value ? 'true' : 'false';
+
+        writer.writeAscii(str);
+      } else {
+        writer.writeByte(value ? BYTE_ONE : BYTE_ZERO);
+      }
+
       return { nextOffset: offset + 1, defined: true };
+    }
     case BSON_TYPE_UTC_DATETIME: // UTC datetime
-      return serializeNestedDateTimeElement(bytes, offset, writer, dateRenderMode);
+      return serializeNestedDateTimeElement(bytes, offset, writer, options.dateRenderMode);
     case BSON_TYPE_NULL: // Null
     case BSON_TYPE_MIN_KEY: // MinKey
     case BSON_TYPE_MAX_KEY: // MaxKey
@@ -586,7 +606,7 @@ function serializeNestedElementValue(
     case BSON_TYPE_SYMBOL: // Symbol
       return serializeNestedSymbolElement(bytes, offset, writer);
     case BSON_TYPE_CODE_WITH_SCOPE: // JavaScript code with scope
-      return serializeNestedCodeWithScopeElement(bytes, offset, depth, writer, dateRenderMode);
+      return serializeNestedCodeWithScopeElement(bytes, offset, depth, writer, options);
     case BSON_TYPE_INT32: {
       // Int32
       writer.writeAscii(String(readInt32LE(bytes, offset)));
@@ -641,9 +661,9 @@ function serializeNestedObjectElement(
   offset: number,
   depth: number,
   writer: JsonBufferWriter,
-  dateRenderMode: DateRenderMode
+  options: SerializeToJsonOptions
 ): { nextOffset: number; defined: boolean } {
-  const result = serializeNestedObjectToJson(bytes, offset, depth + 1, writer, dateRenderMode);
+  const result = serializeNestedObjectToJson(bytes, offset, depth + 1, writer, options);
   return { nextOffset: result.nextOffset, defined: true };
 }
 
@@ -652,9 +672,9 @@ function serializeNestedArrayElement(
   offset: number,
   depth: number,
   writer: JsonBufferWriter,
-  dateRenderMode: DateRenderMode
+  options: SerializeToJsonOptions
 ): { nextOffset: number; defined: boolean } {
-  const result = serializeNestedArrayToJson(bytes, offset, depth + 1, writer, dateRenderMode);
+  const result = serializeNestedArrayToJson(bytes, offset, depth + 1, writer, options);
   return { nextOffset: result.nextOffset, defined: true };
 }
 
@@ -791,14 +811,14 @@ function writeCodeWithScopeJson(
   offset: number,
   depth: number,
   writer: JsonBufferWriter,
-  dateRenderMode: DateRenderMode
+  options: SerializeToJsonOptions
 ) {
   const totalLength = readInt32LE(bytes, offset);
   const { value: code, nextOffset: afterCode } = readBsonString(bytes, offset + 4);
   writer.writeAscii('{"code":');
   writer.writeQuotedJsonString(code);
   writer.writeAscii(',"scope":');
-  serializeNestedObjectToJson(bytes, afterCode, depth + 1, writer, dateRenderMode);
+  serializeNestedObjectToJson(bytes, afterCode, depth + 1, writer, options);
   writer.writeByte(BYTE_RBRACE);
   // code_w_scope carries its own total byte length, so we trust that wrapper
   // rather than reconstructing the end position from the nested scope.
@@ -885,10 +905,10 @@ function serializeNestedCodeWithScopeElement(
   offset: number,
   depth: number,
   writer: JsonBufferWriter,
-  dateRenderMode: DateRenderMode
+  options: SerializeToJsonOptions
 ): { nextOffset: number; defined: boolean } {
   return {
-    nextOffset: writeCodeWithScopeJson(bytes, offset, depth, writer, dateRenderMode),
+    nextOffset: writeCodeWithScopeJson(bytes, offset, depth, writer, options),
     defined: true
   };
 }

package/test/src/buffer_to_sqlite.test.ts

@@ -121,6 +121,15 @@ const testCases: ConverterCase[] = [
   serializableCase('array', [1, 'two', false, null, { deep: 3 }], jsonTextPlacements('[1,"two",0,null,{"deep":3}]')),
   serializableCase('objectId', objectId, jsonStringPlacements('66e834cc91d805df11fa0ecb')),
   serializableCase('bool', true, placements(1n, '[1]', '{"nested":1}')),
+  {
+    name: 'bool (fixed json)',
+    buildBuffer: (placement) => serializeCaseDocument(`bool (fixed json):${placement}`, placement, false),
+    expected: placements(0n, '[false]', '{"nested":false}'),
+    context: new CompatibilityContext({
+      edition: CompatibilityEdition.COMPILED_STREAMS,
+      overrides: new Map([[CompatibilityOption.fixedBooleanInJson, true]])
+    })
+  } satisfies ConverterCase,
   serializableCase('date', normalDate, jsonStringPlacements('2023-03-06 13:47:00.000Z')),
   serializableCase('date:+010000', positiveExtendedDate, jsonStringPlacements('+010000-01-01 00:00:00.000Z')),
   serializableCase('date:-000001', negativeExtendedDate, jsonStringPlacements('-000001-12-31 23:59:59.999Z')),

package/test/src/change_stream_utils.ts

@@ -18,7 +18,7 @@ import {
   updateSyncRulesFromYaml,
   utils
 } from '@powersync/service-core';
-import { bucketRequest, METRICS_HELPER, test_utils } from '@powersync/service-core-tests';
+import { bucketRequest, getTestStorage, METRICS_HELPER, test_utils } from '@powersync/service-core-tests';
 
 import { SentinelLSN } from '@module/common/SentinelLSN.js';
 import { ChangeStream, ChangeStreamOptions } from '@module/replication/ChangeStream.js';
@@ -119,7 +119,7 @@ export class ChangeStreamTestContext {
       updateSyncRulesFromYaml(content, { validate: true, storageVersion: this.storageVersion })
     );
     this.syncRulesContent = replicationStream.syncConfigContent[0];
-    this.storage = this.factory.getInstance(replicationStream);
+    this.storage = await getTestStorage(this.factory, replicationStream);
     return this.storage!;
   }
 
@@ -130,7 +130,7 @@ export class ChangeStreamTestContext {
     }
 
     this.syncRulesContent = syncConfig.content;
-    this.storage = syncConfig.storage;
+    this.storage = await getTestStorage(this.factory, syncConfig.replicationStream);
     return this.storage!;
   }
 
@@ -141,7 +141,7 @@ export class ChangeStreamTestContext {
     }
 
     this.syncRulesContent = syncConfig.content;
-    this.storage = syncConfig.storage;
+    this.storage = await getTestStorage(this.factory, syncConfig.replicationStream);
     return this.storage!;
   }
 

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({

package/test/src/raw_change_stream.test.ts

@@ -5,7 +5,6 @@ import { getCursorBatchBytes } from '@module/replication/replication-index.js';
 import { mongo } from '@powersync/lib-service-mongodb';
 import { bson } from '@powersync/service-core';
 import { DATABASE_TYPE, DatabaseType } from './DatabaseType.js';
-import { testTimeout } from './test-timeouts.js';
 import { clearTestDb, connectMongoData, requireFailCommand } from './util.js';
 
 // DocumentDB only supports cluster-level change streams — collection- and
@@ -102,68 +101,6 @@ describe('internal mongodb utils', () => {
     }
   );
 
-  test(
-    'keeps getMore maxTimeMS when client-side maxAwaitTimeMS is enabled',
-    { timeout: testTimeout(30_000, { cloudOverride: 150_000 }) },
-    async () => {
-      const { db, client } = await connectMongoData({ monitorCommands: true });
-      await using _ = { [Symbol.asyncDispose]: async () => await client.close() };
-      await clearTestDb(db);
-      const collection = db.collection('test_data');
-      // Keep the local Mongo path fast, but give Azure DocumentDB enough time
-      // for slow cloud change-stream delivery when maxTimeMS is sent to getMore.
-      const maxAwaitTimeMS = testTimeout(50, { cloudOverride: 10_000 });
-
-      const started: any[] = [];
-      client.on('commandStarted', (event) => {
-        if (event.commandName == 'aggregate' || event.commandName == 'getMore') {
-          started.push(event);
-        }
-      });
-
-      const stream = rawChangeStream(
-        DATABASE_TYPE == DatabaseType.DOCUMENTDB ? client.db('admin') : db,
-        [
-          {
-            $changeStream: {
-              fullDocument: 'updateLookup',
-              ...(DATABASE_TYPE == DatabaseType.DOCUMENTDB ? { allChangesForCluster: true } : {})
-            }
-          },
-          ...(DATABASE_TYPE == DatabaseType.DOCUMENTDB
-            ? [
-                {
-                  $match: {
-                    'ns.db': db.databaseName,
-                    'ns.coll': collection.collectionName
-                  }
-                }
-              ]
-            : [])
-        ],
-        {
-          batchSize: 10,
-          maxAwaitTimeMS,
-          clientSideMaxAwaitTimeMS: true,
-          maxTimeMS: 1_000
-        }
-      );
-
-      await stream.next();
-      await collection.insertOne({ test: 1 });
-      const nextBatch = await readUntilNonEmptyBatch(stream);
-      await stream.return?.();
-
-      expect(nextBatch.events).toHaveLength(1);
-
-      const aggregate = started.find((event) => event.commandName == 'aggregate');
-      const getMore = started.find((event) => event.commandName == 'getMore');
-
-      expect(aggregate?.command.maxTimeMS).toEqual(1_000);
-      expect(getMore?.command.maxTimeMS).toEqual(maxAwaitTimeMS);
-    }
-  );
-
   // This test uses configureFailPoint to inject a getMore timeout. Azure
   // DocumentDB does not support configureFailPoint.
   test.skipIf(DATABASE_TYPE == DatabaseType.DOCUMENTDB)(