passing

Author: baileympearson

src/operations/execute_operation.ts

@@ -26,7 +26,7 @@ import type { Topology } from '../sdam/topology';
 import type { ClientSession } from '../sessions';
 import { TimeoutContext } from '../timeout';
 import { abortable, supportsRetryableWrites } from '../utils';
-import { AbstractOperation, Aspect, ModernOperation } from './operation';
+import { AbstractOperation, Aspect, ModernizedOperation } from './operation';
 
 const MMAPv1_RETRY_WRITES_ERROR_CODE = MONGODB_ERROR_CODES.IllegalOperation;
 const MMAPv1_RETRY_WRITES_ERROR_MESSAGE =
@@ -233,7 +233,7 @@ async function tryOperation<
   let previousOperationError: MongoError | undefined;
   let previousServer: ServerDescription | undefined;
 
-  const isModernOperation = operation instanceof ModernOperation;
+  const isModernOperation = operation instanceof ModernizedOperation;
 
   for (let tries = 0; tries < maxTries; tries++) {
     if (previousOperationError) {

src/operations/operation.ts

@@ -1,5 +1,6 @@
-import { type Connection, type MongoDBResponse, type MongoError } from '..';
+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, ServerCommandOptions } from '../sdam/server';
@@ -130,11 +131,8 @@ export abstract class AbstractOperation<TResult = any> {
   }
 }
 
-export abstract class ModernOperation<
-  TResponse extends typeof MongoDBResponse | undefined,
-  TResult
-> extends AbstractOperation<TResult> {
-  abstract RESPONSE_TYPE: TResponse;
+export abstract class ModernizedOperation<TResult> extends AbstractOperation<TResult> {
+  abstract SERVER_COMMAND_RESPONSE_TYPE: typeof MongoDBResponse;
 
   /** this will never be used - but we must implement it to satisfy AbstractOperation's interface */
   override execute(
@@ -150,16 +148,27 @@ export abstract class ModernOperation<
   abstract buildOptions(timeoutContext: TimeoutContext): ServerCommandOptions;
 
   /**
-   * Optional - if the operation performs error handling, such as wrapping or renaming the error,
-   * this method can be overridden.
+   * 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;
+   *  }
+   * ```
    */
-  abstract handleOk(
-    response: TResponse extends typeof MongoDBResponse ? InstanceType<TResponse> : Document
-  ): TResult;
+  handleOk(response: InstanceType<typeof this.SERVER_COMMAND_RESPONSE_TYPE>): TResult {
+    return response.toObject(this.bsonOptions) as TResult;
+  }
 
   /**
-   * Optional - if the operation performs post-processing
-   * on the result document, this method can be overridden.
+   * Optional - if the operation performs error handling, such as wrapping or renaming the error,
+   * this method can be overridden.
    */
   handleError(error: MongoError): void {
     throw error;

src/operations/search_indexes/drop.ts

@@ -5,11 +5,12 @@ import { MONGODB_ERROR_CODES, MongoServerError } from '../../error';
 import type { ServerCommandOptions } from '../../sdam/server';
 import type { ClientSession } from '../../sessions';
 import { type TimeoutContext } from '../../timeout';
-import { ModernOperation } from '../operation';
+import { ModernizedOperation } from '../operation';
+import { MongoDBResponse } from '../../cmap/wire_protocol/responses'
 
 /** @internal */
-export class DropSearchIndexOperation extends ModernOperation<undefined, void> {
-  override RESPONSE_TYPE: undefined;
+export class DropSearchIndexOperation extends ModernizedOperation<void> {
+  override SERVER_COMMAND_RESPONSE_TYPE = MongoDBResponse;
 
   private readonly collection: Collection;
   private readonly name: string;
@@ -38,7 +39,7 @@ export class DropSearchIndexOperation extends ModernOperation<undefined, void> {
     return command;
   }
 
-  override handleOk(_response: Document): void {
+  override handleOk(_response: MongoDBResponse): void {
     // do nothing
   }
 

src/sdam/server.ts

@@ -7,10 +7,7 @@ import {
   type ConnectionPoolOptions
 } from '../cmap/connection_pool';
 import { PoolClearedError } from '../cmap/errors';
-import {
-  type MongoDBResponse,
-  type MongoDBResponseConstructor
-} from '../cmap/wire_protocol/responses';
+import { type MongoDBResponseConstructor } from '../cmap/wire_protocol/responses';
 import {
   APM_EVENTS,
   CLOSED,
@@ -41,7 +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 ModernOperation } from '../operations/operation';
+import { type ModernizedOperation } from '../operations/operation';
 import type { ClientSession } from '../sessions';
 import { type TimeoutContext } from '../timeout';
 import { isTransactionCommand } from '../transactions';
@@ -281,14 +278,10 @@ export class Server extends TypedEventEmitter<ServerEvents> {
     }
   }
 
-  public async modernCommand<TResponse extends typeof MongoDBResponse | undefined, TResult>(
-    operation: ModernOperation<TResponse, TResult>,
+  public async modernCommand<TResult>(
+    operation: ModernizedOperation<TResult>,
     timeoutContext: TimeoutContext
-  ): Promise<
-    typeof operation.RESPONSE_TYPE extends typeof MongoDBResponse
-      ? InstanceType<TResponse>
-      : Document
-  > {
+  ): Promise<InstanceType<typeof operation.SERVER_COMMAND_RESPONSE_TYPE>> {
     if (this.s.state === STATE_CLOSING || this.s.state === STATE_CLOSED) {
       throw new MongoServerClosedError();
     }
@@ -333,12 +326,9 @@ export class Server extends TypedEventEmitter<ServerEvents> {
 
     try {
       try {
-        const res = await conn.command(ns, cmd, options, operation.RESPONSE_TYPE);
+        const res = await conn.command(ns, cmd, options, operation.SERVER_COMMAND_RESPONSE_TYPE);
         throwIfWriteConcernError(res);
-        // TODO: figure out why casting is necessary
-        return res as typeof operation.RESPONSE_TYPE extends typeof MongoDBResponse
-          ? InstanceType<TResponse>
-          : Document;
+        return res;
       } catch (commandError) {
         throw this.decorateCommandError(conn, cmd, options, commandError);
       }
@@ -357,12 +347,9 @@ export class Server extends TypedEventEmitter<ServerEvents> {
         reauthPromise = null; // only reachable if reauth succeeds
 
         try {
-          const res = await conn.command(ns, cmd, options);
+          const res = await conn.command(ns, cmd, options, operation.SERVER_COMMAND_RESPONSE_TYPE);
           throwIfWriteConcernError(res);
-          // TODO: figure out why casting is necessary
-          return res as typeof operation.RESPONSE_TYPE extends typeof MongoDBResponse
-            ? InstanceType<TResponse>
-            : Document;
+          return res;
         } catch (commandError) {
           throw this.decorateCommandError(conn, cmd, options, commandError);
         }

test/integration/crud/abstract_operation.test.ts

@@ -290,7 +290,7 @@ describe('abstract operation', function () {
         if (!WrapperSubclasses.includes(subclassType.name.toString())) {
           it(`operation.commandName equals key in command document`, async function () {
             const subclassInstance = subclassCreator();
-            if (subclassInstance instanceof mongodb.ModernOperation) {
+            if (subclassInstance instanceof mongodb.ModernizedOperation) {
               return;
             }
             const yieldDoc =