fix run command stuff

Author: baileympearson

src/admin.ts

@@ -8,11 +8,12 @@ import {
   type ListDatabasesResult
 } from './operations/list_databases';
 import { RemoveUserOperation, type RemoveUserOptions } from './operations/remove_user';
-import { RunAdminCommandOperation, type RunCommandOptions } from './operations/run_command';
+import { RunCommandOperation, type RunCommandOptions } from './operations/run_command';
 import {
   ValidateCollectionOperation,
   type ValidateCollectionOptions
 } from './operations/validate_collection';
+import { MongoDBNamespace } from './utils';
 
 /** @internal */
 export interface AdminPrivate {
@@ -75,7 +76,7 @@ export class Admin {
   async command(command: Document, options?: RunCommandOptions): Promise<Document> {
     return await executeOperation(
       this.s.db.client,
-      new RunAdminCommandOperation(command, {
+      new RunCommandOperation(new MongoDBNamespace('admin'), command, {
         ...resolveBSONOptions(options),
         session: options?.session,
         readPreference: options?.readPreference,

src/cursor/run_command_cursor.ts

@@ -1,5 +1,5 @@
 import type { BSONSerializeOptions, Document } from '../bson';
-import { CursorResponse } from '../cmap/wire_protocol/responses';
+import { type CursorResponse } from '../cmap/wire_protocol/responses';
 import type { Db } from '../db';
 import { MongoAPIError, MongoRuntimeError } from '../error';
 import { executeOperation } from '../operations/execute_operation';
@@ -143,11 +143,10 @@ export class RunCommandCursor extends AbstractCursor {
 
   /** @internal */
   protected async _initialize(session: ClientSession): Promise<InitialCursorResponse> {
-    const operation = new RunCursorCommandOperation(this.db, this.command, {
+    const operation = new RunCursorCommandOperation(this.db.s.namespace, this.command, {
       ...this.cursorOptions,
       session: session,
-      readPreference: this.cursorOptions.readPreference,
-      responseType: CursorResponse
+      readPreference: this.cursorOptions.readPreference
     });
 
     const response = await executeOperation(this.client, operation, this.timeoutContext);

src/db.ts

@@ -272,7 +272,7 @@ export class Db {
     return await executeOperation(
       this.client,
       new RunCommandOperation(
-        this,
+        this.s.namespace,
         command,
         resolveOptions(undefined, {
           ...resolveBSONOptions(options),

src/mongo_client.ts

@@ -2,6 +2,7 @@ import { promises as fs } from 'fs';
 import type { TcpNetConnectOpts } from 'net';
 import type { ConnectionOptions as TLSConnectionOptions, TLSSocketOptions } from 'tls';
 
+import { type ServerCommandOptions, type TimeoutContext } from '.';
 import { type BSONSerializeOptions, type Document, resolveBSONOptions } from './bson';
 import { ChangeStream, type ChangeStreamDocument, type ChangeStreamOptions } from './change_stream';
 import type { AutoEncrypter, AutoEncryptionOptions } from './client-side-encryption/auto_encrypter';
@@ -20,6 +21,7 @@ import {
   makeClientMetadata
 } from './cmap/handshake/client_metadata';
 import type { CompressorName } from './cmap/wire_protocol/compression';
+import { MongoDBResponse } from './cmap/wire_protocol/responses';
 import { parseOptions, resolveSRVRecord } from './connection_string';
 import { MONGO_CLIENT_EVENTS } from './constants';
 import { type AbstractCursor } from './cursor/abstract_cursor';
@@ -42,7 +44,7 @@ import {
 } from './operations/client_bulk_write/common';
 import { ClientBulkWriteExecutor } from './operations/client_bulk_write/executor';
 import { executeOperation } from './operations/execute_operation';
-import { RunAdminCommandOperation } from './operations/run_command';
+import { ModernizedOperation } from './operations/operation';
 import type { ReadConcern, ReadConcernLevel, ReadConcernLike } from './read_concern';
 import { ReadPreference, type ReadPreferenceMode } from './read_preference';
 import { type AsyncDisposable, configureResourceManagement } from './resource_management';
@@ -790,13 +792,25 @@ export class MongoClient extends TypedEventEmitter<MongoClientEvents> implements
       const endSessions = Array.from(this.s.sessionPool.sessions, ({ id }) => id);
       if (endSessions.length !== 0) {
         try {
-          await executeOperation(
-            this,
-            new RunAdminCommandOperation(
-              { endSessions },
-              { readPreference: ReadPreference.primaryPreferred, noResponse: true }
-            )
-          );
+          class EndSessionsOperation extends ModernizedOperation<void> {
+            override SERVER_COMMAND_RESPONSE_TYPE = MongoDBResponse;
+            override buildCommand(_connection: Connection, _session?: ClientSession): Document {
+              return {
+                endSessions
+              };
+            }
+            override buildOptions(timeoutContext: TimeoutContext): ServerCommandOptions {
+              return {
+                timeoutContext,
+                readPreference: ReadPreference.primaryPreferred,
+                noResponse: true
+              };
+            }
+            override get commandName(): string {
+              return 'endSessions';
+            }
+          }
+          await executeOperation(this, new EndSessionsOperation());
         } catch (error) {
           squashError(error);
         }

src/operations/run_command.ts

@@ -1,18 +1,13 @@
 import { type Abortable } from '..';
 import type { BSONSerializeOptions, Document } from '../bson';
 import { type Connection } from '../cmap/connection';
-import {
-  CursorResponse,
-  MongoDBResponse,
-  type MongoDBResponseConstructor
-} from '../cmap/wire_protocol/responses';
-import { type Db } from '../db';
+import { CursorResponse, MongoDBResponse } from '../cmap/wire_protocol/responses';
+import { ModernizedOperation } from '../operations/operation';
 import type { ReadPreferenceLike } from '../read_preference';
 import type { ServerCommandOptions } from '../sdam/server';
 import type { ClientSession } from '../sessions';
 import { type TimeoutContext } from '../timeout';
-import { MongoDBNamespace } from '../utils';
-import { ModernizedCommandOperation } from './command';
+import { type MongoDBNamespace } from '../utils';
 
 /** @public */
 export type RunCommandOptions = {
@@ -27,31 +22,33 @@ export type RunCommandOptions = {
   timeoutMS?: number;
   /** @internal */
   omitMaxTimeMS?: boolean;
+
+  /**
+   * @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 ModernizedCommandOperation<T> {
+export class RunCommandOperation<T = Document> extends ModernizedOperation<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 }
-  ) {
-    super(undefined, options);
+  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 buildCommandDocument(_connection: Connection, _session?: ClientSession): Document {
+  override buildCommand(_connection: Connection, _session?: ClientSession): Document {
     return this.command;
   }
 
@@ -79,37 +76,3 @@ export class RunCursorCommandOperation extends RunCommandOperation {
     return response;
   }
 }
-
-export class RunAdminCommandOperation<T = Document> extends ModernizedCommandOperation<T> {
-  override SERVER_COMMAND_RESPONSE_TYPE = MongoDBResponse;
-  command: Document;
-  override options: RunCommandOptions & {
-    noResponse?: boolean;
-    bypassPinningCheck?: boolean;
-  };
-
-  constructor(
-    command: Document,
-    options: RunCommandOptions & {
-      noResponse?: boolean;
-      bypassPinningCheck?: boolean;
-    }
-  ) {
-    super(undefined, options);
-    this.command = command;
-    this.options = options;
-    this.ns = new MongoDBNamespace('admin', '$cmd');
-  }
-
-  override get commandName() {
-    return 'runCommand' as const;
-  }
-
-  override buildCommandDocument(_connection: Connection, _session?: ClientSession): Document {
-    return this.command;
-  }
-
-  override buildOptions(timeoutContext: TimeoutContext): ServerCommandOptions {
-    return { session: this.session, timeoutContext, noResponse: this.options.noResponse };
-  }
-}

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

test/integration/crud/abstract_operation.test.ts

@@ -192,12 +192,6 @@ describe('abstract operation', function () {
         subclassType: mongodb.RunCommandOperation,
         correctCommandName: 'runCommand'
       },
-      {
-        subclassCreator: () =>
-          new mongodb.RunAdminCommandOperation({ dummyCommand: 'dummyCommand' }, {}),
-        subclassType: mongodb.RunAdminCommandOperation,
-        correctCommandName: 'runCommand'
-      },
       {
         subclassCreator: () =>
           new mongodb.CreateSearchIndexesOperation(collection, [{ definition: { a: 1 } }]),