mongodb 4.6.0 → 4.7.0

package/src/deps.ts

@@ -44,6 +44,30 @@ export interface KerberosClient {
   unwrap: (challenge: string, callback?: Callback<string>) => Promise<string> | void;
 }
 
+type ZStandardLib = {
+  /**
+   * Compress using zstd.
+   * @param buf - Buffer to be compressed.
+   */
+  compress(buf: Buffer, level?: number): Promise<Buffer>;
+
+  /**
+   * Decompress using zstd.
+   */
+  decompress(buf: Buffer): Promise<Buffer>;
+};
+
+export let ZStandard: ZStandardLib | { kModuleError: MongoMissingDependencyError } =
+  makeErrorModule(
+    new MongoMissingDependencyError(
+      'Optional module `@mongodb-js/zstd` not found. Please install it to enable zstd compression'
+    )
+  );
+
+try {
+  ZStandard = require('@mongodb-js/zstd');
+} catch {} // eslint-disable-line
+
 type SnappyLib = {
   [PKG_VERSION]: { major: number; minor: number; patch: number };
 
@@ -300,7 +324,7 @@ export interface AutoEncryptionOptions {
     /** 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).
+     * Full path to a MongoDB Crypt shared library to be used (instead of mongocryptd).
      *
      * This needs to be the path to the file itself, not a directory.
      * It can be an absolute or relative path. If the path is relative and
@@ -308,32 +332,36 @@ export interface AutoEncryptionOptions {
      * containing the mongodb-client-encryption native addon file. Otherwise,
      * the path will be interpreted relative to the current working directory.
      *
-     * Currently, loading different CSFLE shared library files from different
+     * Currently, loading different MongoDB Crypt shared library files from different
      * MongoClients in the same process is not supported.
      *
-     * If this option is provided and no CSFLE shared library could be loaded
+     * If this option is provided and no MongoDB Crypt shared library could be loaded
      * from the specified location, creating the MongoClient will fail.
      *
-     * If this option is not provided and `csfleRequired` is not specified,
+     * If this option is not provided and `cryptSharedLibRequired` is not specified,
      * the AutoEncrypter will attempt to spawn and/or use mongocryptd according
      * to the mongocryptd-specific `extraOptions` options.
      *
      * Specifying a path prevents mongocryptd from being used as a fallback.
+     *
+     * @experimental Requires the MongoDB Crypt shared library, available in MongoDB 6.0 or higher.
      */
-    csflePath?: string;
+    cryptSharedLibPath?: string;
     /**
-     * If specified, never use mongocryptd and instead fail when the CSFLE shared library
-     * could not be loaded.
+     * If specified, never use mongocryptd and instead fail when the MongoDB Crypt
+     * shared library could not be loaded.
      *
-     * This is always true when `csflePath` is specified.
+     * This is always true when `cryptSharedLibPath` is specified.
+     *
+     * @experimental Requires the MongoDB Crypt shared library, available in MongoDB 6.0 or higher.
      */
-    csfleRequired?: boolean;
+    cryptSharedLibRequired?: boolean;
     /**
-     * Search paths for a CSFLE shared library to be used (instead of mongocryptd)
+     * Search paths for a MongoDB Crypt shared library to be used (instead of mongocryptd)
      * Only for driver testing!
      * @internal
      */
-    csfleSearchPaths?: string[];
+    cryptSharedLibSearchPaths?: string[];
   };
   proxyOptions?: ProxyOptions;
   /** The TLS options to use connecting to the KMS provider */
@@ -354,5 +382,6 @@ 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;
+  /** @experimental */
+  readonly cryptSharedLibVersionInfo: { version: bigint; versionStr: string } | null;
 }

package/src/encrypter.ts

@@ -124,9 +124,15 @@ export class Encrypter {
 
   static checkForMongoCrypt(): void {
     let mongodbClientEncryption = undefined;
+    // Ensure you always wrap an optional require in the try block NODE-3199
     try {
-      // Ensure you always wrap an optional require in the try block NODE-3199
-      mongodbClientEncryption = require('mongodb-client-encryption');
+      // Note (NODE-4254): This is to get around the circular dependency between
+      // mongodb-client-encryption and the driver in the test scenarios.
+      if (process.env.MONGODB_CLIENT_ENCRYPTION_OVERRIDE) {
+        mongodbClientEncryption = require(process.env.MONGODB_CLIENT_ENCRYPTION_OVERRIDE);
+      } else {
+        mongodbClientEncryption = require('mongodb-client-encryption');
+      }
     } catch (err) {
       throw new MongoMissingDependencyError(
         'Auto-encryption requested, but the module is not installed. ' +

package/src/index.ts

@@ -171,21 +171,30 @@ export type { UnorderedBulkOperation } from './bulk/unordered';
 export type {
   ChangeStream,
   ChangeStreamAggregateRawResult,
+  ChangeStreamCollModDocument,
+  ChangeStreamCreateDocument,
+  ChangeStreamCreateIndexDocument,
   ChangeStreamCursor,
   ChangeStreamCursorOptions,
   ChangeStreamDeleteDocument,
   ChangeStreamDocument,
+  ChangeStreamDocumentCollectionUUID,
   ChangeStreamDocumentCommon,
   ChangeStreamDocumentKey,
+  ChangeStreamDocumentOperationDescription,
   ChangeStreamDropDatabaseDocument,
   ChangeStreamDropDocument,
+  ChangeStreamDropIndexDocument,
   ChangeStreamEvents,
   ChangeStreamInsertDocument,
   ChangeStreamInvalidateDocument,
   ChangeStreamNameSpace,
   ChangeStreamOptions,
+  ChangeStreamRefineCollectionShardKeyDocument,
   ChangeStreamRenameDocument,
   ChangeStreamReplaceDocument,
+  ChangeStreamReshardCollectionDocument,
+  ChangeStreamShardCollectionDocument,
   ChangeStreamUpdateDocument,
   OperationTime,
   PipeOptions,

package/src/mongo_client.ts

@@ -141,6 +141,8 @@ export interface MongoClientOptions extends BSONSerializeOptions, SupportedNodeC
   maxPoolSize?: number;
   /** The minimum number of connections in the connection pool. */
   minPoolSize?: number;
+  /** The maximum number of connections that may be in the process of being established concurrently by the connection pool. */
+  maxConnecting?: number;
   /** The maximum number of milliseconds that a connection can remain idle in the pool before being removed and closed. */
   maxIdleTimeMS?: number;
   /** The maximum time in milliseconds that a thread can wait for a connection to become available. */
@@ -268,11 +270,13 @@ export interface MongoClientPrivate {
   sessions: Set<ClientSession>;
   bsonOptions: BSONSerializeOptions;
   namespace: MongoDBNamespace;
-  readonly options?: MongoOptions;
+  hasBeenClosed: boolean;
+  readonly options: MongoOptions;
   readonly readConcern?: ReadConcern;
   readonly writeConcern?: WriteConcern;
   readonly readPreference: ReadPreference;
   readonly logger: Logger;
+  readonly isMongoClient: true;
 }
 
 /** @public */
@@ -351,6 +355,7 @@ export class MongoClient extends TypedEventEmitter<MongoClientEvents> {
       sessions: new Set(),
       bsonOptions: resolveBSONOptions(this[kOptions]),
       namespace: ns('admin'),
+      hasBeenClosed: false,
 
       get options() {
         return client[kOptions];
@@ -366,6 +371,9 @@ export class MongoClient extends TypedEventEmitter<MongoClientEvents> {
       },
       get logger() {
         return client[kOptions].logger;
+      },
+      get isMongoClient(): true {
+        return true;
       }
     };
   }
@@ -446,6 +454,14 @@ export class MongoClient extends TypedEventEmitter<MongoClientEvents> {
     forceOrCallback?: boolean | Callback<void>,
     callback?: Callback<void>
   ): Promise<void> | void {
+    // There's no way to set hasBeenClosed back to false
+    Object.defineProperty(this.s, 'hasBeenClosed', {
+      value: true,
+      enumerable: true,
+      configurable: false,
+      writable: false
+    });
+
     if (typeof forceOrCallback === 'function') {
       callback = forceOrCallback;
     }
@@ -638,6 +654,7 @@ export interface MongoOptions
         | 'keepAliveInitialDelay'
         | 'localThresholdMS'
         | 'logger'
+        | 'maxConnecting'
         | 'maxIdleTimeMS'
         | 'maxPoolSize'
         | 'minPoolSize'

package/src/operations/connect.ts

@@ -62,6 +62,7 @@ function createTopology(
   // Events can be emitted before initialization is complete so we have to
   // save the reference to the topology on the client ASAP if the event handlers need to access it
   mongoClient.topology = topology;
+  topology.client = mongoClient;
 
   topology.once(Topology.OPEN, () => mongoClient.emit('open', mongoClient));
 

package/src/operations/create_collection.ts

@@ -91,6 +91,11 @@ export interface CreateCollectionOptions extends CommandOperationOptions {
   expireAfterSeconds?: number;
   /** @experimental */
   encryptedFields?: Document;
+  /**
+   * If set, enables pre-update and post-update document events to be included for any
+   * change streams that listen on this collection.
+   */
+  changeStreamPreAndPostImages?: { enabled: boolean };
 }
 
 /** @internal */
@@ -122,13 +127,18 @@ export class CreateCollectionOperation extends CommandOperation<Collection> {
         db.s.client.options.autoEncryption?.encryptedFieldsMap?.[`${db.databaseName}.${name}`];
 
       if (encryptedFields) {
-        // Create auxilliary collections for FLE2 support.
+        // Create auxilliary collections for queryable encryption support.
         const escCollection = encryptedFields.escCollection ?? `enxcol_.${name}.esc`;
         const eccCollection = encryptedFields.eccCollection ?? `enxcol_.${name}.ecc`;
         const ecocCollection = encryptedFields.ecocCollection ?? `enxcol_.${name}.ecoc`;
 
         for (const collectionName of [escCollection, eccCollection, ecocCollection]) {
-          const createOp = new CreateCollectionOperation(db, collectionName);
+          const createOp = new CreateCollectionOperation(db, collectionName, {
+            clusteredIndex: {
+              key: { _id: 1 },
+              unique: true
+            }
+          });
           await createOp.executeWithoutEncryptedFieldsCheck(server, session);
         }
 
@@ -140,7 +150,7 @@ export class CreateCollectionOperation extends CommandOperation<Collection> {
       const coll = await this.executeWithoutEncryptedFieldsCheck(server, session);
 
       if (encryptedFields) {
-        // Create the required index for FLE2 support.
+        // Create the required index for queryable encryption support.
         const createIndexOp = new CreateIndexOperation(db, name, { __safeContent__: 1 }, {});
         await new Promise<void>((resolve, reject) => {
           createIndexOp.execute(server, session, err => (err ? reject(err) : resolve()));

package/src/operations/drop.ts

@@ -51,24 +51,6 @@ export class DropCollectionOperation extends CommandOperation<boolean> {
         encryptedFields = listCollectionsResult?.[0]?.options?.encryptedFields;
       }
 
-      let result;
-      let errorForMainOperation;
-      try {
-        result = await this.executeWithoutEncryptedFieldsCheck(server, session);
-      } catch (err) {
-        if (
-          !encryptedFields ||
-          !(err instanceof MongoServerError) ||
-          err.code !== MONGODB_ERROR_CODES.NamespaceNotFound
-        ) {
-          throw err;
-        }
-        // Save a possible NamespaceNotFound error for later
-        // in the encryptedFields case, so that the auxilliary
-        // collections will still be dropped.
-        errorForMainOperation = err;
-      }
-
       if (encryptedFields) {
         const escCollection = encryptedFields.escCollection || `enxcol_.${name}.esc`;
         const eccCollection = encryptedFields.eccCollection || `enxcol_.${name}.ecc`;
@@ -88,13 +70,9 @@ export class DropCollectionOperation extends CommandOperation<boolean> {
             }
           }
         }
-
-        if (errorForMainOperation) {
-          throw errorForMainOperation;
-        }
       }
 
-      return result;
+      return await this.executeWithoutEncryptedFieldsCheck(server, session);
     })().then(
       result => callback(undefined, result),
       err => callback(err)

package/src/operations/estimated_document_count.ts

@@ -1,9 +1,8 @@
 import type { Document } from '../bson';
 import type { Collection } from '../collection';
-import type { MongoServerError } from '../error';
 import type { Server } from '../sdam/server';
 import type { ClientSession } from '../sessions';
-import { Callback, maxWireVersion } from '../utils';
+import type { Callback } from '../utils';
 import { CommandOperation, CommandOperationOptions } from './command';
 import { Aspect, defineAspects } from './operation';
 
@@ -32,32 +31,6 @@ export class EstimatedDocumentCountOperation extends CommandOperation<number> {
     server: Server,
     session: ClientSession | undefined,
     callback: Callback<number>
-  ): void {
-    if (maxWireVersion(server) < 12) {
-      return this.executeLegacy(server, session, callback);
-    }
-    const pipeline = [{ $collStats: { count: {} } }, { $group: { _id: 1, n: { $sum: '$count' } } }];
-
-    const cmd: Document = { aggregate: this.collectionName, pipeline, cursor: {} };
-
-    if (typeof this.options.maxTimeMS === 'number') {
-      cmd.maxTimeMS = this.options.maxTimeMS;
-    }
-
-    super.executeCommand(server, session, cmd, (err, response) => {
-      if (err && (err as MongoServerError).code !== 26) {
-        callback(err);
-        return;
-      }
-
-      callback(undefined, response?.cursor?.firstBatch[0]?.n || 0);
-    });
-  }
-
-  executeLegacy(
-    server: Server,
-    session: ClientSession | undefined,
-    callback: Callback<number>
   ): void {
     const cmd: Document = { count: this.collectionName };
 
@@ -71,7 +44,7 @@ export class EstimatedDocumentCountOperation extends CommandOperation<number> {
         return;
       }
 
-      callback(undefined, response.n || 0);
+      callback(undefined, response?.n || 0);
     });
   }
 }

package/src/operations/execute_operation.ts

@@ -7,11 +7,13 @@ import {
   MongoError,
   MongoExpiredSessionError,
   MongoNetworkError,
+  MongoNotConnectedError,
   MongoRuntimeError,
   MongoServerError,
   MongoTransactionError,
   MongoUnexpectedServerResponseError
 } from '../error';
+import type { MongoClient } from '../mongo_client';
 import { ReadPreference } from '../read_preference';
 import type { Server } from '../sdam/server';
 import {
@@ -21,13 +23,7 @@ import {
 } from '../sdam/server_selection';
 import type { Topology } from '../sdam/topology';
 import type { ClientSession } from '../sessions';
-import {
-  Callback,
-  getTopology,
-  maybePromise,
-  supportsRetryableWrites,
-  TopologyProvider
-} from '../utils';
+import { Callback, maybePromise, supportsRetryableWrites } from '../utils';
 import { AbstractOperation, Aspect } from './operation';
 
 const MMAPv1_RETRY_WRITES_ERROR_CODE = MONGODB_ERROR_CODES.IllegalOperation;
@@ -66,45 +62,48 @@ export interface ExecutionResult {
 export function executeOperation<
   T extends AbstractOperation<TResult>,
   TResult = ResultTypeFromOperation<T>
->(topologyProvider: TopologyProvider, operation: T): Promise<TResult>;
+>(client: MongoClient, operation: T): Promise<TResult>;
 export function executeOperation<
   T extends AbstractOperation<TResult>,
   TResult = ResultTypeFromOperation<T>
->(topologyProvider: TopologyProvider, operation: T, callback: Callback<TResult>): void;
+>(client: MongoClient, operation: T, callback: Callback<TResult>): void;
 export function executeOperation<
   T extends AbstractOperation<TResult>,
   TResult = ResultTypeFromOperation<T>
->(
-  topologyProvider: TopologyProvider,
-  operation: T,
-  callback?: Callback<TResult>
-): Promise<TResult> | void;
+>(client: MongoClient, operation: T, callback?: Callback<TResult>): Promise<TResult> | void;
 export function executeOperation<
   T extends AbstractOperation<TResult>,
   TResult = ResultTypeFromOperation<T>
->(
-  topologyProvider: TopologyProvider,
-  operation: T,
-  callback?: Callback<TResult>
-): Promise<TResult> | void {
+>(client: MongoClient, operation: T, callback?: Callback<TResult>): Promise<TResult> | void {
   if (!(operation instanceof AbstractOperation)) {
     // TODO(NODE-3483): Extend MongoRuntimeError
     throw new MongoRuntimeError('This method requires a valid operation instance');
   }
 
   return maybePromise(callback, callback => {
-    let topology: Topology;
-    try {
-      // TODO(NODE-4151): Use skipPingOnConnect and call connect here to make client.connect optional
-      topology = getTopology(topologyProvider);
-    } catch (error) {
-      return callback(error);
+    const topology = client.topology;
+
+    if (topology == null) {
+      if (client.s.hasBeenClosed) {
+        return callback(
+          new MongoNotConnectedError('Client must be connected before running operations')
+        );
+      }
+      client.s.options[Symbol.for('@@mdb.skipPingOnConnect')] = true;
+      return client.connect(error => {
+        delete client.s.options[Symbol.for('@@mdb.skipPingOnConnect')];
+        if (error) {
+          return callback(error);
+        }
+        return executeOperation<T, TResult>(client, operation, callback);
+      });
     }
+
     if (topology.shouldCheckForSessionSupport()) {
       return topology.selectServer(ReadPreference.primaryPreferred, {}, err => {
         if (err) return callback(err);
 
-        executeOperation<T, TResult>(topologyProvider, operation, callback);
+        executeOperation<T, TResult>(client, operation, callback);
       });
     }
 

package/src/operations/indexes.ts

@@ -7,13 +7,7 @@ import type { OneOrMore } from '../mongo_types';
 import { ReadPreference } from '../read_preference';
 import type { Server } from '../sdam/server';
 import type { ClientSession } from '../sessions';
-import {
-  Callback,
-  getTopology,
-  maxWireVersion,
-  MongoDBNamespace,
-  parseIndexOptions
-} from '../utils';
+import { Callback, maxWireVersion, MongoDBNamespace, parseIndexOptions } from '../utils';
 import {
   CollationOptions,
   CommandOperation,
@@ -424,7 +418,7 @@ export class ListIndexesCursor extends AbstractCursor {
   options?: ListIndexesOptions;
 
   constructor(collection: Collection, options?: ListIndexesOptions) {
-    super(getTopology(collection), collection.s.namespace, options);
+    super(collection.s.db.s.client, collection.s.namespace, options);
     this.parent = collection;
     this.options = options;
   }
@@ -444,7 +438,7 @@ export class ListIndexesCursor extends AbstractCursor {
       session
     });
 
-    executeOperation(this.parent, operation, (err, response) => {
+    executeOperation(this.parent.s.db.s.client, operation, (err, response) => {
       if (err || response == null) return callback(err);
 
       // TODO: NODE-2882

package/src/operations/list_collections.ts

@@ -3,7 +3,7 @@ import { AbstractCursor } from '../cursor/abstract_cursor';
 import type { Db } from '../db';
 import type { Server } from '../sdam/server';
 import type { ClientSession } from '../sessions';
-import { Callback, getTopology, maxWireVersion } from '../utils';
+import { Callback, maxWireVersion } from '../utils';
 import { CommandOperation, CommandOperationOptions } from './command';
 import { executeOperation, ExecutionResult } from './execute_operation';
 import { Aspect, defineAspects } from './operation';
@@ -97,7 +97,7 @@ export class ListCollectionsCursor<
   options?: ListCollectionsOptions;
 
   constructor(db: Db, filter: Document, options?: ListCollectionsOptions) {
-    super(getTopology(db), db.s.namespace, options);
+    super(db.s.client, db.s.namespace, options);
     this.parent = db;
     this.filter = filter;
     this.options = options;
@@ -118,7 +118,7 @@ export class ListCollectionsCursor<
       session
     });
 
-    executeOperation(this.parent, operation, (err, response) => {
+    executeOperation(this.parent.s.client, operation, (err, response) => {
       if (err || response == null) return callback(err);
 
       // TODO: NODE-2882

package/src/sdam/monitor.ts

@@ -1,3 +1,5 @@
+import { setTimeout } from 'timers';
+
 import { Document, Long } from '../bson';
 import { connect } from '../cmap/connect';
 import { Connection, ConnectionOptions } from '../cmap/connection';
@@ -88,6 +90,10 @@ export class Monitor extends TypedEventEmitter<MonitorEvents> {
   [kMonitorId]?: InterruptibleAsyncInterval;
   [kRTTPinger]?: RTTPinger;
 
+  get connection(): Connection | undefined {
+    return this[kConnection];
+  }
+
   constructor(server: Server, options: MonitorOptions) {
     super();
 
@@ -310,6 +316,10 @@ function checkServer(monitor: Monitor, callback: Callback<Document | null>) {
     }
 
     if (conn) {
+      // Tell the connection that we are using the streaming protocol so that the
+      // connection's message stream will only read the last hello on the buffer.
+      conn.isMonitoringConnection = true;
+
       if (isInCloseState(monitor)) {
         conn.destroy({ force: true });
         return;

package/src/sdam/srv_polling.ts

@@ -1,4 +1,5 @@
 import * as dns from 'dns';
+import { setTimeout } from 'timers';
 
 import { MongoRuntimeError } from '../error';
 import { Logger, LoggerOptions } from '../logger';

package/src/sdam/topology.ts

@@ -1,4 +1,6 @@
 import Denque = require('denque');
+import { setTimeout } from 'timers';
+
 import type { BSONSerializeOptions, Document } from '../bson';
 import { deserialize, serialize } from '../bson';
 import type { MongoCredentials } from '../cmap/auth/mongo_credentials';
@@ -27,7 +29,7 @@ import {
   MongoServerSelectionError,
   MongoTopologyClosedError
 } from '../error';
-import type { MongoOptions, ServerApi } from '../mongo_client';
+import type { MongoClient, MongoOptions, ServerApi } from '../mongo_client';
 import { TypedEventEmitter } from '../mongo_types';
 import { ReadPreference, ReadPreferenceLike } from '../read_preference';
 import {
@@ -203,6 +205,8 @@ export class Topology extends TypedEventEmitter<TopologyEvents> {
   /** @internal */
   _type?: string;
 
+  client!: MongoClient;
+
   /** @event */
   static readonly SERVER_OPENING = SERVER_OPENING;
   /** @event */
@@ -626,7 +630,7 @@ export class Topology extends TypedEventEmitter<TopologyEvents> {
 
   /** Start a logical session */
   startSession(options: ClientSessionOptions, clientOptions?: MongoOptions): ClientSession {
-    const session = new ClientSession(this, this.s.sessionPool, options, clientOptions);
+    const session = new ClientSession(this.client, this.s.sessionPool, options, clientOptions);
     session.once('ended', () => {
       this.s.sessions.delete(session);
     });