mongodb 4.5.0 → 4.7.0

package/src/cursor/aggregation_cursor.ts

@@ -1,8 +1,8 @@
 import type { Document } from '../bson';
 import type { ExplainVerbosityLike } from '../explain';
+import type { MongoClient } from '../mongo_client';
 import { AggregateOperation, AggregateOptions } from '../operations/aggregate';
 import { executeOperation, ExecutionResult } from '../operations/execute_operation';
-import type { Topology } from '../sdam/topology';
 import type { ClientSession } from '../sessions';
 import type { Sort } from '../sort';
 import type { Callback, MongoDBNamespace } from '../utils';
@@ -33,12 +33,12 @@ export class AggregationCursor<TSchema = any> extends AbstractCursor<TSchema> {
 
   /** @internal */
   constructor(
-    topology: Topology,
+    client: MongoClient,
     namespace: MongoDBNamespace,
     pipeline: Document[] = [],
     options: AggregateOptions = {}
   ) {
-    super(topology, namespace, options);
+    super(client, namespace, options);
 
     this[kPipeline] = pipeline;
     this[kOptions] = options;
@@ -51,7 +51,7 @@ export class AggregationCursor<TSchema = any> extends AbstractCursor<TSchema> {
   clone(): AggregationCursor<TSchema> {
     const clonedOptions = mergeOptions({}, this[kOptions]);
     delete clonedOptions.session;
-    return new AggregationCursor(this.topology, this.namespace, this[kPipeline], {
+    return new AggregationCursor(this.client, this.namespace, this[kPipeline], {
       ...clonedOptions
     });
   }
@@ -68,7 +68,7 @@ export class AggregationCursor<TSchema = any> extends AbstractCursor<TSchema> {
       session
     });
 
-    executeOperation(this, aggregateOperation, (err, response) => {
+    executeOperation(this.client, aggregateOperation, (err, response) => {
       if (err || response == null) return callback(err);
 
       // TODO: NODE-2882
@@ -88,7 +88,7 @@ export class AggregationCursor<TSchema = any> extends AbstractCursor<TSchema> {
     if (verbosity == null) verbosity = true;
 
     return executeOperation(
-      this,
+      this.client,
       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

@@ -1,12 +1,12 @@
 import type { Document } from '../bson';
 import { MongoInvalidArgumentError, MongoTailableCursorError } from '../error';
 import type { ExplainVerbosityLike } from '../explain';
+import type { MongoClient } from '../mongo_client';
 import type { CollationOptions } from '../operations/command';
 import { CountOperation, CountOptions } from '../operations/count';
 import { executeOperation, ExecutionResult } from '../operations/execute_operation';
 import { FindOperation, FindOptions } from '../operations/find';
 import type { Hint } from '../operations/operation';
-import type { Topology } from '../sdam/topology';
 import type { ClientSession } from '../sessions';
 import { formatSort, Sort, SortDirection } from '../sort';
 import { Callback, emitWarningOnce, mergeOptions, MongoDBNamespace } from '../utils';
@@ -40,12 +40,12 @@ export class FindCursor<TSchema = any> extends AbstractCursor<TSchema> {
 
   /** @internal */
   constructor(
-    topology: Topology,
+    client: MongoClient,
     namespace: MongoDBNamespace,
     filter: Document | undefined,
     options: FindOptions = {}
   ) {
-    super(topology, namespace, options);
+    super(client, namespace, options);
 
     this[kFilter] = filter || {};
     this[kBuiltOptions] = options;
@@ -58,7 +58,7 @@ export class FindCursor<TSchema = any> extends AbstractCursor<TSchema> {
   clone(): FindCursor<TSchema> {
     const clonedOptions = mergeOptions({}, this[kBuiltOptions]);
     delete clonedOptions.session;
-    return new FindCursor(this.topology, this.namespace, this[kFilter], {
+    return new FindCursor(this.client, this.namespace, this[kFilter], {
       ...clonedOptions
     });
   }
@@ -75,7 +75,7 @@ export class FindCursor<TSchema = any> extends AbstractCursor<TSchema> {
       session
     });
 
-    executeOperation(this, findOperation, (err, response) => {
+    executeOperation(this.client, findOperation, (err, response) => {
       if (err || response == null) return callback(err);
 
       // TODO: We only need this for legacy queries that do not support `limit`, maybe
@@ -143,7 +143,7 @@ export class FindCursor<TSchema = any> extends AbstractCursor<TSchema> {
     options = options ?? {};
 
     return executeOperation(
-      this,
+      this.client,
       new CountOperation(this.namespace, this[kFilter], {
         ...this[kBuiltOptions], // NOTE: order matters here, we may need to refine this
         ...this.cursorOptions,
@@ -165,7 +165,7 @@ export class FindCursor<TSchema = any> extends AbstractCursor<TSchema> {
     if (verbosity == null) verbosity = true;
 
     return executeOperation(
-      this,
+      this.client,
       new FindOperation(undefined, this.namespace, this[kFilter], {
         ...this[kBuiltOptions], // NOTE: order matters here, we may need to refine this
         ...this.cursorOptions,
@@ -412,11 +412,19 @@ export class FindCursor<TSchema = any> extends AbstractCursor<TSchema> {
    * @remarks
    * {@link https://docs.mongodb.com/manual/reference/command/find/#find-cmd-allowdiskuse | find command allowDiskUse documentation}
    */
-  allowDiskUse(): this {
+  allowDiskUse(allow = true): this {
     assertUninitialized(this);
+
     if (!this[kBuiltOptions].sort) {
       throw new MongoInvalidArgumentError('Option "allowDiskUse" requires a sort specification');
     }
+
+    // As of 6.0 the default is true. This allows users to get back to the old behaviour.
+    if (!allow) {
+      this[kBuiltOptions].allowDiskUse = false;
+      return this;
+    }
+
     this[kBuiltOptions].allowDiskUse = true;
     return this;
   }

package/src/db.ts

@@ -1,6 +1,6 @@
 import { Admin } from './admin';
 import { BSONSerializeOptions, Document, resolveBSONOptions } from './bson';
-import { ChangeStream, ChangeStreamOptions } from './change_stream';
+import { ChangeStream, ChangeStreamDocument, ChangeStreamOptions } from './change_stream';
 import { Collection, CollectionOptions } from './collection';
 import * as CONSTANTS from './constants';
 import { AggregationCursor } from './cursor/aggregation_cursor';
@@ -258,7 +258,7 @@ export class Db {
     if (typeof options === 'function') (callback = options), (options = {});
 
     return executeOperation(
-      this,
+      this.s.client,
       new CreateCollectionOperation(this, name, resolveOptions(this, options)) as TODO_NODE_3286,
       callback
     ) as TODO_NODE_3286;
@@ -286,7 +286,11 @@ export class Db {
     if (typeof options === 'function') (callback = options), (options = {});
 
     // Intentionally, we do not inherit options from parent for this operation.
-    return executeOperation(this, new RunCommandOperation(this, command, options ?? {}), callback);
+    return executeOperation(
+      this.s.client,
+      new RunCommandOperation(this, command, options ?? {}),
+      callback
+    );
   }
 
   /**
@@ -310,7 +314,7 @@ export class Db {
     }
 
     return new AggregationCursor(
-      getTopology(this),
+      this.s.client,
       this.s.namespace,
       pipeline,
       resolveOptions(this, options)
@@ -355,7 +359,7 @@ export class Db {
   ): Promise<Document> | void {
     if (typeof options === 'function') (callback = options), (options = {});
     return executeOperation(
-      this,
+      this.s.client,
       new DbStatsOperation(this, resolveOptions(this, options)),
       callback
     );
@@ -434,7 +438,7 @@ export class Db {
     options.new_collection = true;
 
     return executeOperation(
-      this,
+      this.s.client,
       new RenameOperation(
         this.collection<TSchema>(fromCollection) as TODO_NODE_3286,
         toCollection,
@@ -463,7 +467,7 @@ export class Db {
     if (typeof options === 'function') (callback = options), (options = {});
 
     return executeOperation(
-      this,
+      this.s.client,
       new DropCollectionOperation(this, name, resolveOptions(this, options)),
       callback
     );
@@ -486,7 +490,7 @@ export class Db {
     if (typeof options === 'function') (callback = options), (options = {});
 
     return executeOperation(
-      this,
+      this.s.client,
       new DropDatabaseOperation(this, resolveOptions(this, options)),
       callback
     );
@@ -509,7 +513,7 @@ export class Db {
     if (typeof options === 'function') (callback = options), (options = {});
 
     return executeOperation(
-      this,
+      this.s.client,
       new CollectionsOperation(this, resolveOptions(this, options)),
       callback
     );
@@ -545,7 +549,7 @@ export class Db {
     if (typeof options === 'function') (callback = options), (options = {});
 
     return executeOperation(
-      this,
+      this.s.client,
       new CreateIndexOperation(this, name, indexSpec, resolveOptions(this, options)),
       callback
     );
@@ -591,7 +595,7 @@ export class Db {
     }
 
     return executeOperation(
-      this,
+      this.s.client,
       new AddUserOperation(this, username, password, resolveOptions(this, options)),
       callback
     );
@@ -616,7 +620,7 @@ export class Db {
     if (typeof options === 'function') (callback = options), (options = {});
 
     return executeOperation(
-      this,
+      this.s.client,
       new RemoveUserOperation(this, username, resolveOptions(this, options)),
       callback
     );
@@ -648,7 +652,7 @@ export class Db {
     if (typeof options === 'function') (callback = options), (options = {});
 
     return executeOperation(
-      this,
+      this.s.client,
       new SetProfilingLevelOperation(this, level, resolveOptions(this, options)),
       callback
     );
@@ -671,7 +675,7 @@ export class Db {
     if (typeof options === 'function') (callback = options), (options = {});
 
     return executeOperation(
-      this,
+      this.s.client,
       new ProfilingLevelOperation(this, resolveOptions(this, options)),
       callback
     );
@@ -700,7 +704,7 @@ export class Db {
     if (typeof options === 'function') (callback = options), (options = {});
 
     return executeOperation(
-      this,
+      this.s.client,
       new IndexInformationOperation(this, name, resolveOptions(this, options)),
       callback
     );
@@ -719,20 +723,27 @@ export class Db {
    * replacements, deletions, and invalidations) in this database. Will ignore all
    * changes to system collections.
    *
+   * @remarks
+   * watch() accepts two generic arguments for distinct usecases:
+   * - The first is to provide the schema that may be defined for all the collections within this database
+   * - The second is to override the shape of the change stream document entirely, if it is not provided the type will default to ChangeStreamDocument of the first argument
+   *
    * @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
+   * @typeParam TSchema - Type of the data being detected by the change stream
+   * @typeParam TChange - Type of the whole change stream document emitted
    */
-  watch<TSchema extends Document = Document>(
-    pipeline: Document[] = [],
-    options: ChangeStreamOptions = {}
-  ): ChangeStream<TSchema> {
+  watch<
+    TSchema extends Document = Document,
+    TChange extends Document = ChangeStreamDocument<TSchema>
+  >(pipeline: Document[] = [], options: ChangeStreamOptions = {}): ChangeStream<TSchema, TChange> {
     // Allow optionally not specifying a pipeline
     if (!Array.isArray(pipeline)) {
       options = pipeline;
       pipeline = [];
     }
 
-    return new ChangeStream<TSchema>(this, pipeline, resolveOptions(this, options));
+    return new ChangeStream<TSchema, TChange>(this, pipeline, resolveOptions(this, options));
   }
 
   /** Return the db logger */

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 };
 
@@ -277,8 +301,12 @@ export interface AutoEncryptionOptions {
    * Other validation rules in the JSON schema will not be enforced by the driver and will result in an error.
    */
   schemaMap?: Document;
+  /** @experimental */
+  encryptedFieldsMap?: Document;
   /** Allows the user to bypass auto encryption, maintaining implicit decryption */
   bypassAutoEncryption?: boolean;
+  /** @experimental */
+  bypassQueryAnalysis?: boolean;
   options?: {
     /** An optional hook to catch logging messages from the underlying encryption engine */
     logger?: (level: AutoEncryptionLoggerLevel, message: string) => void;
@@ -296,15 +324,44 @@ 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)
-     * @experimental
+     * 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
+     * its first component is `$ORIGIN`, it will be replaced by the directory
+     * containing the mongodb-client-encryption native addon file. Otherwise,
+     * the path will be interpreted relative to the current working directory.
+     *
+     * 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 MongoDB Crypt shared library could be loaded
+     * from the specified location, creating the MongoClient will fail.
+     *
+     * 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.
+     */
+    cryptSharedLibPath?: string;
+    /**
+     * If specified, never use mongocryptd and instead fail when the MongoDB Crypt
+     * shared library could not be loaded.
+     *
+     * This is always true when `cryptSharedLibPath` is specified.
+     *
+     * @experimental Requires the MongoDB Crypt shared library, available in MongoDB 6.0 or higher.
      */
-    csflePath?: string;
+    cryptSharedLibRequired?: boolean;
     /**
-     * Search paths for a CSFLE shared library to be used (instead of mongocryptd)
-     * @experimental
+     * 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 */
@@ -325,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

@@ -72,7 +72,10 @@ export class Encrypter {
     if (internalClient == null) {
       const clonedOptions: MongoClientOptions = {};
 
-      for (const key of Object.keys(options)) {
+      for (const key of [
+        ...Object.getOwnPropertyNames(options),
+        ...Object.getOwnPropertySymbols(options)
+      ] as string[]) {
         if (['autoEncryption', 'minPoolSize', 'servers', 'caseTranslate', 'dbName'].includes(key))
           continue;
         Reflect.set(clonedOptions, key, Reflect.get(options, key));
@@ -121,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/error.ts

@@ -88,7 +88,8 @@ export const MongoErrorLabel = Object.freeze({
   RetryableWriteError: 'RetryableWriteError',
   TransientTransactionError: 'TransientTransactionError',
   UnknownTransactionCommitResult: 'UnknownTransactionCommitResult',
-  ResumableChangeStreamError: 'ResumableChangeStreamError'
+  ResumableChangeStreamError: 'ResumableChangeStreamError',
+  HandshakeError: 'HandshakeError'
 } as const);
 
 /** @public */
@@ -346,6 +347,23 @@ export class MongoKerberosError extends MongoRuntimeError {
   }
 }
 
+/**
+ * A error generated when the user attempts to authenticate
+ * via AWS, but fails
+ *
+ * @public
+ * @category Error
+ */
+export class MongoAWSError extends MongoRuntimeError {
+  constructor(message: string) {
+    super(message);
+  }
+
+  override get name(): string {
+    return 'MongoAWSError';
+  }
+}
+
 /**
  * An error generated when a ChangeStream operation fails to execute.
  *
@@ -744,21 +762,22 @@ const RETRYABLE_WRITE_ERROR_CODES = new Set<number>([
 ]);
 
 export function needsRetryableWriteLabel(error: Error, maxWireVersion: number): boolean {
-  if (maxWireVersion >= 9) {
-    // 4.4+ servers attach their own retryable write error
-    return false;
-  }
   // pre-4.4 server, then the driver adds an error label for every valid case
   // execute operation will only inspect the label, code/message logic is handled here
-
   if (error instanceof MongoNetworkError) {
     return true;
   }
 
-  if (error instanceof MongoError && error.hasErrorLabel(MongoErrorLabel.RetryableWriteError)) {
-    // Before 4.4 the error label can be one way of identifying retry
-    // so we can return true if we have the label, but fall back to code checking below
-    return true;
+  if (error instanceof MongoError) {
+    if (
+      (maxWireVersion >= 9 || error.hasErrorLabel(MongoErrorLabel.RetryableWriteError)) &&
+      !error.hasErrorLabel(MongoErrorLabel.HandshakeError)
+    ) {
+      // If we already have the error label no need to add it again. 4.4+ servers add the label.
+      // In the case where we have a handshake error, need to fall down to the logic checking
+      // the codes.
+      return false;
+    }
   }
 
   if (error instanceof MongoWriteConcernError) {
@@ -782,6 +801,10 @@ export function needsRetryableWriteLabel(error: Error, maxWireVersion: number):
   return false;
 }
 
+export function isRetryableWriteError(error: MongoError): boolean {
+  return error.hasErrorLabel(MongoErrorLabel.RetryableWriteError);
+}
+
 /** Determines whether an error is something the driver should attempt to retry */
 export function isRetryableReadError(error: MongoError): boolean {
   const hasRetryableErrorCode =
@@ -876,35 +899,26 @@ export function isNetworkTimeoutError(err: MongoError): err is MongoNetworkError
   return !!(err instanceof MongoNetworkError && err.message.match(/timed out/));
 }
 
-// From spec@https://github.com/mongodb/specifications/blob/7a2e93d85935ee4b1046a8d2ad3514c657dc74fa/source/change-streams/change-streams.rst#resumable-error:
-//
-// An error is considered resumable if it meets any of the following criteria:
-// - any error encountered which is not a server error (e.g. a timeout error or network error)
-// - any server error response from a getMore command excluding those containing the error label
-//   NonRetryableChangeStreamError and those containing the following error codes:
-//   - Interrupted: 11601
-//   - CappedPositionLost: 136
-//   - CursorKilled: 237
-//
-// An error on an aggregate command is not a resumable error. Only errors on a getMore command may be considered resumable errors.
+export function isResumableError(error?: Error, wireVersion?: number): boolean {
+  if (error == null || !(error instanceof MongoError)) {
+    return false;
+  }
 
-export function isResumableError(error?: MongoError, wireVersion?: number): boolean {
   if (error instanceof MongoNetworkError) {
     return true;
   }
 
   if (wireVersion != null && wireVersion >= 9) {
     // DRIVERS-1308: For 4.4 drivers running against 4.4 servers, drivers will add a special case to treat the CursorNotFound error code as resumable
-    if (error && error instanceof MongoError && error.code === MONGODB_ERROR_CODES.CursorNotFound) {
+    if (error.code === MONGODB_ERROR_CODES.CursorNotFound) {
       return true;
     }
-    return (
-      error instanceof MongoError && error.hasErrorLabel(MongoErrorLabel.ResumableChangeStreamError)
-    );
+    return error.hasErrorLabel(MongoErrorLabel.ResumableChangeStreamError);
   }
 
-  if (error && typeof error.code === 'number') {
+  if (typeof error.code === 'number') {
     return GET_MORE_RESUMABLE_CODES.has(error.code);
   }
+
   return false;
 }

package/src/gridfs/upload.ts

@@ -196,7 +196,7 @@ export class GridFSBucketWriteStream extends Writable implements NodeJS.Writable
         ? encodingOrCallback
         : callback;
 
-    if (checkAborted(this, callback)) return this;
+    if (this.state.streamEnd || checkAborted(this, callback)) return this;
 
     this.state.streamEnd = true;
 

package/src/index.ts

@@ -38,6 +38,7 @@ export const ObjectID = ObjectId;
 export { AnyBulkWriteOperation, BulkWriteOptions, MongoBulkWriteError } from './bulk/common';
 export {
   MongoAPIError,
+  MongoAWSError,
   MongoBatchReExecutionError,
   MongoChangeStreamError,
   MongoCompatibilityError,
@@ -169,11 +170,32 @@ export type { OrderedBulkOperation } from './bulk/ordered';
 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,
   ResumeOptions,
@@ -335,6 +357,7 @@ export type { IndexInformationOptions } from './operations/common_functions';
 export type { CountOptions } from './operations/count';
 export type { CountDocumentsOptions } from './operations/count_documents';
 export type {
+  ClusteredCollectionOptions,
   CreateCollectionOptions,
   TimeSeriesCollectionOptions
 } from './operations/create_collection';