mongodb 4.1.3 → 4.2.2

package/src/connection_string.ts

@@ -75,7 +75,7 @@ export function resolveSRVRecord(options: MongoOptions, callback: Callback<HostA
 
   // Resolve the SRV record and use the result as the list of hosts to connect to.
   const lookupAddress = options.srvHost;
-  dns.resolveSrv(`_mongodb._tcp.${lookupAddress}`, (err, addresses) => {
+  dns.resolveSrv(`_${options.srvServiceName}._tcp.${lookupAddress}`, (err, addresses) => {
     if (err) return callback(err);
 
     if (addresses.length === 0) {
@@ -92,7 +92,7 @@ export function resolveSRVRecord(options: MongoOptions, callback: Callback<HostA
       HostAddress.fromString(`${r.name}:${r.port ?? 27017}`)
     );
 
-    const lbError = validateLoadBalancedOptions(hostAddresses, options);
+    const lbError = validateLoadBalancedOptions(hostAddresses, options, true);
     if (lbError) {
       return callback(lbError);
     }
@@ -116,14 +116,14 @@ export function resolveSRVRecord(options: MongoOptions, callback: Callback<HostA
           );
         }
 
+        if (VALID_TXT_RECORDS.some(option => txtRecordOptions.get(option) === '')) {
+          return callback(new MongoParseError('Cannot have empty URI params in DNS TXT Record'));
+        }
+
         const source = txtRecordOptions.get('authSource') ?? undefined;
         const replicaSet = txtRecordOptions.get('replicaSet') ?? undefined;
         const loadBalanced = txtRecordOptions.get('loadBalanced') ?? undefined;
 
-        if (source === '' || replicaSet === '') {
-          return callback(new MongoParseError('Cannot have empty URI params in DNS TXT Record'));
-        }
-
         if (!options.userSpecifiedAuthSource && source) {
           options.credentials = MongoCredentials.merge(options.credentials, { source });
         }
@@ -136,7 +136,11 @@ export function resolveSRVRecord(options: MongoOptions, callback: Callback<HostA
           options.loadBalanced = true;
         }
 
-        const lbError = validateLoadBalancedOptions(hostAddresses, options);
+        if (options.replicaSet && options.srvMaxHosts > 0) {
+          return callback(new MongoParseError('Cannot combine replicaSet option with srvMaxHosts'));
+        }
+
+        const lbError = validateLoadBalancedOptions(hostAddresses, options, true);
         if (lbError) {
           return callback(lbError);
         }
@@ -251,13 +255,6 @@ export function parseOptions(
 
   const mongoOptions = Object.create(null);
   mongoOptions.hosts = isSRV ? [] : hosts.map(HostAddress.fromString);
-  if (isSRV) {
-    // SRV Record is resolved upon connecting
-    mongoOptions.srvHost = hosts[0];
-    if (!url.searchParams.has('tls') && !url.searchParams.has('ssl')) {
-      options.tls = true;
-    }
-  }
 
   const urlOptions = new CaseInsensitiveMap();
 
@@ -289,17 +286,6 @@ export function parseOptions(
       throw new MongoAPIError('URI cannot contain options with no value');
     }
 
-    if (key.toLowerCase() === 'serverapi') {
-      throw new MongoParseError(
-        'URI cannot contain `serverApi`, it can only be passed to the client'
-      );
-    }
-
-    if (key.toLowerCase() === 'authsource' && urlOptions.has('authSource')) {
-      // If authSource is an explicit key in the urlOptions we need to remove the implicit dbName
-      urlOptions.delete('authSource');
-    }
-
     if (!urlOptions.has(key)) {
       urlOptions.set(key, values);
     }
@@ -309,10 +295,20 @@ export function parseOptions(
     Object.entries(options).filter(([, v]) => v != null)
   );
 
+  // Validate options that can only be provided by one of uri or object
+
+  if (urlOptions.has('serverApi')) {
+    throw new MongoParseError(
+      'URI cannot contain `serverApi`, it can only be passed to the client'
+    );
+  }
+
   if (objectOptions.has('loadBalanced')) {
     throw new MongoParseError('loadBalanced is only a valid option in the URI');
   }
 
+  // All option collection
+
   const allOptions = new CaseInsensitiveMap();
 
   const allKeys = new Set<string>([
@@ -360,6 +356,8 @@ export function parseOptions(
     );
   }
 
+  // Option parsing and setting
+
   for (const [key, descriptor] of Object.entries(OPTIONS)) {
     const values = allOptions.get(key);
     if (!values || values.length === 0) continue;
@@ -401,25 +399,53 @@ export function parseOptions(
 
   if (options.promiseLibrary) PromiseProvider.set(options.promiseLibrary);
 
-  if (mongoOptions.directConnection && typeof mongoOptions.srvHost === 'string') {
-    throw new MongoAPIError('SRV URI does not support directConnection');
-  }
-
-  const lbError = validateLoadBalancedOptions(hosts, mongoOptions);
+  const lbError = validateLoadBalancedOptions(hosts, mongoOptions, isSRV);
   if (lbError) {
     throw lbError;
   }
+  if (mongoClient && mongoOptions.autoEncryption) {
+    Encrypter.checkForMongoCrypt();
+    mongoOptions.encrypter = new Encrypter(mongoClient, uri, options);
+    mongoOptions.autoEncrypter = mongoOptions.encrypter.autoEncrypter;
+  }
+
+  // Potential SRV Overrides and SRV connection string validations
 
-  // Potential SRV Overrides
   mongoOptions.userSpecifiedAuthSource =
     objectOptions.has('authSource') || urlOptions.has('authSource');
   mongoOptions.userSpecifiedReplicaSet =
     objectOptions.has('replicaSet') || urlOptions.has('replicaSet');
 
-  if (mongoClient && mongoOptions.autoEncryption) {
-    Encrypter.checkForMongoCrypt();
-    mongoOptions.encrypter = new Encrypter(mongoClient, uri, options);
-    mongoOptions.autoEncrypter = mongoOptions.encrypter.autoEncrypter;
+  if (isSRV) {
+    // SRV Record is resolved upon connecting
+    mongoOptions.srvHost = hosts[0];
+
+    if (mongoOptions.directConnection) {
+      throw new MongoAPIError('SRV URI does not support directConnection');
+    }
+
+    if (mongoOptions.srvMaxHosts > 0 && typeof mongoOptions.replicaSet === 'string') {
+      throw new MongoParseError('Cannot use srvMaxHosts option with replicaSet');
+    }
+
+    // SRV turns on TLS by default, but users can override and turn it off
+    const noUserSpecifiedTLS = !objectOptions.has('tls') && !urlOptions.has('tls');
+    const noUserSpecifiedSSL = !objectOptions.has('ssl') && !urlOptions.has('ssl');
+    if (noUserSpecifiedTLS && noUserSpecifiedSSL) {
+      mongoOptions.tls = true;
+    }
+  } else {
+    const userSpecifiedSrvOptions =
+      urlOptions.has('srvMaxHosts') ||
+      objectOptions.has('srvMaxHosts') ||
+      urlOptions.has('srvServiceName') ||
+      objectOptions.has('srvServiceName');
+
+    if (userSpecifiedSrvOptions) {
+      throw new MongoParseError(
+        'Cannot use srvMaxHosts or srvServiceName with a non-srv connection string'
+      );
+    }
   }
 
   return mongoOptions;
@@ -427,7 +453,8 @@ export function parseOptions(
 
 function validateLoadBalancedOptions(
   hosts: HostAddress[] | string[],
-  mongoOptions: MongoOptions
+  mongoOptions: MongoOptions,
+  isSrv: boolean
 ): MongoParseError | undefined {
   if (mongoOptions.loadBalanced) {
     if (hosts.length > 1) {
@@ -439,6 +466,10 @@ function validateLoadBalancedOptions(
     if (mongoOptions.directConnection) {
       return new MongoParseError(LB_DIRECT_CONNECTION_ERROR);
     }
+
+    if (isSrv && mongoOptions.srvMaxHosts > 0) {
+      return new MongoParseError('Cannot limit srv hosts with loadBalanced enabled');
+    }
   }
 }
 
@@ -924,6 +955,14 @@ export const OPTIONS = {
     default: 0,
     type: 'uint'
   },
+  srvMaxHosts: {
+    type: 'uint',
+    default: 0
+  },
+  srvServiceName: {
+    type: 'string',
+    default: 'mongodb'
+  },
   ssl: {
     target: 'tls',
     type: 'boolean'

package/src/cursor/abstract_cursor.ts

@@ -14,7 +14,8 @@ import { ReadPreference, ReadPreferenceLike } from '../read_preference';
 import type { Server } from '../sdam/server';
 import type { Topology } from '../sdam/topology';
 import { Readable, Transform } from 'stream';
-import type { ExecutionResult } from '../operations/execute_operation';
+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';
 
@@ -610,16 +611,13 @@ export abstract class AbstractCursor<
       return;
     }
 
-    server.getMore(
-      cursorNs,
-      cursorId,
-      {
-        ...this[kOptions],
-        session: this[kSession],
-        batchSize
-      },
-      callback
-    );
+    const getMoreOperation = new GetMoreOperation(cursorNs, cursorId, server, {
+      ...this[kOptions],
+      session: this[kSession],
+      batchSize
+    });
+
+    executeOperation(this.topology, getMoreOperation, callback);
   }
 }
 

package/src/db.ts

@@ -226,18 +226,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/error.ts

@@ -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/mongo_client.ts

@@ -132,6 +132,16 @@ export interface MongoClientOptions extends BSONSerializeOptions, SupportedNodeC
   compressors?: CompressorName[] | string;
   /** An integer that specifies the compression level if using zlib for network compression. */
   zlibCompressionLevel?: 0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | undefined;
+  /** The maximum number of hosts to connect to when using an srv connection string, a setting of `0` means unlimited hosts */
+  srvMaxHosts?: number;
+  /**
+   * Modifies the srv URI to look like:
+   *
+   * `_{srvServiceName}._tcp.{hostname}.{domainname}`
+   *
+   * Querying this DNS URI is expected to respond with SRV records
+   */
+  srvServiceName?: string;
   /** The maximum number of connections in the connection pool. */
   maxPoolSize?: number;
   /** The minimum number of connections in the connection pool. */
@@ -643,6 +653,8 @@ export interface MongoOptions
         | 'retryWrites'
         | 'serverSelectionTimeoutMS'
         | 'socketTimeoutMS'
+        | 'srvMaxHosts'
+        | 'srvServiceName'
         | 'tlsAllowInvalidCertificates'
         | 'tlsAllowInvalidHostnames'
         | 'tlsInsecure'

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
@@ -54,9 +56,8 @@ 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>;
+  [P in keyof WithId<TSchema>]?: Condition<WithId<TSchema>[P]>;
+} & RootFilterOperators<WithId<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/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/execute_operation.ts

@@ -17,6 +17,11 @@ import type { Topology } from '../sdam/topology';
 import type { ClientSession } from '../sessions';
 import type { Document } from '../bson';
 import { supportsRetryableWrites } from '../utils';
+import {
+  sameServerSelector,
+  secondaryWritableServerSelector,
+  ServerSelector
+} from '../sdam/server_selection';
 
 const MMAPv1_RETRY_WRITES_ERROR_CODE = MONGODB_ERROR_CODES.IllegalOperation;
 const MMAPv1_RETRY_WRITES_ERROR_MESSAGE =
@@ -150,6 +155,21 @@ function executeWithServerSelection(
     session.unpin();
   }
 
+  let selector: ReadPreference | ServerSelector;
+
+  if (operation.hasAspect(Aspect.CURSOR_ITERATING)) {
+    // Get more operations must always select the same server, but run through
+    // server selection to potentially force monitor checks if the server is
+    // in an unknown state.
+    selector = sameServerSelector(operation.server?.description);
+  } else if (operation.trySecondaryWrite) {
+    // If operation should try to write to secondary use the custom server selector
+    // otherwise provide the read preference.
+    selector = secondaryWritableServerSelector(topology.commonWireVersion, readPreference);
+  } else {
+    selector = readPreference;
+  }
+
   const serverSelectionOptions = { session };
   function callbackWithRetry(err?: any, result?: any) {
     if (err == null) {
@@ -182,7 +202,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 +247,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/get_more.ts

@@ -0,0 +1,49 @@
+import type { Document, Long } from '../bson';
+import { MongoRuntimeError } from '../error';
+import type { Callback, MongoDBNamespace } from '../utils';
+import type { Server } from '../sdam/server';
+import { Aspect, AbstractOperation, OperationOptions, defineAspects } from './operation';
+import type { ClientSession } from '../sessions';
+
+/**
+ * @public
+ */
+// eslint-disable-next-line @typescript-eslint/no-unused-vars
+export interface GetMoreOptions extends OperationOptions {
+  /** Set the batchSize for the getMoreCommand when iterating over the query results. */
+  batchSize?: number;
+  /** You can put a $comment field on a query to make looking in the profiler logs simpler. */
+  comment?: string | Document;
+  /** Number of milliseconds to wait before aborting the query. */
+  maxTimeMS?: number;
+}
+
+/** @internal */
+export class GetMoreOperation extends AbstractOperation {
+  cursorId: Long;
+  options: GetMoreOptions;
+  server: Server;
+
+  constructor(ns: MongoDBNamespace, cursorId: Long, server: Server, options: GetMoreOptions = {}) {
+    super(options);
+    this.options = options;
+    this.ns = ns;
+    this.cursorId = cursorId;
+    this.server = server;
+  }
+
+  /**
+   * Although there is a server already associated with the get more operation, the signature
+   * for execute passes a server so we will just use that one.
+   */
+  execute(server: Server, session: ClientSession, callback: Callback<Document>): void {
+    if (server !== this.server) {
+      return callback(
+        new MongoRuntimeError('Getmore must run on the same server operation began on')
+      );
+    }
+    server.getMore(this.ns, this.cursorId, this.options, callback);
+  }
+}
+
+defineAspects(GetMoreOperation, [Aspect.READ_OPERATION, Aspect.CURSOR_ITERATING]);