mongodb 4.0.0 → 4.1.2

package/src/mongo_types.ts

@@ -95,11 +95,11 @@ export interface FilterOperators<TValue> extends Document {
   $eq?: TValue;
   $gt?: TValue;
   $gte?: TValue;
-  $in?: TValue[];
+  $in?: ReadonlyArray<TValue>;
   $lt?: TValue;
   $lte?: TValue;
   $ne?: TValue;
-  $nin?: TValue[];
+  $nin?: ReadonlyArray<TValue>;
   // Logical
   $not?: TValue extends string ? FilterOperators<TValue> | RegExp : FilterOperators<TValue>;
   // Element
@@ -122,8 +122,8 @@ export interface FilterOperators<TValue> extends Document {
   $nearSphere?: Document;
   $maxDistance?: number;
   // Array
-  $all?: TValue extends ReadonlyArray<any> ? any[] : never;
-  $elemMatch?: TValue extends ReadonlyArray<any> ? Document : never;
+  $all?: ReadonlyArray<any>;
+  $elemMatch?: Document;
   $size?: TValue extends ReadonlyArray<any> ? number : never;
   // Bitwise
   $bitsAllClear?: BitwiseFilter;
@@ -137,7 +137,7 @@ export interface FilterOperators<TValue> extends Document {
 export type BitwiseFilter =
   | number /** numeric bit mask */
   | Binary /** BinData bit mask */
-  | number[]; /** `[ <position1>, <position2>, ... ]` */
+  | ReadonlyArray<number>; /** `[ <position1>, <position2>, ... ]` */
 
 /** @public */
 export const BSONType = Object.freeze({
@@ -169,20 +169,19 @@ export type BSONType = typeof BSONType[keyof typeof BSONType];
 /** @public */
 export type BSONTypeAlias = keyof typeof BSONType;
 
-/** @public */
-export interface ProjectionOperators extends Document {
-  $elemMatch?: Document;
-  $slice?: number | [number, number];
-  $meta?: string;
-  /** @deprecated Since MongoDB 3.2, Use FindCursor#max */
-  $max?: any;
-}
+/**
+ * @public
+ * Projection is flexible to permit the wide array of aggregation operators
+ * @deprecated since v4.1.0: Since projections support all aggregation operations we have no plans to narrow this type further
+ */
+// eslint-disable-next-line @typescript-eslint/no-unused-vars
+export type Projection<TSchema extends Document = Document> = Document;
 
-/** @public */
-export type Projection<TSchema> = {
-  [Key in keyof TSchema]?: ProjectionOperators | 0 | 1 | boolean;
-} &
-  Partial<Record<string, ProjectionOperators | 0 | 1 | boolean>>;
+/**
+ * @public
+ * @deprecated since v4.1.0: Since projections support all aggregation operations we have no plans to narrow this type further
+ */
+export type ProjectionOperators = Document;
 
 /** @public */
 export type IsAny<Type, ResultIfAny, ResultIfNotAny> = true extends false & Type
@@ -286,7 +285,7 @@ export type PullAllOperator<TSchema> = ({
   readonly [key in KeysOfAType<TSchema, ReadonlyArray<any>>]?: TSchema[key];
 } &
   NotAcceptedFields<TSchema, ReadonlyArray<any>>) & {
-  readonly [key: string]: any[];
+  readonly [key: string]: ReadonlyArray<any>;
 };
 
 /** @public */
@@ -320,7 +319,7 @@ export type UpdateFilter<TSchema> = {
 export type Nullable<AnyType> = AnyType | null | undefined;
 
 /** @public */
-export type OneOrMore<T> = T | T[];
+export type OneOrMore<T> = T | ReadonlyArray<T>;
 
 /** @public */
 export type GenericListener = (...args: any[]) => void;

package/src/operations/add_user.ts

@@ -1,7 +1,7 @@
 import * as crypto from 'crypto';
 import { Aspect, defineAspects } from './operation';
 import { CommandOperation, CommandOperationOptions } from './command';
-import { MongoDriverError } from '../error';
+import { MongoInvalidArgumentError } from '../error';
 import { Callback, emitWarningOnce, getTopology } from '../utils';
 import type { Document } from '../bson';
 import type { Server } from '../sdam/server';
@@ -54,9 +54,8 @@ export class AddUserOperation extends CommandOperation<Document> {
     // Error out if digestPassword set
     if (options.digestPassword != null) {
       return callback(
-        new MongoDriverError(
-          'The digestPassword option is not supported via add_user. ' +
-            "Please use db.command('createUser', ...) instead for this option."
+        new MongoInvalidArgumentError(
+          'Option "digestPassword" not supported via addUser, use db.command(...) instead'
         )
       );
     }
@@ -83,7 +82,7 @@ export class AddUserOperation extends CommandOperation<Document> {
       // Use node md5 generator
       const md5 = crypto.createHash('md5');
       // Generate keys used for authentication
-      md5.update(username + ':mongo:' + password);
+      md5.update(`${username}:mongo:${password}`);
       userPassword = md5.digest('hex');
     }
 

package/src/operations/aggregate.ts

@@ -1,12 +1,7 @@
-import {
-  CommandOperation,
-  CommandOperationOptions,
-  OperationParent,
-  CollationOptions
-} from './command';
+import { CommandOperation, CommandOperationOptions, CollationOptions } from './command';
 import { ReadPreference } from '../read_preference';
-import { MongoDriverError } from '../error';
-import { maxWireVersion } from '../utils';
+import { MongoInvalidArgumentError } from '../error';
+import { maxWireVersion, MongoDBNamespace } from '../utils';
 import { Aspect, defineAspects, Hint } from './operation';
 import type { Callback } from '../utils';
 import type { Document } from '../bson';
@@ -47,14 +42,13 @@ export class AggregateOperation<T = Document> extends CommandOperation<T> {
   pipeline: Document[];
   hasWriteStage: boolean;
 
-  constructor(parent: OperationParent, pipeline: Document[], options?: AggregateOptions) {
-    super(parent, options);
+  constructor(ns: MongoDBNamespace, pipeline: Document[], options?: AggregateOptions) {
+    super(undefined, { ...options, dbName: ns.db });
 
     this.options = options ?? {};
-    this.target =
-      parent.s.namespace && parent.s.namespace.collection
-        ? parent.s.namespace.collection
-        : DB_AGGREGATE_COLLECTION;
+
+    // Covers when ns.collection is null, undefined or the empty string, use DB_AGGREGATE_COLLECTION
+    this.target = ns.collection || DB_AGGREGATE_COLLECTION;
 
     this.pipeline = pipeline;
 
@@ -75,11 +69,13 @@ export class AggregateOperation<T = Document> extends CommandOperation<T> {
     }
 
     if (this.explain && this.writeConcern) {
-      throw new MongoDriverError('"explain" cannot be used on an aggregate call with writeConcern');
+      throw new MongoInvalidArgumentError(
+        'Option "explain" cannot be used on an aggregate call with writeConcern'
+      );
     }
 
     if (options?.cursor != null && typeof options.cursor !== 'object') {
-      throw new MongoDriverError('cursor options must be an object');
+      throw new MongoInvalidArgumentError('Cursor options must be an object');
     }
   }
 
@@ -131,4 +127,9 @@ export class AggregateOperation<T = Document> extends CommandOperation<T> {
   }
 }
 
-defineAspects(AggregateOperation, [Aspect.READ_OPERATION, Aspect.RETRYABLE, Aspect.EXPLAINABLE]);
+defineAspects(AggregateOperation, [
+  Aspect.READ_OPERATION,
+  Aspect.RETRYABLE,
+  Aspect.EXPLAINABLE,
+  Aspect.CURSOR_CREATING
+]);

package/src/operations/command.ts

@@ -4,7 +4,7 @@ import { WriteConcern, WriteConcernOptions } from '../write_concern';
 import { maxWireVersion, MongoDBNamespace, Callback, decorateWithExplain } from '../utils';
 import type { ReadPreference } from '../read_preference';
 import { ClientSession, commandSupportsReadConcern } from '../sessions';
-import { MongoDriverError } from '../error';
+import { MongoInvalidArgumentError, MongoCompatibilityError } from '../error';
 import type { Logger } from '../logger';
 import type { Server } from '../sdam/server';
 import type { BSONSerializeOptions, Document } from '../bson';
@@ -31,7 +31,7 @@ export interface CommandOperationOptions
   extends OperationOptions,
     WriteConcernOptions,
     ExplainOptions {
-  /** Return the full server response for the command */
+  /** @deprecated This option does nothing */
   fullResponse?: boolean;
   /** Specify a read concern and level for the collection. (only MongoDB 3.2 or higher supported) */
   readConcern?: ReadConcernLike;
@@ -66,7 +66,6 @@ export abstract class CommandOperation<T> extends AbstractOperation<T> {
   readConcern?: ReadConcern;
   writeConcern?: WriteConcern;
   explain?: Explain;
-  fullResponse?: boolean;
   logger?: Logger;
 
   constructor(parent?: OperationParent, options?: CommandOperationOptions) {
@@ -87,8 +86,6 @@ export abstract class CommandOperation<T> extends AbstractOperation<T> {
 
     this.readConcern = ReadConcern.fromOptions(options);
     this.writeConcern = WriteConcern.fromOptions(options);
-    this.fullResponse =
-      options && typeof options.fullResponse === 'boolean' ? options.fullResponse : false;
 
     // TODO(NODE-2056): make logger another "inheritable" property
     if (parent && parent.logger) {
@@ -97,14 +94,14 @@ export abstract class CommandOperation<T> extends AbstractOperation<T> {
 
     if (this.hasAspect(Aspect.EXPLAINABLE)) {
       this.explain = Explain.fromOptions(options);
-    } else if (options?.explain !== undefined) {
-      throw new MongoDriverError(`explain is not supported on this command`);
+    } else if (options?.explain != null) {
+      throw new MongoInvalidArgumentError(`Option "explain" is not supported on this command`);
     }
   }
 
   get canRetryWrite(): boolean {
     if (this.hasAspect(Aspect.EXPLAINABLE)) {
-      return this.explain === undefined;
+      return this.explain == null;
     }
     return true;
   }
@@ -131,7 +128,7 @@ export abstract class CommandOperation<T> extends AbstractOperation<T> {
 
     if (options.collation && serverWireVersion < SUPPORTS_WRITE_CONCERN_AND_COLLATION) {
       callback(
-        new MongoDriverError(
+        new MongoCompatibilityError(
           `Server ${server.name}, which reports wire version ${serverWireVersion}, does not support collation`
         )
       );
@@ -169,6 +166,6 @@ export abstract class CommandOperation<T> extends AbstractOperation<T> {
       }
     }
 
-    server.command(this.ns, cmd, { fullResult: !!this.fullResponse, ...options }, callback);
+    server.command(this.ns, cmd, options, callback);
   }
 }

package/src/operations/common_functions.ts

@@ -1,4 +1,4 @@
-import { MongoDriverError } from '../error';
+import { MongoTopologyClosedError } from '../error';
 import { Callback, getTopology } from '../utils';
 import type { Document } from '../bson';
 import type { Db } from '../db';
@@ -41,8 +41,7 @@ export function indexInformation(
   const full = options.full == null ? false : options.full;
 
   // Did the user destroy the topology
-  if (getTopology(db).isDestroyed())
-    return callback(new MongoDriverError('topology was destroyed'));
+  if (getTopology(db).isDestroyed()) return callback(new MongoTopologyClosedError());
   // Process all the results from the index command and collection
   function processResults(indexes: any) {
     // Contains all the information

package/src/operations/connect.ts

@@ -1,4 +1,4 @@
-import { MongoDriverError } from '../error';
+import { MongoRuntimeError, MongoInvalidArgumentError } from '../error';
 import { Topology, TOPOLOGY_EVENTS } from '../sdam/topology';
 import { resolveSRVRecord } from '../connection_string';
 import type { Callback } from '../utils';
@@ -21,7 +21,7 @@ export function connect(
   callback: Callback<MongoClient>
 ): void {
   if (!callback) {
-    throw new MongoDriverError('no callback function provided');
+    throw new MongoInvalidArgumentError('Callback function must be provided');
   }
 
   // If a connection already been established, we can terminate early
@@ -41,7 +41,8 @@ export function connect(
       }
 
       // Return a more specific error message for MongoClient.connect
-      return callback(new MongoDriverError(warningMessage));
+      // TODO(NODE-3483)
+      return callback(new MongoRuntimeError(warningMessage));
     }
 
     callback(err, mongoClient);

package/src/operations/count.ts

@@ -25,7 +25,7 @@ export class CountOperation extends CommandOperation<number> {
   query: Document;
 
   constructor(namespace: MongoDBNamespace, filter: Document, options: CountOptions) {
-    super(({ s: { namespace: namespace } } as unknown) as Collection, options);
+    super({ s: { namespace: namespace } } as unknown as Collection, options);
 
     this.options = options;
     this.collectionName = namespace.collection;
@@ -47,7 +47,7 @@ export class CountOperation extends CommandOperation<number> {
       cmd.skip = options.skip;
     }
 
-    if (typeof options.hint !== 'undefined') {
+    if (options.hint != null) {
       cmd.hint = options.hint;
     }
 

package/src/operations/count_documents.ts

@@ -29,7 +29,7 @@ export class CountDocumentsOperation extends AggregateOperation<number> {
 
     pipeline.push({ $group: { _id: 1, n: { $sum: 1 } } });
 
-    super(collection, pipeline, options);
+    super(collection.s.namespace, pipeline, options);
   }
 
   execute(server: Server, session: ClientSession, callback: Callback<number>): void {
@@ -40,7 +40,7 @@ export class CountDocumentsOperation extends AggregateOperation<number> {
       }
 
       // NOTE: We're avoiding creating a cursor here to reduce the callstack.
-      const response = (result as unknown) as Document;
+      const response = result as unknown as Document;
       if (response.cursor == null || response.cursor.firstBatch == null) {
         callback(undefined, 0);
         return;

package/src/operations/delete.ts

@@ -5,7 +5,7 @@ import type { Document } from '../bson';
 import type { Server } from '../sdam/server';
 import type { Collection } from '../collection';
 import type { ClientSession } from '../sessions';
-import { MongoDriverError, MongoServerError } from '../error';
+import { MongoServerError, MongoCompatibilityError } from '../error';
 import type { WriteConcernOptions } from '../write_concern';
 
 /** @public */
@@ -64,7 +64,7 @@ export class DeleteOperation extends CommandOperation<Document> {
       return false;
     }
 
-    return this.statements.every(op => (typeof op.limit !== 'undefined' ? op.limit > 0 : true));
+    return this.statements.every(op => (op.limit != null ? op.limit > 0 : true));
   }
 
   execute(server: Server, session: ClientSession, callback: Callback): void {
@@ -80,23 +80,25 @@ export class DeleteOperation extends CommandOperation<Document> {
       command.let = options.let;
     }
 
-    if (options.explain !== undefined && maxWireVersion(server) < 3) {
+    if (options.explain != null && maxWireVersion(server) < 3) {
       return callback
-        ? callback(new MongoDriverError(`server ${server.name} does not support explain on delete`))
+        ? callback(
+            new MongoCompatibilityError(`Server ${server.name} does not support explain on delete`)
+          )
         : undefined;
     }
 
     const unacknowledgedWrite = this.writeConcern && this.writeConcern.w === 0;
     if (unacknowledgedWrite || maxWireVersion(server) < 5) {
       if (this.statements.find((o: Document) => o.hint)) {
-        callback(new MongoDriverError(`servers < 3.4 do not support hint on delete`));
+        callback(new MongoCompatibilityError(`Servers < 3.4 do not support hint on delete`));
         return;
       }
     }
 
     const statementWithCollation = this.statements.find(statement => !!statement.collation);
     if (statementWithCollation && collationNotSupported(server, statementWithCollation)) {
-      callback(new MongoDriverError(`server ${server.name} does not support collation`));
+      callback(new MongoCompatibilityError(`Server ${server.name} does not support collation`));
       return;
     }
 

package/src/operations/distinct.ts

@@ -4,7 +4,7 @@ import { decorateWithCollation, decorateWithReadConcern, Callback, maxWireVersio
 import type { Document } from '../bson';
 import type { Server } from '../sdam/server';
 import type { Collection } from '../collection';
-import { MongoDriverError } from '../error';
+import { MongoCompatibilityError } from '../error';
 import type { ClientSession } from '../sessions';
 
 /** @public */
@@ -68,7 +68,9 @@ export class DistinctOperation extends CommandOperation<any[]> {
     }
 
     if (this.explain && maxWireVersion(server) < 4) {
-      callback(new MongoDriverError(`server ${server.name} does not support explain on distinct`));
+      callback(
+        new MongoCompatibilityError(`Server ${server.name} does not support explain on distinct`)
+      );
       return;
     }
 
@@ -78,7 +80,7 @@ export class DistinctOperation extends CommandOperation<any[]> {
         return;
       }
 
-      callback(undefined, this.options.fullResponse || this.explain ? result : result.values);
+      callback(undefined, this.explain ? result : result.values);
     });
   }
 }

package/src/operations/estimated_document_count.ts

@@ -68,4 +68,8 @@ export class EstimatedDocumentCountOperation extends CommandOperation<number> {
   }
 }
 
-defineAspects(EstimatedDocumentCountOperation, [Aspect.READ_OPERATION, Aspect.RETRYABLE]);
+defineAspects(EstimatedDocumentCountOperation, [
+  Aspect.READ_OPERATION,
+  Aspect.RETRYABLE,
+  Aspect.CURSOR_CREATING
+]);

package/src/operations/eval.ts

@@ -43,7 +43,7 @@ export class EvalOperation extends CommandOperation<Document> {
     let finalParameters: Document[] = [];
 
     // If not a code object translate to one
-    if (!(finalCode && ((finalCode as unknown) as { _bsontype: string })._bsontype === 'Code')) {
+    if (!(finalCode && (finalCode as unknown as { _bsontype: string })._bsontype === 'Code')) {
       finalCode = new Code(finalCode as never);
     }
 

package/src/operations/execute_operation.ts

@@ -3,16 +3,20 @@ import {
   MongoError,
   isRetryableError,
   MONGODB_ERROR_CODES,
-  MongoDriverError,
-  MongoServerError
+  MongoRuntimeError,
+  MongoNetworkError,
+  MongoCompatibilityError,
+  MongoServerError,
+  MongoExpiredSessionError,
+  MongoTransactionError
 } from '../error';
 import { Aspect, AbstractOperation } from './operation';
 import { maxWireVersion, maybePromise, Callback } from '../utils';
-import { ServerType } from '../sdam/common';
 import type { Server } from '../sdam/server';
 import type { Topology } from '../sdam/topology';
 import type { ClientSession } from '../sessions';
 import type { Document } from '../bson';
+import { supportsRetryableWrites } from '../utils';
 
 const MMAPv1_RETRY_WRITES_ERROR_CODE = MONGODB_ERROR_CODES.IllegalOperation;
 const MMAPv1_RETRY_WRITES_ERROR_MESSAGE =
@@ -64,7 +68,8 @@ export function executeOperation<
   TResult = ResultTypeFromOperation<T>
 >(topology: Topology, operation: T, callback?: Callback<TResult>): Promise<TResult> | void {
   if (!(operation instanceof AbstractOperation)) {
-    throw new MongoDriverError('This method requires a valid operation instance');
+    // TODO(NODE-3483)
+    throw new MongoRuntimeError('This method requires a valid operation instance');
   }
 
   return maybePromise(callback, cb => {
@@ -85,14 +90,14 @@ export function executeOperation<
         owner = Symbol();
         session = topology.startSession({ owner, explicit: false });
       } else if (session.hasEnded) {
-        return cb(new MongoDriverError('Use of expired sessions is not permitted'));
+        return cb(new MongoExpiredSessionError('Use of expired sessions is not permitted'));
       } else if (session.snapshotEnabled && !topology.capabilities.supportsSnapshotReads) {
-        return cb(new MongoDriverError('Snapshot reads require MongoDB 5.0 or later'));
+        return cb(new MongoCompatibilityError('Snapshot reads require MongoDB 5.0 or later'));
       }
     } else if (session) {
       // If the user passed an explicit session and we are still, after server selection,
       // trying to run against a topology that doesn't support sessions we error out.
-      return cb(new MongoDriverError('Current topology does not support sessions'));
+      return cb(new MongoCompatibilityError('Current topology does not support sessions'));
     }
 
     try {
@@ -128,7 +133,7 @@ function executeWithServerSelection(
 
   if (inTransaction && !readPreference.equals(ReadPreference.primary)) {
     callback(
-      new MongoDriverError(
+      new MongoTransactionError(
         `Read preference in a transaction must be primary, not: ${readPreference.mode}`
       )
     );
@@ -136,6 +141,15 @@ function executeWithServerSelection(
     return;
   }
 
+  if (
+    session &&
+    session.isPinned &&
+    session.transaction.isCommitted &&
+    !operation.bypassPinningCheck
+  ) {
+    session.unpin();
+  }
+
   const serverSelectionOptions = { session };
   function callbackWithRetry(err?: any, result?: any) {
     if (err == null) {
@@ -168,16 +182,31 @@ function executeWithServerSelection(
     }
 
     // select a new server, and attempt to retry the operation
-    topology.selectServer(readPreference, serverSelectionOptions, (err?: any, server?: any) => {
+    topology.selectServer(readPreference, serverSelectionOptions, (e?: any, server?: any) => {
       if (
-        err ||
+        e ||
         (operation.hasAspect(Aspect.READ_OPERATION) && !supportsRetryableReads(server)) ||
         (operation.hasAspect(Aspect.WRITE_OPERATION) && !supportsRetryableWrites(server))
       ) {
-        callback(err);
+        callback(e);
         return;
       }
 
+      // If we have a cursor and the initial command fails with a network error,
+      // we can retry it on another connection. So we need to check it back in, clear the
+      // pool for the service id, and retry again.
+      if (
+        err &&
+        err instanceof MongoNetworkError &&
+        server.loadBalanced &&
+        session &&
+        session.isPinned &&
+        !session.inTransaction() &&
+        operation.hasAspect(Aspect.CURSOR_CREATING)
+      ) {
+        session.unpin({ force: true, forceClear: true });
+      }
+
       operation.execute(server, session, callback);
     });
   }
@@ -189,7 +218,7 @@ function executeWithServerSelection(
     session.inTransaction()
   ) {
     callback(
-      new MongoDriverError(
+      new MongoTransactionError(
         `Read preference in a transaction must be primary, not: ${readPreference.mode}`
       )
     );
@@ -238,11 +267,3 @@ function executeWithServerSelection(
 function shouldRetryWrite(err: any) {
   return err instanceof MongoError && err.hasErrorLabel('RetryableWriteError');
 }
-
-function supportsRetryableWrites(server: Server) {
-  return (
-    server.description.maxWireVersion >= 6 &&
-    server.description.logicalSessionTimeoutMinutes &&
-    server.description.type !== ServerType.Standalone
-  );
-}

package/src/operations/find.ts

@@ -6,7 +6,7 @@ import {
   normalizeHintField,
   decorateWithExplain
 } from '../utils';
-import { MongoDriverError } from '../error';
+import { MongoInvalidArgumentError, MongoCompatibilityError } from '../error';
 import type { Document } from '../bson';
 import type { Server } from '../sdam/server';
 import type { Collection } from '../collection';
@@ -15,16 +15,19 @@ import { Sort, formatSort } from '../sort';
 import { isSharded } from '../cmap/wire_protocol/shared';
 import { ReadConcern } from '../read_concern';
 import type { ClientSession } from '../sessions';
-import type { Projection } from '../mongo_types';
 
-/** @public */
-export interface FindOptions<TSchema = Document> extends CommandOperationOptions {
+/**
+ * @public
+ * @typeParam TSchema - Unused schema definition, deprecated usage, only specify `FindOptions` with no generic
+ */
+// eslint-disable-next-line @typescript-eslint/no-unused-vars
+export interface FindOptions<TSchema extends Document = Document> extends CommandOperationOptions {
   /** 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. */
   sort?: Sort;
   /** The fields to return in the query. Object of fields to either include or exclude (one of, not both), `{'a':1, 'b': 1}` **or** `{'a': 0, 'b': 0}` */
-  projection?: Projection<TSchema>;
+  projection?: Document;
   /** Set to skip N documents ahead in your query (useful for pagination). */
   skip?: number;
   /** Tell the query to use specific indexes in the query. Object of indexes to use, `{'_id':1}` */
@@ -84,15 +87,15 @@ export class FindOperation extends CommandOperation<Document> {
     this.ns = ns;
 
     if (typeof filter !== 'object' || Array.isArray(filter)) {
-      throw new MongoDriverError('Query filter must be a plain object or ObjectId');
+      throw new MongoInvalidArgumentError('Query filter must be a plain object or ObjectId');
     }
 
     // If the filter is a buffer, validate that is a valid BSON document
     if (Buffer.isBuffer(filter)) {
       const objectSize = filter[0] | (filter[1] << 8) | (filter[2] << 16) | (filter[3] << 24);
       if (objectSize !== filter.length) {
-        throw new MongoDriverError(
-          `query filter raw message size does not match message header size [${filter.length}] != [${objectSize}]`
+        throw new MongoInvalidArgumentError(
+          `Query filter raw message size does not match message header size [${filter.length}] != [${objectSize}]`
         );
       }
     }
@@ -106,14 +109,16 @@ export class FindOperation extends CommandOperation<Document> {
 
     const serverWireVersion = maxWireVersion(server);
     const options = this.options;
-    if (typeof options.allowDiskUse !== 'undefined' && serverWireVersion < 4) {
-      callback(new MongoDriverError('The `allowDiskUse` option is not supported on MongoDB < 3.2'));
+    if (options.allowDiskUse != null && serverWireVersion < 4) {
+      callback(
+        new MongoCompatibilityError('Option "allowDiskUse" is not supported on MongoDB < 3.2')
+      );
       return;
     }
 
     if (options.collation && serverWireVersion < SUPPORTS_WRITE_CONCERN_AND_COLLATION) {
       callback(
-        new MongoDriverError(
+        new MongoCompatibilityError(
           `Server ${server.name}, which reports wire version ${serverWireVersion}, does not support collation`
         )
       );
@@ -124,8 +129,8 @@ export class FindOperation extends CommandOperation<Document> {
     if (serverWireVersion < 4) {
       if (this.readConcern && this.readConcern.level !== 'local') {
         callback(
-          new MongoDriverError(
-            `server find command does not support a readConcern level of ${this.readConcern.level}`
+          new MongoCompatibilityError(
+            `Server find command does not support a readConcern level of ${this.readConcern.level}`
           )
         );
 
@@ -161,7 +166,6 @@ export class FindOperation extends CommandOperation<Document> {
       this.ns,
       findCommand,
       {
-        fullResult: !!this.fullResponse,
         ...this.options,
         ...this.bsonOptions,
         documentsReturnedIn: 'firstBatch',
@@ -336,11 +340,16 @@ function makeLegacyFindCommand(
     findCommand.$maxTimeMS = options.maxTimeMS;
   }
 
-  if (typeof options.explain !== 'undefined') {
+  if (options.explain != null) {
     findCommand.$explain = true;
   }
 
   return findCommand;
 }
 
-defineAspects(FindOperation, [Aspect.READ_OPERATION, Aspect.RETRYABLE, Aspect.EXPLAINABLE]);
+defineAspects(FindOperation, [
+  Aspect.READ_OPERATION,
+  Aspect.RETRYABLE,
+  Aspect.EXPLAINABLE,
+  Aspect.CURSOR_CREATING
+]);