mongodb 4.3.1 → 4.5.0

package/src/cursor/abstract_cursor.ts

@@ -42,6 +42,8 @@ const kInitialized = Symbol('initialized');
 const kClosed = Symbol('closed');
 /** @internal */
 const kKilled = Symbol('killed');
+/** @internal */
+const kInit = Symbol('kInit');
 
 /** @public */
 export const CURSOR_FLAGS = [
@@ -77,7 +79,15 @@ export interface AbstractCursorOptions extends BSONSerializeOptions {
   readConcern?: ReadConcernLike;
   batchSize?: number;
   maxTimeMS?: number;
-  comment?: Document | string;
+  /**
+   * Comment to apply to the operation.
+   *
+   * In server versions pre-4.4, 'comment' must be string.  A server
+   * error will be thrown if any other type is provided.
+   *
+   * In server versions 4.4 and above, 'comment' can be any valid BSON type.
+   */
+  comment?: unknown;
   tailable?: boolean;
   awaitData?: boolean;
   noCursorTimeout?: boolean;
@@ -118,7 +128,7 @@ export abstract class AbstractCursor<
   /** @internal */
   [kTopology]: Topology;
   /** @internal */
-  [kTransform]?: (doc: TSchema) => Document;
+  [kTransform]?: (doc: TSchema) => any;
   /** @internal */
   [kInitialized]: boolean;
   /** @internal */
@@ -162,7 +172,9 @@ export abstract class AbstractCursor<
       this[kOptions].batchSize = options.batchSize;
     }
 
-    if (options.comment != null) {
+    // we check for undefined specifically here to allow falsy values
+    // eslint-disable-next-line no-restricted-syntax
+    if (options.comment !== undefined) {
       this[kOptions].comment = options.comment;
     }
 
@@ -618,11 +630,70 @@ export abstract class AbstractCursor<
       batchSize
     });
 
-    executeOperation(this.topology, getMoreOperation, callback);
+    executeOperation(this, getMoreOperation, callback);
+  }
+
+  /**
+   * @internal
+   *
+   * This function is exposed for the unified test runner's createChangeStream
+   * operation.  We cannot refactor to use the abstract _initialize method without
+   * a significant refactor.
+   */
+  [kInit](callback: Callback<TSchema | null>): void {
+    if (this[kSession] == null) {
+      if (this[kTopology].shouldCheckForSessionSupport()) {
+        return this[kTopology].selectServer(ReadPreference.primaryPreferred, {}, err => {
+          if (err) return callback(err);
+          return this[kInit](callback);
+        });
+      } else if (this[kTopology].hasSessionSupport()) {
+        this[kSession] = this[kTopology].startSession({ owner: this, explicit: false });
+      }
+    }
+
+    this._initialize(this[kSession], (err, state) => {
+      if (state) {
+        const response = state.response;
+        this[kServer] = state.server;
+        this[kSession] = state.session;
+
+        if (response.cursor) {
+          this[kId] =
+            typeof response.cursor.id === 'number'
+              ? Long.fromNumber(response.cursor.id)
+              : response.cursor.id;
+
+          if (response.cursor.ns) {
+            this[kNamespace] = ns(response.cursor.ns);
+          }
+
+          this[kDocuments] = response.cursor.firstBatch;
+        }
+
+        // When server responses return without a cursor document, we close this cursor
+        // and return the raw server response. This is often the case for explain commands
+        // for example
+        if (this[kId] == null) {
+          this[kId] = Long.ZERO;
+          // TODO(NODE-3286): ExecutionResult needs to accept a generic parameter
+          this[kDocuments] = [state.response as TODO_NODE_3286];
+        }
+      }
+
+      // the cursor is now initialized, even if an error occurred or it is dead
+      this[kInitialized] = true;
+
+      if (err || cursorIsDead(this)) {
+        return cleanupCursor(this, { error: err }, () => callback(err, nextDocument(this)));
+      }
+
+      callback();
+    });
   }
 }
 
-function nextDocument<T>(cursor: AbstractCursor): T | null | undefined {
+function nextDocument<T>(cursor: AbstractCursor): T | null {
   if (cursor[kDocuments] == null || !cursor[kDocuments].length) {
     return null;
   }
@@ -640,67 +711,25 @@ function nextDocument<T>(cursor: AbstractCursor): T | null | undefined {
   return null;
 }
 
-function next<T>(cursor: AbstractCursor, blocking: boolean, callback: Callback<T | null>): void {
+function next<T>(cursor: AbstractCursor<T>, blocking: boolean, callback: Callback<T | null>): void {
   const cursorId = cursor[kId];
   if (cursor.closed) {
     return callback(undefined, null);
   }
 
   if (cursor[kDocuments] && cursor[kDocuments].length) {
-    callback(undefined, nextDocument(cursor));
+    callback(undefined, nextDocument<T>(cursor));
     return;
   }
 
   if (cursorId == null) {
     // All cursors must operate within a session, one must be made implicitly if not explicitly provided
-    if (cursor[kSession] == null && cursor[kTopology].hasSessionSupport()) {
-      cursor[kSession] = cursor[kTopology].startSession({ owner: cursor, explicit: false });
-    }
-
-    cursor._initialize(cursor[kSession], (err, state) => {
-      if (state) {
-        const response = state.response;
-        cursor[kServer] = state.server;
-        cursor[kSession] = state.session;
-
-        if (response.cursor) {
-          cursor[kId] =
-            typeof response.cursor.id === 'number'
-              ? Long.fromNumber(response.cursor.id)
-              : response.cursor.id;
-
-          if (response.cursor.ns) {
-            cursor[kNamespace] = ns(response.cursor.ns);
-          }
-
-          cursor[kDocuments] = response.cursor.firstBatch;
-        } else {
-          // NOTE: This is for support of older servers (<3.2) which do not use commands
-          cursor[kId] =
-            typeof response.cursorId === 'number'
-              ? Long.fromNumber(response.cursorId)
-              : response.cursorId;
-          cursor[kDocuments] = response.documents;
-        }
-
-        // When server responses return without a cursor document, we close this cursor
-        // and return the raw server response. This is often the case for explain commands
-        // for example
-        if (cursor[kId] == null) {
-          cursor[kId] = Long.ZERO;
-          // TODO(NODE-3286): ExecutionResult needs to accept a generic parameter
-          cursor[kDocuments] = [state.response as TODO_NODE_3286];
-        }
-      }
-
-      // the cursor is now initialized, even if an error occurred or it is dead
-      cursor[kInitialized] = true;
-
-      if (err || cursorIsDead(cursor)) {
-        return cleanupCursor(cursor, { error: err }, () => callback(err, nextDocument(cursor)));
+    cursor[kInit]((err, value) => {
+      if (err) return callback(err);
+      if (value) {
+        return callback(undefined, value);
       }
-
-      next(cursor, blocking, callback);
+      return next(cursor, blocking, callback);
     });
 
     return;
@@ -724,7 +753,7 @@ function next<T>(cursor: AbstractCursor, blocking: boolean, callback: Callback<T
     }
 
     if (err || cursorIsDead(cursor)) {
-      return cleanupCursor(cursor, { error: err }, () => callback(err, nextDocument(cursor)));
+      return cleanupCursor(cursor, { error: err }, () => callback(err, nextDocument<T>(cursor)));
     }
 
     if (cursor[kDocuments].length === 0 && blocking === false) {
@@ -812,7 +841,7 @@ export function assertUninitialized(cursor: AbstractCursor): void {
   }
 }
 
-function makeCursorStream<TSchema extends Document>(cursor: AbstractCursor<TSchema>) {
+function makeCursorStream(cursor: AbstractCursor) {
   const readable = new Readable({
     objectMode: true,
     autoDestroy: false,

package/src/cursor/aggregation_cursor.ts

@@ -25,7 +25,7 @@ const kOptions = Symbol('options');
  * or higher stream
  * @public
  */
-export class AggregationCursor<TSchema = Document> extends AbstractCursor<TSchema> {
+export class AggregationCursor<TSchema = any> extends AbstractCursor<TSchema> {
   /** @internal */
   [kPipeline]: Document[];
   /** @internal */
@@ -56,19 +56,19 @@ export class AggregationCursor<TSchema = Document> extends AbstractCursor<TSchem
     });
   }
 
-  map<T>(transform: (doc: TSchema) => T): AggregationCursor<T> {
+  override map<T>(transform: (doc: TSchema) => T): AggregationCursor<T> {
     return super.map(transform) as AggregationCursor<T>;
   }
 
   /** @internal */
-  _initialize(session: ClientSession | undefined, callback: Callback<ExecutionResult>): void {
+  _initialize(session: ClientSession, callback: Callback<ExecutionResult>): void {
     const aggregateOperation = new AggregateOperation(this.namespace, this[kPipeline], {
       ...this[kOptions],
       ...this.cursorOptions,
       session
     });
 
-    executeOperation(this.topology, aggregateOperation, (err, response) => {
+    executeOperation(this, aggregateOperation, (err, response) => {
       if (err || response == null) return callback(err);
 
       // TODO: NODE-2882
@@ -88,7 +88,7 @@ export class AggregationCursor<TSchema = Document> extends AbstractCursor<TSchem
     if (verbosity == null) verbosity = true;
 
     return executeOperation(
-      this.topology,
+      this,
       new AggregateOperation(this.namespace, this[kPipeline], {
         ...this[kOptions], // NOTE: order matters here, we may need to refine this
         ...this.cursorOptions,

package/src/cursor/find_cursor.ts

@@ -9,8 +9,7 @@ import type { Hint } from '../operations/operation';
 import type { Topology } from '../sdam/topology';
 import type { ClientSession } from '../sessions';
 import { formatSort, Sort, SortDirection } from '../sort';
-import type { Callback, MongoDBNamespace } from '../utils';
-import { mergeOptions } from '../utils';
+import { Callback, emitWarningOnce, mergeOptions, MongoDBNamespace } from '../utils';
 import { AbstractCursor, assertUninitialized } from './abstract_cursor';
 
 /** @internal */
@@ -31,7 +30,7 @@ export const FLAGS = [
 ] as const;
 
 /** @public */
-export class FindCursor<TSchema = Document> extends AbstractCursor<TSchema> {
+export class FindCursor<TSchema = any> extends AbstractCursor<TSchema> {
   /** @internal */
   [kFilter]: Document;
   /** @internal */
@@ -64,19 +63,19 @@ export class FindCursor<TSchema = Document> extends AbstractCursor<TSchema> {
     });
   }
 
-  map<T>(transform: (doc: TSchema) => T): FindCursor<T> {
+  override map<T>(transform: (doc: TSchema) => T): FindCursor<T> {
     return super.map(transform) as FindCursor<T>;
   }
 
   /** @internal */
-  _initialize(session: ClientSession | undefined, callback: Callback<ExecutionResult>): void {
+  _initialize(session: ClientSession, callback: Callback<ExecutionResult>): void {
     const findOperation = new FindOperation(undefined, this.namespace, this[kFilter], {
       ...this[kBuiltOptions], // NOTE: order matters here, we may need to refine this
       ...this.cursorOptions,
       session
     });
 
-    executeOperation(this.topology, findOperation, (err, response) => {
+    executeOperation(this, findOperation, (err, response) => {
       if (err || response == null) return callback(err);
 
       // TODO: We only need this for legacy queries that do not support `limit`, maybe
@@ -93,7 +92,7 @@ export class FindCursor<TSchema = Document> extends AbstractCursor<TSchema> {
   }
 
   /** @internal */
-  _getMore(batchSize: number, callback: Callback<Document>): void {
+  override _getMore(batchSize: number, callback: Callback<Document>): void {
     // NOTE: this is to support client provided limits in pre-command servers
     const numReturned = this[kNumReturned];
     if (numReturned) {
@@ -118,15 +117,24 @@ export class FindCursor<TSchema = Document> extends AbstractCursor<TSchema> {
     });
   }
 
-  /** Get the count of documents for this cursor */
+  /**
+   * Get the count of documents for this cursor
+   * @deprecated Use `collection.estimatedDocumentCount` or `collection.countDocuments` instead
+   */
   count(): Promise<number>;
+  /** @deprecated Use `collection.estimatedDocumentCount` or `collection.countDocuments` instead */
   count(callback: Callback<number>): void;
+  /** @deprecated Use `collection.estimatedDocumentCount` or `collection.countDocuments` instead */
   count(options: CountOptions): Promise<number>;
+  /** @deprecated Use `collection.estimatedDocumentCount` or `collection.countDocuments` instead */
   count(options: CountOptions, callback: Callback<number>): void;
   count(
     options?: CountOptions | Callback<number>,
     callback?: Callback<number>
   ): Promise<number> | void {
+    emitWarningOnce(
+      'cursor.count is deprecated and will be removed in the next major version, please use `collection.estimatedDocumentCount` or `collection.countDocuments` instead '
+    );
     if (typeof options === 'boolean') {
       throw new MongoInvalidArgumentError('Invalid first parameter to count');
     }
@@ -135,7 +143,7 @@ export class FindCursor<TSchema = Document> extends AbstractCursor<TSchema> {
     options = options ?? {};
 
     return executeOperation(
-      this.topology,
+      this,
       new CountOperation(this.namespace, this[kFilter], {
         ...this[kBuiltOptions], // NOTE: order matters here, we may need to refine this
         ...this.cursorOptions,
@@ -157,7 +165,7 @@ export class FindCursor<TSchema = Document> extends AbstractCursor<TSchema> {
     if (verbosity == null) verbosity = true;
 
     return executeOperation(
-      this.topology,
+      this,
       new FindOperation(undefined, this.namespace, this[kFilter], {
         ...this[kBuiltOptions], // NOTE: order matters here, we may need to refine this
         ...this.cursorOptions,
@@ -326,7 +334,7 @@ export class FindCursor<TSchema = Document> extends AbstractCursor<TSchema> {
    *
    * @param value - Number of milliseconds to wait before aborting the query.
    */
-  maxTimeMS(value: number): this {
+  override maxTimeMS(value: number): this {
     assertUninitialized(this);
     if (typeof value !== 'number') {
       throw new MongoInvalidArgumentError('Argument for maxTimeMS must be a number');

package/src/db.ts

@@ -258,7 +258,7 @@ export class Db {
     if (typeof options === 'function') (callback = options), (options = {});
 
     return executeOperation(
-      getTopology(this),
+      this,
       new CreateCollectionOperation(this, name, resolveOptions(this, options)) as TODO_NODE_3286,
       callback
     ) as TODO_NODE_3286;
@@ -286,11 +286,7 @@ export class Db {
     if (typeof options === 'function') (callback = options), (options = {});
 
     // Intentionally, we do not inherit options from parent for this operation.
-    return executeOperation(
-      getTopology(this),
-      new RunCommandOperation(this, command, options ?? {}),
-      callback
-    );
+    return executeOperation(this, new RunCommandOperation(this, command, options ?? {}), callback);
   }
 
   /**
@@ -299,7 +295,7 @@ export class Db {
    * @param pipeline - An array of aggregation stages to be executed
    * @param options - Optional settings for the command
    */
-  aggregate<T = Document>(
+  aggregate<T extends Document = Document>(
     pipeline: Document[] = [],
     options?: AggregateOptions
   ): AggregationCursor<T> {
@@ -359,7 +355,7 @@ export class Db {
   ): Promise<Document> | void {
     if (typeof options === 'function') (callback = options), (options = {});
     return executeOperation(
-      getTopology(this),
+      this,
       new DbStatsOperation(this, resolveOptions(this, options)),
       callback
     );
@@ -438,7 +434,7 @@ export class Db {
     options.new_collection = true;
 
     return executeOperation(
-      getTopology(this),
+      this,
       new RenameOperation(
         this.collection<TSchema>(fromCollection) as TODO_NODE_3286,
         toCollection,
@@ -467,7 +463,7 @@ export class Db {
     if (typeof options === 'function') (callback = options), (options = {});
 
     return executeOperation(
-      getTopology(this),
+      this,
       new DropCollectionOperation(this, name, resolveOptions(this, options)),
       callback
     );
@@ -490,7 +486,7 @@ export class Db {
     if (typeof options === 'function') (callback = options), (options = {});
 
     return executeOperation(
-      getTopology(this),
+      this,
       new DropDatabaseOperation(this, resolveOptions(this, options)),
       callback
     );
@@ -513,7 +509,7 @@ export class Db {
     if (typeof options === 'function') (callback = options), (options = {});
 
     return executeOperation(
-      getTopology(this),
+      this,
       new CollectionsOperation(this, resolveOptions(this, options)),
       callback
     );
@@ -549,7 +545,7 @@ export class Db {
     if (typeof options === 'function') (callback = options), (options = {});
 
     return executeOperation(
-      getTopology(this),
+      this,
       new CreateIndexOperation(this, name, indexSpec, resolveOptions(this, options)),
       callback
     );
@@ -595,7 +591,7 @@ export class Db {
     }
 
     return executeOperation(
-      getTopology(this),
+      this,
       new AddUserOperation(this, username, password, resolveOptions(this, options)),
       callback
     );
@@ -620,7 +616,7 @@ export class Db {
     if (typeof options === 'function') (callback = options), (options = {});
 
     return executeOperation(
-      getTopology(this),
+      this,
       new RemoveUserOperation(this, username, resolveOptions(this, options)),
       callback
     );
@@ -652,7 +648,7 @@ export class Db {
     if (typeof options === 'function') (callback = options), (options = {});
 
     return executeOperation(
-      getTopology(this),
+      this,
       new SetProfilingLevelOperation(this, level, resolveOptions(this, options)),
       callback
     );
@@ -675,7 +671,7 @@ export class Db {
     if (typeof options === 'function') (callback = options), (options = {});
 
     return executeOperation(
-      getTopology(this),
+      this,
       new ProfilingLevelOperation(this, resolveOptions(this, options)),
       callback
     );
@@ -704,7 +700,7 @@ export class Db {
     if (typeof options === 'function') (callback = options), (options = {});
 
     return executeOperation(
-      getTopology(this),
+      this,
       new IndexInformationOperation(this, name, resolveOptions(this, options)),
       callback
     );
@@ -726,7 +722,7 @@ export class Db {
    * @param pipeline - An array of {@link https://docs.mongodb.com/manual/reference/operator/aggregation-pipeline/|aggregation pipeline stages} through which to pass change stream documents. This allows for filtering (using $match) and manipulating the change stream documents.
    * @param options - Optional settings for the command
    */
-  watch<TSchema = Document>(
+  watch<TSchema extends Document = Document>(
     pipeline: Document[] = [],
     options: ChangeStreamOptions = {}
   ): ChangeStream<TSchema> {

package/src/deps.ts

@@ -174,6 +174,28 @@ export const AutoEncryptionLoggerLevel = Object.freeze({
 export type AutoEncryptionLoggerLevel =
   typeof AutoEncryptionLoggerLevel[keyof typeof AutoEncryptionLoggerLevel];
 
+/** @public */
+export interface AutoEncryptionTlsOptions {
+  /**
+   * Specifies the location of a local .pem file that contains
+   * either the client's TLS/SSL certificate and key or only the
+   * client's TLS/SSL key when tlsCertificateFile is used to
+   * provide the certificate.
+   */
+  tlsCertificateKeyFile?: string;
+  /**
+   * Specifies the password to de-crypt the tlsCertificateKeyFile.
+   */
+  tlsCertificateKeyFilePassword?: string;
+  /**
+   * Specifies the location of a local .pem file that contains the
+   * root certificate chain from the Certificate Authority.
+   * This file is used to validate the certificate presented by the
+   * KMS provider.
+   */
+  tlsCAFile?: string;
+}
+
 /** @public */
 export interface AutoEncryptionOptions {
   /** @internal */
@@ -234,6 +256,17 @@ export interface AutoEncryptionOptions {
        */
       endpoint?: string | undefined;
     };
+    /**
+     * Configuration options for using 'kmip' as your KMS provider
+     */
+    kmip?: {
+      /**
+       * The output endpoint string.
+       * The endpoint consists of a hostname and port separated by a colon.
+       * E.g. "example.com:123". A port is always present.
+       */
+      endpoint?: string;
+    };
   };
   /**
    * A map of namespaces to a local JSON schema for encryption
@@ -262,8 +295,26 @@ export interface AutoEncryptionOptions {
     mongocryptdSpawnPath?: string;
     /** Command line arguments to use when auto-spawning a mongocryptd */
     mongocryptdSpawnArgs?: string[];
+    /**
+     * Full path to a CSFLE shared library to be used (instead of mongocryptd)
+     * @experimental
+     */
+    csflePath?: string;
+    /**
+     * Search paths for a CSFLE shared library to be used (instead of mongocryptd)
+     * @experimental
+     */
+    csfleSearchPaths?: string[];
   };
   proxyOptions?: ProxyOptions;
+  /** The TLS options to use connecting to the KMS provider */
+  tlsOptions?: {
+    aws?: AutoEncryptionTlsOptions;
+    local?: AutoEncryptionTlsOptions;
+    azure?: AutoEncryptionTlsOptions;
+    gcp?: AutoEncryptionTlsOptions;
+    kmip?: AutoEncryptionTlsOptions;
+  };
 }
 
 /** @public */
@@ -274,4 +325,5 @@ export interface AutoEncrypter {
   teardown(force: boolean, callback: Callback): void;
   encrypt(ns: string, cmd: Document, options: any, callback: Callback<Document>): void;
   decrypt(cmd: Document, options: any, callback: Callback<Document>): void;
+  readonly csfleVersionInfo: { version: bigint; versionStr: string } | null;
 }

package/src/encrypter.ts

@@ -19,7 +19,7 @@ export interface EncrypterOptions {
 
 /** @internal */
 export class Encrypter {
-  [kInternalClient]: MongoClient;
+  [kInternalClient]: MongoClient | null;
   bypassAutoEncryption: boolean;
   needsConnecting: boolean;
   autoEncrypter: AutoEncrypter;
@@ -28,6 +28,8 @@ export class Encrypter {
     if (typeof options.autoEncryption !== 'object') {
       throw new MongoInvalidArgumentError('Option "autoEncryption" must be specified');
     }
+    // initialize to null, if we call getInternalClient, we may set this it is important to not overwrite those function calls.
+    this[kInternalClient] = null;
 
     this.bypassAutoEncryption = !!options.autoEncryption.bypassAutoEncryption;
     this.needsConnecting = false;
@@ -65,7 +67,9 @@ export class Encrypter {
   }
 
   getInternalClient(client: MongoClient, uri: string, options: MongoClientOptions): MongoClient {
-    if (!this[kInternalClient]) {
+    // TODO(NODE-4144): Remove new variable for type narrowing
+    let internalClient = this[kInternalClient];
+    if (internalClient == null) {
       const clonedOptions: MongoClientOptions = {};
 
       for (const key of Object.keys(options)) {
@@ -76,27 +80,30 @@ export class Encrypter {
 
       clonedOptions.minPoolSize = 0;
 
-      this[kInternalClient] = new MongoClient(uri, clonedOptions);
+      internalClient = new MongoClient(uri, clonedOptions);
+      this[kInternalClient] = internalClient;
 
       for (const eventName of MONGO_CLIENT_EVENTS) {
         for (const listener of client.listeners(eventName)) {
-          this[kInternalClient].on(eventName, listener);
+          internalClient.on(eventName, listener);
         }
       }
 
       client.on('newListener', (eventName, listener) => {
-        this[kInternalClient].on(eventName, listener);
+        internalClient?.on(eventName, listener);
       });
 
       this.needsConnecting = true;
     }
-    return this[kInternalClient];
+    return internalClient;
   }
 
   connectInternalClient(callback: Callback): void {
-    if (this.needsConnecting) {
+    // TODO(NODE-4144): Remove new variable for type narrowing
+    const internalClient = this[kInternalClient];
+    if (this.needsConnecting && internalClient != null) {
       this.needsConnecting = false;
-      return this[kInternalClient].connect(callback);
+      return internalClient.connect(callback);
     }
 
     return callback();
@@ -104,8 +111,9 @@ export class Encrypter {
 
   close(client: MongoClient, force: boolean, callback: Callback): void {
     this.autoEncrypter.teardown(!!force, e => {
-      if (this[kInternalClient] && client !== this[kInternalClient]) {
-        return this[kInternalClient].close(force, callback);
+      const internalClient = this[kInternalClient];
+      if (internalClient != null && client !== internalClient) {
+        return internalClient.close(force, callback);
       }
       callback(e);
     });