mongodb 6.18.0 → 6.19.0-dev.20250827.sha.3c5bb1d5

package/src/operations/delete.ts

@@ -1,11 +1,9 @@
 import type { Document } from '../bson';
-import type { Collection } from '../collection';
+import { type Connection } from '../cmap/connection';
+import { MongoDBResponse } from '../cmap/wire_protocol/responses';
 import { MongoCompatibilityError, MongoServerError } from '../error';
-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 { type MongoDBNamespace } from '../utils';
+import { type MongoDBCollectionNamespace, type MongoDBNamespace } from '../utils';
 import { type WriteConcernOptions } from '../write_concern';
 import { type CollationOptions, CommandOperation, type CommandOperationOptions } from './command';
 import { Aspect, defineAspects, type Hint } from './operation';
@@ -43,7 +41,8 @@ export interface DeleteStatement {
 }
 
 /** @internal */
-export class DeleteOperation extends CommandOperation<DeleteResult> {
+export class DeleteOperation extends CommandOperation<Document> {
+  override SERVER_COMMAND_RESPONSE_TYPE = MongoDBResponse;
   override options: DeleteOptions;
   statements: DeleteStatement[];
 
@@ -66,12 +65,9 @@ export class DeleteOperation extends CommandOperation<DeleteResult> {
     return this.statements.every(op => (op.limit != null ? op.limit > 0 : true));
   }
 
-  override async execute(
-    server: Server,
-    session: ClientSession | undefined,
-    timeoutContext: TimeoutContext
-  ): Promise<DeleteResult> {
-    const options = this.options ?? {};
+  override buildCommandDocument(_connection: Connection, _session?: ClientSession): Document {
+    const options = this.options;
+
     const ordered = typeof options.ordered === 'boolean' ? options.ordered : true;
     const command: Document = {
       delete: this.ns.collection,
@@ -97,28 +93,23 @@ export class DeleteOperation extends CommandOperation<DeleteResult> {
       }
     }
 
-    const res: TODO_NODE_3286 = await super.executeCommand(
-      server,
-      session,
-      command,
-      timeoutContext
-    );
-    return res;
+    return command;
   }
 }
 
 export class DeleteOneOperation extends DeleteOperation {
-  constructor(collection: Collection, filter: Document, options: DeleteOptions) {
-    super(collection.s.namespace, [makeDeleteStatement(filter, { ...options, limit: 1 })], options);
+  constructor(ns: MongoDBCollectionNamespace, filter: Document, options: DeleteOptions) {
+    super(ns, [makeDeleteStatement(filter, { ...options, limit: 1 })], options);
   }
 
-  override async execute(
-    server: Server,
-    session: ClientSession | undefined,
-    timeoutContext: TimeoutContext
-  ): Promise<DeleteResult> {
-    const res: TODO_NODE_3286 = await super.execute(server, session, timeoutContext);
+  override handleOk(
+    response: InstanceType<typeof this.SERVER_COMMAND_RESPONSE_TYPE>
+  ): DeleteResult {
+    const res = super.handleOk(response);
+
+    // @ts-expect-error Explain commands have broken TS
     if (this.explain) return res;
+
     if (res.code) throw new MongoServerError(res);
     if (res.writeErrors) throw new MongoServerError(res.writeErrors[0]);
 
@@ -129,17 +120,18 @@ export class DeleteOneOperation extends DeleteOperation {
   }
 }
 export class DeleteManyOperation extends DeleteOperation {
-  constructor(collection: Collection, filter: Document, options: DeleteOptions) {
-    super(collection.s.namespace, [makeDeleteStatement(filter, options)], options);
+  constructor(ns: MongoDBCollectionNamespace, filter: Document, options: DeleteOptions) {
+    super(ns, [makeDeleteStatement(filter, options)], options);
   }
 
-  override async execute(
-    server: Server,
-    session: ClientSession | undefined,
-    timeoutContext: TimeoutContext
-  ): Promise<DeleteResult> {
-    const res: TODO_NODE_3286 = await super.execute(server, session, timeoutContext);
+  override handleOk(
+    response: InstanceType<typeof this.SERVER_COMMAND_RESPONSE_TYPE>
+  ): DeleteResult {
+    const res = super.handleOk(response);
+
+    // @ts-expect-error Explain commands have broken TS
     if (this.explain) return res;
+
     if (res.code) throw new MongoServerError(res);
     if (res.writeErrors) throw new MongoServerError(res.writeErrors[0]);
 

package/src/operations/distinct.ts

@@ -1,9 +1,7 @@
-import type { Document } from '../bson';
+import { type Document } from '../bson';
+import { type Connection } from '../cmap/connection';
+import { MongoDBResponse } from '../cmap/wire_protocol/responses';
 import type { Collection } from '../collection';
-import type { Server } from '../sdam/server';
-import type { ClientSession } from '../sessions';
-import { type TimeoutContext } from '../timeout';
-import { decorateWithCollation, decorateWithReadConcern } from '../utils';
 import { CommandOperation, type CommandOperationOptions } from './command';
 import { Aspect, defineAspects } from './operation';
 
@@ -27,7 +25,8 @@ export type DistinctOptions = CommandOperationOptions & {
  * Return a list of distinct values for the given key across a collection.
  * @internal
  */
-export class DistinctOperation extends CommandOperation<any[]> {
+export class DistinctOperation extends CommandOperation<any[] | Document> {
+  override SERVER_COMMAND_RESPONSE_TYPE = MongoDBResponse;
   override options: DistinctOptions;
   collection: Collection;
   /** Field of the document to find distinct values for. */
@@ -56,48 +55,32 @@ export class DistinctOperation extends CommandOperation<any[]> {
     return 'distinct' as const;
   }
 
-  override async execute(
-    server: Server,
-    session: ClientSession | undefined,
-    timeoutContext: TimeoutContext
-  ): Promise<any[]> {
-    const coll = this.collection;
-    const key = this.key;
-    const query = this.query;
-    const options = this.options;
-
-    // Distinct command
-    const cmd: Document = {
-      distinct: coll.collectionName,
-      key: key,
-      query: query
+  override buildCommandDocument(_connection: Connection): Document {
+    const command: Document = {
+      distinct: this.collection.collectionName,
+      key: this.key,
+      query: this.query
     };
-
-    // Add maxTimeMS if defined
-    if (typeof options.maxTimeMS === 'number') {
-      cmd.maxTimeMS = options.maxTimeMS;
-    }
-
     // we check for undefined specifically here to allow falsy values
     // eslint-disable-next-line no-restricted-syntax
-    if (typeof options.comment !== 'undefined') {
-      cmd.comment = options.comment;
+    if (this.options.comment !== undefined) {
+      command.comment = this.options.comment;
     }
 
-    if (options.hint != null) {
-      cmd.hint = options.hint;
+    if (this.options.hint != null) {
+      command.hint = this.options.hint;
     }
 
-    // Do we have a readConcern specified
-    decorateWithReadConcern(cmd, coll, options);
-
-    // Have we specified collation
-    decorateWithCollation(cmd, coll, options);
-
-    const result = await super.executeCommand(server, session, cmd, timeoutContext);
+    return command;
+  }
 
-    // @ts-expect-error: Explain always returns a document
-    return this.explain ? result : result.values;
+  override handleOk(
+    response: InstanceType<typeof this.SERVER_COMMAND_RESPONSE_TYPE>
+  ): any[] | Document {
+    if (this.explain) {
+      return response.toObject(this.bsonOptions);
+    }
+    return response.toObject(this.bsonOptions).values;
   }
 }
 

package/src/operations/drop.ts

@@ -1,10 +1,13 @@
+import { type Connection, MongoServerError } from '..';
 import type { Document } from '../bson';
+import { MongoDBResponse } from '../cmap/wire_protocol/responses';
+import { CursorTimeoutContext } from '../cursor/abstract_cursor';
 import type { Db } from '../db';
-import { MONGODB_ERROR_CODES, MongoServerError } from '../error';
-import type { Server } from '../sdam/server';
+import { MONGODB_ERROR_CODES } from '../error';
 import type { ClientSession } from '../sessions';
-import { type TimeoutContext } from '../timeout';
+import { TimeoutContext } from '../timeout';
 import { CommandOperation, type CommandOperationOptions } from './command';
+import { executeOperation } from './execute_operation';
 import { Aspect, defineAspects } from './operation';
 
 /** @public */
@@ -15,13 +18,13 @@ export interface DropCollectionOptions extends CommandOperationOptions {
 
 /** @internal */
 export class DropCollectionOperation extends CommandOperation<boolean> {
+  override SERVER_COMMAND_RESPONSE_TYPE = MongoDBResponse;
+
   override options: DropCollectionOptions;
-  db: Db;
   name: string;
 
   constructor(db: Db, name: string, options: DropCollectionOptions = {}) {
     super(db, options);
-    this.db = db;
     this.options = options;
     this.name = name;
   }
@@ -30,61 +33,74 @@ export class DropCollectionOperation extends CommandOperation<boolean> {
     return 'drop' as const;
   }
 
-  override async execute(
-    server: Server,
-    session: ClientSession | undefined,
-    timeoutContext: TimeoutContext
-  ): Promise<boolean> {
-    const db = this.db;
-    const options = this.options;
-    const name = this.name;
-
-    const encryptedFieldsMap = db.client.s.options.autoEncryption?.encryptedFieldsMap;
-    let encryptedFields: Document | undefined =
-      options.encryptedFields ?? encryptedFieldsMap?.[`${db.databaseName}.${name}`];
-
-    if (!encryptedFields && encryptedFieldsMap) {
-      // If the MongoClient was configured with an encryptedFieldsMap,
-      // and no encryptedFields config was available in it or explicitly
-      // passed as an argument, the spec tells us to look one up using
-      // listCollections().
-      const listCollectionsResult = await db
-        .listCollections({ name }, { nameOnly: false })
-        .toArray();
-      encryptedFields = listCollectionsResult?.[0]?.options?.encryptedFields;
-    }
+  override buildCommandDocument(_connection: Connection, _session?: ClientSession): Document {
+    return { drop: this.name };
+  }
+
+  override handleOk(_response: InstanceType<typeof this.SERVER_COMMAND_RESPONSE_TYPE>): boolean {
+    return true;
+  }
+}
 
-    if (encryptedFields) {
-      const escCollection = encryptedFields.escCollection || `enxcol_.${name}.esc`;
-      const ecocCollection = encryptedFields.ecocCollection || `enxcol_.${name}.ecoc`;
-
-      for (const collectionName of [escCollection, ecocCollection]) {
-        // Drop auxilliary collections, ignoring potential NamespaceNotFound errors.
-        const dropOp = new DropCollectionOperation(db, collectionName);
-        try {
-          await dropOp.executeWithoutEncryptedFieldsCheck(server, session, timeoutContext);
-        } catch (err) {
-          if (
-            !(err instanceof MongoServerError) ||
-            err.code !== MONGODB_ERROR_CODES.NamespaceNotFound
-          ) {
-            throw err;
-          }
+export async function dropCollections(
+  db: Db,
+  name: string,
+  options: DropCollectionOptions
+): Promise<boolean> {
+  const timeoutContext = TimeoutContext.create({
+    session: options.session,
+    serverSelectionTimeoutMS: db.client.s.options.serverSelectionTimeoutMS,
+    waitQueueTimeoutMS: db.client.s.options.waitQueueTimeoutMS,
+    timeoutMS: options.timeoutMS
+  });
+
+  const encryptedFieldsMap = db.client.s.options.autoEncryption?.encryptedFieldsMap;
+  let encryptedFields: Document | undefined =
+    options.encryptedFields ?? encryptedFieldsMap?.[`${db.databaseName}.${name}`];
+
+  if (!encryptedFields && encryptedFieldsMap) {
+    // If the MongoClient was configured with an encryptedFieldsMap,
+    // and no encryptedFields config was available in it or explicitly
+    // passed as an argument, the spec tells us to look one up using
+    // listCollections().
+    const listCollectionsResult = await db
+      .listCollections(
+        { name },
+        {
+          nameOnly: false,
+          session: options.session,
+          timeoutContext: new CursorTimeoutContext(timeoutContext, Symbol())
+        }
+      )
+      .toArray();
+    encryptedFields = listCollectionsResult?.[0]?.options?.encryptedFields;
+  }
+
+  if (encryptedFields) {
+    const escCollection = encryptedFields.escCollection || `enxcol_.${name}.esc`;
+    const ecocCollection = encryptedFields.ecocCollection || `enxcol_.${name}.ecoc`;
+
+    for (const collectionName of [escCollection, ecocCollection]) {
+      // Drop auxilliary collections, ignoring potential NamespaceNotFound errors.
+      const dropOp = new DropCollectionOperation(db, collectionName, options);
+      try {
+        await executeOperation(db.client, dropOp, timeoutContext);
+      } catch (err) {
+        if (
+          !(err instanceof MongoServerError) ||
+          err.code !== MONGODB_ERROR_CODES.NamespaceNotFound
+        ) {
+          throw err;
         }
       }
     }
-
-    return await this.executeWithoutEncryptedFieldsCheck(server, session, timeoutContext);
   }
 
-  private async executeWithoutEncryptedFieldsCheck(
-    server: Server,
-    session: ClientSession | undefined,
-    timeoutContext: TimeoutContext
-  ): Promise<boolean> {
-    await super.executeCommand(server, session, { drop: this.name }, timeoutContext);
-    return true;
-  }
+  return await executeOperation(
+    db.client,
+    new DropCollectionOperation(db, name, options),
+    timeoutContext
+  );
 }
 
 /** @public */
@@ -92,6 +108,7 @@ export type DropDatabaseOptions = CommandOperationOptions;
 
 /** @internal */
 export class DropDatabaseOperation extends CommandOperation<boolean> {
+  override SERVER_COMMAND_RESPONSE_TYPE = MongoDBResponse;
   override options: DropDatabaseOptions;
 
   constructor(db: Db, options: DropDatabaseOptions) {
@@ -102,12 +119,11 @@ export class DropDatabaseOperation extends CommandOperation<boolean> {
     return 'dropDatabase' as const;
   }
 
-  override async execute(
-    server: Server,
-    session: ClientSession | undefined,
-    timeoutContext: TimeoutContext
-  ): Promise<boolean> {
-    await super.executeCommand(server, session, { dropDatabase: 1 }, timeoutContext);
+  override buildCommandDocument(_connection: Connection, _session?: ClientSession): Document {
+    return { dropDatabase: 1 };
+  }
+
+  override handleOk(_response: InstanceType<typeof this.SERVER_COMMAND_RESPONSE_TYPE>): boolean {
     return true;
   }
 }

package/src/operations/estimated_document_count.ts

@@ -1,8 +1,8 @@
+import { type Connection } from '..';
 import type { Document } from '../bson';
+import { MongoDBResponse } from '../cmap/wire_protocol/responses';
 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';
 
@@ -18,6 +18,7 @@ export interface EstimatedDocumentCountOptions extends CommandOperationOptions {
 
 /** @internal */
 export class EstimatedDocumentCountOperation extends CommandOperation<number> {
+  override SERVER_COMMAND_RESPONSE_TYPE = MongoDBResponse;
   override options: EstimatedDocumentCountOptions;
   collectionName: string;
 
@@ -31,11 +32,7 @@ export class EstimatedDocumentCountOperation extends CommandOperation<number> {
     return 'count' as const;
   }
 
-  override async execute(
-    server: Server,
-    session: ClientSession | undefined,
-    timeoutContext: TimeoutContext
-  ): Promise<number> {
+  override buildCommandDocument(_connection: Connection, _session?: ClientSession): Document {
     const cmd: Document = { count: this.collectionName };
 
     if (typeof this.options.maxTimeMS === 'number') {
@@ -48,9 +45,11 @@ export class EstimatedDocumentCountOperation extends CommandOperation<number> {
       cmd.comment = this.options.comment;
     }
 
-    const response = await super.executeCommand(server, session, cmd, timeoutContext);
+    return cmd;
+  }
 
-    return response?.n || 0;
+  override handleOk(response: InstanceType<typeof this.SERVER_COMMAND_RESPONSE_TYPE>): number {
+    return response.getNumber('n') ?? 0;
   }
 }
 

package/src/operations/execute_operation.ts

@@ -26,14 +26,16 @@ import type { Topology } from '../sdam/topology';
 import type { ClientSession } from '../sessions';
 import { TimeoutContext } from '../timeout';
 import { abortable, supportsRetryableWrites } from '../utils';
+import { AggregateOperation } from './aggregate';
 import { AbstractOperation, Aspect } from './operation';
 
 const MMAPv1_RETRY_WRITES_ERROR_CODE = MONGODB_ERROR_CODES.IllegalOperation;
 const MMAPv1_RETRY_WRITES_ERROR_MESSAGE =
   'This MongoDB deployment does not support retryable writes. Please add retryWrites=false to your connection string.';
 
-type ResultTypeFromOperation<TOperation> =
-  TOperation extends AbstractOperation<infer K> ? K : never;
+type ResultTypeFromOperation<TOperation extends AbstractOperation> = ReturnType<
+  TOperation['handleOk']
+>;
 
 /**
  * Executes the given operation with provided arguments.
@@ -56,7 +58,7 @@ type ResultTypeFromOperation<TOperation> =
  * @param operation - The operation to execute
  */
 export async function executeOperation<
-  T extends AbstractOperation<TResult>,
+  T extends AbstractOperation,
   TResult = ResultTypeFromOperation<T>
 >(client: MongoClient, operation: T, timeoutContext?: TimeoutContext | null): Promise<TResult> {
   if (!(operation instanceof AbstractOperation)) {
@@ -85,6 +87,8 @@ export async function executeOperation<
     throw new MongoInvalidArgumentError('ClientSession must be from the same MongoClient');
   }
 
+  operation.session ??= session;
+
   const readPreference = operation.readPreference ?? ReadPreference.primary;
   const inTransaction = !!session?.inTransaction();
 
@@ -129,7 +133,7 @@ export async function executeOperation<
  * Connects a client if it has not yet been connected
  * @internal
  */
-async function autoConnect(client: MongoClient): Promise<Topology> {
+export async function autoConnect(client: MongoClient): Promise<Topology> {
   if (client.topology == null) {
     if (client.s.hasBeenClosed) {
       throw new MongoNotConnectedError('Client must be connected before running operations');
@@ -176,10 +180,7 @@ type RetryOptions = {
  *
  * @param operation - The operation to execute
  * */
-async function tryOperation<
-  T extends AbstractOperation<TResult>,
-  TResult = ResultTypeFromOperation<T>
->(
+async function tryOperation<T extends AbstractOperation, TResult = ResultTypeFromOperation<T>>(
   operation: T,
   { topology, timeoutContext, session, readPreference }: RetryOptions
 ): Promise<TResult> {
@@ -190,7 +191,7 @@ async function tryOperation<
     // server selection to potentially force monitor checks if the server is
     // in an unknown state.
     selector = sameServerSelector(operation.server?.description);
-  } else if (operation.trySecondaryWrite) {
+  } else if (operation instanceof AggregateOperation && operation.hasWriteStage) {
     // If operation should try to write to secondary use the custom server selector
     // otherwise provide the read preference.
     selector = secondaryWritableServerSelector(topology.commonWireVersion, readPreference);
@@ -248,8 +249,9 @@ async function tryOperation<
       if (hasWriteAspect && !isRetryableWriteError(previousOperationError))
         throw previousOperationError;
 
-      if (hasReadAspect && !isRetryableReadError(previousOperationError))
+      if (hasReadAspect && !isRetryableReadError(previousOperationError)) {
         throw previousOperationError;
+      }
 
       if (
         previousOperationError instanceof MongoNetworkError &&
@@ -275,12 +277,20 @@ async function tryOperation<
       }
     }
 
+    operation.server = server;
+
     try {
       // If tries > 0 and we are command batching we need to reset the batch.
       if (tries > 0 && operation.hasAspect(Aspect.COMMAND_BATCHING)) {
         operation.resetBatch();
       }
-      return await operation.execute(server, session, timeoutContext);
+
+      try {
+        const result = await server.command(operation, timeoutContext);
+        return operation.handleOk(result);
+      } catch (error) {
+        return operation.handleError(error);
+      }
     } catch (operationError) {
       if (!(operationError instanceof MongoError)) throw operationError;
       if (

package/src/operations/find.ts

@@ -2,14 +2,8 @@ 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 {
-  decorateWithExplain,
-  type ExplainOptions,
-  validateExplainTimeoutOptions
-} from '../explain';
-import { ReadConcern } from '../read_concern';
-import type { Server } from '../sdam/server';
-import type { ClientSession } from '../sessions';
+import { type ExplainOptions } from '../explain';
+import type { ServerCommandOptions } from '../sdam/server';
 import { formatSort, type Sort } from '../sort';
 import { type TimeoutContext } from '../timeout';
 import { type MongoDBNamespace, normalizeHintField } from '../utils';
@@ -81,8 +75,20 @@ export interface FindOptions<TSchema extends Document = Document>
   timeoutMode?: CursorTimeoutMode;
 }
 
+/** @public */
+export interface FindOneOptions extends FindOptions {
+  /** @deprecated Will be removed in the next major version. User provided value will be ignored. */
+  batchSize?: number;
+  /** @deprecated Will be removed in the next major version. User provided value will be ignored. */
+  limit?: number;
+  /** @deprecated Will be removed in the next major version. User provided value will be ignored. */
+  noCursorTimeout?: boolean;
+}
+
 /** @internal */
 export class FindOperation 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
@@ -106,39 +112,32 @@ export class FindOperation extends CommandOperation<CursorResponse> {
 
     // special case passing in an ObjectId as a filter
     this.filter = filter != null && filter._bsontype === 'ObjectId' ? { _id: filter } : filter;
+
+    this.SERVER_COMMAND_RESPONSE_TYPE = this.explain ? ExplainedCursorResponse : CursorResponse;
   }
 
   override get commandName() {
     return 'find' as const;
   }
 
-  override async execute(
-    server: Server,
-    session: ClientSession | undefined,
-    timeoutContext: TimeoutContext
-  ): Promise<CursorResponse> {
-    this.server = server;
-
-    const options = this.options;
+  override buildOptions(timeoutContext: TimeoutContext): ServerCommandOptions {
+    return {
+      ...this.options,
+      ...this.bsonOptions,
+      documentsReturnedIn: 'firstBatch',
+      session: this.session,
+      timeoutContext
+    };
+  }
 
-    let findCommand = makeFindCommand(this.ns, this.filter, options);
-    if (this.explain) {
-      validateExplainTimeoutOptions(this.options, this.explain);
-      findCommand = decorateWithExplain(findCommand, this.explain);
-    }
+  override handleOk(
+    response: InstanceType<typeof this.SERVER_COMMAND_RESPONSE_TYPE>
+  ): CursorResponse {
+    return response;
+  }
 
-    return await server.command(
-      this.ns,
-      findCommand,
-      {
-        ...this.options,
-        ...this.bsonOptions,
-        documentsReturnedIn: 'firstBatch',
-        session,
-        timeoutContext
-      },
-      this.explain ? ExplainedCursorResponse : CursorResponse
-    );
+  override buildCommandDocument(): Document {
+    return makeFindCommand(this.ns, this.filter, this.options);
   }
 }
 
@@ -185,17 +184,15 @@ function makeFindCommand(ns: MongoDBNamespace, filter: Document, options: FindOp
 
   if (typeof options.batchSize === 'number') {
     if (options.batchSize < 0) {
-      if (
-        options.limit &&
-        options.limit !== 0 &&
-        Math.abs(options.batchSize) < Math.abs(options.limit)
-      ) {
-        findCommand.limit = -options.batchSize;
-      }
-
-      findCommand.singleBatch = true;
+      findCommand.limit = -options.batchSize;
     } else {
-      findCommand.batchSize = options.batchSize;
+      if (options.batchSize === options.limit) {
+        // Spec dictates that if these are equal the batchSize should be one more than the
+        // limit to avoid leaving the cursor open.
+        findCommand.batchSize = options.batchSize + 1;
+      } else {
+        findCommand.batchSize = options.batchSize;
+      }
     }
   }
 
@@ -209,15 +206,6 @@ function makeFindCommand(ns: MongoDBNamespace, filter: Document, options: FindOp
     findCommand.comment = options.comment;
   }
 
-  if (typeof options.maxTimeMS === 'number') {
-    findCommand.maxTimeMS = options.maxTimeMS;
-  }
-
-  const readConcern = ReadConcern.fromOptions(options);
-  if (readConcern) {
-    findCommand.readConcern = readConcern.toJSON();
-  }
-
   if (options.max) {
     findCommand.max = options.max;
   }
@@ -255,11 +243,6 @@ function makeFindCommand(ns: MongoDBNamespace, filter: Document, options: FindOp
   if (typeof options.allowPartialResults === 'boolean') {
     findCommand.allowPartialResults = options.allowPartialResults;
   }
-
-  if (options.collation) {
-    findCommand.collation = options.collation;
-  }
-
   if (typeof options.allowDiskUse === 'boolean') {
     findCommand.allowDiskUse = options.allowDiskUse;
   }