mongodb 6.3.0 → 6.4.0

package/src/mongo_types.ts

@@ -12,7 +12,16 @@ import type {
   ObjectId,
   Timestamp
 } from './bson';
-import type { MongoLoggableComponent, MongoLogger } from './mongo_logger';
+import { type CommandStartedEvent } from './cmap/command_monitoring_events';
+import {
+  type LoggableCommandFailedEvent,
+  type LoggableCommandSucceededEvent,
+  type LoggableServerHeartbeatFailedEvent,
+  type LoggableServerHeartbeatStartedEvent,
+  type LoggableServerHeartbeatSucceededEvent,
+  MongoLoggableComponent,
+  type MongoLogger
+} from './mongo_logger';
 import type { Sort } from './sort';
 
 /** @internal */
@@ -237,7 +246,11 @@ export type SetFields<TSchema> = ({
   readonly [key in KeysOfAType<TSchema, ReadonlyArray<any> | undefined>]?:
     | OptionalId<Flatten<TSchema[key]>>
     | AddToSetOperators<Array<OptionalId<Flatten<TSchema[key]>>>>;
-} & NotAcceptedFields<TSchema, ReadonlyArray<any> | undefined>) & {
+} & IsAny<
+  TSchema[keyof TSchema],
+  object,
+  NotAcceptedFields<TSchema, ReadonlyArray<any> | undefined>
+>) & {
   readonly [key: string]: AddToSetOperators<any> | any;
 };
 
@@ -405,13 +418,55 @@ export class TypedEventEmitter<Events extends EventsDescription> extends EventEm
   /** @internal */
   protected component?: MongoLoggableComponent;
   /** @internal */
-  protected emitAndLog<EventKey extends keyof Events>(
+  emitAndLog<EventKey extends keyof Events>(
     event: EventKey | symbol,
     ...args: Parameters<Events[EventKey]>
   ): void {
     this.emit(event, ...args);
     if (this.component) this.mongoLogger?.debug(this.component, args[0]);
   }
+  /** @internal */
+  emitAndLogHeartbeat<EventKey extends keyof Events>(
+    event: EventKey | symbol,
+    topologyId: number,
+    serverConnectionId?: number | '<monitor>',
+    ...args: Parameters<Events[EventKey]>
+  ): void {
+    this.emit(event, ...args);
+    if (this.component) {
+      const loggableHeartbeatEvent:
+        | LoggableServerHeartbeatFailedEvent
+        | LoggableServerHeartbeatSucceededEvent
+        | LoggableServerHeartbeatStartedEvent = {
+        topologyId: topologyId,
+        serverConnectionId: serverConnectionId ?? null,
+        ...args[0]
+      };
+      this.mongoLogger?.debug(this.component, loggableHeartbeatEvent);
+    }
+  }
+  /** @internal */
+  emitAndLogCommand<EventKey extends keyof Events>(
+    monitorCommands: boolean,
+    event: EventKey | symbol,
+    databaseName: string,
+    connectionEstablished: boolean,
+    ...args: Parameters<Events[EventKey]>
+  ): void {
+    if (monitorCommands) {
+      this.emit(event, ...args);
+    }
+    if (connectionEstablished) {
+      const loggableCommandEvent:
+        | CommandStartedEvent
+        | LoggableCommandFailedEvent
+        | LoggableCommandSucceededEvent = {
+        databaseName: databaseName,
+        ...args[0]
+      };
+      this.mongoLogger?.debug(MongoLoggableComponent.COMMAND, loggableCommandEvent);
+    }
+  }
 }
 
 /** @public */

package/src/operations/aggregate.ts

@@ -82,6 +82,10 @@ export class AggregateOperation<T = Document> extends CommandOperation<T> {
     }
   }
 
+  override get commandName() {
+    return 'aggregate' as const;
+  }
+
   override get canRetryRead(): boolean {
     return !this.hasWriteStage;
   }

package/src/operations/bulk_write.ts

@@ -26,6 +26,10 @@ export class BulkWriteOperation extends AbstractOperation<BulkWriteResult> {
     this.operations = operations;
   }
 
+  override get commandName() {
+    return 'bulkWrite' as const;
+  }
+
   override async execute(
     server: Server,
     session: ClientSession | undefined

package/src/operations/collections.ts

@@ -19,6 +19,10 @@ export class CollectionsOperation extends AbstractOperation<Collection[]> {
     this.db = db;
   }
 
+  override get commandName() {
+    return 'listCollections' as const;
+  }
+
   override async execute(
     server: Server,
     session: ClientSession | undefined

package/src/operations/command.ts

@@ -152,6 +152,6 @@ export abstract class CommandOperation<T> extends AbstractOperation<T> {
       cmd = decorateWithExplain(cmd, this.explain);
     }
 
-    return server.commandAsync(this.ns, cmd, options);
+    return server.command(this.ns, cmd, options);
   }
 }

package/src/operations/count.ts

@@ -32,6 +32,10 @@ export class CountOperation extends CommandOperation<number> {
     this.query = filter;
   }
 
+  override get commandName() {
+    return 'count' as const;
+  }
+
   override async execute(server: Server, session: ClientSession | undefined): Promise<number> {
     const options = this.options;
     const cmd: Document = {

package/src/operations/create_collection.ts

@@ -120,6 +120,10 @@ export class CreateCollectionOperation extends CommandOperation<Collection> {
     this.name = name;
   }
 
+  override get commandName() {
+    return 'create' as const;
+  }
+
   override async execute(server: Server, session: ClientSession | undefined): Promise<Collection> {
     const db = this.db;
     const name = this.name;

package/src/operations/delete.ts

@@ -53,6 +53,10 @@ export class DeleteOperation extends CommandOperation<DeleteResult> {
     this.statements = statements;
   }
 
+  override get commandName() {
+    return 'delete' as const;
+  }
+
   override get canRetryWrite(): boolean {
     if (super.canRetryWrite === false) {
       return false;

package/src/operations/distinct.ts

@@ -38,6 +38,10 @@ export class DistinctOperation extends CommandOperation<any[]> {
     this.query = query;
   }
 
+  override get commandName() {
+    return 'distinct' as const;
+  }
+
   override async execute(server: Server, session: ClientSession | undefined): Promise<any[]> {
     const coll = this.collection;
     const key = this.key;

package/src/operations/drop.ts

@@ -25,6 +25,10 @@ export class DropCollectionOperation extends CommandOperation<boolean> {
     this.name = name;
   }
 
+  override get commandName() {
+    return 'drop' as const;
+  }
+
   override async execute(server: Server, session: ClientSession | undefined): Promise<boolean> {
     const db = this.db;
     const options = this.options;
@@ -88,6 +92,10 @@ export class DropDatabaseOperation extends CommandOperation<boolean> {
     super(db, options);
     this.options = options;
   }
+  override get commandName() {
+    return 'dropDatabase' as const;
+  }
+
   override async execute(server: Server, session: ClientSession | undefined): Promise<boolean> {
     await super.executeCommand(server, session, { dropDatabase: 1 });
     return true;

package/src/operations/estimated_document_count.ts

@@ -26,6 +26,10 @@ export class EstimatedDocumentCountOperation extends CommandOperation<number> {
     this.collectionName = collection.collectionName;
   }
 
+  override get commandName() {
+    return 'count' as const;
+  }
+
   override async execute(server: Server, session: ClientSession | undefined): Promise<number> {
     const cmd: Document = { count: this.collectionName };
 

package/src/operations/execute_operation.ts

@@ -18,6 +18,7 @@ import {
 import type { MongoClient } from '../mongo_client';
 import { ReadPreference } from '../read_preference';
 import type { Server } from '../sdam/server';
+import type { ServerDescription } from '../sdam/server_description';
 import {
   sameServerSelector,
   secondaryWritableServerSelector,
@@ -25,7 +26,7 @@ import {
 } from '../sdam/server_selection';
 import type { Topology } from '../sdam/topology';
 import type { ClientSession } from '../sessions';
-import { type Callback, maybeCallback, supportsRetryableWrites } from '../utils';
+import { supportsRetryableWrites } from '../utils';
 import { AbstractOperation, Aspect } from './operation';
 
 const MMAPv1_RETRY_WRITES_ERROR_CODE = MONGODB_ERROR_CODES.IllegalOperation;
@@ -51,36 +52,23 @@ export interface ExecutionResult {
  * @internal
  *
  * @remarks
- * This method reduces large amounts of duplication in the entire codebase by providing
- * a single point for determining whether callbacks or promises should be used. Additionally
- * it allows for a single point of entry to provide features such as implicit sessions, which
+ * Allows for a single point of entry to provide features such as implicit sessions, which
  * are required by the Driver Sessions specification in the event that a ClientSession is
- * not provided
+ * not provided.
  *
- * @param topology - The topology to execute this operation on
+ * The expectation is that this function:
+ * - Connects the MongoClient if it has not already been connected
+ * - Creates a session if none is provided and cleans up the session it creates
+ * - Selects a server based on readPreference or various factors
+ * - Retries an operation if it fails for certain errors, see {@link retryOperation}
+ *
+ * @typeParam T - The operation's type
+ * @typeParam TResult - The type of the operation's result, calculated from T
+ *
+ * @param client - The MongoClient to execute this operation with
  * @param operation - The operation to execute
- * @param callback - The command result callback
  */
-export function executeOperation<
-  T extends AbstractOperation<TResult>,
-  TResult = ResultTypeFromOperation<T>
->(client: MongoClient, operation: T): Promise<TResult>;
-export function executeOperation<
-  T extends AbstractOperation<TResult>,
-  TResult = ResultTypeFromOperation<T>
->(client: MongoClient, operation: T, callback: Callback<TResult>): void;
-export function executeOperation<
-  T extends AbstractOperation<TResult>,
-  TResult = ResultTypeFromOperation<T>
->(client: MongoClient, operation: T, callback?: Callback<TResult>): Promise<TResult> | void;
-export function executeOperation<
-  T extends AbstractOperation<TResult>,
-  TResult = ResultTypeFromOperation<T>
->(client: MongoClient, operation: T, callback?: Callback<TResult>): Promise<TResult> | void {
-  return maybeCallback(() => executeOperationAsync(client, operation), callback);
-}
-
-async function executeOperationAsync<
+export async function executeOperation<
   T extends AbstractOperation<TResult>,
   TResult = ResultTypeFromOperation<T>
 >(client: MongoClient, operation: T): Promise<TResult> {
@@ -151,7 +139,10 @@ async function executeOperationAsync<
     selector = readPreference;
   }
 
-  const server = await topology.selectServerAsync(selector, { session });
+  const server = await topology.selectServerAsync(selector, {
+    session,
+    operationName: operation.commandName
+  });
 
   if (session == null) {
     // No session also means it is not retryable, early exit
@@ -193,7 +184,8 @@ async function executeOperationAsync<
       return await retryOperation(operation, operationError, {
         session,
         topology,
-        selector
+        selector,
+        previousServer: server.description
       });
     }
     throw operationError;
@@ -209,6 +201,7 @@ type RetryOptions = {
   session: ClientSession;
   topology: Topology;
   selector: ReadPreference | ServerSelector;
+  previousServer: ServerDescription;
 };
 
 async function retryOperation<
@@ -217,7 +210,7 @@ async function retryOperation<
 >(
   operation: T,
   originalError: MongoError,
-  { session, topology, selector }: RetryOptions
+  { session, topology, selector, previousServer }: RetryOptions
 ): Promise<TResult> {
   const isWriteOperation = operation.hasAspect(Aspect.WRITE_OPERATION);
   const isReadOperation = operation.hasAspect(Aspect.READ_OPERATION);
@@ -251,7 +244,11 @@ async function retryOperation<
   }
 
   // select a new server, and attempt to retry the operation
-  const server = await topology.selectServerAsync(selector, { session });
+  const server = await topology.selectServerAsync(selector, {
+    session,
+    operationName: operation.commandName,
+    previousServer
+  });
 
   if (isWriteOperation && !supportsRetryableWrites(server)) {
     throw new MongoUnexpectedServerResponseError(

package/src/operations/find.ts

@@ -97,6 +97,10 @@ export class FindOperation extends CommandOperation<Document> {
     this.filter = filter != null && filter._bsontype === 'ObjectId' ? { _id: filter } : filter;
   }
 
+  override get commandName() {
+    return 'find' as const;
+  }
+
   override async execute(server: Server, session: ClientSession | undefined): Promise<Document> {
     this.server = server;
 
@@ -107,7 +111,7 @@ export class FindOperation extends CommandOperation<Document> {
       findCommand = decorateWithExplain(findCommand, this.explain);
     }
 
-    return server.commandAsync(this.ns, findCommand, {
+    return server.command(this.ns, findCommand, {
       ...this.options,
       ...this.bsonOptions,
       documentsReturnedIn: 'firstBatch',

package/src/operations/find_and_modify.ts

@@ -52,8 +52,7 @@ export interface FindOneAndReplaceOptions extends CommandOperationOptions {
   /** Map of parameter names and values that can be accessed using $$var (requires MongoDB 5.0). */
   let?: Document;
   /**
-   * Return the ModifyResult instead of the modified document. Defaults to true
-   * but will default to false in the next major version.
+   * Return the ModifyResult instead of the modified document. Defaults to false
    */
   includeResultMetadata?: boolean;
 }
@@ -77,8 +76,7 @@ export interface FindOneAndUpdateOptions extends CommandOperationOptions {
   /** Map of parameter names and values that can be accessed using $$var (requires MongoDB 5.0). */
   let?: Document;
   /**
-   * Return the ModifyResult instead of the modified document. Defaults to true
-   * but will default to false in the next major version.
+   * Return the ModifyResult instead of the modified document. Defaults to false
    */
   includeResultMetadata?: boolean;
 }
@@ -121,7 +119,7 @@ function configureFindAndModifyCmdBaseUpdateOpts(
 }
 
 /** @internal */
-class FindAndModifyOperation extends CommandOperation<Document> {
+export class FindAndModifyOperation extends CommandOperation<Document> {
   override options: FindOneAndReplaceOptions | FindOneAndUpdateOptions | FindOneAndDeleteOptions;
   cmdBase: FindAndModifyCmdBase;
   collection: Collection;
@@ -178,6 +176,10 @@ class FindAndModifyOperation extends CommandOperation<Document> {
     this.query = query;
   }
 
+  override get commandName() {
+    return 'findAndModify' as const;
+  }
+
   override async execute(server: Server, session: ClientSession | undefined): Promise<Document> {
     const coll = this.collection;
     const query = this.query;

package/src/operations/get_more.ts

@@ -48,6 +48,9 @@ export class GetMoreOperation extends AbstractOperation {
     this.server = server;
   }
 
+  override get commandName() {
+    return 'getMore' as const;
+  }
   /**
    * Although there is a server already associated with the get more operation, the signature
    * for execute passes a server so we will just use that one.
@@ -93,7 +96,7 @@ export class GetMoreOperation extends AbstractOperation {
       ...this.options
     };
 
-    return server.commandAsync(this.ns, getMoreCmd, commandOptions);
+    return server.command(this.ns, getMoreCmd, commandOptions);
   }
 }
 

package/src/operations/indexes.ts

@@ -186,6 +186,10 @@ export class IndexesOperation extends AbstractOperation<Document[]> {
     this.collection = collection;
   }
 
+  override get commandName() {
+    return 'listIndexes' as const;
+  }
+
   override async execute(_server: Server, session: ClientSession | undefined): Promise<Document[]> {
     const coll = this.collection;
     const options = this.options;
@@ -235,6 +239,10 @@ export class CreateIndexesOperation<
     });
   }
 
+  override get commandName() {
+    return 'createIndexes';
+  }
+
   override async execute(server: Server, session: ClientSession | undefined): Promise<T> {
     const options = this.options;
     const indexes = this.indexes;
@@ -272,6 +280,7 @@ export class CreateIndexOperation extends CreateIndexesOperation<string> {
   ) {
     super(parent, collectionName, [makeIndexSpec(indexSpec, options)], options);
   }
+
   override async execute(server: Server, session: ClientSession | undefined): Promise<string> {
     const indexNames = await super.execute(server, session);
     return indexNames[0];
@@ -295,6 +304,10 @@ export class EnsureIndexOperation extends CreateIndexOperation {
     this.collectionName = collectionName;
   }
 
+  override get commandName() {
+    return 'listIndexes';
+  }
+
   override async execute(server: Server, session: ClientSession | undefined): Promise<string> {
     const indexName = this.indexes[0].name;
     const indexes = await this.db
@@ -328,6 +341,10 @@ export class DropIndexOperation extends CommandOperation<Document> {
     this.indexName = indexName;
   }
 
+  override get commandName() {
+    return 'dropIndexes' as const;
+  }
+
   override async execute(server: Server, session: ClientSession | undefined): Promise<Document> {
     const cmd = { dropIndexes: this.collection.collectionName, index: this.indexName };
     return super.executeCommand(server, session, cmd);
@@ -360,6 +377,10 @@ export class ListIndexesOperation extends CommandOperation<Document> {
     this.collectionNamespace = collection.s.namespace;
   }
 
+  override get commandName() {
+    return 'listIndexes' as const;
+  }
+
   override async execute(server: Server, session: ClientSession | undefined): Promise<Document> {
     const serverWireVersion = maxWireVersion(server);
 
@@ -394,6 +415,10 @@ export class IndexExistsOperation extends AbstractOperation<boolean> {
     this.indexes = indexes;
   }
 
+  override get commandName() {
+    return 'listIndexes' as const;
+  }
+
   override async execute(server: Server, session: ClientSession | undefined): Promise<boolean> {
     const coll = this.collection;
     const indexes = this.indexes;
@@ -423,6 +448,10 @@ export class IndexInformationOperation extends AbstractOperation<Document> {
     this.name = name;
   }
 
+  override get commandName() {
+    return 'listIndexes' as const;
+  }
+
   override async execute(server: Server, session: ClientSession | undefined): Promise<Document> {
     const db = this.db;
     const name = this.name;

package/src/operations/insert.ts

@@ -24,6 +24,10 @@ export class InsertOperation extends CommandOperation<Document> {
     this.documents = documents;
   }
 
+  override get commandName() {
+    return 'insert' as const;
+  }
+
   override async execute(server: Server, session: ClientSession | undefined): Promise<Document> {
     const options = this.options ?? {};
     const ordered = typeof options.ordered === 'boolean' ? options.ordered : true;
@@ -114,6 +118,10 @@ export class InsertManyOperation extends AbstractOperation<InsertManyResult> {
     this.docs = docs;
   }
 
+  override get commandName() {
+    return 'insert' as const;
+  }
+
   override async execute(
     server: Server,
     session: ClientSession | undefined

package/src/operations/is_capped.ts

@@ -15,6 +15,10 @@ export class IsCappedOperation extends AbstractOperation<boolean> {
     this.collection = collection;
   }
 
+  override get commandName() {
+    return 'listCollections' as const;
+  }
+
   override async execute(server: Server, session: ClientSession | undefined): Promise<boolean> {
     const coll = this.collection;
     const [collection] = await coll.s.db

package/src/operations/kill_cursors.ts

@@ -25,6 +25,10 @@ export class KillCursorsOperation extends AbstractOperation {
     this.server = server;
   }
 
+  override get commandName() {
+    return 'killCursors' as const;
+  }
+
   override async execute(server: Server, session: ClientSession | undefined): Promise<void> {
     if (server !== this.server) {
       throw new MongoRuntimeError('Killcursor must run on the same server operation began on');
@@ -42,7 +46,7 @@ export class KillCursorsOperation extends AbstractOperation {
       cursors: [this.cursorId]
     };
     try {
-      await server.commandAsync(this.ns, killCursorsCommand, { session });
+      await server.command(this.ns, killCursorsCommand, { session });
     } catch {
       // The driver should never emit errors from killCursors, this is spec-ed behavior
     }

package/src/operations/list_collections.ts

@@ -47,6 +47,10 @@ export class ListCollectionsOperation extends CommandOperation<Document> {
     }
   }
 
+  override get commandName() {
+    return 'listCollections' as const;
+  }
+
   override async execute(server: Server, session: ClientSession | undefined): Promise<Document> {
     return super.executeCommand(server, session, this.generateCommand(maxWireVersion(server)));
   }

package/src/operations/list_databases.ts

@@ -35,6 +35,10 @@ export class ListDatabasesOperation extends CommandOperation<ListDatabasesResult
     this.ns = new MongoDBNamespace('admin', '$cmd');
   }
 
+  override get commandName() {
+    return 'listDatabases' as const;
+  }
+
   override async execute(
     server: Server,
     session: ClientSession | undefined

package/src/operations/operation.ts

@@ -75,6 +75,10 @@ export abstract class AbstractOperation<TResult = any> {
     this.trySecondaryWrite = false;
   }
 
+  /** Must match the first key of the command object sent to the server.
+  Command name should be stateless (should not use 'this' keyword) */
+  abstract get commandName(): string;
+
   abstract execute(server: Server, session: ClientSession | undefined): Promise<TResult>;
 
   hasAspect(aspect: symbol): boolean {

package/src/operations/options_operation.ts

@@ -15,6 +15,9 @@ export class OptionsOperation extends AbstractOperation<Document> {
     this.options = options;
     this.collection = collection;
   }
+  override get commandName() {
+    return 'listCollections' as const;
+  }
 
   override async execute(server: Server, session: ClientSession | undefined): Promise<Document> {
     const coll = this.collection;

package/src/operations/profiling_level.ts

@@ -16,6 +16,10 @@ export class ProfilingLevelOperation extends CommandOperation<string> {
     this.options = options;
   }
 
+  override get commandName() {
+    return 'profile' as const;
+  }
+
   override async execute(server: Server, session: ClientSession | undefined): Promise<string> {
     const doc = await super.executeCommand(server, session, { profile: -1 });
     if (doc.ok === 1) {

package/src/operations/remove_user.ts

@@ -18,6 +18,10 @@ export class RemoveUserOperation extends CommandOperation<boolean> {
     this.username = username;
   }
 
+  override get commandName() {
+    return 'dropUser' as const;
+  }
+
   override async execute(server: Server, session: ClientSession | undefined): Promise<boolean> {
     await super.executeCommand(server, session, { dropUser: this.username });
     return true;

package/src/operations/rename.ts

@@ -25,6 +25,10 @@ export class RenameOperation extends CommandOperation<Document> {
     this.ns = new MongoDBNamespace('admin', '$cmd');
   }
 
+  override get commandName(): string {
+    return 'renameCollection' as const;
+  }
+
   override async execute(server: Server, session: ClientSession | undefined): Promise<Collection> {
     // Build the command
     const renameCollection = this.collection.namespace;

package/src/operations/run_command.ts

@@ -22,9 +22,13 @@ export class RunCommandOperation<T = Document> extends AbstractOperation<T> {
     this.ns = parent.s.namespace.withCollection('$cmd');
   }
 
+  override get commandName() {
+    return 'runCommand' as const;
+  }
+
   override async execute(server: Server, session: ClientSession | undefined): Promise<T> {
     this.server = server;
-    return server.commandAsync(this.ns, this.command, {
+    return server.command(this.ns, this.command, {
       ...this.options,
       readPreference: this.readPreference,
       session
@@ -44,9 +48,13 @@ export class RunAdminCommandOperation<T = Document> extends AbstractOperation<T>
     this.ns = new MongoDBNamespace('admin', '$cmd');
   }
 
+  override get commandName() {
+    return 'runCommand' as const;
+  }
+
   override async execute(server: Server, session: ClientSession | undefined): Promise<T> {
     this.server = server;
-    return server.commandAsync(this.ns, this.command, {
+    return server.command(this.ns, this.command, {
       ...this.options,
       readPreference: this.readPreference,
       session