mongodb 6.10.0-dev.20241106.sha.dc3fe957 → 6.10.0-dev.20241108.sha.fd7acde6

package/src/operations/estimated_document_count.ts

@@ -2,6 +2,7 @@ import type { Document } from '../bson';
 import type { Collection } from '../collection';
 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';
 
@@ -30,7 +31,11 @@ export class EstimatedDocumentCountOperation extends CommandOperation<number> {
     return 'count' as const;
   }
 
-  override async execute(server: Server, session: ClientSession | undefined): Promise<number> {
+  override async execute(
+    server: Server,
+    session: ClientSession | undefined,
+    timeoutContext: TimeoutContext
+  ): Promise<number> {
     const cmd: Document = { count: this.collectionName };
 
     if (typeof this.options.maxTimeMS === 'number') {
@@ -43,7 +48,7 @@ export class EstimatedDocumentCountOperation extends CommandOperation<number> {
       cmd.comment = this.options.comment;
     }
 
-    const response = await super.executeCommand(server, session, cmd);
+    const response = await super.executeCommand(server, session, cmd, timeoutContext);
 
     return response?.n || 0;
   }

package/src/operations/execute_operation.ts

@@ -24,6 +24,7 @@ import {
 } from '../sdam/server_selection';
 import type { Topology } from '../sdam/topology';
 import type { ClientSession } from '../sessions';
+import { TimeoutContext } from '../timeout';
 import { supportsRetryableWrites } from '../utils';
 import { AbstractOperation, Aspect } from './operation';
 
@@ -57,7 +58,7 @@ type ResultTypeFromOperation<TOperation> =
 export async function executeOperation<
   T extends AbstractOperation<TResult>,
   TResult = ResultTypeFromOperation<T>
->(client: MongoClient, operation: T): Promise<TResult> {
+>(client: MongoClient, operation: T, timeoutContext?: TimeoutContext | null): Promise<TResult> {
   if (!(operation instanceof AbstractOperation)) {
     // TODO(NODE-3483): Extend MongoRuntimeError
     throw new MongoRuntimeError('This method requires a valid operation instance');
@@ -80,11 +81,6 @@ export async function executeOperation<
   } else if (session.client !== client) {
     throw new MongoInvalidArgumentError('ClientSession must be from the same MongoClient');
   }
-  if (session.explicit && session?.timeoutMS != null && operation.options.timeoutMS != null) {
-    throw new MongoInvalidArgumentError(
-      'Do not specify timeoutMS on operation if already specified on an explicit session'
-    );
-  }
 
   const readPreference = operation.readPreference ?? ReadPreference.primary;
   const inTransaction = !!session?.inTransaction();
@@ -105,9 +101,17 @@ export async function executeOperation<
     session.unpin();
   }
 
+  timeoutContext ??= TimeoutContext.create({
+    session,
+    serverSelectionTimeoutMS: client.s.options.serverSelectionTimeoutMS,
+    waitQueueTimeoutMS: client.s.options.waitQueueTimeoutMS,
+    timeoutMS: operation.options.timeoutMS
+  });
+
   try {
     return await tryOperation(operation, {
       topology,
+      timeoutContext,
       session,
       readPreference
     });
@@ -148,6 +152,7 @@ type RetryOptions = {
   session: ClientSession | undefined;
   readPreference: ReadPreference;
   topology: Topology;
+  timeoutContext: TimeoutContext;
 };
 
 /**
@@ -171,7 +176,10 @@ type RetryOptions = {
 async function tryOperation<
   T extends AbstractOperation<TResult>,
   TResult = ResultTypeFromOperation<T>
->(operation: T, { topology, session, readPreference }: RetryOptions): Promise<TResult> {
+>(
+  operation: T,
+  { topology, timeoutContext, session, readPreference }: RetryOptions
+): Promise<TResult> {
   let selector: ReadPreference | ServerSelector;
 
   if (operation.hasAspect(Aspect.MUST_SELECT_SAME_SERVER)) {
@@ -189,7 +197,8 @@ async function tryOperation<
 
   let server = await topology.selectServer(selector, {
     session,
-    operationName: operation.commandName
+    operationName: operation.commandName,
+    timeoutContext
   });
 
   const hasReadAspect = operation.hasAspect(Aspect.READ_OPERATION);
@@ -214,12 +223,10 @@ async function tryOperation<
     session.incrementTransactionNumber();
   }
 
-  // TODO(NODE-6231): implement infinite retry within CSOT timeout here
-  const maxTries = willRetry ? 2 : 1;
+  const maxTries = willRetry ? (timeoutContext.csotEnabled() ? Infinity : 2) : 1;
   let previousOperationError: MongoError | undefined;
   let previousServer: ServerDescription | undefined;
 
-  // TODO(NODE-6231): implement infinite retry within CSOT timeout here
   for (let tries = 0; tries < maxTries; tries++) {
     if (previousOperationError) {
       if (hasWriteAspect && previousOperationError.code === MMAPv1_RETRY_WRITES_ERROR_CODE) {
@@ -268,10 +275,9 @@ async function tryOperation<
       if (tries > 0 && operation.hasAspect(Aspect.COMMAND_BATCHING)) {
         operation.resetBatch();
       }
-      return await operation.execute(server, session);
+      return await operation.execute(server, session, timeoutContext);
     } catch (operationError) {
       if (!(operationError instanceof MongoError)) throw operationError;
-
       if (
         previousOperationError != null &&
         operationError.hasErrorLabel(MongoErrorLabel.NoWritesPerformed)
@@ -280,6 +286,9 @@ async function tryOperation<
       }
       previousServer = server.description;
       previousOperationError = operationError;
+
+      // Reset timeouts
+      timeoutContext.clear();
     }
   }
 

package/src/operations/find.ts

@@ -1,12 +1,18 @@
 import type { Document } from '../bson';
 import { CursorResponse, ExplainedCursorResponse } from '../cmap/wire_protocol/responses';
+import { type AbstractCursorOptions, type CursorTimeoutMode } from '../cursor/abstract_cursor';
 import { MongoInvalidArgumentError } from '../error';
-import { type ExplainOptions } from '../explain';
+import {
+  decorateWithExplain,
+  type ExplainOptions,
+  validateExplainTimeoutOptions
+} from '../explain';
 import { ReadConcern } from '../read_concern';
 import type { Server } from '../sdam/server';
 import type { ClientSession } from '../sessions';
 import { formatSort, type Sort } from '../sort';
-import { decorateWithExplain, type MongoDBNamespace, normalizeHintField } from '../utils';
+import { type TimeoutContext } from '../timeout';
+import { type MongoDBNamespace, normalizeHintField } from '../utils';
 import { type CollationOptions, CommandOperation, type CommandOperationOptions } from './command';
 import { Aspect, defineAspects, type Hint } from './operation';
 
@@ -16,7 +22,8 @@ import { Aspect, defineAspects, type Hint } from './operation';
  */
 // eslint-disable-next-line @typescript-eslint/no-unused-vars
 export interface FindOptions<TSchema extends Document = Document>
-  extends Omit<CommandOperationOptions, 'writeConcern' | 'explain'> {
+  extends Omit<CommandOperationOptions, 'writeConcern' | 'explain'>,
+    AbstractCursorOptions {
   /** Sets the limit of documents returned in the query. */
   limit?: number;
   /** Set to sort the documents coming back from the query. Array of indexes, `[['a', 1]]` etc. */
@@ -70,6 +77,8 @@ export interface FindOptions<TSchema extends Document = Document>
    * @deprecated This API is deprecated in favor of `collection.find().explain()`.
    */
   explain?: ExplainOptions['explain'];
+  /** @internal*/
+  timeoutMode?: CursorTimeoutMode;
 }
 
 /** @internal */
@@ -105,7 +114,8 @@ export class FindOperation extends CommandOperation<CursorResponse> {
 
   override async execute(
     server: Server,
-    session: ClientSession | undefined
+    session: ClientSession | undefined,
+    timeoutContext: TimeoutContext
   ): Promise<CursorResponse> {
     this.server = server;
 
@@ -113,6 +123,7 @@ export class FindOperation extends CommandOperation<CursorResponse> {
 
     let findCommand = makeFindCommand(this.ns, this.filter, options);
     if (this.explain) {
+      validateExplainTimeoutOptions(this.options, this.explain);
       findCommand = decorateWithExplain(findCommand, this.explain);
     }
 
@@ -123,7 +134,8 @@ export class FindOperation extends CommandOperation<CursorResponse> {
         ...this.options,
         ...this.bsonOptions,
         documentsReturnedIn: 'firstBatch',
-        session
+        session,
+        timeoutContext
       },
       this.explain ? ExplainedCursorResponse : CursorResponse
     );

package/src/operations/find_and_modify.ts

@@ -5,6 +5,7 @@ import { ReadPreference } from '../read_preference';
 import type { Server } from '../sdam/server';
 import type { ClientSession } from '../sessions';
 import { formatSort, type Sort, type SortForCmd } from '../sort';
+import { type TimeoutContext } from '../timeout';
 import { decorateWithCollation, hasAtomicOperators, maxWireVersion } from '../utils';
 import { type WriteConcern, type WriteConcernSettings } from '../write_concern';
 import { CommandOperation, type CommandOperationOptions } from './command';
@@ -180,7 +181,11 @@ export class FindAndModifyOperation extends CommandOperation<Document> {
     return 'findAndModify' as const;
   }
 
-  override async execute(server: Server, session: ClientSession | undefined): Promise<Document> {
+  override async execute(
+    server: Server,
+    session: ClientSession | undefined,
+    timeoutContext: TimeoutContext
+  ): Promise<Document> {
     const coll = this.collection;
     const query = this.query;
     const options = { ...this.options, ...this.bsonOptions };
@@ -208,7 +213,7 @@ export class FindAndModifyOperation extends CommandOperation<Document> {
     }
 
     // Execute the command
-    const result = await super.executeCommand(server, session, cmd);
+    const result = await super.executeCommand(server, session, cmd, timeoutContext);
     return options.includeResultMetadata ? result : (result.value ?? null);
   }
 }

package/src/operations/get_more.ts

@@ -3,6 +3,7 @@ import { CursorResponse } from '../cmap/wire_protocol/responses';
 import { MongoRuntimeError } from '../error';
 import type { Server } from '../sdam/server';
 import type { ClientSession } from '../sessions';
+import { type TimeoutContext } from '../timeout';
 import { maxWireVersion, type MongoDBNamespace } from '../utils';
 import { AbstractOperation, Aspect, defineAspects, type OperationOptions } from './operation';
 
@@ -58,7 +59,8 @@ export class GetMoreOperation extends AbstractOperation {
    */
   override async execute(
     server: Server,
-    _session: ClientSession | undefined
+    _session: ClientSession | undefined,
+    timeoutContext: TimeoutContext
   ): Promise<CursorResponse> {
     if (server !== this.server) {
       throw new MongoRuntimeError('Getmore must run on the same server operation began on');
@@ -97,6 +99,7 @@ export class GetMoreOperation extends AbstractOperation {
     const commandOptions = {
       returnFieldSelector: null,
       documentsReturnedIn: 'nextBatch',
+      timeoutContext,
       ...this.options
     };
 

package/src/operations/indexes.ts

@@ -6,6 +6,7 @@ import { MongoCompatibilityError } from '../error';
 import { type OneOrMore } from '../mongo_types';
 import type { Server } from '../sdam/server';
 import type { ClientSession } from '../sessions';
+import { type TimeoutContext } from '../timeout';
 import { isObject, maxWireVersion, type MongoDBNamespace } from '../utils';
 import {
   type CollationOptions,
@@ -296,7 +297,11 @@ export class CreateIndexesOperation extends CommandOperation<string[]> {
     return 'createIndexes';
   }
 
-  override async execute(server: Server, session: ClientSession | undefined): Promise<string[]> {
+  override async execute(
+    server: Server,
+    session: ClientSession | undefined,
+    timeoutContext: TimeoutContext
+  ): Promise<string[]> {
     const options = this.options;
     const indexes = this.indexes;
 
@@ -316,7 +321,7 @@ export class CreateIndexesOperation extends CommandOperation<string[]> {
     // collation is set on each index, it should not be defined at the root
     this.options.collation = undefined;
 
-    await super.executeCommand(server, session, cmd);
+    await super.executeCommand(server, session, cmd, timeoutContext);
 
     const indexNames = indexes.map(index => index.name || '');
     return indexNames;
@@ -344,14 +349,21 @@ export class DropIndexOperation extends CommandOperation<Document> {
     return 'dropIndexes' as const;
   }
 
-  override async execute(server: Server, session: ClientSession | undefined): Promise<Document> {
+  override async execute(
+    server: Server,
+    session: ClientSession | undefined,
+    timeoutContext: TimeoutContext
+  ): Promise<Document> {
     const cmd = { dropIndexes: this.collection.collectionName, index: this.indexName };
-    return await super.executeCommand(server, session, cmd);
+    return await super.executeCommand(server, session, cmd, timeoutContext);
   }
 }
 
 /** @public */
-export type ListIndexesOptions = AbstractCursorOptions;
+export type ListIndexesOptions = AbstractCursorOptions & {
+  /** @internal */
+  omitMaxTimeMS?: boolean;
+};
 
 /** @internal */
 export class ListIndexesOperation extends CommandOperation<CursorResponse> {
@@ -379,7 +391,8 @@ export class ListIndexesOperation extends CommandOperation<CursorResponse> {
 
   override async execute(
     server: Server,
-    session: ClientSession | undefined
+    session: ClientSession | undefined,
+    timeoutContext: TimeoutContext
   ): Promise<CursorResponse> {
     const serverWireVersion = maxWireVersion(server);
 
@@ -393,7 +406,7 @@ export class ListIndexesOperation extends CommandOperation<CursorResponse> {
       command.comment = this.options.comment;
     }
 
-    return await super.executeCommand(server, session, command, CursorResponse);
+    return await super.executeCommand(server, session, command, timeoutContext, CursorResponse);
   }
 }
 

package/src/operations/insert.ts

@@ -5,6 +5,7 @@ import { MongoInvalidArgumentError, MongoServerError } from '../error';
 import type { InferIdType } from '../mongo_types';
 import type { Server } from '../sdam/server';
 import type { ClientSession } from '../sessions';
+import { type TimeoutContext } from '../timeout';
 import { maybeAddIdToDocuments, type MongoDBNamespace } from '../utils';
 import { WriteConcern } from '../write_concern';
 import { BulkWriteOperation } from './bulk_write';
@@ -27,7 +28,11 @@ export class InsertOperation extends CommandOperation<Document> {
     return 'insert' as const;
   }
 
-  override async execute(server: Server, session: ClientSession | undefined): Promise<Document> {
+  override async execute(
+    server: Server,
+    session: ClientSession | undefined,
+    timeoutContext: TimeoutContext
+  ): Promise<Document> {
     const options = this.options ?? {};
     const ordered = typeof options.ordered === 'boolean' ? options.ordered : true;
     const command: Document = {
@@ -46,7 +51,7 @@ export class InsertOperation extends CommandOperation<Document> {
       command.comment = options.comment;
     }
 
-    return await super.executeCommand(server, session, command);
+    return await super.executeCommand(server, session, command, timeoutContext);
   }
 }
 
@@ -73,9 +78,10 @@ export class InsertOneOperation extends InsertOperation {
 
   override async execute(
     server: Server,
-    session: ClientSession | undefined
+    session: ClientSession | undefined,
+    timeoutContext: TimeoutContext
   ): Promise<InsertOneResult> {
-    const res = await super.execute(server, session);
+    const res = await super.execute(server, session, timeoutContext);
     if (res.code) throw new MongoServerError(res);
     if (res.writeErrors) {
       // This should be a WriteError but we can't change it now because of error hierarchy
@@ -123,7 +129,8 @@ export class InsertManyOperation extends AbstractOperation<InsertManyResult> {
 
   override async execute(
     server: Server,
-    session: ClientSession | undefined
+    session: ClientSession | undefined,
+    timeoutContext: TimeoutContext
   ): Promise<InsertManyResult> {
     const coll = this.collection;
     const options = { ...this.options, ...this.bsonOptions, readPreference: this.readPreference };
@@ -137,7 +144,7 @@ export class InsertManyOperation extends AbstractOperation<InsertManyResult> {
     );
 
     try {
-      const res = await bulkWriteOperation.execute(server, session);
+      const res = await bulkWriteOperation.execute(server, session, timeoutContext);
       return {
         acknowledged: writeConcern?.w !== 0,
         insertedCount: res.insertedCount,

package/src/operations/kill_cursors.ts

@@ -2,6 +2,7 @@ import type { Long } from '../bson';
 import { MongoRuntimeError } from '../error';
 import type { Server } from '../sdam/server';
 import type { ClientSession } from '../sessions';
+import { type TimeoutContext } from '../timeout';
 import { type MongoDBNamespace, squashError } from '../utils';
 import { AbstractOperation, Aspect, defineAspects, type OperationOptions } from './operation';
 
@@ -29,7 +30,11 @@ export class KillCursorsOperation extends AbstractOperation {
     return 'killCursors' as const;
   }
 
-  override async execute(server: Server, session: ClientSession | undefined): Promise<void> {
+  override async execute(
+    server: Server,
+    session: ClientSession | undefined,
+    timeoutContext: TimeoutContext
+  ): Promise<void> {
     if (server !== this.server) {
       throw new MongoRuntimeError('Killcursor must run on the same server operation began on');
     }
@@ -46,7 +51,10 @@ export class KillCursorsOperation extends AbstractOperation {
       cursors: [this.cursorId]
     };
     try {
-      await server.command(this.ns, killCursorsCommand, { session });
+      await server.command(this.ns, killCursorsCommand, {
+        session,
+        timeoutContext
+      });
     } catch (error) {
       // The driver should never emit errors from killCursors, this is spec-ed behavior
       squashError(error);

package/src/operations/list_collections.ts

@@ -1,8 +1,10 @@
 import type { Binary, Document } from '../bson';
 import { CursorResponse } from '../cmap/wire_protocol/responses';
+import { type CursorTimeoutContext, type CursorTimeoutMode } from '../cursor/abstract_cursor';
 import type { Db } from '../db';
 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';
@@ -15,6 +17,11 @@ export interface ListCollectionsOptions extends Omit<CommandOperationOptions, 'w
   authorizedCollections?: boolean;
   /** The batchSize for the returned command cursor or if pre 2.8 the systems batch collection */
   batchSize?: number;
+  /** @internal */
+  timeoutMode?: CursorTimeoutMode;
+
+  /** @internal */
+  timeoutContext?: CursorTimeoutContext;
 }
 
 /** @internal */
@@ -54,12 +61,14 @@ export class ListCollectionsOperation extends CommandOperation<CursorResponse> {
 
   override async execute(
     server: Server,
-    session: ClientSession | undefined
+    session: ClientSession | undefined,
+    timeoutContext: TimeoutContext
   ): Promise<CursorResponse> {
     return await super.executeCommand(
       server,
       session,
       this.generateCommand(maxWireVersion(server)),
+      timeoutContext,
       CursorResponse
     );
   }

package/src/operations/list_databases.ts

@@ -3,6 +3,7 @@ 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';
@@ -41,7 +42,8 @@ export class ListDatabasesOperation extends CommandOperation<ListDatabasesResult
 
   override async execute(
     server: Server,
-    session: ClientSession | undefined
+    session: ClientSession | undefined,
+    timeoutContext: TimeoutContext
   ): Promise<ListDatabasesResult> {
     const cmd: Document = { listDatabases: 1 };
 
@@ -63,7 +65,12 @@ export class ListDatabasesOperation extends CommandOperation<ListDatabasesResult
       cmd.comment = this.options.comment;
     }
 
-    return await (super.executeCommand(server, session, cmd) as Promise<TODO_NODE_3286>);
+    return await (super.executeCommand(
+      server,
+      session,
+      cmd,
+      timeoutContext
+    ) as Promise<TODO_NODE_3286>);
   }
 }
 

package/src/operations/operation.ts

@@ -2,6 +2,7 @@ import { type BSONSerializeOptions, type Document, resolveBSONOptions } from '..
 import { ReadPreference, type ReadPreferenceLike } from '../read_preference';
 import type { Server } from '../sdam/server';
 import type { ClientSession } from '../sessions';
+import { type TimeoutContext } from '../timeout';
 import type { MongoDBNamespace } from '../utils';
 
 export const Aspect = {
@@ -31,7 +32,13 @@ export interface OperationOptions extends BSONSerializeOptions {
   bypassPinningCheck?: boolean;
   omitReadPreference?: boolean;
 
-  /** @internal TODO(NODE-5688): make this public */
+  /** @internal Hint to `executeOperation` to omit maxTimeMS */
+  omitMaxTimeMS?: boolean;
+
+  /**
+   * @experimental
+   * Specifies the time an operation will run until it throws a timeout error
+   */
   timeoutMS?: number;
 }
 
@@ -57,6 +64,9 @@ export abstract class AbstractOperation<TResult = any> {
 
   options: OperationOptions;
 
+  /** Specifies the time an operation will run until it throws a timeout error. */
+  timeoutMS?: number;
+
   [kSession]: ClientSession | undefined;
 
   static aspects?: Set<symbol>;
@@ -80,7 +90,11 @@ export abstract class AbstractOperation<TResult = any> {
   Command name should be stateless (should not use 'this' keyword) */
   abstract get commandName(): string;
 
-  abstract execute(server: Server, session: ClientSession | undefined): Promise<TResult>;
+  abstract execute(
+    server: Server,
+    session: ClientSession | undefined,
+    timeoutContext: TimeoutContext
+  ): Promise<TResult>;
 
   hasAspect(aspect: symbol): boolean {
     const ctor = this.constructor as { aspects?: Set<symbol> };

package/src/operations/profiling_level.ts

@@ -2,6 +2,7 @@ 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 */
@@ -20,8 +21,12 @@ export class ProfilingLevelOperation extends CommandOperation<string> {
     return 'profile' as const;
   }
 
-  override async execute(server: Server, session: ClientSession | undefined): Promise<string> {
-    const doc = await super.executeCommand(server, session, { profile: -1 });
+  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;
       if (was === 0) return 'off';

package/src/operations/remove_user.ts

@@ -1,6 +1,7 @@
 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';
 
@@ -22,8 +23,12 @@ export class RemoveUserOperation extends CommandOperation<boolean> {
     return 'dropUser' as const;
   }
 
-  override async execute(server: Server, session: ClientSession | undefined): Promise<boolean> {
-    await super.executeCommand(server, session, { dropUser: this.username });
+  override async execute(
+    server: Server,
+    session: ClientSession | undefined,
+    timeoutContext: TimeoutContext
+  ): Promise<boolean> {
+    await super.executeCommand(server, session, { dropUser: this.username }, timeoutContext);
     return true;
   }
 }

package/src/operations/rename.ts

@@ -2,6 +2,7 @@ import type { Document } from '../bson';
 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';
@@ -29,7 +30,11 @@ export class RenameOperation extends CommandOperation<Document> {
     return 'renameCollection' as const;
   }
 
-  override async execute(server: Server, session: ClientSession | undefined): Promise<Collection> {
+  override async execute(
+    server: Server,
+    session: ClientSession | undefined,
+    timeoutContext: TimeoutContext
+  ): Promise<Collection> {
     // Build the command
     const renameCollection = this.collection.namespace;
     const toCollection = this.collection.s.namespace.withCollection(this.newName).toString();
@@ -42,7 +47,7 @@ export class RenameOperation extends CommandOperation<Document> {
       dropTarget: dropTarget
     };
 
-    await super.executeCommand(server, session, command);
+    await super.executeCommand(server, session, command, timeoutContext);
     return new Collection(this.collection.s.db, this.newName, this.collection.s.options);
   }
 }