mongodb 4.2.1 → 4.4.0

package/src/constants.ts

@@ -4,3 +4,125 @@ export const SYSTEM_PROFILE_COLLECTION = 'system.profile';
 export const SYSTEM_USER_COLLECTION = 'system.users';
 export const SYSTEM_COMMAND_COLLECTION = '$cmd';
 export const SYSTEM_JS_COLLECTION = 'system.js';
+
+// events
+export const ERROR = 'error' as const;
+export const TIMEOUT = 'timeout' as const;
+export const CLOSE = 'close' as const;
+export const OPEN = 'open' as const;
+export const CONNECT = 'connect' as const;
+export const CLOSED = 'closed' as const;
+export const ENDED = 'ended' as const;
+export const MESSAGE = 'message' as const;
+export const PINNED = 'pinned' as const;
+export const UNPINNED = 'unpinned' as const;
+export const DESCRIPTION_RECEIVED = 'descriptionReceived';
+export const SERVER_OPENING = 'serverOpening' as const;
+export const SERVER_CLOSED = 'serverClosed' as const;
+export const SERVER_DESCRIPTION_CHANGED = 'serverDescriptionChanged' as const;
+export const TOPOLOGY_OPENING = 'topologyOpening' as const;
+export const TOPOLOGY_CLOSED = 'topologyClosed' as const;
+export const TOPOLOGY_DESCRIPTION_CHANGED = 'topologyDescriptionChanged' as const;
+export const CONNECTION_POOL_CREATED = 'connectionPoolCreated' as const;
+export const CONNECTION_POOL_CLOSED = 'connectionPoolClosed' as const;
+export const CONNECTION_POOL_CLEARED = 'connectionPoolCleared' as const;
+export const CONNECTION_CREATED = 'connectionCreated' as const;
+export const CONNECTION_READY = 'connectionReady' as const;
+export const CONNECTION_CLOSED = 'connectionClosed' as const;
+export const CONNECTION_CHECK_OUT_STARTED = 'connectionCheckOutStarted' as const;
+export const CONNECTION_CHECK_OUT_FAILED = 'connectionCheckOutFailed' as const;
+export const CONNECTION_CHECKED_OUT = 'connectionCheckedOut' as const;
+export const CONNECTION_CHECKED_IN = 'connectionCheckedIn' as const;
+export const CLUSTER_TIME_RECEIVED = 'clusterTimeReceived' as const;
+export const COMMAND_STARTED = 'commandStarted' as const;
+export const COMMAND_SUCCEEDED = 'commandSucceeded' as const;
+export const COMMAND_FAILED = 'commandFailed' as const;
+export const SERVER_HEARTBEAT_STARTED = 'serverHeartbeatStarted' as const;
+export const SERVER_HEARTBEAT_SUCCEEDED = 'serverHeartbeatSucceeded' as const;
+export const SERVER_HEARTBEAT_FAILED = 'serverHeartbeatFailed' as const;
+
+/** @public */
+export const HEARTBEAT_EVENTS = Object.freeze([
+  SERVER_HEARTBEAT_STARTED,
+  SERVER_HEARTBEAT_SUCCEEDED,
+  SERVER_HEARTBEAT_FAILED
+] as const);
+
+/** @public */
+export const CMAP_EVENTS = Object.freeze([
+  CONNECTION_POOL_CREATED,
+  CONNECTION_POOL_CLOSED,
+  CONNECTION_CREATED,
+  CONNECTION_READY,
+  CONNECTION_CLOSED,
+  CONNECTION_CHECK_OUT_STARTED,
+  CONNECTION_CHECK_OUT_FAILED,
+  CONNECTION_CHECKED_OUT,
+  CONNECTION_CHECKED_IN,
+  CONNECTION_POOL_CLEARED
+] as const);
+
+/** @public */
+export const TOPOLOGY_EVENTS = Object.freeze([
+  SERVER_OPENING,
+  SERVER_CLOSED,
+  SERVER_DESCRIPTION_CHANGED,
+  TOPOLOGY_OPENING,
+  TOPOLOGY_CLOSED,
+  TOPOLOGY_DESCRIPTION_CHANGED,
+  ERROR,
+  TIMEOUT,
+  CLOSE
+] as const);
+
+/** @public */
+export const APM_EVENTS = Object.freeze([
+  COMMAND_STARTED,
+  COMMAND_SUCCEEDED,
+  COMMAND_FAILED
+] as const);
+
+/**
+ * All events that we relay to the `Topology`
+ * @internal
+ */
+export const SERVER_RELAY_EVENTS = Object.freeze([
+  SERVER_HEARTBEAT_STARTED,
+  SERVER_HEARTBEAT_SUCCEEDED,
+  SERVER_HEARTBEAT_FAILED,
+  COMMAND_STARTED,
+  COMMAND_SUCCEEDED,
+  COMMAND_FAILED,
+  ...CMAP_EVENTS
+] as const);
+
+/**
+ * All events we listen to from `Server` instances, but do not forward to the client
+ * @internal
+ */
+export const LOCAL_SERVER_EVENTS = Object.freeze([
+  CONNECT,
+  DESCRIPTION_RECEIVED,
+  CLOSED,
+  ENDED
+] as const);
+
+/** @public */
+export const MONGO_CLIENT_EVENTS = Object.freeze([
+  ...CMAP_EVENTS,
+  ...APM_EVENTS,
+  ...TOPOLOGY_EVENTS,
+  ...HEARTBEAT_EVENTS
+] as const);
+
+/**
+ * @internal
+ * The legacy hello command that was deprecated in MongoDB 5.0.
+ */
+export const LEGACY_HELLO_COMMAND = 'ismaster';
+
+/**
+ * @internal
+ * The legacy hello command that was deprecated in MongoDB 5.0.
+ */
+export const LEGACY_HELLO_COMMAND_CAMEL_CASE = 'isMaster';

package/src/cursor/abstract_cursor.ts

@@ -1,23 +1,24 @@
-import { Callback, maybePromise, MongoDBNamespace, ns } from '../utils';
-import { Long, Document, BSONSerializeOptions, pluckBSONSerializeOptions } from '../bson';
-import { ClientSession, maybeClearPinnedConnection } from '../sessions';
+import { Readable, Transform } from 'stream';
+
+import { BSONSerializeOptions, Document, Long, pluckBSONSerializeOptions } from '../bson';
 import {
   AnyError,
-  MongoRuntimeError,
-  MongoNetworkError,
-  MongoInvalidArgumentError,
   MongoCursorExhaustedError,
-  MongoTailableCursorError,
-  MongoCursorInUseError
+  MongoCursorInUseError,
+  MongoInvalidArgumentError,
+  MongoNetworkError,
+  MongoRuntimeError,
+  MongoTailableCursorError
 } from '../error';
-import { ReadPreference, ReadPreferenceLike } from '../read_preference';
-import type { Server } from '../sdam/server';
-import type { Topology } from '../sdam/topology';
-import { Readable, Transform } from 'stream';
+import { TODO_NODE_3286, TypedEventEmitter } from '../mongo_types';
 import { executeOperation, ExecutionResult } from '../operations/execute_operation';
 import { GetMoreOperation } from '../operations/get_more';
 import { ReadConcern, ReadConcernLike } from '../read_concern';
-import { TODO_NODE_3286, TypedEventEmitter } from '../mongo_types';
+import { ReadPreference, ReadPreferenceLike } from '../read_preference';
+import type { Server } from '../sdam/server';
+import type { Topology } from '../sdam/topology';
+import { ClientSession, maybeClearPinnedConnection } from '../sessions';
+import { Callback, maybePromise, MongoDBNamespace, ns } from '../utils';
 
 /** @internal */
 const kId = Symbol('id');

package/src/cursor/aggregation_cursor.ts

@@ -1,14 +1,14 @@
+import type { Document } from '../bson';
+import type { ExplainVerbosityLike } from '../explain';
 import { AggregateOperation, AggregateOptions } from '../operations/aggregate';
-import { AbstractCursor, assertUninitialized } from './abstract_cursor';
 import { executeOperation, ExecutionResult } from '../operations/execute_operation';
-import { mergeOptions } from '../utils';
-import type { Document } from '../bson';
-import type { Sort } from '../sort';
 import type { Topology } from '../sdam/topology';
-import type { Callback, MongoDBNamespace } from '../utils';
 import type { ClientSession } from '../sessions';
+import type { Sort } from '../sort';
+import type { Callback, MongoDBNamespace } from '../utils';
+import { mergeOptions } from '../utils';
 import type { AbstractCursorOptions } from './abstract_cursor';
-import type { ExplainVerbosityLike } from '../explain';
+import { AbstractCursor, assertUninitialized } from './abstract_cursor';
 
 /** @public */
 export interface AggregationCursorOptions extends AbstractCursorOptions, AggregateOptions {}

package/src/cursor/find_cursor.ts

@@ -1,16 +1,15 @@
 import type { Document } from '../bson';
 import { MongoInvalidArgumentError, MongoTailableCursorError } from '../error';
 import type { ExplainVerbosityLike } from '../explain';
+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 { mergeOptions } from '../utils';
 import type { Hint } from '../operations/operation';
-import type { CollationOptions } from '../operations/command';
 import type { Topology } from '../sdam/topology';
 import type { ClientSession } from '../sessions';
 import { formatSort, Sort, SortDirection } from '../sort';
-import type { Callback, MongoDBNamespace } from '../utils';
+import { Callback, emitWarningOnce, mergeOptions, MongoDBNamespace } from '../utils';
 import { AbstractCursor, assertUninitialized } from './abstract_cursor';
 
 /** @internal */
@@ -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');
     }

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;
   }
 

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');
@@ -173,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 */
@@ -233,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,6 +296,15 @@ export interface AutoEncryptionOptions {
     /** Command line arguments to use when auto-spawning a mongocryptd */
     mongocryptdSpawnArgs?: 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 */

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`
+          )
         );
       }