mongodb 6.4.0 → 6.5.0

package/src/bulk/common.ts

@@ -1,6 +1,6 @@
 import { promisify } from 'util';
 
-import { type BSONSerializeOptions, type Document, ObjectId, resolveBSONOptions } from '../bson';
+import { type BSONSerializeOptions, type Document, resolveBSONOptions } from '../bson';
 import type { Collection } from '../collection';
 import {
   type AnyError,
@@ -12,6 +12,7 @@ import {
 } from '../error';
 import type { Filter, OneOrMore, OptionalId, UpdateFilter, WithoutId } from '../mongo_types';
 import type { CollationOptions, CommandOperationOptions } from '../operations/command';
+import { maybeAddIdToDocuments } from '../operations/common_functions';
 import { DeleteOperation, type DeleteStatement, makeDeleteStatement } from '../operations/delete';
 import { executeOperation } from '../operations/execute_operation';
 import { InsertOperation } from '../operations/insert';
@@ -917,7 +918,7 @@ export abstract class BulkOperationBase {
    * Create a new OrderedBulkOperation or UnorderedBulkOperation instance
    * @internal
    */
-  constructor(collection: Collection, options: BulkWriteOptions, isOrdered: boolean) {
+  constructor(private collection: Collection, options: BulkWriteOptions, isOrdered: boolean) {
     // determine whether bulkOperation is ordered or unordered
     this.isOrdered = isOrdered;
 
@@ -1032,9 +1033,9 @@ export abstract class BulkOperationBase {
    * ```
    */
   insert(document: Document): BulkOperationBase {
-    if (document._id == null && !shouldForceServerObjectId(this)) {
-      document._id = new ObjectId();
-    }
+    maybeAddIdToDocuments(this.collection, document, {
+      forceServerObjectId: this.shouldForceServerObjectId()
+    });
 
     return this.addToOperationsList(BatchType.INSERT, document);
   }
@@ -1093,21 +1094,16 @@ export abstract class BulkOperationBase {
       throw new MongoInvalidArgumentError('Operation must be an object with an operation key');
     }
     if ('insertOne' in op) {
-      const forceServerObjectId = shouldForceServerObjectId(this);
-      if (op.insertOne && op.insertOne.document == null) {
-        // NOTE: provided for legacy support, but this is a malformed operation
-        if (forceServerObjectId !== true && (op.insertOne as Document)._id == null) {
-          (op.insertOne as Document)._id = new ObjectId();
-        }
-
-        return this.addToOperationsList(BatchType.INSERT, op.insertOne);
-      }
+      const forceServerObjectId = this.shouldForceServerObjectId();
+      const document =
+        op.insertOne && op.insertOne.document == null
+          ? // TODO(NODE-6003): remove support for omitting the `documents` subdocument in bulk inserts
+            (op.insertOne as Document)
+          : op.insertOne.document;
 
-      if (forceServerObjectId !== true && op.insertOne.document._id == null) {
-        op.insertOne.document._id = new ObjectId();
-      }
+      maybeAddIdToDocuments(this.collection, document, { forceServerObjectId });
 
-      return this.addToOperationsList(BatchType.INSERT, op.insertOne.document);
+      return this.addToOperationsList(BatchType.INSERT, document);
     }
 
     if ('replaceOne' in op || 'updateOne' in op || 'updateMany' in op) {
@@ -1268,6 +1264,13 @@ export abstract class BulkOperationBase {
     batchType: BatchType,
     document: Document | UpdateStatement | DeleteStatement
   ): this;
+
+  private shouldForceServerObjectId(): boolean {
+    return (
+      this.s.options.forceServerObjectId === true ||
+      this.s.collection.s.db.options?.forceServerObjectId === true
+    );
+  }
 }
 
 Object.defineProperty(BulkOperationBase.prototype, 'length', {
@@ -1277,18 +1280,6 @@ Object.defineProperty(BulkOperationBase.prototype, 'length', {
   }
 });
 
-function shouldForceServerObjectId(bulkOperation: BulkOperationBase): boolean {
-  if (typeof bulkOperation.s.options.forceServerObjectId === 'boolean') {
-    return bulkOperation.s.options.forceServerObjectId;
-  }
-
-  if (typeof bulkOperation.s.collection.s.db.options?.forceServerObjectId === 'boolean') {
-    return bulkOperation.s.collection.s.db.options?.forceServerObjectId;
-  }
-
-  return false;
-}
-
 function isInsertBatch(batch: Batch): boolean {
   return batch.batchType === BatchType.INSERT;
 }

package/src/cmap/commands.ts

@@ -1,7 +1,7 @@
 import type { BSONSerializeOptions, Document, Long } from '../bson';
 import * as BSON from '../bson';
 import { MongoInvalidArgumentError, MongoRuntimeError } from '../error';
-import { ReadPreference } from '../read_preference';
+import { type ReadPreference } from '../read_preference';
 import type { ClientSession } from '../sessions';
 import type { CommandOptions } from './connection';
 import {
@@ -51,7 +51,6 @@ export interface OpQueryOptions extends CommandOptions {
   requestId?: number;
   moreToCome?: boolean;
   exhaustAllowed?: boolean;
-  readPreference?: ReadPreference;
 }
 
 /**************************************************************
@@ -77,7 +76,6 @@ export class OpQueryRequest {
   awaitData: boolean;
   exhaust: boolean;
   partial: boolean;
-  documentsReturnedIn?: string;
 
   constructor(public databaseName: string, public query: Document, options: OpQueryOptions) {
     // Basic options needed to be passed in
@@ -503,10 +501,6 @@ export class OpMsgRequest {
     // Basic options
     this.command.$db = databaseName;
 
-    if (options.readPreference && options.readPreference.mode !== ReadPreference.PRIMARY) {
-      this.command.$readPreference = options.readPreference.toJSON();
-    }
-
     // Ensure empty options
     this.options = options ?? {};
 

package/src/cmap/connect.ts

@@ -25,7 +25,6 @@ import {
   type ConnectionOptions,
   CryptoConnection
 } from './connection';
-import type { ClientMetadata } from './handshake/client_metadata';
 import {
   MAX_SUPPORTED_SERVER_VERSION,
   MAX_SUPPORTED_WIRE_VERSION,
@@ -44,7 +43,7 @@ export async function connect(options: ConnectionOptions): Promise<Connection> {
     await performInitialHandshake(connection, options);
     return connection;
   } catch (error) {
-    connection?.destroy({ force: false });
+    connection?.destroy();
     throw error;
   }
 }
@@ -183,7 +182,7 @@ export interface HandshakeDocument extends Document {
   ismaster?: boolean;
   hello?: boolean;
   helloOk?: boolean;
-  client: ClientMetadata;
+  client: Document;
   compression: string[];
   saslSupportedMechs?: string;
   loadBalanced?: boolean;
@@ -200,11 +199,12 @@ export async function prepareHandshakeDocument(
   const options = authContext.options;
   const compressors = options.compressors ? options.compressors : [];
   const { serverApi } = authContext.connection;
+  const clientMetadata: Document = await options.extendedMetadata;
 
   const handshakeDoc: HandshakeDocument = {
     [serverApi?.version || options.loadBalanced === true ? 'hello' : LEGACY_HELLO_COMMAND]: 1,
     helloOk: true,
-    client: options.metadata,
+    client: clientMetadata,
     compression: compressors
   };
 
@@ -319,7 +319,6 @@ export async function makeSocket(options: MakeConnectionOptions): Promise<Stream
   const useTLS = options.tls ?? false;
   const noDelay = options.noDelay ?? true;
   const connectTimeoutMS = options.connectTimeoutMS ?? 30000;
-  const rejectUnauthorized = options.rejectUnauthorized ?? true;
   const existingSocket = options.existingSocket;
 
   let socket: Stream;
@@ -375,10 +374,6 @@ export async function makeSocket(options: MakeConnectionOptions): Promise<Stream
     return socket;
   } catch (error) {
     socket.destroy();
-    if ('authorizationError' in socket && socket.authorizationError != null && rejectUnauthorized) {
-      // TODO(NODE-5192): wrap this with a MongoError subclass
-      throw socket.authorizationError;
-    }
     throw error;
   } finally {
     socket.setTimeout(0);

package/src/cmap/connection.ts

@@ -1,6 +1,5 @@
 import { type Readable, Transform, type TransformCallback } from 'stream';
 import { clearTimeout, setTimeout } from 'timers';
-import { promisify } from 'util';
 
 import type { BSONSerializeOptions, Document, ObjectId } from '../bson';
 import type { AutoEncrypter } from '../client-side-encryption/auto_encrypter';
@@ -27,7 +26,8 @@ import type { ServerApi, SupportedNodeConnectionOptions } from '../mongo_client'
 import { type MongoClientAuthProviders } from '../mongo_client_auth_providers';
 import { MongoLoggableComponent, type MongoLogger, SeverityLevel } from '../mongo_logger';
 import { type CancellationToken, TypedEventEmitter } from '../mongo_types';
-import type { ReadPreferenceLike } from '../read_preference';
+import { ReadPreference, type ReadPreferenceLike } from '../read_preference';
+import { ServerType } from '../sdam/common';
 import { applySession, type ClientSession, updateSessionFromResponse } from '../sessions';
 import {
   BufferPool,
@@ -37,7 +37,7 @@ import {
   maxWireVersion,
   type MongoDBNamespace,
   now,
-  promiseWithResolvers,
+  once,
   uuidV4
 } from '../utils';
 import type { WriteConcern } from '../write_concern';
@@ -84,6 +84,8 @@ export interface CommandOptions extends BSONSerializeOptions {
   willRetryWrite?: boolean;
 
   writeConcern?: WriteConcern;
+
+  directConnection?: boolean;
 }
 
 /** @public */
@@ -119,15 +121,11 @@ export interface ConnectionOptions
   cancellationToken?: CancellationToken;
   metadata: ClientMetadata;
   /** @internal */
+  extendedMetadata: Promise<Document>;
+  /** @internal */
   mongoLogger?: MongoLogger | undefined;
 }
 
-/** @internal */
-export interface DestroyOptions {
-  /** Force the destruction. */
-  force: boolean;
-}
-
 /** @public */
 export type ConnectionEvents = {
   commandStarted(event: CommandStartedEvent): void;
@@ -180,18 +178,18 @@ export class Connection extends TypedEventEmitter<ConnectionEvents> {
    * Once connection is established, command logging can log events (if enabled)
    */
   public established: boolean;
+  /** Indicates that the connection (including underlying TCP socket) has been closed. */
+  public closed = false;
 
   private lastUseTime: number;
   private clusterTime: Document | null = null;
+  private error: Error | null = null;
+  private dataEvents: AsyncGenerator<Buffer, void, void> | null = null;
 
   private readonly socketTimeoutMS: number;
   private readonly monitorCommands: boolean;
   private readonly socket: Stream;
-  private readonly controller: AbortController;
-  private readonly signal: AbortSignal;
   private readonly messageStream: Readable;
-  private readonly socketWrite: (buffer: Uint8Array) => Promise<void>;
-  private readonly aborted: Promise<never>;
 
   /** @event */
   static readonly COMMAND_STARTED = COMMAND_STARTED;
@@ -211,6 +209,7 @@ export class Connection extends TypedEventEmitter<ConnectionEvents> {
   constructor(stream: Stream, options: ConnectionOptions) {
     super();
 
+    this.socket = stream;
     this.id = options.id;
     this.address = streamIdentifier(stream, options);
     this.socketTimeoutMS = options.socketTimeoutMS ?? 0;
@@ -223,39 +222,12 @@ export class Connection extends TypedEventEmitter<ConnectionEvents> {
     this.generation = options.generation;
     this.lastUseTime = now();
 
-    this.socket = stream;
-
-    // TODO: Remove signal from connection layer
-    this.controller = new AbortController();
-    const { signal } = this.controller;
-    this.signal = signal;
-    const { promise: aborted, reject } = promiseWithResolvers<never>();
-    aborted.then(undefined, () => null); // Prevent unhandled rejection
-    this.signal.addEventListener(
-      'abort',
-      function onAbort() {
-        reject(signal.reason);
-      },
-      { once: true }
-    );
-    this.aborted = aborted;
-
     this.messageStream = this.socket
       .on('error', this.onError.bind(this))
       .pipe(new SizedMessageTransform({ connection: this }))
       .on('error', this.onError.bind(this));
     this.socket.on('close', this.onClose.bind(this));
     this.socket.on('timeout', this.onTimeout.bind(this));
-
-    const socketWrite = promisify(this.socket.write.bind(this.socket));
-    this.socketWrite = async buffer => {
-      return Promise.race([socketWrite(buffer), this.aborted]);
-    };
-  }
-
-  /** Indicates that the connection (including underlying TCP socket) has been closed. */
-  public get closed(): boolean {
-    return this.signal.aborted;
   }
 
   public get hello() {
@@ -306,7 +278,7 @@ export class Connection extends TypedEventEmitter<ConnectionEvents> {
     this.lastUseTime = now();
   }
 
-  public onError(error?: Error) {
+  public onError(error: Error) {
     this.cleanup(error);
   }
 
@@ -323,14 +295,10 @@ export class Connection extends TypedEventEmitter<ConnectionEvents> {
     }, 1).unref(); // No need for this timer to hold the event loop open
   }
 
-  public destroy(options: DestroyOptions, callback?: Callback): void {
+  public destroy(): void {
     if (this.closed) {
-      if (typeof callback === 'function') process.nextTick(callback);
       return;
     }
-    if (typeof callback === 'function') {
-      this.once('close', () => process.nextTick(() => callback()));
-    }
 
     // load balanced mode requires that these listeners remain on the connection
     // after cleanup on timeouts, errors or close so we remove them before calling
@@ -349,13 +317,15 @@ export class Connection extends TypedEventEmitter<ConnectionEvents> {
    *
    * This method does nothing if the connection is already closed.
    */
-  private cleanup(error?: Error): void {
+  private cleanup(error: Error): void {
     if (this.closed) {
       return;
     }
 
     this.socket.destroy();
-    this.controller.abort(error);
+    this.error = error;
+    this.dataEvents?.throw(error).then(undefined, () => null); // squash unhandled rejection
+    this.closed = true;
     this.emit(Connection.CLOSE);
   }
 
@@ -394,16 +364,34 @@ export class Connection extends TypedEventEmitter<ConnectionEvents> {
       cmd.$clusterTime = clusterTime;
     }
 
-    if (
-      isSharded(this) &&
-      !this.supportsOpMsg &&
-      readPreference &&
-      readPreference.mode !== 'primary'
-    ) {
-      cmd = {
-        $query: cmd,
-        $readPreference: readPreference.toJSON()
-      };
+    // For standalone, drivers MUST NOT set $readPreference.
+    if (this.description.type !== ServerType.Standalone) {
+      if (
+        !isSharded(this) &&
+        !this.description.loadBalanced &&
+        this.supportsOpMsg &&
+        options.directConnection === true &&
+        readPreference?.mode === 'primary'
+      ) {
+        // For mongos and load balancers with 'primary' mode, drivers MUST NOT set $readPreference.
+        // For all other types with a direct connection, if the read preference is 'primary'
+        // (driver sets 'primary' as default if no read preference is configured),
+        // the $readPreference MUST be set to 'primaryPreferred'
+        // to ensure that any server type can handle the request.
+        cmd.$readPreference = ReadPreference.primaryPreferred.toJSON();
+      } else if (isSharded(this) && !this.supportsOpMsg && readPreference?.mode !== 'primary') {
+        // When sending a read operation via OP_QUERY and the $readPreference modifier,
+        // the query MUST be provided using the $query modifier.
+        cmd = {
+          $query: cmd,
+          $readPreference: readPreference.toJSON()
+        };
+      } else if (readPreference?.mode !== 'primary') {
+        // For mode 'primary', drivers MUST NOT set $readPreference.
+        // For all other read preference modes (i.e. 'secondary', 'primaryPreferred', ...),
+        // drivers MUST set $readPreference
+        cmd.$readPreference = readPreference.toJSON();
+      }
     }
 
     const commandOptions = {
@@ -412,8 +400,7 @@ export class Connection extends TypedEventEmitter<ConnectionEvents> {
       checkKeys: false,
       // This value is not overridable
       secondaryOk: readPreference.secondaryOk(),
-      ...options,
-      readPreference // ensure we pass in ReadPreference instance
+      ...options
     };
 
     const message = this.supportsOpMsg
@@ -596,7 +583,7 @@ export class Connection extends TypedEventEmitter<ConnectionEvents> {
   }
 
   private throwIfAborted() {
-    this.signal.throwIfAborted();
+    if (this.error) throw this.error;
   }
 
   /**
@@ -619,7 +606,8 @@ export class Connection extends TypedEventEmitter<ConnectionEvents> {
 
     const buffer = Buffer.concat(await finalCommand.toBin());
 
-    return this.socketWrite(buffer);
+    if (this.socket.write(buffer)) return;
+    return once(this.socket, 'drain');
   }
 
   /**
@@ -632,13 +620,19 @@ 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> {
-    for await (const message of onData(this.messageStream, { signal: this.signal })) {
-      const response = await decompressResponse(message);
-      yield response;
+    try {
+      this.dataEvents = onData(this.messageStream);
+      for await (const message of this.dataEvents) {
+        const response = await decompressResponse(message);
+        yield response;
 
-      if (!response.moreToCome) {
-        return;
+        if (!response.moreToCome) {
+          return;
+        }
       }
+    } finally {
+      this.dataEvents = null;
+      this.throwIfAborted();
     }
   }
 }

package/src/cmap/connection_pool.ts

@@ -28,7 +28,6 @@ import { CancellationToken, TypedEventEmitter } from '../mongo_types';
 import type { Server } from '../sdam/server';
 import {
   type Callback,
-  eachAsync,
   List,
   makeCounter,
   promiseWithResolvers,
@@ -119,7 +118,11 @@ export const PoolState = Object.freeze({
   closed: 'closed'
 } as const);
 
-/** @public */
+/**
+ * @public
+ * @deprecated This interface is deprecated and will be removed in a future release as it is not used
+ * in the driver
+ */
 export interface CloseOptions {
   force?: boolean;
 }
@@ -233,8 +236,7 @@ export class ConnectionPool extends TypedEventEmitter<ConnectionPoolEvents> {
       maxIdleTimeMS: options.maxIdleTimeMS ?? 0,
       waitQueueTimeoutMS: options.waitQueueTimeoutMS ?? 0,
       minPoolSizeCheckFrequencyMS: options.minPoolSizeCheckFrequencyMS ?? 100,
-      autoEncrypter: options.autoEncrypter,
-      metadata: options.metadata
+      autoEncrypter: options.autoEncrypter
     });
 
     if (this.options.minPoolSize > this.options.maxPoolSize) {
@@ -494,25 +496,16 @@ export class ConnectionPool extends TypedEventEmitter<ConnectionPoolEvents> {
   private interruptInUseConnections(minGeneration: number) {
     for (const connection of this[kCheckedOut]) {
       if (connection.generation <= minGeneration) {
-        this.checkIn(connection);
         connection.onError(new PoolClearedOnNetworkError(this));
+        this.checkIn(connection);
       }
     }
   }
 
   /** Close the pool */
-  close(callback: Callback<void>): void;
-  close(options: CloseOptions, callback: Callback<void>): void;
-  close(_options?: CloseOptions | Callback<void>, _cb?: Callback<void>): void {
-    let options = _options as CloseOptions;
-    const callback = (_cb ?? _options) as Callback<void>;
-    if (typeof options === 'function') {
-      options = {};
-    }
-
-    options = Object.assign({ force: false }, options);
+  close(): void {
     if (this.closed) {
-      return callback();
+      return;
     }
 
     // immediately cancel any in-flight connections
@@ -527,21 +520,15 @@ export class ConnectionPool extends TypedEventEmitter<ConnectionPoolEvents> {
     this.clearMinPoolSizeTimer();
     this.processWaitQueue();
 
-    eachAsync<Connection>(
-      this[kConnections].toArray(),
-      (conn, cb) => {
-        this.emitAndLog(
-          ConnectionPool.CONNECTION_CLOSED,
-          new ConnectionClosedEvent(this, conn, 'poolClosed')
-        );
-        conn.destroy({ force: !!options.force }, cb);
-      },
-      err => {
-        this[kConnections].clear();
-        this.emitAndLog(ConnectionPool.CONNECTION_POOL_CLOSED, new ConnectionPoolClosedEvent(this));
-        callback(err);
-      }
-    );
+    for (const conn of this[kConnections]) {
+      this.emitAndLog(
+        ConnectionPool.CONNECTION_CLOSED,
+        new ConnectionClosedEvent(this, conn, 'poolClosed')
+      );
+      conn.destroy();
+    }
+    this[kConnections].clear();
+    this.emitAndLog(ConnectionPool.CONNECTION_POOL_CLOSED, new ConnectionPoolClosedEvent(this));
   }
 
   /**
@@ -593,7 +580,7 @@ export class ConnectionPool extends TypedEventEmitter<ConnectionPoolEvents> {
       new ConnectionClosedEvent(this, connection, reason)
     );
     // destroy the connection
-    process.nextTick(() => connection.destroy({ force: false }));
+    connection.destroy();
   }
 
   private connectionIsStale(connection: Connection) {
@@ -649,7 +636,7 @@ export class ConnectionPool extends TypedEventEmitter<ConnectionPoolEvents> {
         // The pool might have closed since we started trying to create a connection
         if (this[kPoolState] !== PoolState.ready) {
           this[kPending]--;
-          connection.destroy({ force: true });
+          connection.destroy();
           callback(this.closed ? new PoolClosedError(this) : new PoolClearedError(this));
           return;
         }

package/src/cmap/handshake/client_metadata.ts

@@ -1,7 +1,8 @@
+import { promises as fs } from 'fs';
 import * as os from 'os';
 import * as process from 'process';
 
-import { BSON, Int32 } from '../../bson';
+import { BSON, type Document, Int32 } from '../../bson';
 import { MongoInvalidArgumentError } from '../../error';
 import type { MongoOptions } from '../../mongo_client';
 
@@ -71,13 +72,13 @@ export class LimitedSizeDocument {
     return true;
   }
 
-  toObject(): ClientMetadata {
+  toObject(): Document {
     return BSON.deserialize(BSON.serialize(this.document), {
       promoteLongs: false,
       promoteBuffers: false,
       promoteValues: false,
       useBigInt64: false
-    }) as ClientMetadata;
+    });
   }
 }
 
@@ -152,8 +153,57 @@ export function makeClientMetadata(options: MakeClientMetadataOptions): ClientMe
       }
     }
   }
+  return metadataDocument.toObject() as ClientMetadata;
+}
+
+let dockerPromise: Promise<boolean>;
+/** @internal */
+async function getContainerMetadata() {
+  const containerMetadata: Record<string, any> = {};
+  dockerPromise ??= fs.access('/.dockerenv').then(
+    () => true,
+    () => false
+  );
+  const isDocker = await dockerPromise;
+
+  const { KUBERNETES_SERVICE_HOST = '' } = process.env;
+  const isKubernetes = KUBERNETES_SERVICE_HOST.length > 0 ? true : false;
+
+  if (isDocker) containerMetadata.runtime = 'docker';
+  if (isKubernetes) containerMetadata.orchestrator = 'kubernetes';
+
+  return containerMetadata;
+}
+
+/**
+ * @internal
+ * Re-add each metadata value.
+ * Attempt to add new env container metadata, but keep old data if it does not fit.
+ */
+export async function addContainerMetadata(originalMetadata: ClientMetadata) {
+  const containerMetadata = await getContainerMetadata();
+  if (Object.keys(containerMetadata).length === 0) return originalMetadata;
+
+  const extendedMetadata = new LimitedSizeDocument(512);
+
+  const extendedEnvMetadata = { ...originalMetadata?.env, container: containerMetadata };
+
+  for (const [key, val] of Object.entries(originalMetadata)) {
+    if (key !== 'env') {
+      extendedMetadata.ifItFitsItSits(key, val);
+    } else {
+      if (!extendedMetadata.ifItFitsItSits('env', extendedEnvMetadata)) {
+        // add in old data if newer / extended metadata does not fit
+        extendedMetadata.ifItFitsItSits('env', val);
+      }
+    }
+  }
+
+  if (!('env' in originalMetadata)) {
+    extendedMetadata.ifItFitsItSits('env', extendedEnvMetadata);
+  }
 
-  return metadataDocument.toObject();
+  return extendedMetadata.toObject();
 }
 
 /**

package/src/cmap/stream_description.ts

@@ -22,7 +22,7 @@ export interface StreamDescriptionOptions {
 /** @public */
 export class StreamDescription {
   address: string;
-  type: string;
+  type: ServerType;
   minWireVersion?: number;
   maxWireVersion?: number;
   maxBsonObjectSize: number;