mongodb 4.1.1 → 4.2.0

package/src/mongo_types.ts

@@ -38,9 +38,11 @@ export type WithId<TSchema> = EnhancedOmit<TSchema, '_id'> & { _id: InferIdType<
  * `TSchema['_id'] extends ObjectId` which translated to "Is the _id property ObjectId?"
  * we instead ask "Does ObjectId look like (have the same shape) as the _id?"
  */
-export type OptionalId<TSchema extends { _id?: any }> = ObjectId extends TSchema['_id'] // a Schema with ObjectId _id type or "any" or "indexed type" provided
-  ? EnhancedOmit<TSchema, '_id'> & { _id?: InferIdType<TSchema> } // a Schema provided but _id type is not ObjectId
-  : WithId<TSchema>; // TODO(NODE-3285): Improve type readability
+export type OptionalId<TSchema> = TSchema extends { _id?: any }
+  ? ObjectId extends TSchema['_id'] // a Schema with ObjectId _id type or "any" or "indexed type" provided
+    ? EnhancedOmit<TSchema, '_id'> & { _id?: InferIdType<TSchema> } // a Schema provided but _id type is not ObjectId
+    : WithId<TSchema>
+  : EnhancedOmit<TSchema, '_id'> & { _id?: InferIdType<TSchema> }; // TODO(NODE-3285): Improve type readability
 
 /** TypeScript Omit (Exclude to be specific) does not work for objects with an "any" indexed type, and breaks discriminated unions @public */
 export type EnhancedOmit<TRecordOrUnion, KeyUnion> = string extends keyof TRecordOrUnion
@@ -55,8 +57,7 @@ export type WithoutId<TSchema> = Omit<TSchema, '_id'>;
 /** A MongoDB filter can be some portion of the schema or a set of operators @public */
 export type Filter<TSchema> = {
   [P in keyof TSchema]?: Condition<TSchema[P]>;
-} &
-  RootFilterOperators<TSchema>;
+} & RootFilterOperators<TSchema>;
 
 /** @public */
 export type Condition<T> = AlternativeType<T> | FilterOperators<AlternativeType<T>>;
@@ -255,8 +256,7 @@ export type SetFields<TSchema> = ({
   readonly [key in KeysOfAType<TSchema, ReadonlyArray<any> | undefined>]?:
     | OptionalId<Flatten<TSchema[key]>>
     | AddToSetOperators<Array<OptionalId<Flatten<TSchema[key]>>>>;
-} &
-  NotAcceptedFields<TSchema, ReadonlyArray<any> | undefined>) & {
+} & NotAcceptedFields<TSchema, ReadonlyArray<any> | undefined>) & {
   readonly [key: string]: AddToSetOperators<any> | any;
 };
 
@@ -265,8 +265,7 @@ export type PushOperator<TSchema> = ({
   readonly [key in KeysOfAType<TSchema, ReadonlyArray<any>>]?:
     | Flatten<TSchema[key]>
     | ArrayOperator<Array<Flatten<TSchema[key]>>>;
-} &
-  NotAcceptedFields<TSchema, ReadonlyArray<any>>) & {
+} & NotAcceptedFields<TSchema, ReadonlyArray<any>>) & {
   readonly [key: string]: ArrayOperator<any> | any;
 };
 
@@ -275,16 +274,14 @@ export type PullOperator<TSchema> = ({
   readonly [key in KeysOfAType<TSchema, ReadonlyArray<any>>]?:
     | Partial<Flatten<TSchema[key]>>
     | FilterOperations<Flatten<TSchema[key]>>;
-} &
-  NotAcceptedFields<TSchema, ReadonlyArray<any>>) & {
+} & NotAcceptedFields<TSchema, ReadonlyArray<any>>) & {
   readonly [key: string]: FilterOperators<any> | any;
 };
 
 /** @public */
 export type PullAllOperator<TSchema> = ({
   readonly [key in KeysOfAType<TSchema, ReadonlyArray<any>>]?: TSchema[key];
-} &
-  NotAcceptedFields<TSchema, ReadonlyArray<any>>) & {
+} & NotAcceptedFields<TSchema, ReadonlyArray<any>>) & {
   readonly [key: string]: ReadonlyArray<any>;
 };
 

package/src/operations/aggregate.ts

@@ -1,5 +1,4 @@
 import { CommandOperation, CommandOperationOptions, CollationOptions } from './command';
-import { ReadPreference } from '../read_preference';
 import { MongoInvalidArgumentError } from '../error';
 import { maxWireVersion, MongoDBNamespace } from '../utils';
 import { Aspect, defineAspects, Hint } from './operation';
@@ -65,7 +64,7 @@ export class AggregateOperation<T = Document> extends CommandOperation<T> {
     }
 
     if (this.hasWriteStage) {
-      this.readPreference = ReadPreference.primary;
+      this.trySecondaryWrite = true;
     }
 
     if (this.explain && this.writeConcern) {

package/src/operations/command.ts

@@ -10,6 +10,7 @@ import type { Server } from '../sdam/server';
 import type { BSONSerializeOptions, Document } from '../bson';
 import type { ReadConcernLike } from './../read_concern';
 import { Explain, ExplainOptions } from '../explain';
+import { MIN_SECONDARY_WRITE_WIRE_VERSION } from '../sdam/server_selection';
 
 const SUPPORTS_WRITE_CONCERN_AND_COLLATION = 5;
 
@@ -126,6 +127,10 @@ export abstract class CommandOperation<T> extends AbstractOperation<T> {
       Object.assign(cmd, { readConcern: this.readConcern });
     }
 
+    if (this.trySecondaryWrite && serverWireVersion < MIN_SECONDARY_WRITE_WIRE_VERSION) {
+      options.omitReadPreference = true;
+    }
+
     if (options.collation && serverWireVersion < SUPPORTS_WRITE_CONCERN_AND_COLLATION) {
       callback(
         new MongoCompatibilityError(

package/src/operations/count.ts

@@ -25,7 +25,7 @@ export class CountOperation extends CommandOperation<number> {
   query: Document;
 
   constructor(namespace: MongoDBNamespace, filter: Document, options: CountOptions) {
-    super(({ s: { namespace: namespace } } as unknown) as Collection, options);
+    super({ s: { namespace: namespace } } as unknown as Collection, options);
 
     this.options = options;
     this.collectionName = namespace.collection;

package/src/operations/count_documents.ts

@@ -40,7 +40,7 @@ export class CountDocumentsOperation extends AggregateOperation<number> {
       }
 
       // NOTE: We're avoiding creating a cursor here to reduce the callstack.
-      const response = (result as unknown) as Document;
+      const response = result as unknown as Document;
       if (response.cursor == null || response.cursor.firstBatch == null) {
         callback(undefined, 0);
         return;

package/src/operations/create_collection.ts

@@ -37,7 +37,7 @@ const ILLEGAL_COMMAND_FIELDS = new Set([
 export interface TimeSeriesCollectionOptions extends Document {
   timeField: string;
   metaField?: string;
-  granularity?: string;
+  granularity?: 'seconds' | 'minutes' | 'hours' | string;
 }
 
 /** @public */

package/src/operations/eval.ts

@@ -43,7 +43,7 @@ export class EvalOperation extends CommandOperation<Document> {
     let finalParameters: Document[] = [];
 
     // If not a code object translate to one
-    if (!(finalCode && ((finalCode as unknown) as { _bsontype: string })._bsontype === 'Code')) {
+    if (!(finalCode && (finalCode as unknown as { _bsontype: string })._bsontype === 'Code')) {
       finalCode = new Code(finalCode as never);
     }
 

package/src/operations/execute_operation.ts

@@ -17,6 +17,7 @@ import type { Topology } from '../sdam/topology';
 import type { ClientSession } from '../sessions';
 import type { Document } from '../bson';
 import { supportsRetryableWrites } from '../utils';
+import { secondaryWritableServerSelector, ServerSelector } from '../sdam/server_selection';
 
 const MMAPv1_RETRY_WRITES_ERROR_CODE = MONGODB_ERROR_CODES.IllegalOperation;
 const MMAPv1_RETRY_WRITES_ERROR_MESSAGE =
@@ -150,6 +151,16 @@ function executeWithServerSelection(
     session.unpin();
   }
 
+  let selector: ReadPreference | ServerSelector;
+
+  // If operation should try to write to secondary use the custom server selector
+  // otherwise provide the read preference.
+  if (operation.trySecondaryWrite) {
+    selector = secondaryWritableServerSelector(topology.commonWireVersion, readPreference);
+  } else {
+    selector = readPreference;
+  }
+
   const serverSelectionOptions = { session };
   function callbackWithRetry(err?: any, result?: any) {
     if (err == null) {
@@ -182,7 +193,7 @@ function executeWithServerSelection(
     }
 
     // select a new server, and attempt to retry the operation
-    topology.selectServer(readPreference, serverSelectionOptions, (e?: any, server?: any) => {
+    topology.selectServer(selector, serverSelectionOptions, (e?: any, server?: any) => {
       if (
         e ||
         (operation.hasAspect(Aspect.READ_OPERATION) && !supportsRetryableReads(server)) ||
@@ -227,7 +238,7 @@ function executeWithServerSelection(
   }
 
   // select a server, and execute the operation against it
-  topology.selectServer(readPreference, serverSelectionOptions, (err?: any, server?: any) => {
+  topology.selectServer(selector, serverSelectionOptions, (err?: any, server?: any) => {
     if (err) {
       callback(err);
       return;

package/src/operations/indexes.ts

@@ -159,7 +159,7 @@ function makeIndexSpec(indexSpec: IndexSpecification, options: any): IndexDescri
 }
 
 /** @internal */
-export class IndexesOperation extends AbstractOperation<Document> {
+export class IndexesOperation extends AbstractOperation<Document[]> {
   options: IndexInformationOptions;
   collection: Collection;
 
@@ -169,7 +169,7 @@ export class IndexesOperation extends AbstractOperation<Document> {
     this.collection = collection;
   }
 
-  execute(server: Server, session: ClientSession, callback: Callback<Document>): void {
+  execute(server: Server, session: ClientSession, callback: Callback<Document[]>): void {
     const coll = this.collection;
     const options = this.options;
 

package/src/operations/list_collections.ts

@@ -15,6 +15,8 @@ const LIST_COLLECTIONS_WIRE_VERSION = 3;
 export interface ListCollectionsOptions extends CommandOperationOptions {
   /** Since 4.0: If true, will only return the collection name in the response, and will omit additional info */
   nameOnly?: boolean;
+  /** Since 4.0: If true and nameOnly is true, allows a user without the required privilege (i.e. listCollections action on the database) to run the command when access control is enforced. */
+  authorizedCollections?: boolean;
   /** The batchSize for the returned command cursor or if pre 2.8 the systems batch collection */
   batchSize?: number;
 }
@@ -25,6 +27,7 @@ export class ListCollectionsOperation extends CommandOperation<string[]> {
   db: Db;
   filter: Document;
   nameOnly: boolean;
+  authorizedCollections: boolean;
   batchSize?: number;
 
   constructor(db: Db, filter: Document, options?: ListCollectionsOptions) {
@@ -34,6 +37,7 @@ export class ListCollectionsOperation extends CommandOperation<string[]> {
     this.db = db;
     this.filter = filter;
     this.nameOnly = !!this.options.nameOnly;
+    this.authorizedCollections = !!this.options.authorizedCollections;
 
     if (typeof this.options.batchSize === 'number') {
       this.batchSize = this.options.batchSize;
@@ -90,14 +94,18 @@ export class ListCollectionsOperation extends CommandOperation<string[]> {
       return;
     }
 
-    const command = {
+    return super.executeCommand(server, session, this.generateCommand(), callback);
+  }
+
+  /* This is here for the purpose of unit testing the final command that gets sent. */
+  generateCommand(): Document {
+    return {
       listCollections: 1,
       filter: this.filter,
       cursor: this.batchSize ? { batchSize: this.batchSize } : {},
-      nameOnly: this.nameOnly
+      nameOnly: this.nameOnly,
+      authorizedCollections: this.authorizedCollections
     };
-
-    return super.executeCommand(server, session, command, callback);
   }
 }
 

package/src/operations/list_databases.ts

@@ -7,7 +7,12 @@ import type { Db } from '../db';
 import type { ClientSession } from '../sessions';
 
 /** @public */
-export type ListDatabasesResult = string[] | Document[];
+export interface ListDatabasesResult {
+  databases: ({ name: string; sizeOnDisk?: number; empty?: boolean } & Document)[];
+  totalSize?: number;
+  totalSizeMb?: number;
+  ok: 1 | 0;
+}
 
 /** @public */
 export interface ListDatabasesOptions extends CommandOperationOptions {

package/src/operations/operation.ts

@@ -31,6 +31,7 @@ export interface OperationOptions extends BSONSerializeOptions {
 
   /** @internal Hints to `executeOperation` that this operation should not unpin on an ended transaction */
   bypassPinningCheck?: boolean;
+  omitReadPreference?: boolean;
 }
 
 /** @internal */
@@ -49,6 +50,7 @@ export abstract class AbstractOperation<TResult = any> {
   readPreference: ReadPreference;
   server!: Server;
   bypassPinningCheck: boolean;
+  trySecondaryWrite: boolean;
 
   // BSON serialization options
   bsonOptions?: BSONSerializeOptions;
@@ -72,6 +74,7 @@ export abstract class AbstractOperation<TResult = any> {
 
     this.options = options;
     this.bypassPinningCheck = !!options.bypassPinningCheck;
+    this.trySecondaryWrite = false;
   }
 
   abstract execute(server: Server, session: ClientSession, callback: Callback<TResult>): void;

package/src/sdam/server.ts

@@ -299,6 +299,14 @@ export class Server extends TypedEventEmitter<ServerEvents> {
     // Clone the options
     const finalOptions = Object.assign({}, options, { wireProtocolCommand: false });
 
+    // There are cases where we need to flag the read preference not to get sent in
+    // the command, such as pre-5.0 servers attempting to perform an aggregate write
+    // with a non-primary read preference. In this case the effective read preference
+    // (primary) is not the same as the provided and must be removed completely.
+    if (finalOptions.omitReadPreference) {
+      delete finalOptions.readPreference;
+    }
+
     // error if collation not supported
     if (collationNotSupported(this, cmd)) {
       callback(new MongoCompatibilityError(`Server ${this.name} does not support collation`));

package/src/sdam/server_selection.ts

@@ -8,6 +8,9 @@ import type { ServerDescription, TagSet } from './server_description';
 const IDLE_WRITE_PERIOD = 10000;
 const SMALLEST_MAX_STALENESS_SECONDS = 90;
 
+//  Minimum version to try writes on secondaries.
+export const MIN_SECONDARY_WRITE_WIRE_VERSION = 13;
+
 /** @public */
 export type ServerSelector = (
   topologyDescription: TopologyDescription,
@@ -28,6 +31,28 @@ export function writableServerSelector(): ServerSelector {
     );
 }
 
+/**
+ * Returns a server selector that uses a read preference to select a
+ * server potentially for a write on a secondary.
+ */
+export function secondaryWritableServerSelector(
+  wireVersion?: number,
+  readPreference?: ReadPreference
+): ServerSelector {
+  // If server version < 5.0, read preference always primary.
+  // If server version >= 5.0...
+  // - If read preference is supplied, use that.
+  // - If no read preference is supplied, use primary.
+  if (
+    !readPreference ||
+    !wireVersion ||
+    (wireVersion && wireVersion < MIN_SECONDARY_WRITE_WIRE_VERSION)
+  ) {
+    return readPreferenceServerSelector(ReadPreference.primary);
+  }
+  return readPreferenceServerSelector(readPreference);
+}
+
 /**
  * Reduces the passed in array of servers by the rules of the "Max Staleness" specification
  * found here: https://github.com/mongodb/specifications/blob/master/source/max-staleness/max-staleness.rst

package/src/sdam/srv_polling.ts

@@ -29,18 +29,15 @@ export class SrvPollingEvent {
     this.srvRecords = srvRecords;
   }
 
-  addresses(): Map<string, HostAddress> {
-    return new Map(
-      this.srvRecords.map(record => {
-        const host = new HostAddress(`${record.name}:${record.port}`);
-        return [host.toString(), host];
-      })
-    );
+  hostnames(): Set<string> {
+    return new Set(this.srvRecords.map(r => HostAddress.fromSrvRecord(r).toString()));
   }
 }
 
 /** @internal */
 export interface SrvPollerOptions extends LoggerOptions {
+  srvServiceName: string;
+  srvMaxHosts: number;
   srvHost: string;
   heartbeatFrequencyMS: number;
 }
@@ -58,6 +55,8 @@ export class SrvPoller extends TypedEventEmitter<SrvPollerEvents> {
   logger: Logger;
   haMode: boolean;
   generation: number;
+  srvMaxHosts: number;
+  srvServiceName: string;
   _timeout?: NodeJS.Timeout;
 
   /** @event */
@@ -71,8 +70,10 @@ export class SrvPoller extends TypedEventEmitter<SrvPollerEvents> {
     }
 
     this.srvHost = options.srvHost;
+    this.srvMaxHosts = options.srvMaxHosts ?? 0;
+    this.srvServiceName = options.srvServiceName ?? 'mongodb';
     this.rescanSrvIntervalMS = 60000;
-    this.heartbeatFrequencyMS = options.heartbeatFrequencyMS || 10000;
+    this.heartbeatFrequencyMS = options.heartbeatFrequencyMS ?? 10000;
     this.logger = new Logger('srvPoller', options);
 
     this.haMode = false;
@@ -82,7 +83,7 @@ export class SrvPoller extends TypedEventEmitter<SrvPollerEvents> {
   }
 
   get srvAddress(): string {
-    return `_mongodb._tcp.${this.srvHost}`;
+    return `_${this.srvServiceName}._tcp.${this.srvHost}`;
   }
 
   get intervalMS(): number {
@@ -143,13 +144,13 @@ export class SrvPoller extends TypedEventEmitter<SrvPollerEvents> {
       }
 
       const finalAddresses: dns.SrvRecord[] = [];
-      srvRecords.forEach((record: dns.SrvRecord) => {
+      for (const record of srvRecords) {
         if (matchesParentDomain(record.name, this.srvHost)) {
           finalAddresses.push(record);
         } else {
           this.parentDomainMismatch(record);
         }
-      });
+      }
 
       if (!finalAddresses.length) {
         this.failure('No valid addresses found at host');

package/src/sdam/topology.ts

@@ -27,7 +27,8 @@ import {
   HostAddress,
   ns,
   emitWarning,
-  EventEmitterWithState
+  EventEmitterWithState,
+  shuffle
 } from '../utils';
 import {
   TopologyType,
@@ -140,6 +141,8 @@ export interface TopologyPrivate {
 
 /** @public */
 export interface TopologyOptions extends BSONSerializeOptions, ServerOptions {
+  srvMaxHosts: number;
+  srvServiceName: string;
   hosts: HostAddress[];
   retryWrites: boolean;
   retryReads: boolean;
@@ -182,8 +185,8 @@ export type TopologyEvents = {
   topologyOpening(event: TopologyOpeningEvent): void;
   topologyDescriptionChanged(event: TopologyDescriptionChangedEvent): void;
   error(error: Error): void;
-  /** TODO(NODE-3273) - remove error @internal */
-  open(error: undefined, topology: Topology): void;
+  /** @internal */
+  open(topology: Topology): void;
   close(): void;
   timeout(): void;
 } & Omit<ServerEvents, 'connect'> &
@@ -290,8 +293,15 @@ export class Topology extends TypedEventEmitter<TopologyEvents> {
     const topologyType = topologyTypeFromOptions(options);
     const topologyId = globalTopologyCounter++;
 
+    const selectedHosts =
+      options.srvMaxHosts == null ||
+      options.srvMaxHosts === 0 ||
+      options.srvMaxHosts >= seedlist.length
+        ? seedlist
+        : shuffle(seedlist, options.srvMaxHosts);
+
     const serverDescriptions = new Map();
-    for (const hostAddress of seedlist) {
+    for (const hostAddress of selectedHosts) {
       serverDescriptions.set(hostAddress.toString(), new ServerDescription(hostAddress));
     }
 
@@ -339,7 +349,9 @@ export class Topology extends TypedEventEmitter<TopologyEvents> {
         options.srvPoller ??
         new SrvPoller({
           heartbeatFrequencyMS: this.s.heartbeatFrequencyMS,
-          srvHost: options.srvHost
+          srvHost: options.srvHost,
+          srvMaxHosts: options.srvMaxHosts,
+          srvServiceName: options.srvServiceName
         });
 
       this.on(Topology.TOPOLOGY_DESCRIPTION_CHANGED, this.s.detectShardedTopology);
@@ -363,7 +375,10 @@ export class Topology extends TypedEventEmitter<TopologyEvents> {
 
   private detectSrvRecords(ev: SrvPollingEvent) {
     const previousTopologyDescription = this.s.description;
-    this.s.description = this.s.description.updateFromSrvPollingEvent(ev);
+    this.s.description = this.s.description.updateFromSrvPollingEvent(
+      ev,
+      this.s.options.srvMaxHosts
+    );
     if (this.s.description === previousTopologyDescription) {
       // Nothing changed, so return
       return;
@@ -456,8 +471,7 @@ export class Topology extends TypedEventEmitter<TopologyEvents> {
           }
 
           stateTransition(this, STATE_CONNECTED);
-          // TODO(NODE-3273) - remove err
-          this.emit(Topology.OPEN, err, this);
+          this.emit(Topology.OPEN, this);
           this.emit(Topology.CONNECT, this);
 
           if (typeof callback === 'function') callback(undefined, this);
@@ -467,8 +481,7 @@ export class Topology extends TypedEventEmitter<TopologyEvents> {
       }
 
       stateTransition(this, STATE_CONNECTED);
-      // TODO(NODE-3273) - remove err
-      this.emit(Topology.OPEN, err, this);
+      this.emit(Topology.OPEN, this);
       this.emit(Topology.CONNECT, this);
 
       if (typeof callback === 'function') callback(undefined, this);
@@ -797,6 +810,10 @@ export class Topology extends TypedEventEmitter<TopologyEvents> {
     return result;
   }
 
+  get commonWireVersion(): number | undefined {
+    return this.description.commonWireVersion;
+  }
+
   get logicalSessionTimeoutMinutes(): number | undefined {
     return this.description.logicalSessionTimeoutMinutes;
   }

package/src/sdam/topology_description.ts

@@ -4,6 +4,7 @@ import { TopologyType, ServerType } from './common';
 import type { ObjectId, Document } from '../bson';
 import type { SrvPollingEvent } from './srv_polling';
 import { MongoError, MongoRuntimeError } from '../error';
+import { shuffle } from '../utils';
 
 // constants related to compatibility checks
 const MIN_SUPPORTED_SERVER_VERSION = WIRE_CONSTANTS.MIN_SUPPORTED_SERVER_VERSION;
@@ -139,23 +140,46 @@ export class TopologyDescription {
    * Returns a new TopologyDescription based on the SrvPollingEvent
    * @internal
    */
-  updateFromSrvPollingEvent(ev: SrvPollingEvent): TopologyDescription {
-    const newAddresses = ev.addresses();
-    const serverDescriptions = new Map(this.servers);
-    for (const address of this.servers.keys()) {
-      if (newAddresses.has(address)) {
-        newAddresses.delete(address);
-      } else {
-        serverDescriptions.delete(address);
+  updateFromSrvPollingEvent(ev: SrvPollingEvent, srvMaxHosts = 0): TopologyDescription {
+    /** The SRV addresses defines the set of addresses we should be using */
+    const incomingHostnames = ev.hostnames();
+    const currentHostnames = new Set(this.servers.keys());
+
+    const hostnamesToAdd = new Set<string>(incomingHostnames);
+    const hostnamesToRemove = new Set<string>();
+    for (const hostname of currentHostnames) {
+      // filter hostnamesToAdd (made from incomingHostnames) down to what is *not* present in currentHostnames
+      hostnamesToAdd.delete(hostname);
+      if (!incomingHostnames.has(hostname)) {
+        // If the SRV Records no longer include this hostname
+        // we have to stop using it
+        hostnamesToRemove.add(hostname);
       }
     }
 
-    if (serverDescriptions.size === this.servers.size && newAddresses.size === 0) {
+    if (hostnamesToAdd.size === 0 && hostnamesToRemove.size === 0) {
+      // No new hosts to add and none to remove
       return this;
     }
 
-    for (const [address, host] of newAddresses) {
-      serverDescriptions.set(address, new ServerDescription(host));
+    const serverDescriptions = new Map(this.servers);
+    for (const removedHost of hostnamesToRemove) {
+      serverDescriptions.delete(removedHost);
+    }
+
+    if (hostnamesToAdd.size > 0) {
+      if (srvMaxHosts === 0) {
+        // Add all!
+        for (const hostToAdd of hostnamesToAdd) {
+          serverDescriptions.set(hostToAdd, new ServerDescription(hostToAdd));
+        }
+      } else if (serverDescriptions.size < srvMaxHosts) {
+        // Add only the amount needed to get us back to srvMaxHosts
+        const selectedHosts = shuffle(hostnamesToAdd, srvMaxHosts - serverDescriptions.size);
+        for (const selectedHostToAdd of selectedHosts) {
+          serverDescriptions.set(selectedHostToAdd, new ServerDescription(selectedHostToAdd));
+        }
+      }
     }
 
     return new TopologyDescription(

package/src/transactions.ts

@@ -1,6 +1,6 @@
 import { ReadPreference } from './read_preference';
 import { MongoRuntimeError, MongoTransactionError } from './error';
-import { ReadConcern } from './read_concern';
+import { ReadConcern, ReadConcernLike } from './read_concern';
 import { WriteConcern } from './write_concern';
 import type { Server } from './sdam/server';
 import type { CommandOperationOptions } from './operations/command';
@@ -63,7 +63,7 @@ const COMMITTED_STATES: Set<TxnState> = new Set([
 export interface TransactionOptions extends CommandOperationOptions {
   // TODO(NODE-3344): These options use the proper class forms of these settings, it should accept the basic enum values too
   /** A default read concern for commands in this transaction */
-  readConcern?: ReadConcern;
+  readConcern?: ReadConcernLike;
   /** A default writeConcern for commands in this transaction */
   writeConcern?: WriteConcern;
   /** A default read preference for commands in this transaction */