@depup/mongodb 7.5.0-depup.7 → 7.6.0-depup.0

package/src/client-side-encryption/kms_options.ts

@@ -0,0 +1,93 @@
+import { type Duplex } from 'stream';
+
+import { type MongoClientOptions } from '../mongo_client';
+
+/**
+ * @public
+ *
+ * TLS options to use when connecting. The spec specifically calls out which insecure
+ * tls options are not allowed:
+ *
+ *  - tlsAllowInvalidCertificates
+ *  - tlsAllowInvalidHostnames
+ *  - tlsInsecure
+ *
+ * These options are not included in the type, and are ignored if provided.
+ */
+export type ClientEncryptionTlsOptions = Pick<
+  MongoClientOptions,
+  'tlsCAFile' | 'tlsCertificateKeyFile' | 'tlsCertificateKeyFilePassword' | 'secureContext'
+>;
+
+/** @public */
+export type CSFLEKMSTlsOptions = {
+  aws?: ClientEncryptionTlsOptions;
+  gcp?: ClientEncryptionTlsOptions;
+  kmip?: ClientEncryptionTlsOptions;
+  local?: ClientEncryptionTlsOptions;
+  azure?: ClientEncryptionTlsOptions;
+
+  [key: string]: ClientEncryptionTlsOptions | undefined;
+};
+
+/**
+ * @public
+ *
+ * Socket options to use for KMS requests.
+ */
+export type ClientEncryptionSocketOptions = Pick<
+  MongoClientOptions,
+  'autoSelectFamily' | 'autoSelectFamilyAttemptTimeout'
+>;
+
+/**
+ * @public
+ *
+ * A callback that establishes the connection to a KMS host.
+ *
+ * When provided on `AutoEncryptionOptions` or `ClientEncryptionOptions`, the driver invokes this
+ * callback instead of connecting to the KMS host itself, passing the target `host` and `port`. The
+ * callback MUST return a `Duplex` stream connected to the KMS host, either directly or tunneled
+ * through a proxy; a `net.Socket` satisfies this, as does any other `Duplex`. The returned stream is
+ * passed to Node.js' `tls.connect()` as its `socket`, and the driver performs the KMS host's TLS
+ * handshake over it using the KMS provider's configured TLS options. The callback therefore MUST NOT
+ * perform the KMS host's TLS handshake itself, though it MAY use TLS for its own transport, e.g. when
+ * connecting to an HTTPS proxy. This enables routing KMS requests through an HTTP proxy via the HTTP
+ * CONNECT method.
+ *
+ * When the operation has a client-side operation timeout (CSOT) configured, `timeoutMS` is the
+ * remaining time budget in milliseconds; it is `undefined` otherwise. The `signal` aborts when the
+ * connection attempt exceeds that budget; the callback should stop connecting and reject when it fires.
+ *
+ * @example <caption>Route KMS requests through an HTTP proxy using the HTTP CONNECT method</caption>
+ * ```ts
+ * import * as net from 'net';
+ *
+ * const kmsConnectCallback: KMSConnectCallback = ({ host, port, signal }) =>
+ *   new Promise((resolve, reject) => {
+ *     // Open a plain connection to the proxy, not to the KMS host.
+ *     const socket = net.connect({ host: 'proxy.example.com', port: 8080, signal });
+ *     socket.once('error', reject);
+ *     socket.once('connect', () => {
+ *       // Ask the proxy to tunnel to the KMS host, then hand the socket back for the driver's TLS.
+ *       socket.write(`CONNECT ${host}:${port} HTTP/1.1\r\nHost: ${host}:${port}\r\n\r\n`);
+ *       socket.once('data', chunk => {
+ *         if (chunk.toString('utf8').startsWith('HTTP/1.1 200')) resolve(socket);
+ *         else reject(new Error('Proxy refused the CONNECT request'));
+ *       });
+ *     });
+ *   });
+ *
+ * const clientEncryption = new ClientEncryption(keyVaultClient, {
+ *   keyVaultNamespace,
+ *   kmsProviders,
+ *   kmsConnectCallback
+ * });
+ * ```
+ */
+export type KMSConnectCallback = (options: {
+  host: string;
+  port: number;
+  timeoutMS?: number;
+  signal: AbortSignal;
+}) => Promise<Duplex>;

package/src/client-side-encryption/state_machine.ts

@@ -15,7 +15,7 @@ import { type ProxyOptions } from '../cmap/connection';
 import { CursorTimeoutContext } from '../cursor/abstract_cursor';
 import { getSocks, type SocksLib } from '../deps';
 import { MongoOperationTimeoutError } from '../error';
-import { type MongoClient, type MongoClientOptions } from '../mongo_client';
+import { type MongoClient } from '../mongo_client';
 import { type Abortable } from '../mongo_types';
 import { type CollectionInfo } from '../operations/list_collections';
 import { Timeout, type TimeoutContext, TimeoutError } from '../timeout';
@@ -28,6 +28,12 @@ import {
 } from '../utils';
 import { autoSelectSocketOptions, type DataKey } from './client_encryption';
 import { MongoCryptError } from './errors';
+import {
+  type ClientEncryptionSocketOptions,
+  type ClientEncryptionTlsOptions,
+  type CSFLEKMSTlsOptions,
+  type KMSConnectCallback
+} from './kms_options';
 import { type MongocryptdManager } from './mongocryptd_manager';
 import { type KMSProviders } from './providers';
 
@@ -93,44 +99,6 @@ declare module 'mongodb-client-encryption' {
   }
 }
 
-/**
- * @public
- *
- * TLS options to use when connecting. The spec specifically calls out which insecure
- * tls options are not allowed:
- *
- *  - tlsAllowInvalidCertificates
- *  - tlsAllowInvalidHostnames
- *  - tlsInsecure
- *
- * These options are not included in the type, and are ignored if provided.
- */
-export type ClientEncryptionTlsOptions = Pick<
-  MongoClientOptions,
-  'tlsCAFile' | 'tlsCertificateKeyFile' | 'tlsCertificateKeyFilePassword' | 'secureContext'
->;
-
-/** @public */
-export type CSFLEKMSTlsOptions = {
-  aws?: ClientEncryptionTlsOptions;
-  gcp?: ClientEncryptionTlsOptions;
-  kmip?: ClientEncryptionTlsOptions;
-  local?: ClientEncryptionTlsOptions;
-  azure?: ClientEncryptionTlsOptions;
-
-  [key: string]: ClientEncryptionTlsOptions | undefined;
-};
-
-/**
- * @public
- *
- * Socket options to use for KMS requests.
- */
-export type ClientEncryptionSocketOptions = Pick<
-  MongoClientOptions,
-  'autoSelectFamily' | 'autoSelectFamilyAttemptTimeout'
->;
-
 /**
  * This is kind of a hack.  For `rewrapManyDataKey`, we have tests that
  * guarantee that when there are no matching keys, `rewrapManyDataKey` returns
@@ -173,6 +141,9 @@ export type StateMachineOptions = {
 
   /** Socket specific options we support. */
   socketOptions: ClientEncryptionSocketOptions;
+
+  /** Optional callback that establishes the KMS socket, if set. */
+  kmsConnectCallback?: KMSConnectCallback;
 } & Pick<BSONSerializeOptions, 'promoteLongs' | 'promoteValues'>;
 
 /**
@@ -388,9 +359,55 @@ export class StateMachine {
     }
 
     let abortListener;
+    let kmsRequestTimeout: Timeout | undefined;
 
     try {
-      if (this.options.proxyOptions && this.options.proxyOptions.proxyHost) {
+      options?.signal?.throwIfAborted();
+
+      if (this.options.kmsConnectCallback) {
+        const remainingTimeMS = options?.timeoutContext?.csotEnabled()
+          ? options.timeoutContext.getRemainingTimeMSOrThrow(
+              `KMS request timed out after ${options.timeoutContext.timeoutMS}ms`
+            )
+          : undefined;
+        // A non-finite budget (timeoutMS: 0) means no timeout; otherwise back the callback with one.
+        const timeoutMS = Number.isFinite(remainingTimeMS) ? remainingTimeMS : undefined;
+        const controller = new AbortController();
+        // Forward the operation's own abort signal so aborting the operation also aborts the callback.
+        const forwardAbort = addAbortListener(options?.signal, function () {
+          controller.abort(this.reason);
+        });
+        const connectPromise = this.options.kmsConnectCallback({
+          host: socketOptions.host,
+          port: socketOptions.port,
+          timeoutMS,
+          signal: controller.signal
+        });
+        // If the callback resolves a socket after we already aborted, close it so it does not leak.
+        connectPromise.then(
+          resolvedSocket => {
+            if (controller.signal.aborted) resolvedSocket.destroy();
+          },
+          () => null
+        );
+        const timeout = timeoutMS ? Timeout.expires(timeoutMS) : undefined;
+        try {
+          socketOptions.socket = timeout
+            ? await Promise.race([connectPromise, timeout])
+            : await connectPromise;
+        } catch (err) {
+          if (TimeoutError.is(err)) {
+            const timeoutError = new MongoOperationTimeoutError('KMS request timed out');
+            // Abort with the timeout error as the reason so the callback sees it on `signal.reason`.
+            controller.abort(timeoutError);
+            throw timeoutError;
+          }
+          throw onerror(err);
+        } finally {
+          timeout?.clear();
+          forwardAbort?.[kDispose]();
+        }
+      } else if (this.options.proxyOptions && this.options.proxyOptions.proxyHost) {
         netSocket = new net.Socket();
 
         const {
@@ -465,20 +482,24 @@ export class StateMachine {
             resolve();
           }
         });
-      await (options?.timeoutContext?.csotEnabled()
-        ? Promise.all([
-            willResolveKmsRequest,
-            Timeout.expires(options.timeoutContext?.remainingTimeMS)
-          ])
+      const remainingTimeMS = options?.timeoutContext?.csotEnabled()
+        ? options.timeoutContext.getRemainingTimeMSOrThrow(
+            `KMS request timed out after ${options.timeoutContext.timeoutMS}ms`
+          )
+        : undefined;
+      const timeoutMS = Number.isFinite(remainingTimeMS) ? remainingTimeMS : undefined;
+      kmsRequestTimeout = timeoutMS ? Timeout.expires(timeoutMS) : undefined;
+      await (kmsRequestTimeout
+        ? Promise.race([willResolveKmsRequest, kmsRequestTimeout])
         : willResolveKmsRequest);
     } catch (error) {
-      if (error instanceof TimeoutError)
-        throw new MongoOperationTimeoutError('KMS request timed out');
+      if (TimeoutError.is(error)) throw new MongoOperationTimeoutError('KMS request timed out');
       throw error;
     } finally {
       // There's no need for any more activity on this socket at this point.
       destroySockets();
       abortListener?.[kDispose]();
+      kmsRequestTimeout?.clear();
     }
   }
 

package/src/cmap/auth/gssapi.ts

@@ -69,10 +69,7 @@ export class GSSAPI extends AuthProvider {
 }
 
 async function makeKerberosClient({
-  options: {
-    hostAddress,
-    runtime: { os }
-  },
+  options: { hostAddress, runtime },
   credentials
 }: AuthContext): Promise<KerberosClient> {
   if (!hostAddress || typeof hostAddress.host !== 'string' || !credentials) {
@@ -81,6 +78,8 @@ async function makeKerberosClient({
     );
   }
 
+  const { os } = await runtime;
+
   loadKrb();
   if ('kModuleError' in krb) {
     throw krb['kModuleError'];

package/src/cmap/auth/mongo_credentials.ts

@@ -25,7 +25,6 @@ function getDefaultAuthMechanism(hello: Document | null): AuthMechanism {
     }
   }
 
-  // Default auth mechanism for 4.0 and higher.
   return AuthMechanism.MONGODB_SCRAM_SHA256;
 }
 

package/src/cmap/auth/mongodb_aws.ts

@@ -1,11 +1,7 @@
 import { type Binary, type BSONSerializeOptions, ByteUtils } from '../../bson';
 import * as BSON from '../../bson';
-import {
-  MongoCompatibilityError,
-  MongoMissingCredentialsError,
-  MongoRuntimeError
-} from '../../error';
-import { maxWireVersion, ns, randomBytes } from '../../utils';
+import { MongoMissingCredentialsError, MongoRuntimeError } from '../../error';
+import { ns, randomBytes } from '../../utils';
 import { type AuthContext, AuthProvider } from './auth_provider';
 import {
   type AWSCredentialProvider,
@@ -45,12 +41,6 @@ export class MongoDBAWS extends AuthProvider {
       throw new MongoMissingCredentialsError('AuthContext must provide credentials.');
     }
 
-    if (maxWireVersion(connection) < 9) {
-      throw new MongoCompatibilityError(
-        'MONGODB-AWS authentication requires MongoDB version 4.4 or later'
-      );
-    }
-
     authContext.credentials = await makeTempCredentials(
       authContext.credentials,
       this.credentialFetcher

package/src/cmap/command_monitoring_events.ts

@@ -32,7 +32,7 @@ export class CommandStartedEvent {
   /**
    * Server generated connection id
    * Distinct from the connection id and is returned by the hello or legacy hello response as "connectionId"
-   * from the server on 4.2+.
+   * from the server.
    */
   serverConnectionId: bigint | null;
   serviceId?: ObjectId;
@@ -88,7 +88,7 @@ export class CommandSucceededEvent {
   connectionId?: string | number;
   /**
    * Server generated connection id
-   * Distinct from the connection id and is returned by the hello or legacy hello response as "connectionId" from the server on 4.2+.
+   * Distinct from the connection id and is returned by the hello or legacy hello response as "connectionId" from the server.
    */
   serverConnectionId: bigint | null;
   requestId: number;
@@ -148,7 +148,7 @@ export class CommandFailedEvent {
   connectionId?: string | number;
   /**
    * Server generated connection id
-   * Distinct from the connection id and is returned by the hello or legacy hello response as "connectionId" from the server on 4.2+.
+   * Distinct from the connection id and is returned by the hello or legacy hello response as "connectionId" from the server.
    */
   serverConnectionId: bigint | null;
   requestId: number;
@@ -249,13 +249,12 @@ const LEGACY_FIND_OPTIONS_MAP = {
 function extractCommand(command: WriteProtocolMessageType): Document {
   if (command instanceof OpMsgRequest) {
     const cmd = { ...command.command };
-    // For OP_MSG with payload type 1 we need to pull the documents
-    // array out of the document sequence for monitoring.
-    if (cmd.ops instanceof DocumentSequence) {
-      cmd.ops = cmd.ops.documents;
-    }
-    if (cmd.nsInfo instanceof DocumentSequence) {
-      cmd.nsInfo = cmd.nsInfo.documents;
+    // For OP_MSG payload type 1, replace any document-sequence field with its
+    // documents array for monitoring (ops, nsInfo, documents, updates, deletes).
+    for (const key of Object.keys(cmd)) {
+      if (cmd[key] instanceof DocumentSequence) {
+        cmd[key] = cmd[key].documents;
+      }
     }
     return cmd;
   }

package/src/cmap/commands.ts

@@ -500,6 +500,23 @@ export class DocumentSequence {
   }
 }
 
+/**
+ * Build a DocumentSequence from documents that have already been serialized,
+ * reusing the provided buffers instead of re-serializing.
+ * @internal
+ */
+export function makeDocumentSequence(
+  field: string,
+  documents: Document[],
+  serialized: Uint8Array[]
+): DocumentSequence {
+  const sequence = new DocumentSequence(field);
+  for (let i = 0; i < documents.length; i++) {
+    sequence.push(documents[i], serialized[i]);
+  }
+  return sequence;
+}
+
 /** @internal */
 export class OpMsgRequest {
   requestId: number;

package/src/cmap/connect.ts

@@ -174,7 +174,7 @@ export async function performInitialHandshake(
 
       if (error instanceof MongoError) {
         error.addErrorLabel(MongoErrorLabel.HandshakeError);
-        if (needsRetryableWriteLabel(error, response.maxWireVersion, conn.description.type)) {
+        if (needsRetryableWriteLabel(error)) {
           error.addErrorLabel(MongoErrorLabel.RetryableWriteError);
         }
       }
@@ -224,7 +224,7 @@ export interface HandshakeDocument extends Document {
   compression: string[];
   saslSupportedMechs?: string;
   loadBalanced?: boolean;
-  backpressure: true;
+  backpressure: '2';
 }
 
 /**
@@ -242,7 +242,7 @@ export async function prepareHandshakeDocument(
 
   const handshakeDoc: HandshakeDocument = {
     [serverApi?.version || options.loadBalanced === true ? 'hello' : LEGACY_HELLO_COMMAND]: 1,
-    backpressure: true,
+    backpressure: '2',
     helloOk: true,
     client: clientMetadata,
     compression: compressors

package/src/cmap/connection.ts

@@ -146,7 +146,7 @@ export interface ConnectionOptions
   /** @internal */
   mongoLogger?: MongoLogger | undefined;
   /** @internal */
-  runtime: Runtime;
+  runtime: Promise<Runtime>;
 }
 
 /** @public */
@@ -286,7 +286,9 @@ export class Connection extends TypedEventEmitter<ConnectionEvents> {
   private get supportsOpMsg(): boolean {
     return (
       this.description != null &&
-      // TODO(NODE-6672,NODE-6287): This guard is primarily for maxWireVersion = 0
+      // OP_MSG was introduced in server 3.6 (wire version 6). This also guards
+      // against the pre-handshake case where maxWireVersion() returns 0.
+      // TODO(NODE-6672,NODE-6287): remove this helper once OP_QUERY support is dropped
       maxWireVersion(this) >= 6 &&
       !this.description.__nodejs_mock_server__
     );

package/src/cmap/handshake/client_metadata.ts

@@ -107,8 +107,9 @@ type MakeClientMetadataOptions = Pick<MongoOptions, 'appName' | 'runtime'>;
  */
 export async function makeClientMetadata(
   driverInfoList: DriverInfo[],
-  { appName = '', runtime: { os } }: MakeClientMetadataOptions
+  { appName = '', runtime }: MakeClientMetadataOptions
 ): Promise<ClientMetadata> {
+  const { os } = await runtime;
   const metadataDocument = new LimitedSizeDocument(512);
 
   // Add app name first, it must be sent

package/src/cmap/wire_protocol/constants.ts

@@ -1,8 +1,8 @@
-export const MIN_SUPPORTED_SERVER_VERSION = '4.2';
+export const MIN_SUPPORTED_SERVER_VERSION = '4.4';
 export const MAX_SUPPORTED_SERVER_VERSION = '9.0';
 export const MIN_SUPPORTED_SNAPSHOT_READS_WIRE_VERSION = 13;
 export const MIN_SUPPORTED_SNAPSHOT_READS_SERVER_VERSION = '5.0';
-export const MIN_SUPPORTED_WIRE_VERSION = 8;
+export const MIN_SUPPORTED_WIRE_VERSION = 9;
 export const MAX_SUPPORTED_WIRE_VERSION = 29;
 export const MIN_SUPPORTED_QE_WIRE_VERSION = 21;
 export const MIN_SUPPORTED_QE_SERVER_VERSION = '7.0';

package/src/connection_string.ts

@@ -544,6 +544,10 @@ export function parseOptions(
   );
 
   mongoOptions.runtime = resolveRuntimeAdapters(options);
+  // Mark the promise as handled so a rejection before any consumer awaits it (possible only in
+  // runtimes where the dynamic import of the default os adapter fails) cannot crash the process
+  // as an unhandled rejection; consumers awaiting `runtime` still observe the rejection.
+  mongoOptions.runtime.then(undefined, squashError);
 
   return mongoOptions;
 }

package/src/cursor/abstract_cursor.ts

@@ -126,11 +126,6 @@ export interface AbstractCursorOptions extends BSONSerializeOptions {
   maxAwaitTimeMS?: number;
   /**
    * Comment to apply to the operation.
-   *
-   * In server versions pre-4.4, 'comment' must be string.  A server
-   * error will be thrown if any other type is provided.
-   *
-   * In server versions 4.4 and above, 'comment' can be any valid BSON type.
    */
   comment?: unknown;
   /**

package/src/error.ts

@@ -3,7 +3,6 @@ import {
   type ClientBulkWriteError,
   type ClientBulkWriteResult
 } from './operations/client_bulk_write/common';
-import type { ServerType } from './sdam/common';
 import type { TopologyVersion } from './sdam/server_description';
 import type { TopologyDescription } from './sdam/topology_description';
 
@@ -1394,23 +1393,13 @@ const RETRYABLE_READ_ERROR_CODES = new Set<number>([
 // see: https://github.com/mongodb/specifications/blob/master/source/retryable-writes/retryable-writes.md#terms
 const RETRYABLE_WRITE_ERROR_CODES = RETRYABLE_READ_ERROR_CODES;
 
-export function needsRetryableWriteLabel(
-  error: Error,
-  maxWireVersion: number,
-  serverType: ServerType
-): boolean {
-  // pre-4.4 server, then the driver adds an error label for every valid case
-  // execute operation will only inspect the label, code/message logic is handled here
+export function needsRetryableWriteLabel(error: Error): boolean {
   if (error instanceof MongoNetworkError) {
     return true;
   }
-
   if (error instanceof MongoError) {
-    if (
-      (maxWireVersion >= 9 || isRetryableWriteError(error)) &&
-      !error.hasErrorLabel(MongoErrorLabel.HandshakeError)
-    ) {
-      // If we already have the error label no need to add it again. 4.4+ servers add the label.
+    if (!error.hasErrorLabel(MongoErrorLabel.HandshakeError)) {
+      // If we already have the error label no need to add it again. servers add the label.
       // In the case where we have a handshake error, need to fall down to the logic checking
       // the codes.
       return false;
@@ -1418,10 +1407,6 @@ export function needsRetryableWriteLabel(
   }
 
   if (error instanceof MongoWriteConcernError) {
-    if (serverType === 'Mongos' && maxWireVersion < 9) {
-      // use original top-level code from server response
-      return RETRYABLE_WRITE_ERROR_CODES.has(error.result.code ?? 0);
-    }
     const code = error.result.writeConcernError.code ?? Number(error.code);
     return RETRYABLE_WRITE_ERROR_CODES.has(Number.isNaN(code) ? 0 : code);
   }
@@ -1551,8 +1536,11 @@ export function isResumableError(error?: Error, wireVersion?: number): boolean {
     return true;
   }
 
+  // wireVersion of 0 is possible when the server version is unknown (e.g heartbeat failure), so despite
+  // all supported servers being wire version 9+, the >= 9 bound must stay to route "unknown" to the
+  // code-list fallback below to maintain parity.
   if (wireVersion != null && wireVersion >= 9) {
-    // DRIVERS-1308: For 4.4 drivers running against 4.4 servers, drivers will add a special case to treat the CursorNotFound error code as resumable
+    // DRIVERS-1308: Drivers will add a special case to treat the CursorNotFound error code as resumable
     if (error.code === MONGODB_ERROR_CODES.CursorNotFound) {
       return true;
     }

package/src/gridfs/download.ts

@@ -351,7 +351,7 @@ function init(stream: GridFSBucketReadStream): void {
 
     const filter: Document = { files_id: doc._id };
 
-    // Currently (MongoDB 3.4.4) skip function does not support the index,
+    // Currently the skip function does not support the index,
     // it needs to retrieve all the documents first and then skip them. (CS-25811)
     // As work around we use $gte on the "n" field.
     if (stream.s.options && stream.s.options.start != null) {

package/src/index.ts

@@ -252,6 +252,12 @@ export {
   MongoCryptInvalidArgumentError,
   MongoCryptKMSRequestNetworkTimeoutError
 } from './client-side-encryption/errors';
+export type {
+  ClientEncryptionSocketOptions,
+  ClientEncryptionTlsOptions,
+  CSFLEKMSTlsOptions,
+  KMSConnectCallback
+} from './client-side-encryption/kms_options';
 export type { MongocryptdManager } from './client-side-encryption/mongocryptd_manager';
 export type {
   AWSKMSProviderConfiguration,
@@ -263,12 +269,7 @@ export type {
   KMSProviders,
   LocalKMSProviderConfiguration
 } from './client-side-encryption/providers/index';
-export type {
-  ClientEncryptionSocketOptions,
-  ClientEncryptionTlsOptions,
-  CSFLEKMSTlsOptions,
-  StateMachineExecutable
-} from './client-side-encryption/state_machine';
+export type { StateMachineExecutable } from './client-side-encryption/state_machine';
 export type { AuthContext, AuthProvider } from './cmap/auth/auth_provider';
 export type {
   AuthMechanismProperties,

package/src/mongo_client.ts

@@ -1178,5 +1178,5 @@ export interface MongoOptions
   __skipPingOnConnect?: boolean;
 
   /** @internal */
-  runtime: Runtime;
+  runtime: Promise<Runtime>;
 }

package/src/operations/command.ts

@@ -46,11 +46,6 @@ export interface CommandOperationOptions
   maxTimeMS?: number;
   /**
    * Comment to apply to the operation.
-   *
-   * In server versions pre-4.4, 'comment' must be string.  A server
-   * error will be thrown if any other type is provided.
-   *
-   * In server versions 4.4 and above, 'comment' can be any valid BSON type.
    */
   comment?: unknown;
   // Admin command overrides.

package/src/operations/delete.ts

@@ -1,9 +1,10 @@
 import type { Document } from '../bson';
+import { makeDocumentSequence } from '../cmap/commands';
 import { type Connection } from '../cmap/connection';
 import { MongoDBResponse } from '../cmap/wire_protocol/responses';
-import { MongoCompatibilityError, MongoServerError } from '../error';
+import { MongoServerError } from '../error';
 import type { ClientSession } from '../sessions';
-import { maxWireVersion, type MongoDBCollectionNamespace, type MongoDBNamespace } from '../utils';
+import { type MongoDBCollectionNamespace, type MongoDBNamespace } from '../utils';
 import { type WriteConcernOptions } from '../write_concern';
 import { type CollationOptions, CommandOperation, type CommandOperationOptions } from './command';
 import { Aspect, defineAspects, type Hint } from './operation';
@@ -45,12 +46,20 @@ export class DeleteOperation extends CommandOperation<Document> {
   override SERVER_COMMAND_RESPONSE_TYPE = MongoDBResponse;
   override options: DeleteOptions;
   statements: DeleteStatement[];
-
-  constructor(ns: MongoDBNamespace, statements: DeleteStatement[], options: DeleteOptions) {
+  /** @internal */
+  serializedOperations?: Uint8Array[];
+
+  constructor(
+    ns: MongoDBNamespace,
+    statements: DeleteStatement[],
+    options: DeleteOptions,
+    serializedOperations?: Uint8Array[]
+  ) {
     super(undefined, options);
     this.options = options;
     this.ns = ns;
     this.statements = statements;
+    this.serializedOperations = serializedOperations;
   }
 
   override get commandName() {
@@ -65,13 +74,15 @@ export class DeleteOperation extends CommandOperation<Document> {
     return this.statements.every(op => (op.limit != null ? op.limit > 0 : true));
   }
 
-  override buildCommandDocument(connection: Connection, _session?: ClientSession): Document {
+  override buildCommandDocument(_connection: Connection, _session?: ClientSession): Document {
     const options = this.options;
 
     const ordered = typeof options.ordered === 'boolean' ? options.ordered : true;
     const command: Document = {
       delete: this.ns.collection,
-      deletes: this.statements,
+      deletes: this.serializedOperations
+        ? makeDocumentSequence('deletes', this.statements, this.serializedOperations)
+        : this.statements,
       ordered
     };
 
@@ -85,15 +96,6 @@ export class DeleteOperation extends CommandOperation<Document> {
       command.comment = options.comment;
     }
 
-    const unacknowledgedWrite = this.writeConcern && this.writeConcern.w === 0;
-    if (unacknowledgedWrite && maxWireVersion(connection) < 9) {
-      if (this.statements.find((o: Document) => o.hint)) {
-        throw new MongoCompatibilityError(
-          `hint for the delete command is only supported on MongoDB 4.4+`
-        );
-      }
-    }
-
     return command;
   }
 }