mongodb 4.0.0 → 4.1.2

package/src/cmap/metrics.ts

@@ -0,0 +1,58 @@
+/** @internal */
+export class ConnectionPoolMetrics {
+  static readonly TXN = 'txn' as const;
+  static readonly CURSOR = 'cursor' as const;
+  static readonly OTHER = 'other' as const;
+
+  txnConnections = 0;
+  cursorConnections = 0;
+  otherConnections = 0;
+
+  /**
+   * Mark a connection as pinned for a specific operation.
+   */
+  markPinned(pinType: string): void {
+    if (pinType === ConnectionPoolMetrics.TXN) {
+      this.txnConnections += 1;
+    } else if (pinType === ConnectionPoolMetrics.CURSOR) {
+      this.cursorConnections += 1;
+    } else {
+      this.otherConnections += 1;
+    }
+  }
+
+  /**
+   * Unmark a connection as pinned for an operation.
+   */
+  markUnpinned(pinType: string): void {
+    if (pinType === ConnectionPoolMetrics.TXN) {
+      this.txnConnections -= 1;
+    } else if (pinType === ConnectionPoolMetrics.CURSOR) {
+      this.cursorConnections -= 1;
+    } else {
+      this.otherConnections -= 1;
+    }
+  }
+
+  /**
+   * Return information about the cmap metrics as a string.
+   */
+  info(maxPoolSize: number): string {
+    return (
+      'Timed out while checking out a connection from connection pool: ' +
+      `maxPoolSize: ${maxPoolSize}, ` +
+      `connections in use by cursors: ${this.cursorConnections}, ` +
+      `connections in use by transactions: ${this.txnConnections}, ` +
+      `connections in use by other operations: ${this.otherConnections}`
+    );
+  }
+
+  /**
+   * Reset the metrics to the initial values.
+   */
+  reset(): void {
+    this.txnConnections = 0;
+    this.cursorConnections = 0;
+    this.otherConnections = 0;
+  }
+}

package/src/cmap/stream_description.ts

@@ -15,6 +15,8 @@ const RESPONSE_FIELDS = [
 /** @public */
 export interface StreamDescriptionOptions {
   compressors?: CompressorName[];
+  logicalSessionTimeoutMinutes?: number;
+  loadBalanced: boolean;
 }
 
 /** @public */
@@ -29,6 +31,7 @@ export class StreamDescription {
   compressors: CompressorName[];
   compressor?: CompressorName;
   logicalSessionTimeoutMinutes?: number;
+  loadBalanced: boolean;
 
   __nodejs_mock_server__?: boolean;
 
@@ -42,6 +45,8 @@ export class StreamDescription {
     this.maxBsonObjectSize = 16777216;
     this.maxMessageSizeBytes = 48000000;
     this.maxWriteBatchSize = 100000;
+    this.logicalSessionTimeoutMinutes = options?.logicalSessionTimeoutMinutes;
+    this.loadBalanced = !!options?.loadBalanced;
     this.compressors =
       options && options.compressors && Array.isArray(options.compressors)
         ? options.compressors
@@ -51,7 +56,7 @@ export class StreamDescription {
   receiveResponse(response: Document): void {
     this.type = parseServerType(response);
     RESPONSE_FIELDS.forEach(field => {
-      if (typeof response[field] !== 'undefined') {
+      if (typeof response[field] != null) {
         this[field] = response[field];
       }
 

package/src/cmap/wire_protocol/compression.ts

@@ -2,8 +2,8 @@ import * as zlib from 'zlib';
 import type { Callback } from '../../utils';
 import type { OperationDescription } from '../message_stream';
 
-import { Snappy } from '../../deps';
-import { MongoDriverError } from '../../error';
+import { PKG_VERSION, Snappy } from '../../deps';
+import { MongoDecompressionError, MongoInvalidArgumentError } from '../../error';
 
 /** @public */
 export const Compressor = Object.freeze({
@@ -39,12 +39,20 @@ export function compress(
 ): void {
   const zlibOptions = {} as zlib.ZlibOptions;
   switch (self.options.agreedCompressor) {
-    case 'snappy':
+    case 'snappy': {
       if ('kModuleError' in Snappy) {
         return callback(Snappy['kModuleError']);
       }
-      Snappy.compress(dataToBeCompressed, callback);
+
+      if (Snappy[PKG_VERSION].major <= 6) {
+        Snappy.compress(dataToBeCompressed, callback);
+      } else {
+        Snappy.compress(dataToBeCompressed)
+          .then(buffer => callback(undefined, buffer))
+          .catch(error => callback(error));
+      }
       break;
+    }
     case 'zlib':
       // Determine zlibCompressionLevel
       if (self.options.zlibCompressionLevel) {
@@ -53,10 +61,8 @@ export function compress(
       zlib.deflate(dataToBeCompressed, zlibOptions, callback as zlib.CompressCallback);
       break;
     default:
-      throw new MongoDriverError(
-        'Attempt to compress message using unknown compressor "' +
-          self.options.agreedCompressor +
-          '".'
+      throw new MongoInvalidArgumentError(
+        `Unknown compressor ${self.options.agreedCompressor} failed to compress`
       );
   }
 }
@@ -68,19 +74,26 @@ export function decompress(
   callback: Callback<Buffer>
 ): void {
   if (compressorID < 0 || compressorID > Math.max(2)) {
-    throw new MongoDriverError(
-      `Server sent message compressed using an unsupported compressor.` +
-        ` (Received compressor ID ${compressorID})`
+    throw new MongoDecompressionError(
+      `Server sent message compressed using an unsupported compressor. (Received compressor ID ${compressorID})`
     );
   }
 
   switch (compressorID) {
-    case Compressor.snappy:
+    case Compressor.snappy: {
       if ('kModuleError' in Snappy) {
         return callback(Snappy['kModuleError']);
       }
-      Snappy.uncompress(compressedData, { asBuffer: true }, callback as Callback);
+
+      if (Snappy[PKG_VERSION].major <= 6) {
+        Snappy.uncompress(compressedData, { asBuffer: true }, callback);
+      } else {
+        Snappy.uncompress(compressedData, { asBuffer: true })
+          .then(buffer => callback(undefined, buffer))
+          .catch(error => callback(error));
+      }
       break;
+    }
     case Compressor.zlib:
       zlib.inflate(compressedData, callback as zlib.CompressCallback);
       break;

package/src/cmap/wire_protocol/shared.ts

@@ -1,6 +1,6 @@
 import { ServerType } from '../../sdam/common';
 import { TopologyDescription } from '../../sdam/topology_description';
-import { MongoDriverError } from '../../error';
+import { MongoInvalidArgumentError } from '../../error';
 import { ReadPreference } from '../../read_preference';
 import type { Document } from '../../bson';
 import type { OpQueryOptions } from '../commands';
@@ -28,7 +28,9 @@ export function getReadPreference(cmd: Document, options?: ReadPreferenceOption)
   }
 
   if (!(readPreference instanceof ReadPreference)) {
-    throw new MongoDriverError('read preference must be a ReadPreference instance');
+    throw new MongoInvalidArgumentError(
+      'Option "readPreference" must be a ReadPreference instance'
+    );
   }
 
   return readPreference;

package/src/collection.ts

@@ -8,7 +8,7 @@ import {
   getTopology
 } from './utils';
 import { Document, BSONSerializeOptions, resolveBSONOptions } from './bson';
-import { MongoDriverError } from './error';
+import { MongoInvalidArgumentError } from './error';
 import { UnorderedBulkOperation } from './bulk/unordered';
 import { OrderedBulkOperation } from './bulk/ordered';
 import { ChangeStream, ChangeStreamOptions } from './change_stream';
@@ -40,7 +40,6 @@ import {
   EstimatedDocumentCountOptions
 } from './operations/estimated_document_count';
 import type { FindOptions } from './operations/find';
-import { FindOneOperation } from './operations/find_one';
 import {
   FindOneAndDeleteOperation,
   FindOneAndReplaceOperation,
@@ -100,7 +99,7 @@ import type {
 
 /** @public */
 export interface ModifyResult<TSchema = Document> {
-  value?: TSchema;
+  value: TSchema | null;
   lastErrorObject?: Document;
   ok: 0 | 1;
 }
@@ -390,7 +389,7 @@ export class Collection<TSchema extends Document = Document> {
     options = options || { ordered: true };
 
     if (!Array.isArray(operations)) {
-      throw new MongoDriverError('operations must be an array of documents');
+      throw new MongoInvalidArgumentError('Argument "operations" must be an array of documents');
     }
 
     return executeOperation(
@@ -415,34 +414,39 @@ export class Collection<TSchema extends Document = Document> {
   updateOne(
     filter: Filter<TSchema>,
     update: UpdateFilter<TSchema> | Partial<TSchema>
-  ): Promise<UpdateResult | Document>;
+  ): Promise<UpdateResult>;
   updateOne(
     filter: Filter<TSchema>,
     update: UpdateFilter<TSchema> | Partial<TSchema>,
-    callback: Callback<UpdateResult | Document>
+    callback: Callback<UpdateResult>
   ): void;
   updateOne(
     filter: Filter<TSchema>,
     update: UpdateFilter<TSchema> | Partial<TSchema>,
     options: UpdateOptions
-  ): Promise<UpdateResult | Document>;
+  ): Promise<UpdateResult>;
   updateOne(
     filter: Filter<TSchema>,
     update: UpdateFilter<TSchema> | Partial<TSchema>,
     options: UpdateOptions,
-    callback: Callback<UpdateResult | Document>
+    callback: Callback<UpdateResult>
   ): void;
   updateOne(
     filter: Filter<TSchema>,
     update: UpdateFilter<TSchema> | Partial<TSchema>,
-    options?: UpdateOptions | Callback<UpdateResult | Document>,
-    callback?: Callback<UpdateResult | Document>
-  ): Promise<UpdateResult | Document> | void {
+    options?: UpdateOptions | Callback<UpdateResult>,
+    callback?: Callback<UpdateResult>
+  ): Promise<UpdateResult> | void {
     if (typeof options === 'function') (callback = options), (options = {});
 
     return executeOperation(
       getTopology(this),
-      new UpdateOneOperation(this as TODO_NODE_3286, filter, update, resolveOptions(this, options)),
+      new UpdateOneOperation(
+        this as TODO_NODE_3286,
+        filter,
+        update,
+        resolveOptions(this, options)
+      ) as TODO_NODE_3286,
       callback
     );
   }
@@ -621,7 +625,7 @@ export class Collection<TSchema extends Document = Document> {
    */
   rename(newName: string): Promise<Collection>;
   rename(newName: string, callback: Callback<Collection>): void;
-  rename(newName: string, options: RenameOptions): Promise<Collection> | void;
+  rename(newName: string, options: RenameOptions): Promise<Collection>;
   rename(newName: string, options: RenameOptions, callback: Callback<Collection>): void;
   rename(
     newName: string,
@@ -672,52 +676,48 @@ export class Collection<TSchema extends Document = Document> {
    * @param options - Optional settings for the command
    * @param callback - An optional callback, a Promise will be returned if none is provided
    */
-  findOne(): Promise<TSchema | undefined>;
-  findOne(callback: Callback<TSchema | undefined>): void;
-  findOne(filter: Filter<TSchema>): Promise<TSchema | undefined>;
-  findOne(filter: Filter<TSchema>, callback: Callback<TSchema | undefined>): void;
-  findOne(filter: Filter<TSchema>, options: FindOptions<TSchema>): Promise<TSchema | undefined>;
-  findOne(
-    filter: Filter<TSchema>,
-    options: FindOptions<TSchema>,
-    callback: Callback<TSchema | undefined>
-  ): void;
+  findOne(): Promise<TSchema | null>;
+  findOne(callback: Callback<TSchema | null>): void;
+  findOne(filter: Filter<TSchema>): Promise<TSchema | null>;
+  findOne(filter: Filter<TSchema>, callback: Callback<TSchema | null>): void;
+  findOne(filter: Filter<TSchema>, options: FindOptions): Promise<TSchema | null>;
+  findOne(filter: Filter<TSchema>, options: FindOptions, callback: Callback<TSchema | null>): void;
 
   // allow an override of the schema.
-  findOne<T = TSchema>(): Promise<T | undefined>;
-  findOne<T = TSchema>(callback: Callback<T | undefined>): void;
-  findOne<T = TSchema>(filter: Filter<T>): Promise<T | undefined>;
-  findOne<T = TSchema>(filter: Filter<T>, options?: FindOptions<T>): Promise<T | undefined>;
+  findOne<T = TSchema>(): Promise<T | null>;
+  findOne<T = TSchema>(callback: Callback<T | null>): void;
+  findOne<T = TSchema>(filter: Filter<TSchema>): Promise<T | null>;
+  findOne<T = TSchema>(filter: Filter<TSchema>, options?: FindOptions): Promise<T | null>;
   findOne<T = TSchema>(
-    filter: Filter<T>,
-    options?: FindOptions<T>,
-    callback?: Callback<T | undefined>
+    filter: Filter<TSchema>,
+    options?: FindOptions,
+    callback?: Callback<T | null>
   ): void;
 
   findOne(
-    filter?: Filter<TSchema> | Callback<TSchema | undefined>,
-    options?: FindOptions<TSchema> | Callback<TSchema | undefined>,
-    callback?: Callback<TSchema>
-  ): Promise<TSchema | undefined> | void {
-    if (callback !== undefined && typeof callback !== 'function') {
-      throw new MongoDriverError('Third parameter to `findOne()` must be a callback or undefined');
+    filter?: Filter<TSchema> | Callback<TSchema | null>,
+    options?: FindOptions | Callback<TSchema | null>,
+    callback?: Callback<TSchema | null>
+  ): Promise<TSchema | null> | void {
+    if (callback != null && typeof callback !== 'function') {
+      throw new MongoInvalidArgumentError(
+        'Third parameter to `findOne()` must be a callback or undefined'
+      );
     }
 
-    if (typeof filter === 'function')
-      (callback = filter as Callback<Document | undefined>), (filter = {}), (options = {});
-    if (typeof options === 'function') (callback = options), (options = {});
-
-    filter ??= {};
+    if (typeof filter === 'function') {
+      callback = filter as Callback<TSchema | null>;
+      filter = {};
+      options = {};
+    }
+    if (typeof options === 'function') {
+      callback = options;
+      options = {};
+    }
 
-    return executeOperation(
-      getTopology(this),
-      new FindOneOperation(
-        this as TODO_NODE_3286,
-        filter,
-        resolveOptions(this, options)
-      ) as TODO_NODE_3286,
-      callback as TODO_NODE_3286
-    );
+    const finalFilter = filter ?? {};
+    const finalOptions = options ?? {};
+    return this.find(finalFilter, finalOptions).limit(-1).batchSize(1).next(callback);
   }
 
   /**
@@ -726,14 +726,16 @@ export class Collection<TSchema extends Document = Document> {
    * @param filter - The filter predicate. If unspecified, then all documents in the collection will match the predicate
    */
   find(): FindCursor<TSchema>;
-  find(filter: Filter<TSchema>, options?: FindOptions<TSchema>): FindCursor<TSchema>;
-  find<T = TSchema>(filter: Filter<T>, options?: FindOptions<T>): FindCursor<T>;
-  find(filter?: Filter<TSchema>, options?: FindOptions<TSchema>): FindCursor<TSchema> {
+  find(filter: Filter<TSchema>, options?: FindOptions): FindCursor<TSchema>;
+  find<T>(filter: Filter<TSchema>, options?: FindOptions): FindCursor<T>;
+  find(filter?: Filter<TSchema>, options?: FindOptions): FindCursor<TSchema> {
     if (arguments.length > 2) {
-      throw new MongoDriverError('Third parameter to `collection.find()` must be undefined');
+      throw new MongoInvalidArgumentError(
+        'Method "collection.find()" accepts at most two arguments'
+      );
     }
     if (typeof options === 'function') {
-      throw new MongoDriverError('`options` parameter must not be function');
+      throw new MongoInvalidArgumentError('Argument "options" must not be function');
     }
 
     return new FindCursor<TSchema>(
@@ -1084,7 +1086,7 @@ export class Collection<TSchema extends Document = Document> {
     options?: CountDocumentsOptions | Callback<number>,
     callback?: Callback<number>
   ): Promise<number> | void {
-    if (typeof filter === 'undefined') {
+    if (filter == null) {
       (filter = {}), (options = {}), (callback = undefined);
     } else if (typeof filter === 'function') {
       (callback = filter as Callback<number>), (filter = {}), (options = {});
@@ -1188,14 +1190,14 @@ export class Collection<TSchema extends Document = Document> {
    * @param options - Optional settings for the command
    * @param callback - An optional callback, a Promise will be returned if none is provided
    */
-  indexes(): Promise<Document>;
-  indexes(callback: Callback<Document>): void;
-  indexes(options: IndexInformationOptions): Promise<Document>;
-  indexes(options: IndexInformationOptions, callback: Callback<Document>): void;
+  indexes(): Promise<Document[]>;
+  indexes(callback: Callback<Document[]>): void;
+  indexes(options: IndexInformationOptions): Promise<Document[]>;
+  indexes(options: IndexInformationOptions, callback: Callback<Document[]>): void;
   indexes(
-    options?: IndexInformationOptions | Callback<Document>,
-    callback?: Callback<Document>
-  ): Promise<Document> | void {
+    options?: IndexInformationOptions | Callback<Document[]>,
+    callback?: Callback<Document[]>
+  ): Promise<Document[]> | void {
     if (typeof options === 'function') (callback = options), (options = {});
 
     return executeOperation(
@@ -1237,11 +1239,11 @@ export class Collection<TSchema extends Document = Document> {
    * @param callback - An optional callback, a Promise will be returned if none is provided
    */
   findOneAndDelete(filter: Filter<TSchema>): Promise<ModifyResult<TSchema>>;
-  findOneAndDelete(filter: Filter<TSchema>, callback: Callback<ModifyResult<TSchema>>): void;
   findOneAndDelete(
     filter: Filter<TSchema>,
     options: FindOneAndDeleteOptions
   ): Promise<ModifyResult<TSchema>>;
+  findOneAndDelete(filter: Filter<TSchema>, callback: Callback<ModifyResult<TSchema>>): void;
   findOneAndDelete(
     filter: Filter<TSchema>,
     options: FindOneAndDeleteOptions,
@@ -1369,17 +1371,20 @@ export class Collection<TSchema extends Document = Document> {
     options?: AggregateOptions
   ): AggregationCursor<T> {
     if (arguments.length > 2) {
-      throw new MongoDriverError('Third parameter to `collection.aggregate()` must be undefined');
+      throw new MongoInvalidArgumentError(
+        'Method "collection.aggregate()" accepts at most two arguments'
+      );
     }
     if (!Array.isArray(pipeline)) {
-      throw new MongoDriverError('`pipeline` parameter must be an array of aggregation stages');
+      throw new MongoInvalidArgumentError(
+        'Argument "pipeline" must be an array of aggregation stages'
+      );
     }
     if (typeof options === 'function') {
-      throw new MongoDriverError('`options` parameter must not be function');
+      throw new MongoInvalidArgumentError('Argument "options" must not be function');
     }
 
     return new AggregationCursor(
-      this as TODO_NODE_3286,
       getTopology(this),
       this.s.namespace,
       pipeline,
@@ -1445,8 +1450,8 @@ export class Collection<TSchema extends Document = Document> {
     // Out must always be defined (make sure we don't break weirdly on pre 1.8+ servers)
     // TODO NODE-3339: Figure out if this is still necessary given we no longer officially support pre-1.8
     if (options?.out == null) {
-      throw new MongoDriverError(
-        'the out option parameter must be defined, see mongodb docs for possible values'
+      throw new MongoInvalidArgumentError(
+        'Option "out" must be defined, see mongodb docs for possible values'
       );
     }