mongodb 6.5.0-dev.20240406.sha.62ea94b → 6.5.0-dev.20240409.sha.30cac05

package/src/cmap/commands.ts

@@ -37,7 +37,6 @@ export type WriteProtocolMessageType = OpQueryRequest | OpMsgRequest;
 export interface OpQueryOptions extends CommandOptions {
   socketTimeoutMS?: number;
   session?: ClientSession;
-  documentsReturnedIn?: string;
   numberToSkip?: number;
   numberToReturn?: number;
   returnFieldSelector?: Document;
@@ -53,9 +52,6 @@ export interface OpQueryOptions extends CommandOptions {
   exhaustAllowed?: boolean;
 }
 
-/**************************************************************
- * QUERY
- **************************************************************/
 /** @internal */
 export class OpQueryRequest {
   ns: string;
@@ -284,16 +280,11 @@ export interface MessageHeader {
 }
 
 /** @internal */
-export interface OpResponseOptions extends BSONSerializeOptions {
-  documentsReturnedIn?: string | null;
-}
-
-/** @internal */
-export class OpQueryResponse {
+export class OpReply {
   parsed: boolean;
   raw: Buffer;
   data: Buffer;
-  opts: OpResponseOptions;
+  opts: BSONSerializeOptions;
   length: number;
   requestId: number;
   responseTo: number;
@@ -303,7 +294,6 @@ export class OpQueryResponse {
   cursorId?: Long;
   startingFrom?: number;
   numberReturned?: number;
-  documents: (Document | Buffer)[] = new Array(0);
   cursorNotFound?: boolean;
   queryFailure?: boolean;
   shardConfigStale?: boolean;
@@ -313,7 +303,8 @@ export class OpQueryResponse {
   promoteValues: boolean;
   promoteBuffers: boolean;
   bsonRegExp?: boolean;
-  index?: number;
+  index = 0;
+  sections: Uint8Array[] = [];
 
   /** moreToCome is an OP_MSG only concept */
   moreToCome = false;
@@ -322,7 +313,7 @@ export class OpQueryResponse {
     message: Buffer,
     msgHeader: MessageHeader,
     msgBody: Buffer,
-    opts?: OpResponseOptions
+    opts?: BSONSerializeOptions
   ) {
     this.parsed = false;
     this.raw = message;
@@ -356,29 +347,9 @@ export class OpQueryResponse {
     return this.parsed;
   }
 
-  parse(options: OpResponseOptions): void {
+  parse(): Uint8Array {
     // Don't parse again if not needed
-    if (this.parsed) return;
-    options = options ?? {};
-
-    // Allow the return of raw documents instead of parsing
-    const raw = options.raw || false;
-    const documentsReturnedIn = options.documentsReturnedIn || null;
-    const useBigInt64 = options.useBigInt64 ?? this.opts.useBigInt64;
-    const promoteLongs = options.promoteLongs ?? this.opts.promoteLongs;
-    const promoteValues = options.promoteValues ?? this.opts.promoteValues;
-    const promoteBuffers = options.promoteBuffers ?? this.opts.promoteBuffers;
-    const bsonRegExp = options.bsonRegExp ?? this.opts.bsonRegExp;
-    let bsonSize;
-
-    // Set up the options
-    const _options: BSONSerializeOptions = {
-      useBigInt64,
-      promoteLongs,
-      promoteValues,
-      promoteBuffers,
-      bsonRegExp
-    };
+    if (this.parsed) return this.sections[0];
 
     // Position within OP_REPLY at which documents start
     // (See https://www.mongodb.com/docs/manual/reference/mongodb-wire-protocol/#wire-op-reply)
@@ -390,8 +361,11 @@ export class OpQueryResponse {
     this.startingFrom = this.data.readInt32LE(12);
     this.numberReturned = this.data.readInt32LE(16);
 
-    // Preallocate document array
-    this.documents = new Array(this.numberReturned);
+    if (this.numberReturned < 0 || this.numberReturned > 2 ** 32 - 1) {
+      throw new RangeError(
+        `OP_REPLY numberReturned is an invalid array length ${this.numberReturned}`
+      );
+    }
 
     this.cursorNotFound = (this.responseFlags & CURSOR_NOT_FOUND) !== 0;
     this.queryFailure = (this.responseFlags & QUERY_FAILURE) !== 0;
@@ -400,67 +374,26 @@ export class OpQueryResponse {
 
     // Parse Body
     for (let i = 0; i < this.numberReturned; i++) {
-      bsonSize =
+      const bsonSize =
         this.data[this.index] |
         (this.data[this.index + 1] << 8) |
         (this.data[this.index + 2] << 16) |
         (this.data[this.index + 3] << 24);
 
-      // If we have raw results specified slice the return document
-      if (raw) {
-        this.documents[i] = this.data.slice(this.index, this.index + bsonSize);
-      } else {
-        this.documents[i] = BSON.deserialize(
-          this.data.slice(this.index, this.index + bsonSize),
-          _options
-        );
-      }
+      const section = this.data.subarray(this.index, this.index + bsonSize);
+      this.sections.push(section);
 
       // Adjust the index
       this.index = this.index + bsonSize;
     }
 
-    if (this.documents.length === 1 && documentsReturnedIn != null && raw) {
-      const fieldsAsRaw: Document = {};
-      fieldsAsRaw[documentsReturnedIn] = true;
-      _options.fieldsAsRaw = fieldsAsRaw;
-
-      const doc = BSON.deserialize(this.documents[0] as Buffer, _options);
-      this.documents = [doc];
-    }
-
     // Set parsed
     this.parsed = true;
+
+    return this.sections[0];
   }
 }
 
-// Implementation of OP_MSG spec:
-// https://github.com/mongodb/specifications/blob/master/source/message/OP_MSG.rst
-//
-// struct Section {
-//   uint8 payloadType;
-//   union payload {
-//       document  document; // payloadType == 0
-//       struct sequence { // payloadType == 1
-//           int32      size;
-//           cstring    identifier;
-//           document*  documents;
-//       };
-//   };
-// };
-
-// struct OP_MSG {
-//   struct MsgHeader {
-//       int32  messageLength;
-//       int32  requestID;
-//       int32  responseTo;
-//       int32  opCode = 2013;
-//   };
-//   uint32      flagBits;
-//   Section+    sections;
-//   [uint32     checksum;]
-// };
-
 // Msg Flags
 const OPTS_CHECKSUM_PRESENT = 1;
 const OPTS_MORE_TO_COME = 2;
@@ -587,7 +520,7 @@ export class OpMsgResponse {
   parsed: boolean;
   raw: Buffer;
   data: Buffer;
-  opts: OpResponseOptions;
+  opts: BSONSerializeOptions;
   length: number;
   requestId: number;
   responseTo: number;
@@ -603,14 +536,14 @@ export class OpMsgResponse {
   promoteValues: boolean;
   promoteBuffers: boolean;
   bsonRegExp: boolean;
-  documents: (Document | Buffer)[];
-  index?: number;
+  index = 0;
+  sections: Uint8Array[] = [];
 
   constructor(
     message: Buffer,
     msgHeader: MessageHeader,
     msgBody: Buffer,
-    opts?: OpResponseOptions
+    opts?: BSONSerializeOptions
   ) {
     this.parsed = false;
     this.raw = message;
@@ -642,47 +575,26 @@ export class OpMsgResponse {
     this.promoteBuffers =
       typeof this.opts.promoteBuffers === 'boolean' ? this.opts.promoteBuffers : false;
     this.bsonRegExp = typeof this.opts.bsonRegExp === 'boolean' ? this.opts.bsonRegExp : false;
-
-    this.documents = [];
   }
 
   isParsed(): boolean {
     return this.parsed;
   }
 
-  parse(options: OpResponseOptions): void {
+  parse(): Uint8Array {
     // Don't parse again if not needed
-    if (this.parsed) return;
-    options = options ?? {};
+    if (this.parsed) return this.sections[0];
 
     this.index = 4;
-    // Allow the return of raw documents instead of parsing
-    const raw = options.raw || false;
-    const documentsReturnedIn = options.documentsReturnedIn || null;
-    const useBigInt64 = options.useBigInt64 ?? this.opts.useBigInt64;
-    const promoteLongs = options.promoteLongs ?? this.opts.promoteLongs;
-    const promoteValues = options.promoteValues ?? this.opts.promoteValues;
-    const promoteBuffers = options.promoteBuffers ?? this.opts.promoteBuffers;
-    const bsonRegExp = options.bsonRegExp ?? this.opts.bsonRegExp;
-    const validation = this.parseBsonSerializationOptions(options);
-
-    // Set up the options
-    const bsonOptions: BSONSerializeOptions = {
-      useBigInt64,
-      promoteLongs,
-      promoteValues,
-      promoteBuffers,
-      bsonRegExp,
-      validation
-      // Due to the strictness of the BSON libraries validation option we need this cast
-    } as BSONSerializeOptions & { validation: { utf8: { writeErrors: boolean } } };
 
     while (this.index < this.data.length) {
       const payloadType = this.data.readUInt8(this.index++);
       if (payloadType === 0) {
         const bsonSize = this.data.readUInt32LE(this.index);
-        const bin = this.data.slice(this.index, this.index + bsonSize);
-        this.documents.push(raw ? bin : BSON.deserialize(bin, bsonOptions));
+        const bin = this.data.subarray(this.index, this.index + bsonSize);
+
+        this.sections.push(bin);
+
         this.index += bsonSize;
       } else if (payloadType === 1) {
         // It was decided that no driver makes use of payload type 1
@@ -692,25 +604,9 @@ export class OpMsgResponse {
       }
     }
 
-    if (this.documents.length === 1 && documentsReturnedIn != null && raw) {
-      const fieldsAsRaw: Document = {};
-      fieldsAsRaw[documentsReturnedIn] = true;
-      bsonOptions.fieldsAsRaw = fieldsAsRaw;
-      const doc = BSON.deserialize(this.documents[0] as Buffer, bsonOptions);
-      this.documents = [doc];
-    }
-
     this.parsed = true;
-  }
-
-  parseBsonSerializationOptions({ enableUtf8Validation }: BSONSerializeOptions): {
-    utf8: { writeErrors: false } | false;
-  } {
-    if (enableUtf8Validation === false) {
-      return { utf8: false };
-    }
 
-    return { utf8: { writeErrors: false } };
+    return this.sections[0];
   }
 }
 

package/src/cmap/connect.ts

@@ -103,7 +103,7 @@ export async function performInitialHandshake(
   const handshakeDoc = await prepareHandshakeDocument(authContext);
 
   // @ts-expect-error: TODO(NODE-5141): The options need to be filtered properly, Connection options differ from Command options
-  const handshakeOptions: CommandOptions = { ...options };
+  const handshakeOptions: CommandOptions = { ...options, raw: false };
   if (typeof options.connectTimeoutMS === 'number') {
     // The handshake technically is a monitoring check, so its socket timeout should be connectTimeoutMS
     handshakeOptions.socketTimeoutMS = options.connectTimeoutMS;

package/src/cmap/connection.ts

@@ -54,7 +54,7 @@ import {
   OpMsgRequest,
   type OpMsgResponse,
   OpQueryRequest,
-  type OpQueryResponse,
+  type OpReply,
   type WriteProtocolMessageType
 } from './commands';
 import type { Stream } from './connect';
@@ -62,6 +62,7 @@ import type { ClientMetadata } from './handshake/client_metadata';
 import { StreamDescription, type StreamDescriptionOptions } from './stream_description';
 import { type CompressorName, decompressResponse } from './wire_protocol/compression';
 import { onData } from './wire_protocol/on_data';
+import { MongoDBResponse, type MongoDBResponseConstructor } from './wire_protocol/responses';
 import { getReadPreference, isSharded } from './wire_protocol/shared';
 
 /** @internal */
@@ -412,7 +413,11 @@ export class Connection extends TypedEventEmitter<ConnectionEvents> {
     return message;
   }
 
-  private async *sendWire(message: WriteProtocolMessageType, options: CommandOptions) {
+  private async *sendWire(
+    message: WriteProtocolMessageType,
+    options: CommandOptions,
+    responseType?: MongoDBResponseConstructor
+  ): AsyncGenerator<MongoDBResponse> {
     this.throwIfAborted();
 
     if (typeof options.socketTimeoutMS === 'number') {
@@ -428,7 +433,7 @@ export class Connection extends TypedEventEmitter<ConnectionEvents> {
       });
 
       if (options.noResponse) {
-        yield { ok: 1 };
+        yield MongoDBResponse.empty;
         return;
       }
 
@@ -436,21 +441,9 @@ export class Connection extends TypedEventEmitter<ConnectionEvents> {
 
       for await (const response of this.readMany()) {
         this.socket.setTimeout(0);
-        response.parse(options);
-
-        const [document] = response.documents;
+        const bson = response.parse();
 
-        if (!Buffer.isBuffer(document)) {
-          const { session } = options;
-          if (session) {
-            updateSessionFromResponse(session, document);
-          }
-
-          if (document.$clusterTime) {
-            this.clusterTime = document.$clusterTime;
-            this.emit(Connection.CLUSTER_TIME_RECEIVED, document.$clusterTime);
-          }
-        }
+        const document = new (responseType ?? MongoDBResponse)(bson, 0, false);
 
         yield document;
         this.throwIfAborted();
@@ -469,7 +462,8 @@ export class Connection extends TypedEventEmitter<ConnectionEvents> {
   private async *sendCommand(
     ns: MongoDBNamespace,
     command: Document,
-    options: CommandOptions = {}
+    options: CommandOptions,
+    responseType?: MongoDBResponseConstructor
   ) {
     const message = this.prepareCommand(ns.db, command, options);
 
@@ -485,19 +479,41 @@ export class Connection extends TypedEventEmitter<ConnectionEvents> {
       );
     }
 
-    let document;
+    // If `documentsReturnedIn` not set or raw is not enabled, use input bson options
+    // Otherwise, support raw flag. Raw only works for cursors that hardcode firstBatch/nextBatch fields
+    const bsonOptions =
+      options.documentsReturnedIn == null || !options.raw
+        ? options
+        : {
+            ...options,
+            raw: false,
+            fieldsAsRaw: { [options.documentsReturnedIn]: true }
+          };
+
+    /** MongoDBResponse instance or subclass */
+    let document: MongoDBResponse | undefined = undefined;
+    /** Cached result of a toObject call */
+    let object: Document | undefined = undefined;
     try {
       this.throwIfAborted();
-      for await (document of this.sendWire(message, options)) {
-        if (!Buffer.isBuffer(document) && document.writeConcernError) {
-          throw new MongoWriteConcernError(document.writeConcernError, document);
+      for await (document of this.sendWire(message, options, responseType)) {
+        object = undefined;
+        if (options.session != null) {
+          updateSessionFromResponse(options.session, document);
+        }
+
+        if (document.$clusterTime) {
+          this.clusterTime = document.$clusterTime;
+          this.emit(Connection.CLUSTER_TIME_RECEIVED, document.$clusterTime);
         }
 
-        if (
-          !Buffer.isBuffer(document) &&
-          (document.ok === 0 || document.$err || document.errmsg || document.code)
-        ) {
-          throw new MongoServerError(document);
+        if (document.has('writeConcernError')) {
+          object ??= document.toObject(bsonOptions);
+          throw new MongoWriteConcernError(object.writeConcernError, object);
+        }
+
+        if (document.isError) {
+          throw new MongoServerError((object ??= document.toObject(bsonOptions)));
         }
 
         if (this.shouldEmitAndLogCommand) {
@@ -509,14 +525,19 @@ export class Connection extends TypedEventEmitter<ConnectionEvents> {
             new CommandSucceededEvent(
               this,
               message,
-              options.noResponse ? undefined : document,
+              options.noResponse ? undefined : (object ??= document.toObject(bsonOptions)),
               started,
               this.description.serverConnectionId
             )
           );
         }
 
-        yield document;
+        if (responseType == null) {
+          yield (object ??= document.toObject(bsonOptions));
+        } else {
+          yield document;
+        }
+
         this.throwIfAborted();
       }
     } catch (error) {
@@ -530,7 +551,7 @@ export class Connection extends TypedEventEmitter<ConnectionEvents> {
             new CommandSucceededEvent(
               this,
               message,
-              options.noResponse ? undefined : document,
+              options.noResponse ? undefined : (object ??= document?.toObject(bsonOptions)),
               started,
               this.description.serverConnectionId
             )
@@ -555,13 +576,27 @@ export class Connection extends TypedEventEmitter<ConnectionEvents> {
     }
   }
 
+  public async command<T extends MongoDBResponseConstructor>(
+    ns: MongoDBNamespace,
+    command: Document,
+    options: CommandOptions | undefined,
+    responseType: T | undefined
+  ): Promise<typeof responseType extends undefined ? Document : InstanceType<T>>;
+
+  public async command(
+    ns: MongoDBNamespace,
+    command: Document,
+    options?: CommandOptions
+  ): Promise<Document>;
+
   public async command(
     ns: MongoDBNamespace,
     command: Document,
-    options: CommandOptions = {}
+    options: CommandOptions = {},
+    responseType?: MongoDBResponseConstructor
   ): Promise<Document> {
     this.throwIfAborted();
-    for await (const document of this.sendCommand(ns, command, options)) {
+    for await (const document of this.sendCommand(ns, command, options, responseType)) {
       return document;
     }
     throw new MongoUnexpectedServerResponseError('Unable to get response from server');
@@ -622,7 +657,7 @@ export class Connection extends TypedEventEmitter<ConnectionEvents> {
    *
    * Note that `for-await` loops call `return` automatically when the loop is exited.
    */
-  private async *readMany(): AsyncGenerator<OpMsgResponse | OpQueryResponse> {
+  private async *readMany(): AsyncGenerator<OpMsgResponse | OpReply> {
     try {
       this.dataEvents = onData(this.messageStream);
       for await (const message of this.dataEvents) {
@@ -687,11 +722,24 @@ export class CryptoConnection extends Connection {
     this.autoEncrypter = options.autoEncrypter;
   }
 
-  /** @internal @override */
-  override async command(
+  public override async command<T extends MongoDBResponseConstructor>(
+    ns: MongoDBNamespace,
+    command: Document,
+    options: CommandOptions | undefined,
+    responseType: T
+  ): Promise<InstanceType<T>>;
+
+  public override async command(
+    ns: MongoDBNamespace,
+    command: Document,
+    options?: CommandOptions
+  ): Promise<Document>;
+
+  override async command<T extends MongoDBResponseConstructor>(
     ns: MongoDBNamespace,
     cmd: Document,
-    options: CommandOptions
+    options?: CommandOptions,
+    responseType?: T | undefined
   ): Promise<Document> {
     const { autoEncrypter } = this;
     if (!autoEncrypter) {
@@ -705,7 +753,7 @@ export class CryptoConnection extends Connection {
     const serverWireVersion = maxWireVersion(this);
     if (serverWireVersion === 0) {
       // This means the initial handshake hasn't happened yet
-      return await super.command(ns, cmd, options);
+      return await super.command<T>(ns, cmd, options, responseType);
     }
 
     if (serverWireVersion < 8) {
@@ -739,7 +787,7 @@ export class CryptoConnection extends Connection {
       }
     }
 
-    const response = await super.command(ns, encrypted, options);
+    const response = await super.command<T>(ns, encrypted, options, responseType);
 
     return await autoEncrypter.decrypt(response, options);
   }

package/src/cmap/wire_protocol/compression.ts

@@ -8,7 +8,7 @@ import {
   type MessageHeader,
   OpCompressedRequest,
   OpMsgResponse,
-  OpQueryResponse,
+  OpReply,
   type WriteProtocolMessageType
 } from '../commands';
 import { OP_COMPRESSED, OP_MSG } from './constants';
@@ -163,9 +163,7 @@ export async function compressCommand(
  *
  * This method does not parse the response's BSON.
  */
-export async function decompressResponse(
-  message: Buffer
-): Promise<OpMsgResponse | OpQueryResponse> {
+export async function decompressResponse(message: Buffer): Promise<OpMsgResponse | OpReply> {
   const messageHeader: MessageHeader = {
     length: message.readInt32LE(0),
     requestId: message.readInt32LE(4),
@@ -174,7 +172,7 @@ export async function decompressResponse(
   };
 
   if (messageHeader.opCode !== OP_COMPRESSED) {
-    const ResponseType = messageHeader.opCode === OP_MSG ? OpMsgResponse : OpQueryResponse;
+    const ResponseType = messageHeader.opCode === OP_MSG ? OpMsgResponse : OpReply;
     const messageBody = message.subarray(MESSAGE_HEADER_SIZE);
     return new ResponseType(message, messageHeader, messageBody);
   }
@@ -189,7 +187,7 @@ export async function decompressResponse(
   const compressedBuffer = message.slice(MESSAGE_HEADER_SIZE + 9);
 
   // recalculate based on wrapped opcode
-  const ResponseType = header.opCode === OP_MSG ? OpMsgResponse : OpQueryResponse;
+  const ResponseType = header.opCode === OP_MSG ? OpMsgResponse : OpReply;
   const messageBody = await decompress(compressorID, compressedBuffer);
   if (messageBody.length !== header.length) {
     throw new MongoDecompressionError('Message body and message header must be the same length');

package/src/cmap/wire_protocol/on_demand/document.ts

@@ -23,6 +23,7 @@ const enum BSONElementOffset {
   length = 4
 }
 
+/** @internal */
 export type JSTypeOf = {
   [BSONType.null]: null;
   [BSONType.undefined]: null;

package/src/cmap/wire_protocol/responses.ts

@@ -0,0 +1,109 @@
+import { type BSONSerializeOptions, BSONType, type Document, type Timestamp } from '../../bson';
+import { type ClusterTime } from '../../sdam/common';
+import { OnDemandDocument } from './on_demand/document';
+
+/** @internal */
+export type MongoDBResponseConstructor = {
+  new (bson: Uint8Array, offset?: number, isArray?: boolean): MongoDBResponse;
+};
+
+/** @internal */
+export class MongoDBResponse extends OnDemandDocument {
+  // {ok:1}
+  static empty = new MongoDBResponse(new Uint8Array([13, 0, 0, 0, 16, 111, 107, 0, 1, 0, 0, 0, 0]));
+
+  /** Indicates this document is a server error */
+  public get isError() {
+    let isError = this.ok === 0;
+    isError ||= this.has('errmsg');
+    isError ||= this.has('code');
+    isError ||= this.has('$err'); // The '$err' field is used in OP_REPLY responses
+    return isError;
+  }
+
+  /**
+   * Drivers can safely assume that the `recoveryToken` field is always a BSON document but drivers MUST NOT modify the
+   * contents of the document.
+   */
+  get recoveryToken(): Document | null {
+    return (
+      this.get('recoveryToken', BSONType.object)?.toObject({
+        promoteValues: false,
+        promoteLongs: false,
+        promoteBuffers: false
+      }) ?? null
+    );
+  }
+
+  /**
+   * The server creates a cursor in response to a snapshot find/aggregate command and reports atClusterTime within the cursor field in the response.
+   * For the distinct command the server adds a top-level atClusterTime field to the response.
+   * The atClusterTime field represents the timestamp of the read and is guaranteed to be majority committed.
+   */
+  public get atClusterTime(): Timestamp | null {
+    return (
+      this.get('cursor', BSONType.object)?.get('atClusterTime', BSONType.timestamp) ??
+      this.get('atClusterTime', BSONType.timestamp)
+    );
+  }
+
+  public get operationTime(): Timestamp | null {
+    return this.get('operationTime', BSONType.timestamp);
+  }
+
+  public get ok(): 0 | 1 {
+    return this.getNumber('ok') ? 1 : 0;
+  }
+
+  public get $err(): string | null {
+    return this.get('$err', BSONType.string);
+  }
+
+  public get errmsg(): string | null {
+    return this.get('errmsg', BSONType.string);
+  }
+
+  public get code(): number | null {
+    return this.getNumber('code');
+  }
+
+  private clusterTime?: ClusterTime | null;
+  public get $clusterTime(): ClusterTime | null {
+    if (!('clusterTime' in this)) {
+      const clusterTimeDoc = this.get('$clusterTime', BSONType.object);
+      if (clusterTimeDoc == null) {
+        this.clusterTime = null;
+        return null;
+      }
+      const clusterTime = clusterTimeDoc.get('clusterTime', BSONType.timestamp, true);
+      const signature = clusterTimeDoc.get('signature', BSONType.object)?.toObject();
+      // @ts-expect-error: `signature` is incorrectly typed. It is public API.
+      this.clusterTime = { clusterTime, signature };
+    }
+    return this.clusterTime ?? null;
+  }
+
+  public override toObject(options: BSONSerializeOptions = {}): Record<string, any> {
+    const exactBSONOptions = {
+      useBigInt64: options.useBigInt64,
+      promoteLongs: options.promoteLongs,
+      promoteValues: options.promoteValues,
+      promoteBuffers: options.promoteBuffers,
+      bsonRegExp: options.bsonRegExp,
+      raw: options.raw ?? false,
+      fieldsAsRaw: options.fieldsAsRaw ?? {},
+      validation: this.parseBsonSerializationOptions(options)
+    };
+    return super.toObject(exactBSONOptions);
+  }
+
+  private parseBsonSerializationOptions({ enableUtf8Validation }: BSONSerializeOptions): {
+    utf8: { writeErrors: false } | false;
+  } {
+    if (enableUtf8Validation === false) {
+      return { utf8: false };
+    }
+
+    return { utf8: { writeErrors: false } };
+  }
+}