mongodb 6.18.0 → 6.19.0-dev.20250827.sha.3c5bb1d5

package/src/operations/list_collections.ts

@@ -1,11 +1,9 @@
+import { type Connection } from '..';
 import type { Binary, Document } from '../bson';
-import { CursorResponse } from '../cmap/wire_protocol/responses';
+import { CursorResponse, ExplainedCursorResponse } from '../cmap/wire_protocol/responses';
 import { type CursorTimeoutContext, type CursorTimeoutMode } from '../cursor/abstract_cursor';
 import type { Db } from '../db';
 import { type Abortable } from '../mongo_types';
-import type { Server } from '../sdam/server';
-import type { ClientSession } from '../sessions';
-import { type TimeoutContext } from '../timeout';
 import { maxWireVersion } from '../utils';
 import { CommandOperation, type CommandOperationOptions } from './command';
 import { Aspect, defineAspects } from './operation';
@@ -29,6 +27,7 @@ export interface ListCollectionsOptions
 
 /** @internal */
 export class ListCollectionsOperation extends CommandOperation<CursorResponse> {
+  override SERVER_COMMAND_RESPONSE_TYPE = CursorResponse;
   /**
    * @remarks WriteConcern can still be present on the options because
    * we inherit options from the client/db/collection.  The
@@ -56,28 +55,15 @@ export class ListCollectionsOperation extends CommandOperation<CursorResponse> {
     if (typeof this.options.batchSize === 'number') {
       this.batchSize = this.options.batchSize;
     }
+
+    this.SERVER_COMMAND_RESPONSE_TYPE = this.explain ? ExplainedCursorResponse : CursorResponse;
   }
 
   override get commandName() {
     return 'listCollections' as const;
   }
 
-  override async execute(
-    server: Server,
-    session: ClientSession | undefined,
-    timeoutContext: TimeoutContext
-  ): Promise<CursorResponse> {
-    return await super.executeCommand(
-      server,
-      session,
-      this.generateCommand(maxWireVersion(server)),
-      timeoutContext,
-      CursorResponse
-    );
-  }
-
-  /* This is here for the purpose of unit testing the final command that gets sent. */
-  generateCommand(wireVersion: number): Document {
+  override buildCommandDocument(connection: Connection): Document {
     const command: Document = {
       listCollections: 1,
       filter: this.filter,
@@ -88,12 +74,18 @@ export class ListCollectionsOperation extends CommandOperation<CursorResponse> {
 
     // we check for undefined specifically here to allow falsy values
     // eslint-disable-next-line no-restricted-syntax
-    if (wireVersion >= 9 && this.options.comment !== undefined) {
+    if (maxWireVersion(connection) >= 9 && this.options.comment !== undefined) {
       command.comment = this.options.comment;
     }
 
     return command;
   }
+
+  override handleOk(
+    response: InstanceType<typeof this.SERVER_COMMAND_RESPONSE_TYPE>
+  ): CursorResponse {
+    return response;
+  }
 }
 
 /** @public */

package/src/operations/list_databases.ts

@@ -1,9 +1,8 @@
+import { type Connection } from '..';
 import type { Document } from '../bson';
+import { MongoDBResponse } from '../cmap/wire_protocol/responses';
 import type { Db } from '../db';
-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 { maxWireVersion, MongoDBNamespace } from '../utils';
 import { CommandOperation, type CommandOperationOptions } from './command';
 import { Aspect, defineAspects } from './operation';
@@ -28,6 +27,7 @@ export interface ListDatabasesOptions extends CommandOperationOptions {
 
 /** @internal */
 export class ListDatabasesOperation extends CommandOperation<ListDatabasesResult> {
+  override SERVER_COMMAND_RESPONSE_TYPE = MongoDBResponse;
   override options: ListDatabasesOptions;
 
   constructor(db: Db, options?: ListDatabasesOptions) {
@@ -40,11 +40,7 @@ export class ListDatabasesOperation extends CommandOperation<ListDatabasesResult
     return 'listDatabases' as const;
   }
 
-  override async execute(
-    server: Server,
-    session: ClientSession | undefined,
-    timeoutContext: TimeoutContext
-  ): Promise<ListDatabasesResult> {
+  override buildCommandDocument(connection: Connection, _session?: ClientSession): Document {
     const cmd: Document = { listDatabases: 1 };
 
     if (typeof this.options.nameOnly === 'boolean') {
@@ -61,16 +57,11 @@ export class ListDatabasesOperation extends CommandOperation<ListDatabasesResult
 
     // we check for undefined specifically here to allow falsy values
     // eslint-disable-next-line no-restricted-syntax
-    if (maxWireVersion(server) >= 9 && this.options.comment !== undefined) {
+    if (maxWireVersion(connection) >= 9 && this.options.comment !== undefined) {
       cmd.comment = this.options.comment;
     }
 
-    return await (super.executeCommand(
-      server,
-      session,
-      cmd,
-      timeoutContext
-    ) as Promise<TODO_NODE_3286>);
+    return cmd;
   }
 }
 

package/src/operations/operation.ts

@@ -1,7 +1,9 @@
+import { type Connection, type MongoError } from '..';
 import { type BSONSerializeOptions, type Document, resolveBSONOptions } from '../bson';
+import { type MongoDBResponse } from '../cmap/wire_protocol/responses';
 import { type Abortable } from '../mongo_types';
 import { ReadPreference, type ReadPreferenceLike } from '../read_preference';
-import type { Server } from '../sdam/server';
+import type { Server, ServerCommandOptions } from '../sdam/server';
 import type { ClientSession } from '../sessions';
 import { type TimeoutContext } from '../timeout';
 import type { MongoDBNamespace } from '../utils';
@@ -31,7 +33,6 @@ export interface OperationOptions extends BSONSerializeOptions {
 
   /** @internal Hints to `executeOperation` that this operation should not unpin on an ended transaction */
   bypassPinningCheck?: boolean;
-  omitReadPreference?: boolean;
 
   /** @internal Hint to `executeOperation` to omit maxTimeMS */
   omitMaxTimeMS?: boolean;
@@ -55,7 +56,6 @@ export abstract class AbstractOperation<TResult = any> {
   readPreference: ReadPreference;
   server!: Server;
   bypassPinningCheck: boolean;
-  trySecondaryWrite: boolean;
 
   // BSON serialization options
   bsonOptions?: BSONSerializeOptions;
@@ -81,19 +81,12 @@ export abstract class AbstractOperation<TResult = any> {
 
     this.options = options;
     this.bypassPinningCheck = !!options.bypassPinningCheck;
-    this.trySecondaryWrite = false;
   }
 
   /** Must match the first key of the command object sent to the server.
   Command name should be stateless (should not use 'this' keyword) */
   abstract get commandName(): string;
 
-  abstract execute(
-    server: Server,
-    session: ClientSession | undefined,
-    timeoutContext: TimeoutContext
-  ): Promise<TResult>;
-
   hasAspect(aspect: symbol): boolean {
     const ctor = this.constructor as { aspects?: Set<symbol> };
     if (ctor.aspects == null) {
@@ -108,6 +101,10 @@ export abstract class AbstractOperation<TResult = any> {
     return this._session;
   }
 
+  set session(session: ClientSession) {
+    this._session = session;
+  }
+
   clearSession() {
     this._session = undefined;
   }
@@ -123,6 +120,46 @@ export abstract class AbstractOperation<TResult = any> {
   get canRetryWrite(): boolean {
     return this.hasAspect(Aspect.RETRYABLE) && this.hasAspect(Aspect.WRITE_OPERATION);
   }
+  abstract SERVER_COMMAND_RESPONSE_TYPE: typeof MongoDBResponse;
+
+  /**
+   * Build a raw command document.
+   */
+  abstract buildCommand(connection: Connection, session?: ClientSession): Document;
+
+  /**
+   * Builds an instance of `ServerCommandOptions` to be used for operation execution.
+   */
+  abstract buildOptions(timeoutContext: TimeoutContext): ServerCommandOptions;
+
+  /**
+   * Given an instance of a MongoDBResponse, map the response to the correct result type.  For
+   * example, a `CountOperation` might map the response as follows:
+   *
+   * ```typescript
+   *  override handleOk(response: InstanceType<typeof this.SERVER_COMMAND_RESPONSE_TYPE>): TResult {
+   *    return response.toObject(this.bsonOptions).n ?? 0;
+   *  }
+   *
+   *  // or, with type safety:
+   *  override handleOk(response: InstanceType<typeof this.SERVER_COMMAND_RESPONSE_TYPE>): TResult {
+   *    return response.getNumber('n') ?? 0;
+   *  }
+   * ```
+   */
+  handleOk(response: InstanceType<typeof this.SERVER_COMMAND_RESPONSE_TYPE>): TResult {
+    return response.toObject(this.bsonOptions) as TResult;
+  }
+
+  /**
+   * Optional.
+   *
+   * If the operation performs error handling, such as wrapping, renaming the error, or squashing errors
+   * this method can be overridden.
+   */
+  handleError(error: MongoError): TResult | never {
+    throw error;
+  }
 }
 
 export function defineAspects(

package/src/operations/profiling_level.ts

@@ -1,15 +1,22 @@
+import { BSONType, type Document } from '../bson';
+import { type Connection } from '../cmap/connection';
+import { MongoDBResponse } from '../cmap/wire_protocol/responses';
 import type { Db } from '../db';
 import { MongoUnexpectedServerResponseError } from '../error';
-import type { Server } from '../sdam/server';
-import type { ClientSession } from '../sessions';
-import { type TimeoutContext } from '../timeout';
 import { CommandOperation, type CommandOperationOptions } from './command';
 
 /** @public */
 export type ProfilingLevelOptions = CommandOperationOptions;
 
+class ProfilingLevelResponse extends MongoDBResponse {
+  get was() {
+    return this.get('was', BSONType.int, true);
+  }
+}
+
 /** @internal */
 export class ProfilingLevelOperation extends CommandOperation<string> {
+  override SERVER_COMMAND_RESPONSE_TYPE = ProfilingLevelResponse;
   override options: ProfilingLevelOptions;
 
   constructor(db: Db, options: ProfilingLevelOptions) {
@@ -21,14 +28,13 @@ export class ProfilingLevelOperation extends CommandOperation<string> {
     return 'profile' as const;
   }
 
-  override async execute(
-    server: Server,
-    session: ClientSession | undefined,
-    timeoutContext: TimeoutContext
-  ): Promise<string> {
-    const doc = await super.executeCommand(server, session, { profile: -1 }, timeoutContext);
-    if (doc.ok === 1) {
-      const was = doc.was;
+  override buildCommandDocument(_connection: Connection): Document {
+    return { profile: -1 };
+  }
+
+  override handleOk(response: InstanceType<typeof this.SERVER_COMMAND_RESPONSE_TYPE>): string {
+    if (response.ok === 1) {
+      const was = response.was;
       if (was === 0) return 'off';
       if (was === 1) return 'slow_only';
       if (was === 2) return 'all';

package/src/operations/remove_user.ts

@@ -1,7 +1,7 @@
+import { type Document } from '../bson';
+import { type Connection } from '../cmap/connection';
+import { MongoDBResponse } from '../cmap/wire_protocol/responses';
 import type { Db } from '../db';
-import type { Server } from '../sdam/server';
-import type { ClientSession } from '../sessions';
-import { type TimeoutContext } from '../timeout';
 import { CommandOperation, type CommandOperationOptions } from './command';
 import { Aspect, defineAspects } from './operation';
 
@@ -10,6 +10,7 @@ export type RemoveUserOptions = CommandOperationOptions;
 
 /** @internal */
 export class RemoveUserOperation extends CommandOperation<boolean> {
+  override SERVER_COMMAND_RESPONSE_TYPE = MongoDBResponse;
   override options: RemoveUserOptions;
   username: string;
 
@@ -23,12 +24,11 @@ export class RemoveUserOperation extends CommandOperation<boolean> {
     return 'dropUser' as const;
   }
 
-  override async execute(
-    server: Server,
-    session: ClientSession | undefined,
-    timeoutContext: TimeoutContext
-  ): Promise<boolean> {
-    await super.executeCommand(server, session, { dropUser: this.username }, timeoutContext);
+  override buildCommandDocument(_connection: Connection): Document {
+    return { dropUser: this.username };
+  }
+
+  override handleOk(_response: InstanceType<typeof this.SERVER_COMMAND_RESPONSE_TYPE>): boolean {
     return true;
   }
 }

package/src/operations/rename.ts

@@ -1,8 +1,8 @@
+import { type Connection } from '..';
 import type { Document } from '../bson';
+import { MongoDBResponse } from '../cmap/wire_protocol/responses';
 import { Collection } from '../collection';
-import type { Server } from '../sdam/server';
 import type { ClientSession } from '../sessions';
-import { type TimeoutContext } from '../timeout';
 import { MongoDBNamespace } from '../utils';
 import { CommandOperation, type CommandOperationOptions } from './command';
 import { Aspect, defineAspects } from './operation';
@@ -17,6 +17,7 @@ export interface RenameOptions extends CommandOperationOptions {
 
 /** @internal */
 export class RenameOperation extends CommandOperation<Document> {
+  override SERVER_COMMAND_RESPONSE_TYPE = MongoDBResponse;
   collection: Collection;
   newName: string;
   override options: RenameOptions;
@@ -33,24 +34,20 @@ export class RenameOperation extends CommandOperation<Document> {
     return 'renameCollection' as const;
   }
 
-  override async execute(
-    server: Server,
-    session: ClientSession | undefined,
-    timeoutContext: TimeoutContext
-  ): Promise<Collection> {
-    // Build the command
+  override buildCommandDocument(_connection: Connection, _session?: ClientSession): Document {
     const renameCollection = this.collection.namespace;
-    const toCollection = this.collection.s.namespace.withCollection(this.newName).toString();
+    const to = this.collection.s.namespace.withCollection(this.newName).toString();
     const dropTarget =
       typeof this.options.dropTarget === 'boolean' ? this.options.dropTarget : false;
 
-    const command = {
-      renameCollection: renameCollection,
-      to: toCollection,
-      dropTarget: dropTarget
+    return {
+      renameCollection,
+      to,
+      dropTarget
     };
+  }
 
-    await super.executeCommand(server, session, command, timeoutContext);
+  override handleOk(_response: InstanceType<typeof this.SERVER_COMMAND_RESPONSE_TYPE>): Document {
     return new Collection(this.collection.s.db, this.newName, this.collection.s.options);
   }
 }

package/src/operations/run_command.ts

@@ -1,13 +1,13 @@
+import { type Abortable } from '..';
 import type { BSONSerializeOptions, Document } from '../bson';
-import { type MongoDBResponseConstructor } from '../cmap/wire_protocol/responses';
-import { type Db } from '../db';
-import { type TODO_NODE_3286 } from '../mongo_types';
+import { type Connection } from '../cmap/connection';
+import { CursorResponse, MongoDBResponse } from '../cmap/wire_protocol/responses';
+import { AbstractOperation } from '../operations/operation';
 import type { ReadPreferenceLike } from '../read_preference';
-import type { Server } from '../sdam/server';
+import type { ServerCommandOptions } from '../sdam/server';
 import type { ClientSession } from '../sessions';
 import { type TimeoutContext } from '../timeout';
-import { MongoDBNamespace } from '../utils';
-import { AbstractOperation } from './operation';
+import { type MongoDBNamespace } from '../utils';
 
 /** @public */
 export type RunCommandOptions = {
@@ -22,86 +22,58 @@ export type RunCommandOptions = {
   timeoutMS?: number;
   /** @internal */
   omitMaxTimeMS?: boolean;
-} & BSONSerializeOptions;
+
+  /**
+   * @internal Hints to `executeOperation` that this operation should not unpin on an ended transaction
+   * This is only used by the driver for transaction commands
+   */
+  bypassPinningCheck?: boolean;
+} & BSONSerializeOptions &
+  Abortable;
 
 /** @internal */
 export class RunCommandOperation<T = Document> extends AbstractOperation<T> {
+  override SERVER_COMMAND_RESPONSE_TYPE = MongoDBResponse;
   command: Document;
-  override options: RunCommandOptions & { responseType?: MongoDBResponseConstructor };
+  override options: RunCommandOptions;
 
-  constructor(
-    parent: Db,
-    command: Document,
-    options: RunCommandOptions & { responseType?: MongoDBResponseConstructor }
-  ) {
+  constructor(namespace: MongoDBNamespace, command: Document, options: RunCommandOptions) {
     super(options);
     this.command = command;
     this.options = options;
-    this.ns = parent.s.namespace.withCollection('$cmd');
+    this.ns = namespace.withCollection('$cmd');
   }
 
   override get commandName() {
     return 'runCommand' as const;
   }
 
-  override async execute(
-    server: Server,
-    session: ClientSession | undefined,
-    timeoutContext: TimeoutContext
-  ): Promise<T> {
-    this.server = server;
-    const res: TODO_NODE_3286 = await server.command(
-      this.ns,
-      this.command,
-      {
-        ...this.options,
-        readPreference: this.readPreference,
-        session,
-        timeoutContext
-      },
-      this.options.responseType
-    );
-
-    return res;
+  override buildCommand(_connection: Connection, _session?: ClientSession): Document {
+    return this.command;
   }
-}
-
-export class RunAdminCommandOperation<T = Document> extends AbstractOperation<T> {
-  command: Document;
-  override options: RunCommandOptions & {
-    noResponse?: boolean;
-    bypassPinningCheck?: boolean;
-  };
 
-  constructor(
-    command: Document,
-    options: RunCommandOptions & {
-      noResponse?: boolean;
-      bypassPinningCheck?: boolean;
-    }
-  ) {
-    super(options);
-    this.command = command;
-    this.options = options;
-    this.ns = new MongoDBNamespace('admin', '$cmd');
+  override buildOptions(timeoutContext: TimeoutContext): ServerCommandOptions {
+    return {
+      ...this.options,
+      session: this.session,
+      timeoutContext,
+      signal: this.options.signal,
+      readPreference: this.options.readPreference
+    };
   }
+}
 
-  override get commandName() {
-    return 'runCommand' as const;
-  }
+/**
+ * @internal
+ *
+ * A specialized subclass of RunCommandOperation for cursor-creating commands.
+ */
+export class RunCursorCommandOperation extends RunCommandOperation {
+  override SERVER_COMMAND_RESPONSE_TYPE = CursorResponse;
 
-  override async execute(
-    server: Server,
-    session: ClientSession | undefined,
-    timeoutContext: TimeoutContext
-  ): Promise<T> {
-    this.server = server;
-    const res: TODO_NODE_3286 = await server.command(this.ns, this.command, {
-      ...this.options,
-      readPreference: this.readPreference,
-      session,
-      timeoutContext
-    });
-    return res;
+  override handleOk(
+    response: InstanceType<typeof this.SERVER_COMMAND_RESPONSE_TYPE>
+  ): CursorResponse {
+    return response;
   }
 }

package/src/operations/search_indexes/create.ts

@@ -1,6 +1,8 @@
-import type { Document } from '../../bson';
+import { type Document } from '../../bson';
+import { type Connection } from '../../cmap/connection';
+import { MongoDBResponse } from '../../cmap/wire_protocol/responses';
 import type { Collection } from '../../collection';
-import type { Server } from '../../sdam/server';
+import type { ServerCommandOptions } from '../../sdam/server';
 import type { ClientSession } from '../../sessions';
 import { type TimeoutContext } from '../../timeout';
 import { AbstractOperation } from '../operation';
@@ -20,7 +22,8 @@ export interface SearchIndexDescription extends Document {
 }
 
 /** @internal */
-export class CreateSearchIndexesOperation extends AbstractOperation<string[]> {
+export class CreateSearchIndexesOperation extends AbstractOperation<Document> {
+  override SERVER_COMMAND_RESPONSE_TYPE = MongoDBResponse;
   private readonly collection: Collection;
   private readonly descriptions: ReadonlyArray<SearchIndexDescription>;
 
@@ -28,29 +31,26 @@ export class CreateSearchIndexesOperation extends AbstractOperation<string[]> {
     super();
     this.collection = collection;
     this.descriptions = descriptions;
+    this.ns = collection.fullNamespace;
   }
 
   override get commandName() {
     return 'createSearchIndexes' as const;
   }
 
-  override async execute(
-    server: Server,
-    session: ClientSession | undefined,
-    timeoutContext: TimeoutContext
-  ): Promise<string[]> {
+  override buildCommand(_connection: Connection, _session?: ClientSession): Document {
     const namespace = this.collection.fullNamespace;
-    const command = {
+    return {
       createSearchIndexes: namespace.collection,
       indexes: this.descriptions
     };
+  }
 
-    const res = await server.command(namespace, command, {
-      session,
-      timeoutContext
-    });
+  override handleOk(response: InstanceType<typeof this.SERVER_COMMAND_RESPONSE_TYPE>): string[] {
+    return super.handleOk(response).indexesCreated.map((val: { name: string }) => val.name);
+  }
 
-    const indexesCreated: Array<{ name: string }> = res?.indexesCreated ?? [];
-    return indexesCreated.map(({ name }) => name);
+  override buildOptions(timeoutContext: TimeoutContext): ServerCommandOptions {
+    return { session: this.session, timeoutContext };
   }
 }

package/src/operations/search_indexes/drop.ts

@@ -1,13 +1,17 @@
+import { type Connection, type MongoError } from '../..';
 import type { Document } from '../../bson';
+import { MongoDBResponse } from '../../cmap/wire_protocol/responses';
 import type { Collection } from '../../collection';
 import { MONGODB_ERROR_CODES, MongoServerError } from '../../error';
-import type { Server } from '../../sdam/server';
+import type { ServerCommandOptions } from '../../sdam/server';
 import type { ClientSession } from '../../sessions';
 import { type TimeoutContext } from '../../timeout';
 import { AbstractOperation } from '../operation';
 
 /** @internal */
 export class DropSearchIndexOperation extends AbstractOperation<void> {
+  override SERVER_COMMAND_RESPONSE_TYPE = MongoDBResponse;
+
   private readonly collection: Collection;
   private readonly name: string;
 
@@ -15,17 +19,14 @@ export class DropSearchIndexOperation extends AbstractOperation<void> {
     super();
     this.collection = collection;
     this.name = name;
+    this.ns = collection.fullNamespace;
   }
 
   override get commandName() {
     return 'dropSearchIndex' as const;
   }
 
-  override async execute(
-    server: Server,
-    session: ClientSession | undefined,
-    timeoutContext: TimeoutContext
-  ): Promise<void> {
+  override buildCommand(_connection: Connection, _session?: ClientSession): Document {
     const namespace = this.collection.fullNamespace;
 
     const command: Document = {
@@ -36,14 +37,22 @@ export class DropSearchIndexOperation extends AbstractOperation<void> {
       command.name = this.name;
     }
 
-    try {
-      await server.command(namespace, command, { session, timeoutContext });
-    } catch (error) {
-      const isNamespaceNotFoundError =
-        error instanceof MongoServerError && error.code === MONGODB_ERROR_CODES.NamespaceNotFound;
-      if (!isNamespaceNotFoundError) {
-        throw error;
-      }
+    return command;
+  }
+
+  override handleOk(_response: MongoDBResponse): void {
+    // do nothing
+  }
+
+  override buildOptions(timeoutContext: TimeoutContext): ServerCommandOptions {
+    return { session: this.session, timeoutContext };
+  }
+
+  override handleError(error: MongoError): void {
+    const isNamespaceNotFoundError =
+      error instanceof MongoServerError && error.code === MONGODB_ERROR_CODES.NamespaceNotFound;
+    if (!isNamespaceNotFoundError) {
+      throw error;
     }
   }
 }