mongodb 6.18.0-dev.20250823.sha.c2166a50 → 6.18.0-dev.20250826.sha.66706f8e

package/src/operations/search_indexes/create.ts

@@ -5,7 +5,7 @@ import type { Collection } from '../../collection';
 import type { ServerCommandOptions } from '../../sdam/server';
 import type { ClientSession } from '../../sessions';
 import { type TimeoutContext } from '../../timeout';
-import { ModernizedOperation } from '../operation';
+import { AbstractOperation } from '../operation';
 
 /**
  * @public
@@ -22,7 +22,7 @@ export interface SearchIndexDescription extends Document {
 }
 
 /** @internal */
-export class CreateSearchIndexesOperation extends ModernizedOperation<Document> {
+export class CreateSearchIndexesOperation extends AbstractOperation<Document> {
   override SERVER_COMMAND_RESPONSE_TYPE = MongoDBResponse;
   private readonly collection: Collection;
   private readonly descriptions: ReadonlyArray<SearchIndexDescription>;

package/src/operations/search_indexes/drop.ts

@@ -6,10 +6,10 @@ import { MONGODB_ERROR_CODES, MongoServerError } from '../../error';
 import type { ServerCommandOptions } from '../../sdam/server';
 import type { ClientSession } from '../../sessions';
 import { type TimeoutContext } from '../../timeout';
-import { ModernizedOperation } from '../operation';
+import { AbstractOperation } from '../operation';
 
 /** @internal */
-export class DropSearchIndexOperation extends ModernizedOperation<void> {
+export class DropSearchIndexOperation extends AbstractOperation<void> {
   override SERVER_COMMAND_RESPONSE_TYPE = MongoDBResponse;
 
   private readonly collection: Collection;

package/src/operations/search_indexes/update.ts

@@ -5,10 +5,10 @@ import type { Collection } from '../../collection';
 import type { ServerCommandOptions } from '../../sdam/server';
 import type { ClientSession } from '../../sessions';
 import { type TimeoutContext } from '../../timeout';
-import { ModernizedOperation } from '../operation';
+import { AbstractOperation } from '../operation';
 
 /** @internal */
-export class UpdateSearchIndexOperation extends ModernizedOperation<void> {
+export class UpdateSearchIndexOperation extends AbstractOperation<void> {
   override SERVER_COMMAND_RESPONSE_TYPE = MongoDBResponse;
   private readonly collection: Collection;
   private readonly name: string;

package/src/operations/set_profiling_level.ts

@@ -1,8 +1,8 @@
+import { type Document } from '../bson';
+import { type Connection } from '../cmap/connection';
+import { MongoDBResponse } from '../cmap/wire_protocol/responses';
 import type { Db } from '../db';
 import { MongoInvalidArgumentError } from '../error';
-import type { Server } from '../sdam/server';
-import type { ClientSession } from '../sessions';
-import { type TimeoutContext } from '../timeout';
 import { enumToString } from '../utils';
 import { CommandOperation, type CommandOperationOptions } from './command';
 
@@ -23,6 +23,7 @@ export type SetProfilingLevelOptions = CommandOperationOptions;
 
 /** @internal */
 export class SetProfilingLevelOperation extends CommandOperation<ProfilingLevel> {
+  override SERVER_COMMAND_RESPONSE_TYPE = MongoDBResponse;
   override options: SetProfilingLevelOptions;
   level: ProfilingLevel;
   profile: 0 | 1 | 2;
@@ -52,21 +53,22 @@ export class SetProfilingLevelOperation extends CommandOperation<ProfilingLevel>
     return 'profile' as const;
   }
 
-  override async execute(
-    server: Server,
-    session: ClientSession | undefined,
-    timeoutContext: TimeoutContext
-  ): Promise<ProfilingLevel> {
+  override buildCommandDocument(_connection: Connection): Document {
     const level = this.level;
 
     if (!levelValues.has(level)) {
+      // TODO(NODE-3483): Determine error to put here
       throw new MongoInvalidArgumentError(
         `Profiling level must be one of "${enumToString(ProfilingLevel)}"`
       );
     }
 
-    // TODO(NODE-3483): Determine error to put here
-    await super.executeCommand(server, session, { profile: this.profile }, timeoutContext);
-    return level;
+    return { profile: this.profile };
+  }
+
+  override handleOk(
+    _response: InstanceType<typeof this.SERVER_COMMAND_RESPONSE_TYPE>
+  ): ProfilingLevel {
+    return this.level;
   }
 }

package/src/operations/stats.ts

@@ -1,8 +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';
 
@@ -14,6 +13,7 @@ export interface DbStatsOptions extends CommandOperationOptions {
 
 /** @internal */
 export class DbStatsOperation extends CommandOperation<Document> {
+  override SERVER_COMMAND_RESPONSE_TYPE = MongoDBResponse;
   override options: DbStatsOptions;
 
   constructor(db: Db, options: DbStatsOptions) {
@@ -25,17 +25,12 @@ export class DbStatsOperation extends CommandOperation<Document> {
     return 'dbStats' as const;
   }
 
-  override async execute(
-    server: Server,
-    session: ClientSession | undefined,
-    timeoutContext: TimeoutContext
-  ): Promise<Document> {
+  override buildCommandDocument(_connection: Connection): Document {
     const command: Document = { dbStats: true };
     if (this.options.scale != null) {
       command.scale = this.options.scale;
     }
-
-    return await super.executeCommand(server, session, command, timeoutContext);
+    return command;
   }
 }
 

package/src/operations/update.ts

@@ -10,11 +10,7 @@ import {
   type MongoDBCollectionNamespace,
   type MongoDBNamespace
 } from '../utils';
-import {
-  type CollationOptions,
-  type CommandOperationOptions,
-  ModernizedCommandOperation
-} from './command';
+import { type CollationOptions, CommandOperation, type CommandOperationOptions } from './command';
 import { Aspect, defineAspects, type Hint } from './operation';
 
 /** @public */
@@ -74,7 +70,7 @@ export interface UpdateStatement {
  * @internal
  * UpdateOperation is used in bulk write, while UpdateOneOperation and UpdateManyOperation are only used in the collections API
  */
-export class UpdateOperation extends ModernizedCommandOperation<Document> {
+export class UpdateOperation extends CommandOperation<Document> {
   override SERVER_COMMAND_RESPONSE_TYPE = MongoDBResponse;
   override options: UpdateOptions & { ordered?: boolean };
   statements: UpdateStatement[];

package/src/operations/validate_collection.ts

@@ -4,7 +4,7 @@ import { type Document } from '../bson';
 import { MongoDBResponse } from '../cmap/wire_protocol/responses';
 import { MongoUnexpectedServerResponseError } from '../error';
 import type { ClientSession } from '../sessions';
-import { type CommandOperationOptions, ModernizedCommandOperation } from './command';
+import { CommandOperation, type CommandOperationOptions } from './command';
 
 /** @public */
 export interface ValidateCollectionOptions extends CommandOperationOptions {
@@ -13,7 +13,7 @@ export interface ValidateCollectionOptions extends CommandOperationOptions {
 }
 
 /** @internal */
-export class ValidateCollectionOperation extends ModernizedCommandOperation<Document> {
+export class ValidateCollectionOperation extends CommandOperation<Document> {
   override SERVER_COMMAND_RESPONSE_TYPE = MongoDBResponse;
   override options: ValidateCollectionOptions;
   collectionName: string;

package/src/sdam/server.ts

@@ -7,7 +7,6 @@ import {
   type ConnectionPoolOptions
 } from '../cmap/connection_pool';
 import { PoolClearedError } from '../cmap/errors';
-import { type MongoDBResponseConstructor } from '../cmap/wire_protocol/responses';
 import {
   APM_EVENTS,
   CLOSED,
@@ -27,7 +26,6 @@ import {
   MONGODB_ERROR_CODES,
   MongoError,
   MongoErrorLabel,
-  MongoInvalidArgumentError,
   MongoNetworkError,
   MongoNetworkTimeoutError,
   MongoRuntimeError,
@@ -39,7 +37,7 @@ import type { ServerApi } from '../mongo_client';
 import { type Abortable, TypedEventEmitter } from '../mongo_types';
 import { AggregateOperation } from '../operations/aggregate';
 import type { GetMoreOptions } from '../operations/get_more';
-import { type ModernizedOperation } from '../operations/operation';
+import { type AbstractOperation } from '../operations/operation';
 import type { ClientSession } from '../sessions';
 import { type TimeoutContext } from '../timeout';
 import { isTransactionCommand } from '../transactions';
@@ -48,7 +46,6 @@ import {
   type EventEmitterWithState,
   makeStateMachine,
   maxWireVersion,
-  type MongoDBNamespace,
   noop,
   squashError,
   supportsRetryableWrites
@@ -281,8 +278,8 @@ export class Server extends TypedEventEmitter<ServerEvents> {
     }
   }
 
-  public async modernCommand<TResult>(
-    operation: ModernizedOperation<TResult>,
+  public async command<TResult>(
+    operation: AbstractOperation<TResult>,
     timeoutContext: TimeoutContext
   ): Promise<InstanceType<typeof operation.SERVER_COMMAND_RESPONSE_TYPE>> {
     if (this.s.state === STATE_CLOSING || this.s.state === STATE_CLOSED) {
@@ -295,7 +292,7 @@ export class Server extends TypedEventEmitter<ServerEvents> {
     this.incrementOperationCount();
     if (conn == null) {
       try {
-        conn = await this.pool.checkOut({ timeoutContext });
+        conn = await this.pool.checkOut({ timeoutContext, signal: operation.options.signal });
       } catch (checkoutError) {
         this.decrementOperationCount();
         if (!(checkoutError instanceof PoolClearedError)) this.handleError(checkoutError);
@@ -385,106 +382,6 @@ export class Server extends TypedEventEmitter<ServerEvents> {
     }
   }
 
-  public async command<T extends MongoDBResponseConstructor>(
-    ns: MongoDBNamespace,
-    command: Document,
-    options: ServerCommandOptions,
-    responseType: T | undefined
-  ): Promise<typeof responseType extends undefined ? Document : InstanceType<T>>;
-
-  public async command(
-    ns: MongoDBNamespace,
-    command: Document,
-    options: ServerCommandOptions
-  ): Promise<Document>;
-
-  public async command(
-    ns: MongoDBNamespace,
-    cmd: Document,
-    { ...options }: ServerCommandOptions,
-    responseType?: MongoDBResponseConstructor
-  ): Promise<Document> {
-    if (ns.db == null || typeof ns === 'string') {
-      throw new MongoInvalidArgumentError('Namespace must not be a string');
-    }
-
-    if (this.s.state === STATE_CLOSING || this.s.state === STATE_CLOSED) {
-      throw new MongoServerClosedError();
-    }
-
-    options.directConnection = this.topology.s.options.directConnection;
-
-    if (this.description.iscryptd) {
-      options.omitMaxTimeMS = true;
-    }
-
-    const session = options.session;
-    let conn = session?.pinnedConnection;
-
-    this.incrementOperationCount();
-    if (conn == null) {
-      try {
-        conn = await this.pool.checkOut(options);
-        if (this.loadBalanced && isPinnableCommand(cmd, session)) {
-          session?.pin(conn);
-        }
-      } catch (checkoutError) {
-        this.decrementOperationCount();
-        if (!(checkoutError instanceof PoolClearedError)) this.handleError(checkoutError);
-        throw checkoutError;
-      }
-    }
-
-    let reauthPromise: Promise<void> | null = null;
-
-    try {
-      try {
-        const res = await conn.command(ns, cmd, options, responseType);
-        throwIfWriteConcernError(res);
-        return res;
-      } catch (commandError) {
-        throw this.decorateCommandError(conn, cmd, options, commandError);
-      }
-    } catch (operationError) {
-      if (
-        operationError instanceof MongoError &&
-        operationError.code === MONGODB_ERROR_CODES.Reauthenticate
-      ) {
-        reauthPromise = this.pool.reauthenticate(conn);
-        reauthPromise.then(undefined, error => {
-          reauthPromise = null;
-          squashError(error);
-        });
-
-        await abortable(reauthPromise, options);
-        reauthPromise = null; // only reachable if reauth succeeds
-
-        try {
-          const res = await conn.command(ns, cmd, options, responseType);
-          throwIfWriteConcernError(res);
-          return res;
-        } catch (commandError) {
-          throw this.decorateCommandError(conn, cmd, options, commandError);
-        }
-      } else {
-        throw operationError;
-      }
-    } finally {
-      this.decrementOperationCount();
-      if (session?.pinnedConnection !== conn) {
-        if (reauthPromise != null) {
-          // The reauth promise only exists if it hasn't thrown.
-          const checkBackIn = () => {
-            this.pool.checkIn(conn);
-          };
-          void reauthPromise.then(checkBackIn, checkBackIn);
-        } else {
-          this.pool.checkIn(conn);
-        }
-      }
-    }
-  }
-
   /**
    * Handle SDAM error
    * @internal

package/src/sdam/topology.ts

@@ -750,7 +750,7 @@ export class Topology extends TypedEventEmitter<TopologyEvents> {
   }
 
   auth(credentials?: MongoCredentials, callback?: Callback): void {
-    if (typeof credentials === 'function') (callback = credentials), (credentials = undefined);
+    if (typeof credentials === 'function') ((callback = credentials), (credentials = undefined));
     if (typeof callback === 'function') callback(undefined, true);
   }
 

package/src/sessions.ts

@@ -24,7 +24,7 @@ import {
 import type { MongoClient, MongoOptions } from './mongo_client';
 import { TypedEventEmitter } from './mongo_types';
 import { executeOperation } from './operations/execute_operation';
-import { RunAdminCommandOperation } from './operations/run_command';
+import { RunCommandOperation } from './operations/run_command';
 import { ReadConcernLevel } from './read_concern';
 import { ReadPreference } from './read_preference';
 import { type AsyncDisposable, configureResourceManagement } from './resource_management';
@@ -43,6 +43,7 @@ import {
   isPromiseLike,
   List,
   maxWireVersion,
+  MongoDBNamespace,
   noop,
   now,
   squashError,
@@ -505,7 +506,7 @@ export class ClientSession
       command.recoveryToken = this.transaction.recoveryToken;
     }
 
-    const operation = new RunAdminCommandOperation(command, {
+    const operation = new RunCommandOperation(new MongoDBNamespace('admin'), command, {
       session: this,
       readPreference: ReadPreference.primary,
       bypassPinningCheck: true
@@ -536,7 +537,7 @@ export class ClientSession
         try {
           await executeOperation(
             this.client,
-            new RunAdminCommandOperation(command, {
+            new RunCommandOperation(new MongoDBNamespace('admin'), command, {
               session: this,
               readPreference: ReadPreference.primary,
               bypassPinningCheck: true
@@ -637,7 +638,7 @@ export class ClientSession
       command.recoveryToken = this.transaction.recoveryToken;
     }
 
-    const operation = new RunAdminCommandOperation(command, {
+    const operation = new RunCommandOperation(new MongoDBNamespace('admin'), command, {
       session: this,
       readPreference: ReadPreference.primary,
       bypassPinningCheck: true