mongodb 6.18.0-dev.20250801.sha.aac76296 → 6.18.0-dev.20250805.sha.ff9a7858

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';
+import { ModernizedOperation } from '../operation';
 
 /** @internal */
-export class DropSearchIndexOperation extends AbstractOperation<void> {
+export class DropSearchIndexOperation extends ModernizedOperation<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;
     }
   }
 }

package/src/sdam/server.ts

@@ -38,6 +38,7 @@ import {
 import type { ServerApi } from '../mongo_client';
 import { type Abortable, TypedEventEmitter } from '../mongo_types';
 import type { GetMoreOptions } from '../operations/get_more';
+import { type ModernizedOperation } from '../operations/operation';
 import type { ClientSession } from '../sessions';
 import { type TimeoutContext } from '../timeout';
 import { isTransactionCommand } from '../transactions';
@@ -277,6 +278,100 @@ export class Server extends TypedEventEmitter<ServerEvents> {
     }
   }
 
+  public async modernCommand<TResult>(
+    operation: ModernizedOperation<TResult>,
+    timeoutContext: TimeoutContext
+  ): Promise<InstanceType<typeof operation.SERVER_COMMAND_RESPONSE_TYPE>> {
+    if (this.s.state === STATE_CLOSING || this.s.state === STATE_CLOSED) {
+      throw new MongoServerClosedError();
+    }
+    const session = operation.session;
+
+    let conn = session?.pinnedConnection;
+
+    this.incrementOperationCount();
+    if (conn == null) {
+      try {
+        conn = await this.pool.checkOut({ timeoutContext });
+      } catch (checkoutError) {
+        this.decrementOperationCount();
+        if (!(checkoutError instanceof PoolClearedError)) this.handleError(checkoutError);
+        throw checkoutError;
+      }
+    }
+
+    const cmd = operation.buildCommand(conn, session);
+    const options = operation.buildOptions(timeoutContext);
+    const ns = operation.ns;
+
+    if (this.loadBalanced && isPinnableCommand(cmd, session) && !session?.pinnedConnection) {
+      session?.pin(conn);
+    }
+
+    options.directConnection = this.topology.s.options.directConnection;
+
+    // There are cases where we need to flag the read preference not to get sent in
+    // the command, such as pre-5.0 servers attempting to perform an aggregate write
+    // with a non-primary read preference. In this case the effective read preference
+    // (primary) is not the same as the provided and must be removed completely.
+    if (options.omitReadPreference) {
+      delete options.readPreference;
+    }
+
+    if (this.description.iscryptd) {
+      options.omitMaxTimeMS = true;
+    }
+
+    let reauthPromise: Promise<void> | null = null;
+
+    try {
+      try {
+        const res = await conn.command(ns, cmd, options, operation.SERVER_COMMAND_RESPONSE_TYPE);
+        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, operation.SERVER_COMMAND_RESPONSE_TYPE);
+          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);
+        }
+      }
+    }
+  }
+
   public async command<T extends MongoDBResponseConstructor>(
     ns: MongoDBNamespace,
     command: Document,