mongodb 6.18.0-dev.20250806.sha.e628296a → 6.18.0-dev.20250814.sha.33d340ef

package/src/operations/create_collection.ts

@@ -1,16 +1,18 @@
+import { type Connection } from '..';
 import type { Document } from '../bson';
 import {
   MIN_SUPPORTED_QE_SERVER_VERSION,
   MIN_SUPPORTED_QE_WIRE_VERSION
 } from '../cmap/wire_protocol/constants';
+import { MongoDBResponse } from '../cmap/wire_protocol/responses';
 import { Collection } from '../collection';
 import type { Db } from '../db';
 import { MongoCompatibilityError } from '../error';
 import type { PkFactory } from '../mongo_client';
-import type { Server } from '../sdam/server';
 import type { ClientSession } from '../sessions';
 import { TimeoutContext } from '../timeout';
-import { CommandOperation, type CommandOperationOptions } from './command';
+import { maxWireVersion } from '../utils';
+import { type CommandOperationOptions, ModernizedCommandOperation } from './command';
 import { executeOperation } from './execute_operation';
 import { CreateIndexesOperation } from './indexes';
 import { Aspect, defineAspects } from './operation';
@@ -110,7 +112,8 @@ const INVALID_QE_VERSION =
   'Driver support of Queryable Encryption is incompatible with server. Upgrade server to use Queryable Encryption.';
 
 /** @internal */
-export class CreateCollectionOperation extends CommandOperation<Collection> {
+export class CreateCollectionOperation extends ModernizedCommandOperation<Collection> {
+  override SERVER_COMMAND_RESPONSE_TYPE = MongoDBResponse;
   override options: CreateCollectionOptions;
   db: Db;
   name: string;
@@ -127,25 +130,19 @@ export class CreateCollectionOperation extends CommandOperation<Collection> {
     return 'create' as const;
   }
 
-  override async execute(
-    server: Server,
-    session: ClientSession | undefined,
-    timeoutContext: TimeoutContext
-  ): Promise<Collection> {
-    const db = this.db;
-    const name = this.name;
-    const options = this.options;
-
-    const cmd: Document = { create: name };
-    for (const [option, value] of Object.entries(options)) {
-      if (value != null && typeof value !== 'function' && !ILLEGAL_COMMAND_FIELDS.has(option)) {
-        cmd[option] = value;
-      }
-    }
+  override buildCommandDocument(_connection: Connection, _session?: ClientSession): Document {
+    const isOptionValid = ([k, v]: [k: string, v: unknown]) =>
+      v != null && typeof v !== 'function' && !ILLEGAL_COMMAND_FIELDS.has(k);
+    return {
+      create: this.name,
+      ...Object.fromEntries(Object.entries(this.options).filter(isOptionValid))
+    };
+  }
 
-    // otherwise just execute the command
-    await super.executeCommand(server, session, cmd, timeoutContext);
-    return new Collection(db, name, options);
+  override handleOk(
+    _response: InstanceType<typeof this.SERVER_COMMAND_RESPONSE_TYPE>
+  ): Collection<Document> {
+    return new Collection(this.db, this.name, this.options);
   }
 }
 
@@ -167,23 +164,17 @@ export async function createCollections<TSchema extends Document>(
 
   if (encryptedFields) {
     class CreateSupportingFLEv2CollectionOperation extends CreateCollectionOperation {
-      override execute(
-        server: Server,
-        session: ClientSession | undefined,
-        timeoutContext: TimeoutContext
-      ): Promise<Collection> {
-        // Creating a QE collection required min server of 7.0.0
-        // TODO(NODE-5353): Get wire version information from connection.
+      override buildCommandDocument(connection: Connection, session?: ClientSession): Document {
         if (
-          !server.loadBalanced &&
-          server.description.maxWireVersion < MIN_SUPPORTED_QE_WIRE_VERSION
+          !connection.description.loadBalanced &&
+          maxWireVersion(connection) < MIN_SUPPORTED_QE_WIRE_VERSION
         ) {
           throw new MongoCompatibilityError(
             `${INVALID_QE_VERSION} The minimum server version required is ${MIN_SUPPORTED_QE_SERVER_VERSION}`
           );
         }
 
-        return super.execute(server, session, timeoutContext);
+        return super.buildCommandDocument(connection, session);
       }
     }
 

package/src/operations/delete.ts

@@ -1,13 +1,15 @@
 import type { Document } from '../bson';
-import type { Collection } from '../collection';
+import { type Connection } from '../cmap/connection';
+import { MongoDBResponse } from '../cmap/wire_protocol/responses';
 import { MongoCompatibilityError, MongoServerError } from '../error';
-import { type TODO_NODE_3286 } from '../mongo_types';
-import type { Server } from '../sdam/server';
 import type { ClientSession } from '../sessions';
-import { type TimeoutContext } from '../timeout';
-import { 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 {
+  type CollationOptions,
+  type CommandOperationOptions,
+  ModernizedCommandOperation
+} from './command';
 import { Aspect, defineAspects, type Hint } from './operation';
 
 /** @public */
@@ -43,7 +45,8 @@ export interface DeleteStatement {
 }
 
 /** @internal */
-export class DeleteOperation extends CommandOperation<DeleteResult> {
+export class DeleteOperation extends ModernizedCommandOperation<Document> {
+  override SERVER_COMMAND_RESPONSE_TYPE = MongoDBResponse;
   override options: DeleteOptions;
   statements: DeleteStatement[];
 
@@ -66,12 +69,9 @@ export class DeleteOperation extends CommandOperation<DeleteResult> {
     return this.statements.every(op => (op.limit != null ? op.limit > 0 : true));
   }
 
-  override async execute(
-    server: Server,
-    session: ClientSession | undefined,
-    timeoutContext: TimeoutContext
-  ): Promise<DeleteResult> {
-    const options = this.options ?? {};
+  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,
@@ -97,28 +97,23 @@ export class DeleteOperation extends CommandOperation<DeleteResult> {
       }
     }
 
-    const res: TODO_NODE_3286 = await super.executeCommand(
-      server,
-      session,
-      command,
-      timeoutContext
-    );
-    return res;
+    return command;
   }
 }
 
 export class DeleteOneOperation extends DeleteOperation {
-  constructor(collection: Collection, filter: Document, options: DeleteOptions) {
-    super(collection.s.namespace, [makeDeleteStatement(filter, { ...options, limit: 1 })], options);
+  constructor(ns: MongoDBCollectionNamespace, filter: Document, options: DeleteOptions) {
+    super(ns, [makeDeleteStatement(filter, { ...options, limit: 1 })], options);
   }
 
-  override async execute(
-    server: Server,
-    session: ClientSession | undefined,
-    timeoutContext: TimeoutContext
-  ): Promise<DeleteResult> {
-    const res: TODO_NODE_3286 = await super.execute(server, session, timeoutContext);
+  override handleOk(
+    response: InstanceType<typeof this.SERVER_COMMAND_RESPONSE_TYPE>
+  ): DeleteResult {
+    const res = super.handleOk(response);
+
+    // @ts-expect-error Explain commands have broken TS
     if (this.explain) return res;
+
     if (res.code) throw new MongoServerError(res);
     if (res.writeErrors) throw new MongoServerError(res.writeErrors[0]);
 
@@ -129,17 +124,18 @@ export class DeleteOneOperation extends DeleteOperation {
   }
 }
 export class DeleteManyOperation extends DeleteOperation {
-  constructor(collection: Collection, filter: Document, options: DeleteOptions) {
-    super(collection.s.namespace, [makeDeleteStatement(filter, options)], options);
+  constructor(ns: MongoDBCollectionNamespace, filter: Document, options: DeleteOptions) {
+    super(ns, [makeDeleteStatement(filter, options)], options);
   }
 
-  override async execute(
-    server: Server,
-    session: ClientSession | undefined,
-    timeoutContext: TimeoutContext
-  ): Promise<DeleteResult> {
-    const res: TODO_NODE_3286 = await super.execute(server, session, timeoutContext);
+  override handleOk(
+    response: InstanceType<typeof this.SERVER_COMMAND_RESPONSE_TYPE>
+  ): DeleteResult {
+    const res = super.handleOk(response);
+
+    // @ts-expect-error Explain commands have broken TS
     if (this.explain) return res;
+
     if (res.code) throw new MongoServerError(res);
     if (res.writeErrors) throw new MongoServerError(res.writeErrors[0]);
 

package/src/operations/drop.ts

@@ -1,12 +1,12 @@
-import { MongoServerError } from '..';
+import { type Connection, MongoServerError } from '..';
 import type { Document } from '../bson';
+import { MongoDBResponse } from '../cmap/wire_protocol/responses';
 import { CursorTimeoutContext } from '../cursor/abstract_cursor';
 import type { Db } from '../db';
 import { MONGODB_ERROR_CODES } from '../error';
-import type { Server } from '../sdam/server';
 import type { ClientSession } from '../sessions';
 import { TimeoutContext } from '../timeout';
-import { CommandOperation, type CommandOperationOptions } from './command';
+import { type CommandOperationOptions, ModernizedCommandOperation } from './command';
 import { executeOperation } from './execute_operation';
 import { Aspect, defineAspects } from './operation';
 
@@ -17,7 +17,9 @@ export interface DropCollectionOptions extends CommandOperationOptions {
 }
 
 /** @internal */
-export class DropCollectionOperation extends CommandOperation<boolean> {
+export class DropCollectionOperation extends ModernizedCommandOperation<boolean> {
+  override SERVER_COMMAND_RESPONSE_TYPE = MongoDBResponse;
+
   override options: DropCollectionOptions;
   name: string;
 
@@ -31,12 +33,11 @@ export class DropCollectionOperation extends CommandOperation<boolean> {
     return 'drop' as const;
   }
 
-  override async execute(
-    server: Server,
-    session: ClientSession | undefined,
-    timeoutContext: TimeoutContext
-  ): Promise<boolean> {
-    await super.executeCommand(server, session, { drop: this.name }, timeoutContext);
+  override buildCommandDocument(_connection: Connection, _session?: ClientSession): Document {
+    return { drop: this.name };
+  }
+
+  override handleOk(_response: InstanceType<typeof this.SERVER_COMMAND_RESPONSE_TYPE>): boolean {
     return true;
   }
 }
@@ -106,7 +107,8 @@ export async function dropCollections(
 export type DropDatabaseOptions = CommandOperationOptions;
 
 /** @internal */
-export class DropDatabaseOperation extends CommandOperation<boolean> {
+export class DropDatabaseOperation extends ModernizedCommandOperation<boolean> {
+  override SERVER_COMMAND_RESPONSE_TYPE = MongoDBResponse;
   override options: DropDatabaseOptions;
 
   constructor(db: Db, options: DropDatabaseOptions) {
@@ -117,12 +119,11 @@ export class DropDatabaseOperation extends CommandOperation<boolean> {
     return 'dropDatabase' as const;
   }
 
-  override async execute(
-    server: Server,
-    session: ClientSession | undefined,
-    timeoutContext: TimeoutContext
-  ): Promise<boolean> {
-    await super.executeCommand(server, session, { dropDatabase: 1 }, timeoutContext);
+  override buildCommandDocument(_connection: Connection, _session?: ClientSession): Document {
+    return { dropDatabase: 1 };
+  }
+
+  override handleOk(_response: InstanceType<typeof this.SERVER_COMMAND_RESPONSE_TYPE>): boolean {
     return true;
   }
 }

package/src/operations/estimated_document_count.ts

@@ -1,9 +1,9 @@
+import { type Connection } from '..';
 import type { Document } from '../bson';
+import { MongoDBResponse } from '../cmap/wire_protocol/responses';
 import type { Collection } from '../collection';
-import type { Server } from '../sdam/server';
 import type { ClientSession } from '../sessions';
-import { type TimeoutContext } from '../timeout';
-import { CommandOperation, type CommandOperationOptions } from './command';
+import { type CommandOperationOptions, ModernizedCommandOperation } from './command';
 import { Aspect, defineAspects } from './operation';
 
 /** @public */
@@ -17,7 +17,8 @@ export interface EstimatedDocumentCountOptions extends CommandOperationOptions {
 }
 
 /** @internal */
-export class EstimatedDocumentCountOperation extends CommandOperation<number> {
+export class EstimatedDocumentCountOperation extends ModernizedCommandOperation<number> {
+  override SERVER_COMMAND_RESPONSE_TYPE = MongoDBResponse;
   override options: EstimatedDocumentCountOptions;
   collectionName: string;
 
@@ -31,11 +32,7 @@ export class EstimatedDocumentCountOperation extends CommandOperation<number> {
     return 'count' as const;
   }
 
-  override async execute(
-    server: Server,
-    session: ClientSession | undefined,
-    timeoutContext: TimeoutContext
-  ): Promise<number> {
+  override buildCommandDocument(_connection: Connection, _session?: ClientSession): Document {
     const cmd: Document = { count: this.collectionName };
 
     if (typeof this.options.maxTimeMS === 'number') {
@@ -48,9 +45,11 @@ export class EstimatedDocumentCountOperation extends CommandOperation<number> {
       cmd.comment = this.options.comment;
     }
 
-    const response = await super.executeCommand(server, session, cmd, timeoutContext);
+    return cmd;
+  }
 
-    return response?.n || 0;
+  override handleOk(response: InstanceType<typeof this.SERVER_COMMAND_RESPONSE_TYPE>): number {
+    return response.getNumber('n') ?? 0;
   }
 }
 

package/src/operations/execute_operation.ts

@@ -34,7 +34,11 @@ const MMAPv1_RETRY_WRITES_ERROR_MESSAGE =
   'This MongoDB deployment does not support retryable writes. Please add retryWrites=false to your connection string.';
 
 type ResultTypeFromOperation<TOperation> =
-  TOperation extends AbstractOperation<infer K> ? K : never;
+  TOperation extends ModernizedOperation<infer _>
+    ? ReturnType<TOperation['handleOk']>
+    : TOperation extends AbstractOperation<infer K>
+      ? K
+      : never;
 
 /**
  * Executes the given operation with provided arguments.
@@ -57,7 +61,7 @@ type ResultTypeFromOperation<TOperation> =
  * @param operation - The operation to execute
  */
 export async function executeOperation<
-  T extends AbstractOperation<TResult>,
+  T extends AbstractOperation,
   TResult = ResultTypeFromOperation<T>
 >(client: MongoClient, operation: T, timeoutContext?: TimeoutContext | null): Promise<TResult> {
   if (!(operation instanceof AbstractOperation)) {
@@ -179,10 +183,7 @@ type RetryOptions = {
  *
  * @param operation - The operation to execute
  * */
-async function tryOperation<
-  T extends AbstractOperation<TResult>,
-  TResult = ResultTypeFromOperation<T>
->(
+async function tryOperation<T extends AbstractOperation, TResult = ResultTypeFromOperation<T>>(
   operation: T,
   { topology, timeoutContext, session, readPreference }: RetryOptions
 ): Promise<TResult> {

package/src/operations/find_and_modify.ts

@@ -1,14 +1,14 @@
+import { type Connection } from '..';
 import type { Document } from '../bson';
+import { MongoDBResponse } from '../cmap/wire_protocol/responses';
 import type { Collection } from '../collection';
 import { MongoCompatibilityError, MongoInvalidArgumentError } from '../error';
 import { ReadPreference } from '../read_preference';
-import type { Server } from '../sdam/server';
 import type { ClientSession } from '../sessions';
 import { formatSort, type Sort, type SortForCmd } from '../sort';
-import { type TimeoutContext } from '../timeout';
-import { decorateWithCollation, hasAtomicOperators, maxWireVersion } from '../utils';
+import { decorateWithCollation, hasAtomicOperators } from '../utils';
 import { type WriteConcern, type WriteConcernSettings } from '../write_concern';
-import { CommandOperation, type CommandOperationOptions } from './command';
+import { type CommandOperationOptions, ModernizedCommandOperation } from './command';
 import { Aspect, defineAspects } from './operation';
 
 /** @public */
@@ -120,9 +120,9 @@ function configureFindAndModifyCmdBaseUpdateOpts(
 }
 
 /** @internal */
-export class FindAndModifyOperation extends CommandOperation<Document> {
+export class FindAndModifyOperation extends ModernizedCommandOperation<Document> {
+  override SERVER_COMMAND_RESPONSE_TYPE = MongoDBResponse;
   override options: FindOneAndReplaceOptions | FindOneAndUpdateOptions | FindOneAndDeleteOptions;
-  cmdBase: FindAndModifyCmdBase;
   collection: Collection;
   query: Document;
   doc?: Document;
@@ -133,8 +133,26 @@ export class FindAndModifyOperation extends CommandOperation<Document> {
     options: FindOneAndReplaceOptions | FindOneAndUpdateOptions | FindOneAndDeleteOptions
   ) {
     super(collection, options);
-    this.options = options ?? {};
-    this.cmdBase = {
+    this.options = options;
+    // force primary read preference
+    this.readPreference = ReadPreference.primary;
+
+    this.collection = collection;
+    this.query = query;
+  }
+
+  override get commandName() {
+    return 'findAndModify' as const;
+  }
+
+  override buildCommandDocument(
+    _connection: Connection,
+    _session?: ClientSession
+  ): Document & FindAndModifyCmdBase {
+    const options = this.options;
+    const command: Document & FindAndModifyCmdBase = {
+      findAndModify: this.collection.collectionName,
+      query: this.query,
       remove: false,
       new: false,
       upsert: false
@@ -144,77 +162,51 @@ export class FindAndModifyOperation extends CommandOperation<Document> {
 
     const sort = formatSort(options.sort);
     if (sort) {
-      this.cmdBase.sort = sort;
+      command.sort = sort;
     }
 
     if (options.projection) {
-      this.cmdBase.fields = options.projection;
+      command.fields = options.projection;
     }
 
     if (options.maxTimeMS) {
-      this.cmdBase.maxTimeMS = options.maxTimeMS;
+      command.maxTimeMS = options.maxTimeMS;
     }
 
     // Decorate the findAndModify command with the write Concern
     if (options.writeConcern) {
-      this.cmdBase.writeConcern = options.writeConcern;
+      command.writeConcern = options.writeConcern;
     }
 
     if (options.let) {
-      this.cmdBase.let = options.let;
+      command.let = options.let;
     }
 
     // we check for undefined specifically here to allow falsy values
     // eslint-disable-next-line no-restricted-syntax
     if (options.comment !== undefined) {
-      this.cmdBase.comment = options.comment;
+      command.comment = options.comment;
     }
 
-    // force primary read preference
-    this.readPreference = ReadPreference.primary;
-
-    this.collection = collection;
-    this.query = query;
-  }
-
-  override get commandName() {
-    return 'findAndModify' as const;
-  }
-
-  override async execute(
-    server: Server,
-    session: ClientSession | undefined,
-    timeoutContext: TimeoutContext
-  ): Promise<Document> {
-    const coll = this.collection;
-    const query = this.query;
-    const options = { ...this.options, ...this.bsonOptions };
-
-    // Create findAndModify command object
-    const cmd: Document = {
-      findAndModify: coll.collectionName,
-      query: query,
-      ...this.cmdBase
-    };
-
-    decorateWithCollation(cmd, coll, options);
+    decorateWithCollation(command, this.collection, options);
 
     if (options.hint) {
-      // TODO: once this method becomes a CommandOperation we will have the server
-      // in place to check.
       const unacknowledgedWrite = this.writeConcern?.w === 0;
-      if (unacknowledgedWrite || maxWireVersion(server) < 8) {
+      if (unacknowledgedWrite) {
         throw new MongoCompatibilityError(
           'The current topology does not support a hint on findAndModify commands'
         );
       }
 
-      cmd.hint = options.hint;
+      command.hint = options.hint;
     }
 
-    // Execute the command
-    const result = await super.executeCommand(server, session, cmd, timeoutContext);
-    return options.includeResultMetadata ? result : (result.value ?? null);
+    return command;
+  }
+
+  override handleOk(response: InstanceType<typeof this.SERVER_COMMAND_RESPONSE_TYPE>): Document {
+    const result = super.handleOk(response);
+    return this.options.includeResultMetadata ? result : (result.value ?? null);
   }
 }
 
@@ -227,12 +219,21 @@ export class FindOneAndDeleteOperation extends FindAndModifyOperation {
     }
 
     super(collection, filter, options);
-    this.cmdBase.remove = true;
+  }
+
+  override buildCommandDocument(
+    connection: Connection,
+    session?: ClientSession
+  ): Document & FindAndModifyCmdBase {
+    const document = super.buildCommandDocument(connection, session);
+    document.remove = true;
+    return document;
   }
 }
 
 /** @internal */
 export class FindOneAndReplaceOperation extends FindAndModifyOperation {
+  private replacement: Document;
   constructor(
     collection: Collection,
     filter: Document,
@@ -252,13 +253,25 @@ export class FindOneAndReplaceOperation extends FindAndModifyOperation {
     }
 
     super(collection, filter, options);
-    this.cmdBase.update = replacement;
-    configureFindAndModifyCmdBaseUpdateOpts(this.cmdBase, options);
+    this.replacement = replacement;
+  }
+
+  override buildCommandDocument(
+    connection: Connection,
+    session?: ClientSession
+  ): Document & FindAndModifyCmdBase {
+    const document = super.buildCommandDocument(connection, session);
+    document.update = this.replacement;
+    configureFindAndModifyCmdBaseUpdateOpts(document, this.options);
+    return document;
   }
 }
 
 /** @internal */
 export class FindOneAndUpdateOperation extends FindAndModifyOperation {
+  override options: FindOneAndUpdateOptions;
+
+  private update: Document;
   constructor(
     collection: Collection,
     filter: Document,
@@ -278,12 +291,23 @@ export class FindOneAndUpdateOperation extends FindAndModifyOperation {
     }
 
     super(collection, filter, options);
-    this.cmdBase.update = update;
-    configureFindAndModifyCmdBaseUpdateOpts(this.cmdBase, options);
+    this.update = update;
+    this.options = options;
+  }
 
-    if (options.arrayFilters) {
-      this.cmdBase.arrayFilters = options.arrayFilters;
+  override buildCommandDocument(
+    connection: Connection,
+    session?: ClientSession
+  ): Document & FindAndModifyCmdBase {
+    const document = super.buildCommandDocument(connection, session);
+    document.update = this.update;
+    configureFindAndModifyCmdBaseUpdateOpts(document, this.options);
+
+    if (this.options.arrayFilters) {
+      document.arrayFilters = this.options.arrayFilters;
     }
+
+    return document;
   }
 }