mongodb 4.1.4 → 4.3.0

package/src/db.ts

@@ -1,39 +1,31 @@
-import {
-  Callback,
-  resolveOptions,
-  filterOptions,
-  MongoDBNamespace,
-  getTopology,
-  DEFAULT_PK_FACTORY
-} from './utils';
-import { AggregationCursor } from './cursor/aggregation_cursor';
-import { Document, BSONSerializeOptions, resolveBSONOptions } from './bson';
-import { ReadPreference, ReadPreferenceLike } from './read_preference';
-import { MongoAPIError, MongoInvalidArgumentError } from './error';
-import { Collection, CollectionOptions } from './collection';
+import { Admin } from './admin';
+import { BSONSerializeOptions, Document, resolveBSONOptions } from './bson';
 import { ChangeStream, ChangeStreamOptions } from './change_stream';
+import { Collection, CollectionOptions } from './collection';
 import * as CONSTANTS from './constants';
-import { WriteConcern, WriteConcernOptions } from './write_concern';
-import { ReadConcern } from './read_concern';
+import { AggregationCursor } from './cursor/aggregation_cursor';
+import { MongoAPIError, MongoInvalidArgumentError } from './error';
 import { Logger, LoggerOptions } from './logger';
-import type { AggregateOptions } from './operations/aggregate';
+import type { MongoClient, PkFactory } from './mongo_client';
+import type { TODO_NODE_3286 } from './mongo_types';
 import { AddUserOperation, AddUserOptions } from './operations/add_user';
+import type { AggregateOptions } from './operations/aggregate';
 import { CollectionsOperation } from './operations/collections';
-import { DbStatsOperation, DbStatsOptions } from './operations/stats';
-import { RunCommandOperation, RunCommandOptions } from './operations/run_command';
+import type { IndexInformationOptions } from './operations/common_functions';
 import { CreateCollectionOperation, CreateCollectionOptions } from './operations/create_collection';
 import {
+  DropCollectionOperation,
+  DropCollectionOptions,
+  DropDatabaseOperation,
+  DropDatabaseOptions
+} from './operations/drop';
+import { executeOperation } from './operations/execute_operation';
+import {
+  CreateIndexesOptions,
   CreateIndexOperation,
   IndexInformationOperation,
-  CreateIndexesOptions,
   IndexSpecification
 } from './operations/indexes';
-import {
-  DropCollectionOperation,
-  DropDatabaseOperation,
-  DropDatabaseOptions,
-  DropCollectionOptions
-} from './operations/drop';
 import {
   CollectionInfo,
   ListCollectionsCursor,
@@ -42,16 +34,24 @@ import {
 import { ProfilingLevelOperation, ProfilingLevelOptions } from './operations/profiling_level';
 import { RemoveUserOperation, RemoveUserOptions } from './operations/remove_user';
 import { RenameOperation, RenameOptions } from './operations/rename';
+import { RunCommandOperation, RunCommandOptions } from './operations/run_command';
 import {
+  ProfilingLevel,
   SetProfilingLevelOperation,
-  SetProfilingLevelOptions,
-  ProfilingLevel
+  SetProfilingLevelOptions
 } from './operations/set_profiling_level';
-import { executeOperation } from './operations/execute_operation';
-import type { IndexInformationOptions } from './operations/common_functions';
-import type { MongoClient, PkFactory } from './mongo_client';
-import { Admin } from './admin';
-import type { TODO_NODE_3286 } from './mongo_types';
+import { DbStatsOperation, DbStatsOptions } from './operations/stats';
+import { ReadConcern } from './read_concern';
+import { ReadPreference, ReadPreferenceLike } from './read_preference';
+import {
+  Callback,
+  DEFAULT_PK_FACTORY,
+  filterOptions,
+  getTopology,
+  MongoDBNamespace,
+  resolveOptions
+} from './utils';
+import { WriteConcern, WriteConcernOptions } from './write_concern';
 
 // Allowed parameters
 const DB_OPTIONS_ALLOW_LIST = [
@@ -73,6 +73,7 @@ const DB_OPTIONS_ALLOW_LIST = [
   'promoteBuffers',
   'promoteLongs',
   'bsonRegExp',
+  'enableUtf8Validation',
   'promoteValues',
   'compression',
   'retryWrites'
@@ -184,8 +185,18 @@ export class Db {
     return this.s.options;
   }
 
-  // slaveOk specified
+  /**
+   * slaveOk specified
+   * @deprecated Use secondaryOk instead
+   */
   get slaveOk(): boolean {
+    return this.secondaryOk;
+  }
+
+  /**
+   * Check if a secondary can be used (because the read preference is *not* set to primary)
+   */
+  get secondaryOk(): boolean {
     return this.s.readPreference?.preference !== 'primary' || false;
   }
 
@@ -226,18 +237,17 @@ export class Db {
    * @param options - Optional settings for the command
    * @param callback - An optional callback, a Promise will be returned if none is provided
    */
-  createCollection<TSchema extends Document = Document>(name: string): Promise<Collection<TSchema>>;
   createCollection<TSchema extends Document = Document>(
     name: string,
-    callback: Callback<Collection<TSchema>>
-  ): void;
+    options?: CreateCollectionOptions
+  ): Promise<Collection<TSchema>>;
   createCollection<TSchema extends Document = Document>(
     name: string,
-    options: CreateCollectionOptions
-  ): Promise<Collection<TSchema>>;
+    callback: Callback<Collection<TSchema>>
+  ): void;
   createCollection<TSchema extends Document = Document>(
     name: string,
-    options: CreateCollectionOptions,
+    options: CreateCollectionOptions | undefined,
     callback: Callback<Collection<TSchema>>
   ): void;
   createCollection<TSchema extends Document = Document>(

package/src/deps.ts

@@ -1,7 +1,8 @@
 /* eslint-disable @typescript-eslint/no-var-requires */
+import type { deserialize, Document, serialize } from './bson';
+import type { ProxyOptions } from './cmap/connection';
 import { MongoMissingDependencyError } from './error';
 import type { MongoClient } from './mongo_client';
-import type { deserialize, Document, serialize } from './bson';
 import { Callback, parsePackageVersion } from './utils';
 
 export const PKG_VERSION = Symbol('kPkgVersion');
@@ -262,6 +263,7 @@ export interface AutoEncryptionOptions {
     /** Command line arguments to use when auto-spawning a mongocryptd */
     mongocryptdSpawnArgs?: string[];
   };
+  proxyOptions?: ProxyOptions;
 }
 
 /** @public */

package/src/encrypter.ts

@@ -1,10 +1,10 @@
 /* eslint-disable @typescript-eslint/no-var-requires */
-import { MongoClient, MongoClientOptions } from './mongo_client';
+import { deserialize, serialize } from './bson';
+import { MONGO_CLIENT_EVENTS } from './constants';
 import type { AutoEncrypter, AutoEncryptionOptions } from './deps';
 import { MongoInvalidArgumentError, MongoMissingDependencyError } from './error';
-import { deserialize, serialize } from './bson';
+import { MongoClient, MongoClientOptions } from './mongo_client';
 import type { Callback } from './utils';
-import { MONGO_CLIENT_EVENTS } from './operations/connect';
 
 let AutoEncrypterClass: AutoEncrypter;
 
@@ -46,6 +46,15 @@ export class Encrypter {
       options.autoEncryption.metadataClient = this.getInternalClient(client, uri, options);
     }
 
+    if (options.proxyHost) {
+      options.autoEncryption.proxyOptions = {
+        proxyHost: options.proxyHost,
+        proxyPort: options.proxyPort,
+        proxyUsername: options.proxyUsername,
+        proxyPassword: options.proxyPassword
+      };
+    }
+
     options.autoEncryption.bson = Object.create(null);
     // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
     options.autoEncryption.bson!.serialize = serialize;

package/src/error.ts

@@ -1,5 +1,5 @@
-import type { TopologyVersion } from './sdam/server_description';
 import type { Document } from './bson';
+import type { TopologyVersion } from './sdam/server_description';
 import type { TopologyDescription } from './sdam/topology_description';
 
 /** @public */
@@ -8,6 +8,27 @@ export type AnyError = MongoError | Error;
 /** @internal */
 const kErrorLabels = Symbol('errorLabels');
 
+/**
+ * @internal
+ * The legacy error message from the server that indicates the node is not a writable primary
+ * https://github.com/mongodb/specifications/blob/b07c26dc40d04ac20349f989db531c9845fdd755/source/server-discovery-and-monitoring/server-discovery-and-monitoring.rst#not-writable-primary-and-node-is-recovering
+ */
+export const LEGACY_NOT_WRITABLE_PRIMARY_ERROR_MESSAGE = 'not master';
+
+/**
+ * @internal
+ * The legacy error message from the server that indicates the node is not a primary or secondary
+ * https://github.com/mongodb/specifications/blob/b07c26dc40d04ac20349f989db531c9845fdd755/source/server-discovery-and-monitoring/server-discovery-and-monitoring.rst#not-writable-primary-and-node-is-recovering
+ */
+export const LEGACY_NOT_PRIMARY_OR_SECONDARY_ERROR_MESSAGE = 'not master or secondary';
+
+/**
+ * @internal
+ * The error message from the server that indicates the node is recovering
+ * https://github.com/mongodb/specifications/blob/b07c26dc40d04ac20349f989db531c9845fdd755/source/server-discovery-and-monitoring/server-discovery-and-monitoring.rst#not-writable-primary-and-node-is-recovering
+ */
+export const NODE_IS_RECOVERING_ERROR_MESSAGE = 'node is recovering';
+
 /** @internal MongoDB Error Codes */
 export const MONGODB_ERROR_CODES = Object.freeze({
   HostUnreachable: 6,
@@ -17,11 +38,11 @@ export const MONGODB_ERROR_CODES = Object.freeze({
   PrimarySteppedDown: 189,
   ExceededTimeLimit: 262,
   SocketException: 9001,
-  NotMaster: 10107,
+  NotWritablePrimary: 10107,
   InterruptedAtShutdown: 11600,
   InterruptedDueToReplStateChange: 11602,
-  NotMasterNoSlaveOk: 13435,
-  NotMasterOrSecondary: 13436,
+  NotPrimaryNoSecondaryOk: 13435,
+  NotPrimaryOrSecondary: 13436,
   StaleShardVersion: 63,
   StaleEpoch: 150,
   StaleConfig: 13388,
@@ -46,11 +67,11 @@ export const GET_MORE_RESUMABLE_CODES = new Set<number>([
   MONGODB_ERROR_CODES.PrimarySteppedDown,
   MONGODB_ERROR_CODES.ExceededTimeLimit,
   MONGODB_ERROR_CODES.SocketException,
-  MONGODB_ERROR_CODES.NotMaster,
+  MONGODB_ERROR_CODES.NotWritablePrimary,
   MONGODB_ERROR_CODES.InterruptedAtShutdown,
   MONGODB_ERROR_CODES.InterruptedDueToReplStateChange,
-  MONGODB_ERROR_CODES.NotMasterNoSlaveOk,
-  MONGODB_ERROR_CODES.NotMasterOrSecondary,
+  MONGODB_ERROR_CODES.NotPrimaryNoSecondaryOk,
+  MONGODB_ERROR_CODES.NotPrimaryOrSecondary,
   MONGODB_ERROR_CODES.StaleShardVersion,
   MONGODB_ERROR_CODES.StaleEpoch,
   MONGODB_ERROR_CODES.StaleConfig,
@@ -675,19 +696,19 @@ const RETRYABLE_ERROR_CODES = new Set<number>([
   MONGODB_ERROR_CODES.ShutdownInProgress,
   MONGODB_ERROR_CODES.PrimarySteppedDown,
   MONGODB_ERROR_CODES.SocketException,
-  MONGODB_ERROR_CODES.NotMaster,
+  MONGODB_ERROR_CODES.NotWritablePrimary,
   MONGODB_ERROR_CODES.InterruptedAtShutdown,
   MONGODB_ERROR_CODES.InterruptedDueToReplStateChange,
-  MONGODB_ERROR_CODES.NotMasterNoSlaveOk,
-  MONGODB_ERROR_CODES.NotMasterOrSecondary
+  MONGODB_ERROR_CODES.NotPrimaryNoSecondaryOk,
+  MONGODB_ERROR_CODES.NotPrimaryOrSecondary
 ]);
 
 const RETRYABLE_WRITE_ERROR_CODES = new Set<number>([
   MONGODB_ERROR_CODES.InterruptedAtShutdown,
   MONGODB_ERROR_CODES.InterruptedDueToReplStateChange,
-  MONGODB_ERROR_CODES.NotMaster,
-  MONGODB_ERROR_CODES.NotMasterNoSlaveOk,
-  MONGODB_ERROR_CODES.NotMasterOrSecondary,
+  MONGODB_ERROR_CODES.NotWritablePrimary,
+  MONGODB_ERROR_CODES.NotPrimaryNoSecondaryOk,
+  MONGODB_ERROR_CODES.NotPrimaryOrSecondary,
   MONGODB_ERROR_CODES.PrimarySteppedDown,
   MONGODB_ERROR_CODES.ShutdownInProgress,
   MONGODB_ERROR_CODES.HostNotFound,
@@ -697,6 +718,10 @@ const RETRYABLE_WRITE_ERROR_CODES = new Set<number>([
   MONGODB_ERROR_CODES.ExceededTimeLimit
 ]);
 
+export function isRetryableEndTransactionError(error: MongoError): boolean {
+  return error.hasErrorLabel('RetryableWriteError');
+}
+
 export function isRetryableWriteError(error: MongoError): boolean {
   if (error instanceof MongoWriteConcernError) {
     return RETRYABLE_WRITE_ERROR_CODES.has(error.result?.code ?? error.code ?? 0);
@@ -710,8 +735,8 @@ export function isRetryableError(error: MongoError): boolean {
     // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
     (typeof error.code === 'number' && RETRYABLE_ERROR_CODES.has(error.code!)) ||
     error instanceof MongoNetworkError ||
-    !!error.message.match(/not master/) ||
-    !!error.message.match(/node is recovering/)
+    !!error.message.match(new RegExp(LEGACY_NOT_WRITABLE_PRIMARY_ERROR_MESSAGE)) ||
+    !!error.message.match(new RegExp(NODE_IS_RECOVERING_ERROR_MESSAGE))
   );
 }
 
@@ -720,12 +745,12 @@ const SDAM_RECOVERING_CODES = new Set<number>([
   MONGODB_ERROR_CODES.PrimarySteppedDown,
   MONGODB_ERROR_CODES.InterruptedAtShutdown,
   MONGODB_ERROR_CODES.InterruptedDueToReplStateChange,
-  MONGODB_ERROR_CODES.NotMasterOrSecondary
+  MONGODB_ERROR_CODES.NotPrimaryOrSecondary
 ]);
 
-const SDAM_NOTMASTER_CODES = new Set<number>([
-  MONGODB_ERROR_CODES.NotMaster,
-  MONGODB_ERROR_CODES.NotMasterNoSlaveOk,
+const SDAM_NOTPRIMARY_CODES = new Set<number>([
+  MONGODB_ERROR_CODES.NotWritablePrimary,
+  MONGODB_ERROR_CODES.NotPrimaryNoSecondaryOk,
   MONGODB_ERROR_CODES.LegacyNotPrimary
 ]);
 
@@ -740,20 +765,23 @@ function isRecoveringError(err: MongoError) {
     return SDAM_RECOVERING_CODES.has(err.code);
   }
 
-  return /not master or secondary/.test(err.message) || /node is recovering/.test(err.message);
+  return (
+    new RegExp(LEGACY_NOT_PRIMARY_OR_SECONDARY_ERROR_MESSAGE).test(err.message) ||
+    new RegExp(NODE_IS_RECOVERING_ERROR_MESSAGE).test(err.message)
+  );
 }
 
-function isNotMasterError(err: MongoError) {
+function isNotWritablePrimaryError(err: MongoError) {
   if (typeof err.code === 'number') {
     // If any error code exists, we ignore the error.message
-    return SDAM_NOTMASTER_CODES.has(err.code);
+    return SDAM_NOTPRIMARY_CODES.has(err.code);
   }
 
   if (isRecoveringError(err)) {
     return false;
   }
 
-  return /not master/.test(err.message);
+  return new RegExp(LEGACY_NOT_WRITABLE_PRIMARY_ERROR_MESSAGE).test(err.message);
 }
 
 export function isNodeShuttingDownError(err: MongoError): boolean {
@@ -774,7 +802,7 @@ export function isSDAMUnrecoverableError(error: MongoError): boolean {
     return true;
   }
 
-  return isRecoveringError(error) || isNotMasterError(error);
+  return isRecoveringError(error) || isNotWritablePrimaryError(error);
 }
 
 export function isNetworkTimeoutError(err: MongoError): err is MongoNetworkError {

package/src/gridfs/download.ts

@@ -1,19 +1,19 @@
 import { Readable } from 'stream';
+
+import type { Document, ObjectId } from '../bson';
+import type { Collection } from '../collection';
+import type { FindCursor } from '../cursor/find_cursor';
 import {
-  MongoRuntimeError,
   MongoGridFSChunkError,
   MongoGridFSStreamError,
-  MongoInvalidArgumentError
+  MongoInvalidArgumentError,
+  MongoRuntimeError
 } from '../error';
-import type { Document } from '../bson';
 import type { FindOptions } from '../operations/find';
+import type { ReadPreference } from '../read_preference';
 import type { Sort } from '../sort';
 import type { Callback } from '../utils';
-import type { Collection } from '../collection';
-import type { ReadPreference } from '../read_preference';
 import type { GridFSChunk } from './upload';
-import type { FindCursor } from '../cursor/find_cursor';
-import type { ObjectId } from 'bson';
 
 /** @public */
 export interface GridFSBucketReadStreamOptions {
@@ -262,7 +262,9 @@ function doRead(stream: GridFSBucketReadStream): void {
       if (bytesRemaining <= 0) {
         return stream.emit(
           GridFSBucketReadStream.ERROR,
-          new MongoGridFSChunkError(`ExtraChunk: Got unexpected n: ${doc.n}`)
+          new MongoGridFSChunkError(
+            `ExtraChunk: Got unexpected n: ${doc.n}, expected file length ${stream.s.file.length} bytes but already read ${stream.s.bytesRead} bytes`
+          )
         );
       }
 

package/src/gridfs/index.ts

@@ -1,4 +1,15 @@
+import type { ObjectId } from '../bson';
+import type { Collection } from '../collection';
+import type { FindCursor } from '../cursor/find_cursor';
+import type { Db } from '../db';
 import { MongoRuntimeError } from '../error';
+import type { Logger } from '../logger';
+import { Filter, TypedEventEmitter } from '../mongo_types';
+import type { ReadPreference } from '../read_preference';
+import type { Sort } from '../sort';
+import { Callback, executeLegacyOperation, getTopology } from '../utils';
+import { WriteConcern, WriteConcernOptions } from '../write_concern';
+import type { FindOptions } from './../operations/find';
 import {
   GridFSBucketReadStream,
   GridFSBucketReadStreamOptions,
@@ -6,17 +17,6 @@ import {
   GridFSFile
 } from './download';
 import { GridFSBucketWriteStream, GridFSBucketWriteStreamOptions, GridFSChunk } from './upload';
-import { executeLegacyOperation, Callback, getTopology } from '../utils';
-import { WriteConcernOptions, WriteConcern } from '../write_concern';
-import type { ObjectId } from '../bson';
-import type { Db } from '../db';
-import type { ReadPreference } from '../read_preference';
-import type { Collection } from '../collection';
-import type { FindOptions } from './../operations/find';
-import type { Sort } from '../sort';
-import type { Logger } from '../logger';
-import type { FindCursor } from '../cursor/find_cursor';
-import { Filter, TypedEventEmitter } from '../mongo_types';
 
 const DEFAULT_GRIDFS_BUCKET_OPTIONS: {
   bucketName: string;

package/src/gridfs/upload.ts

@@ -1,8 +1,9 @@
 import { Writable } from 'stream';
+
 import type { Document } from '../bson';
 import { ObjectId } from '../bson';
 import type { Collection } from '../collection';
-import { AnyError, MONGODB_ERROR_CODES, MongoError, MongoAPIError } from '../error';
+import { AnyError, MongoAPIError, MONGODB_ERROR_CODES, MongoError } from '../error';
 import { Callback, maybePromise } from '../utils';
 import type { WriteConcernOptions } from '../write_concern';
 import { WriteConcern } from './../write_concern';
@@ -171,21 +172,21 @@ export class GridFSBucketWriteStream extends Writable implements NodeJS.Writable
    * @param encoding - Optional encoding for the buffer
    * @param callback - Function to call when all files and chunks have been persisted to MongoDB
    */
-  end(): void;
-  end(chunk: Buffer): void;
-  end(callback: Callback<GridFSFile | void>): void;
-  end(chunk: Buffer, callback: Callback<GridFSFile | void>): void;
-  end(chunk: Buffer, encoding: BufferEncoding): void;
+  end(): this;
+  end(chunk: Buffer): this;
+  end(callback: Callback<GridFSFile | void>): this;
+  end(chunk: Buffer, callback: Callback<GridFSFile | void>): this;
+  end(chunk: Buffer, encoding: BufferEncoding): this;
   end(
     chunk: Buffer,
     encoding: BufferEncoding | undefined,
     callback: Callback<GridFSFile | void>
-  ): void;
+  ): this;
   end(
     chunkOrCallback?: Buffer | Callback<GridFSFile | void>,
     encodingOrCallback?: BufferEncoding | Callback<GridFSFile | void>,
     callback?: Callback<GridFSFile | void>
-  ): void {
+  ): this {
     const chunk = typeof chunkOrCallback === 'function' ? undefined : chunkOrCallback;
     const encoding = typeof encodingOrCallback === 'function' ? undefined : encodingOrCallback;
     callback =
@@ -195,7 +196,7 @@ export class GridFSBucketWriteStream extends Writable implements NodeJS.Writable
         ? encodingOrCallback
         : callback;
 
-    if (checkAborted(this, callback)) return;
+    if (checkAborted(this, callback)) return this;
 
     this.state.streamEnd = true;
 
@@ -207,12 +208,14 @@ export class GridFSBucketWriteStream extends Writable implements NodeJS.Writable
 
     if (!chunk) {
       waitForIndexes(this, () => !!writeRemnant(this));
-      return;
+      return this;
     }
 
     this.write(chunk, encoding, () => {
       writeRemnant(this);
     });
+
+    return this;
   }
 }