mongodb 6.18.0 → 6.19.0

package/src/operations/find_and_modify.ts

@@ -1,12 +1,12 @@
+import { type Connection } from '..';
 import type { Document } from '../bson';
+import { MongoDBResponse } from '../cmap/wire_protocol/responses';
 import type { Collection } from '../collection';
 import { MongoCompatibilityError, MongoInvalidArgumentError } from '../error';
 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 { decorateWithCollation, hasAtomicOperators } from '../utils';
 import { type WriteConcern, type WriteConcernSettings } from '../write_concern';
 import { CommandOperation, type CommandOperationOptions } from './command';
 import { Aspect, defineAspects } from './operation';
@@ -121,8 +121,8 @@ function configureFindAndModifyCmdBaseUpdateOpts(
 
 /** @internal */
 export class FindAndModifyOperation extends CommandOperation<Document> {
+  override SERVER_COMMAND_RESPONSE_TYPE = MongoDBResponse;
   override options: FindOneAndReplaceOptions | FindOneAndUpdateOptions | FindOneAndDeleteOptions;
-  cmdBase: FindAndModifyCmdBase;
   collection: Collection;
   query: Document;
   doc?: Document;
@@ -133,8 +133,26 @@ export class FindAndModifyOperation extends CommandOperation<Document> {
     options: FindOneAndReplaceOptions | FindOneAndUpdateOptions | FindOneAndDeleteOptions
   ) {
     super(collection, options);
-    this.options = options ?? {};
-    this.cmdBase = {
+    this.options = options;
+    // force primary read preference
+    this.readPreference = ReadPreference.primary;
+
+    this.collection = collection;
+    this.query = query;
+  }
+
+  override get commandName() {
+    return 'findAndModify' as const;
+  }
+
+  override buildCommandDocument(
+    _connection: Connection,
+    _session?: ClientSession
+  ): Document & FindAndModifyCmdBase {
+    const options = this.options;
+    const command: Document & FindAndModifyCmdBase = {
+      findAndModify: this.collection.collectionName,
+      query: this.query,
       remove: false,
       new: false,
       upsert: false
@@ -144,77 +162,51 @@ export class FindAndModifyOperation extends CommandOperation<Document> {
 
     const sort = formatSort(options.sort);
     if (sort) {
-      this.cmdBase.sort = sort;
+      command.sort = sort;
     }
 
     if (options.projection) {
-      this.cmdBase.fields = options.projection;
+      command.fields = options.projection;
     }
 
     if (options.maxTimeMS) {
-      this.cmdBase.maxTimeMS = options.maxTimeMS;
+      command.maxTimeMS = options.maxTimeMS;
     }
 
     // Decorate the findAndModify command with the write Concern
     if (options.writeConcern) {
-      this.cmdBase.writeConcern = options.writeConcern;
+      command.writeConcern = options.writeConcern;
     }
 
     if (options.let) {
-      this.cmdBase.let = options.let;
+      command.let = options.let;
     }
 
     // we check for undefined specifically here to allow falsy values
     // eslint-disable-next-line no-restricted-syntax
     if (options.comment !== undefined) {
-      this.cmdBase.comment = options.comment;
+      command.comment = options.comment;
     }
 
-    // force primary read preference
-    this.readPreference = ReadPreference.primary;
-
-    this.collection = collection;
-    this.query = query;
-  }
-
-  override get commandName() {
-    return 'findAndModify' as const;
-  }
-
-  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 };
-
-    // Create findAndModify command object
-    const cmd: Document = {
-      findAndModify: coll.collectionName,
-      query: query,
-      ...this.cmdBase
-    };
-
-    decorateWithCollation(cmd, coll, options);
+    decorateWithCollation(command, this.collection, options);
 
     if (options.hint) {
-      // TODO: once this method becomes a CommandOperation we will have the server
-      // in place to check.
       const unacknowledgedWrite = this.writeConcern?.w === 0;
-      if (unacknowledgedWrite || maxWireVersion(server) < 8) {
+      if (unacknowledgedWrite) {
         throw new MongoCompatibilityError(
           'The current topology does not support a hint on findAndModify commands'
         );
       }
 
-      cmd.hint = options.hint;
+      command.hint = options.hint;
     }
 
-    // Execute the command
-    const result = await super.executeCommand(server, session, cmd, timeoutContext);
-    return options.includeResultMetadata ? result : (result.value ?? null);
+    return command;
+  }
+
+  override handleOk(response: InstanceType<typeof this.SERVER_COMMAND_RESPONSE_TYPE>): Document {
+    const result = super.handleOk(response);
+    return this.options.includeResultMetadata ? result : (result.value ?? null);
   }
 }
 
@@ -227,12 +219,21 @@ export class FindOneAndDeleteOperation extends FindAndModifyOperation {
     }
 
     super(collection, filter, options);
-    this.cmdBase.remove = true;
+  }
+
+  override buildCommandDocument(
+    connection: Connection,
+    session?: ClientSession
+  ): Document & FindAndModifyCmdBase {
+    const document = super.buildCommandDocument(connection, session);
+    document.remove = true;
+    return document;
   }
 }
 
 /** @internal */
 export class FindOneAndReplaceOperation extends FindAndModifyOperation {
+  private replacement: Document;
   constructor(
     collection: Collection,
     filter: Document,
@@ -252,13 +253,25 @@ export class FindOneAndReplaceOperation extends FindAndModifyOperation {
     }
 
     super(collection, filter, options);
-    this.cmdBase.update = replacement;
-    configureFindAndModifyCmdBaseUpdateOpts(this.cmdBase, options);
+    this.replacement = replacement;
+  }
+
+  override buildCommandDocument(
+    connection: Connection,
+    session?: ClientSession
+  ): Document & FindAndModifyCmdBase {
+    const document = super.buildCommandDocument(connection, session);
+    document.update = this.replacement;
+    configureFindAndModifyCmdBaseUpdateOpts(document, this.options);
+    return document;
   }
 }
 
 /** @internal */
 export class FindOneAndUpdateOperation extends FindAndModifyOperation {
+  override options: FindOneAndUpdateOptions;
+
+  private update: Document;
   constructor(
     collection: Collection,
     filter: Document,
@@ -278,12 +291,23 @@ export class FindOneAndUpdateOperation extends FindAndModifyOperation {
     }
 
     super(collection, filter, options);
-    this.cmdBase.update = update;
-    configureFindAndModifyCmdBaseUpdateOpts(this.cmdBase, options);
+    this.update = update;
+    this.options = options;
+  }
 
-    if (options.arrayFilters) {
-      this.cmdBase.arrayFilters = options.arrayFilters;
+  override buildCommandDocument(
+    connection: Connection,
+    session?: ClientSession
+  ): Document & FindAndModifyCmdBase {
+    const document = super.buildCommandDocument(connection, session);
+    document.update = this.update;
+    configureFindAndModifyCmdBaseUpdateOpts(document, this.options);
+
+    if (this.options.arrayFilters) {
+      document.arrayFilters = this.options.arrayFilters;
     }
+
+    return document;
   }
 }
 

package/src/operations/get_more.ts

@@ -1,8 +1,8 @@
-import type { Long } from '../bson';
+import type { Document, Long } from '../bson';
+import { type Connection } from '../cmap/connection';
 import { CursorResponse } from '../cmap/wire_protocol/responses';
 import { MongoRuntimeError } from '../error';
-import type { Server } from '../sdam/server';
-import type { ClientSession } from '../sessions';
+import type { Server, ServerCommandOptions } from '../sdam/server';
 import { type TimeoutContext } from '../timeout';
 import { maxWireVersion, type MongoDBNamespace } from '../utils';
 import { AbstractOperation, Aspect, defineAspects, type OperationOptions } from './operation';
@@ -37,7 +37,8 @@ export interface GetMoreCommand {
 }
 
 /** @internal */
-export class GetMoreOperation extends AbstractOperation {
+export class GetMoreOperation extends AbstractOperation<CursorResponse> {
+  override SERVER_COMMAND_RESPONSE_TYPE = CursorResponse;
   cursorId: Long;
   override options: GetMoreOptions;
 
@@ -53,19 +54,8 @@ export class GetMoreOperation extends AbstractOperation {
   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.
-   */
-  override async execute(
-    server: Server,
-    _session: ClientSession | undefined,
-    timeoutContext: TimeoutContext
-  ): Promise<CursorResponse> {
-    if (server !== this.server) {
-      throw new MongoRuntimeError('Getmore must run on the same server operation began on');
-    }
 
+  override buildCommand(connection: Connection): Document {
     if (this.cursorId == null || this.cursorId.isZero()) {
       throw new MongoRuntimeError('Unable to iterate cursor with no id');
     }
@@ -92,18 +82,26 @@ export class GetMoreOperation extends AbstractOperation {
 
     // we check for undefined specifically here to allow falsy values
     // eslint-disable-next-line no-restricted-syntax
-    if (this.options.comment !== undefined && maxWireVersion(server) >= 9) {
+    if (this.options.comment !== undefined && maxWireVersion(connection) >= 9) {
       getMoreCmd.comment = this.options.comment;
     }
 
-    const commandOptions = {
+    return getMoreCmd;
+  }
+
+  override buildOptions(timeoutContext: TimeoutContext): ServerCommandOptions {
+    return {
       returnFieldSelector: null,
       documentsReturnedIn: 'nextBatch',
       timeoutContext,
       ...this.options
     };
+  }
 
-    return await server.command(this.ns, getMoreCmd, commandOptions, CursorResponse);
+  override handleOk(
+    response: InstanceType<typeof this.SERVER_COMMAND_RESPONSE_TYPE>
+  ): CursorResponse {
+    return response;
   }
 }
 

package/src/operations/indexes.ts

@@ -1,12 +1,10 @@
 import type { Document } from '../bson';
-import { CursorResponse } from '../cmap/wire_protocol/responses';
+import { type Connection } from '../cmap/connection';
+import { CursorResponse, MongoDBResponse } from '../cmap/wire_protocol/responses';
 import type { Collection } from '../collection';
 import { type AbstractCursorOptions } from '../cursor/abstract_cursor';
 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,
@@ -245,6 +243,7 @@ type ResolvedIndexDescription = Omit<IndexDescription, 'key' | 'version'> & {
 
 /** @internal */
 export class CreateIndexesOperation extends CommandOperation<string[]> {
+  override SERVER_COMMAND_RESPONSE_TYPE = MongoDBResponse;
   override options: CreateIndexesOptions;
   collectionName: string;
   indexes: ReadonlyArray<ResolvedIndexDescription>;
@@ -258,6 +257,8 @@ export class CreateIndexesOperation extends CommandOperation<string[]> {
     super(parent, options);
 
     this.options = options ?? {};
+    // collation is set on each index, it should not be defined at the root
+    this.options.collation = undefined;
     this.collectionName = collectionName;
     this.indexes = indexes.map((userIndex: IndexDescription): ResolvedIndexDescription => {
       // Ensure the key is a Map to preserve index key ordering
@@ -271,6 +272,7 @@ export class CreateIndexesOperation extends CommandOperation<string[]> {
         key
       };
     });
+    this.ns = parent.s.namespace;
   }
 
   static fromIndexDescriptionArray(
@@ -297,15 +299,11 @@ export class CreateIndexesOperation extends CommandOperation<string[]> {
     return 'createIndexes';
   }
 
-  override async execute(
-    server: Server,
-    session: ClientSession | undefined,
-    timeoutContext: TimeoutContext
-  ): Promise<string[]> {
+  override buildCommandDocument(connection: Connection): Document {
     const options = this.options;
     const indexes = this.indexes;
 
-    const serverWireVersion = maxWireVersion(server);
+    const serverWireVersion = maxWireVersion(connection);
 
     const cmd: Document = { createIndexes: this.collectionName, indexes };
 
@@ -317,13 +315,11 @@ export class CreateIndexesOperation extends CommandOperation<string[]> {
       }
       cmd.commitQuorum = options.commitQuorum;
     }
+    return cmd;
+  }
 
-    // collation is set on each index, it should not be defined at the root
-    this.options.collation = undefined;
-
-    await super.executeCommand(server, session, cmd, timeoutContext);
-
-    const indexNames = indexes.map(index => index.name || '');
+  override handleOk(_response: InstanceType<typeof this.SERVER_COMMAND_RESPONSE_TYPE>): string[] {
+    const indexNames = this.indexes.map(index => index.name || '');
     return indexNames;
   }
 }
@@ -333,6 +329,7 @@ export type DropIndexesOptions = CommandOperationOptions;
 
 /** @internal */
 export class DropIndexOperation extends CommandOperation<Document> {
+  override SERVER_COMMAND_RESPONSE_TYPE = MongoDBResponse;
   override options: DropIndexesOptions;
   collection: Collection;
   indexName: string;
@@ -343,19 +340,15 @@ export class DropIndexOperation extends CommandOperation<Document> {
     this.options = options ?? {};
     this.collection = collection;
     this.indexName = indexName;
+    this.ns = collection.fullNamespace;
   }
 
   override get commandName() {
     return 'dropIndexes' as const;
   }
 
-  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, timeoutContext);
+  override buildCommandDocument(_connection: Connection): Document {
+    return { dropIndexes: this.collection.collectionName, index: this.indexName };
   }
 }
 
@@ -367,6 +360,7 @@ export type ListIndexesOptions = AbstractCursorOptions & {
 
 /** @internal */
 export class ListIndexesOperation extends CommandOperation<CursorResponse> {
+  override SERVER_COMMAND_RESPONSE_TYPE = CursorResponse;
   /**
    * @remarks WriteConcern can still be present on the options because
    * we inherit options from the client/db/collection.  The
@@ -389,12 +383,8 @@ export class ListIndexesOperation extends CommandOperation<CursorResponse> {
     return 'listIndexes' as const;
   }
 
-  override async execute(
-    server: Server,
-    session: ClientSession | undefined,
-    timeoutContext: TimeoutContext
-  ): Promise<CursorResponse> {
-    const serverWireVersion = maxWireVersion(server);
+  override buildCommandDocument(connection: Connection): Document {
+    const serverWireVersion = maxWireVersion(connection);
 
     const cursor = this.options.batchSize ? { batchSize: this.options.batchSize } : {};
 
@@ -406,7 +396,13 @@ export class ListIndexesOperation extends CommandOperation<CursorResponse> {
       command.comment = this.options.comment;
     }
 
-    return await super.executeCommand(server, session, command, timeoutContext, CursorResponse);
+    return command;
+  }
+
+  override handleOk(
+    response: InstanceType<typeof this.SERVER_COMMAND_RESPONSE_TYPE>
+  ): CursorResponse {
+    return response;
   }
 }
 

package/src/operations/insert.ts

@@ -1,20 +1,19 @@
+import { type Connection } from '..';
 import type { Document } from '../bson';
 import type { BulkWriteOptions } from '../bulk/common';
+import { MongoDBResponse } from '../cmap/wire_protocol/responses';
 import type { Collection } from '../collection';
-import { MongoInvalidArgumentError, MongoServerError } from '../error';
+import { 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';
 import { CommandOperation, type CommandOperationOptions } from './command';
-import { AbstractOperation, Aspect, defineAspects } from './operation';
-
+import { Aspect, defineAspects } from './operation';
 /** @internal */
 export class InsertOperation extends CommandOperation<Document> {
+  override SERVER_COMMAND_RESPONSE_TYPE = MongoDBResponse;
   override options: BulkWriteOptions;
+
   documents: Document[];
 
   constructor(ns: MongoDBNamespace, documents: Document[], options: BulkWriteOptions) {
@@ -28,11 +27,7 @@ export class InsertOperation extends CommandOperation<Document> {
     return 'insert' as const;
   }
 
-  override async execute(
-    server: Server,
-    session: ClientSession | undefined,
-    timeoutContext: TimeoutContext
-  ): Promise<Document> {
+  override buildCommandDocument(_connection: Connection, _session?: ClientSession): Document {
     const options = this.options ?? {};
     const ordered = typeof options.ordered === 'boolean' ? options.ordered : true;
     const command: Document = {
@@ -51,7 +46,7 @@ export class InsertOperation extends CommandOperation<Document> {
       command.comment = options.comment;
     }
 
-    return await super.executeCommand(server, session, command, timeoutContext);
+    return command;
   }
 }
 
@@ -73,15 +68,11 @@ export interface InsertOneResult<TSchema = Document> {
 
 export class InsertOneOperation extends InsertOperation {
   constructor(collection: Collection, doc: Document, options: InsertOneOptions) {
-    super(collection.s.namespace, maybeAddIdToDocuments(collection, [doc], options), options);
+    super(collection.s.namespace, [maybeAddIdToDocuments(collection, doc, options)], options);
   }
 
-  override async execute(
-    server: Server,
-    session: ClientSession | undefined,
-    timeoutContext: TimeoutContext
-  ): Promise<InsertOneResult> {
-    const res = await super.execute(server, session, timeoutContext);
+  override handleOk(response: InstanceType<typeof this.SERVER_COMMAND_RESPONSE_TYPE>): Document {
+    const res = super.handleOk(response);
     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
@@ -105,62 +96,5 @@ export interface InsertManyResult<TSchema = Document> {
   insertedIds: { [key: number]: InferIdType<TSchema> };
 }
 
-/** @internal */
-export class InsertManyOperation extends AbstractOperation<InsertManyResult> {
-  override options: BulkWriteOptions;
-  collection: Collection;
-  docs: ReadonlyArray<Document>;
-
-  constructor(collection: Collection, docs: ReadonlyArray<Document>, options: BulkWriteOptions) {
-    super(options);
-
-    if (!Array.isArray(docs)) {
-      throw new MongoInvalidArgumentError('Argument "docs" must be an array of documents');
-    }
-
-    this.options = options;
-    this.collection = collection;
-    this.docs = docs;
-  }
-
-  override get commandName() {
-    return 'insert' as const;
-  }
-
-  override async execute(
-    server: Server,
-    session: ClientSession | undefined,
-    timeoutContext: TimeoutContext
-  ): Promise<InsertManyResult> {
-    const coll = this.collection;
-    const options = { ...this.options, ...this.bsonOptions, readPreference: this.readPreference };
-    const writeConcern = WriteConcern.fromOptions(options);
-    const bulkWriteOperation = new BulkWriteOperation(
-      coll,
-      this.docs.map(document => ({
-        insertOne: { document }
-      })),
-      options
-    );
-
-    try {
-      const res = await bulkWriteOperation.execute(server, session, timeoutContext);
-      return {
-        acknowledged: writeConcern?.w !== 0,
-        insertedCount: res.insertedCount,
-        insertedIds: res.insertedIds
-      };
-    } catch (err) {
-      if (err && err.message === 'Operation must be an object with an operation key') {
-        throw new MongoInvalidArgumentError(
-          'Collection.insertMany() cannot be called with an array that has null/undefined values'
-        );
-      }
-      throw err;
-    }
-  }
-}
-
 defineAspects(InsertOperation, [Aspect.RETRYABLE, Aspect.WRITE_OPERATION]);
 defineAspects(InsertOneOperation, [Aspect.RETRYABLE, Aspect.WRITE_OPERATION]);
-defineAspects(InsertManyOperation, [Aspect.WRITE_OPERATION]);

package/src/operations/kill_cursors.ts

@@ -1,9 +1,11 @@
 import type { Long } from '../bson';
-import { MongoRuntimeError } from '../error';
-import type { Server } from '../sdam/server';
+import { type Connection } from '../cmap/connection';
+import { MongoDBResponse } from '../cmap/wire_protocol/responses';
+import { type MongoError, MongoRuntimeError } from '../error';
+import type { Server, ServerCommandOptions } from '../sdam/server';
 import type { ClientSession } from '../sessions';
 import { type TimeoutContext } from '../timeout';
-import { type MongoDBNamespace, squashError } from '../utils';
+import { type MongoDBNamespace } from '../utils';
 import { AbstractOperation, Aspect, defineAspects, type OperationOptions } from './operation';
 
 /**
@@ -16,7 +18,8 @@ interface KillCursorsCommand {
   comment?: unknown;
 }
 
-export class KillCursorsOperation extends AbstractOperation {
+export class KillCursorsOperation extends AbstractOperation<void> {
+  override SERVER_COMMAND_RESPONSE_TYPE = MongoDBResponse;
   cursorId: Long;
 
   constructor(cursorId: Long, ns: MongoDBNamespace, server: Server, options: OperationOptions) {
@@ -30,15 +33,7 @@ export class KillCursorsOperation extends AbstractOperation {
     return 'killCursors' as const;
   }
 
-  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');
-    }
-
+  override buildCommand(_connection: Connection, _session?: ClientSession): KillCursorsCommand {
     const killCursors = this.ns.collection;
     if (killCursors == null) {
       // Cursors should have adopted the namespace returned by MongoDB
@@ -50,15 +45,19 @@ export class KillCursorsOperation extends AbstractOperation {
       killCursors,
       cursors: [this.cursorId]
     };
-    try {
-      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);
-    }
+
+    return killCursorsCommand;
+  }
+
+  override buildOptions(timeoutContext: TimeoutContext): ServerCommandOptions {
+    return {
+      session: this.session,
+      timeoutContext
+    };
+  }
+
+  override handleError(_error: MongoError): void {
+    // The driver should never emit errors from killCursors, this is spec-ed behavior
   }
 }