mongodb 4.2.0 → 4.3.1

package/src/collection.ts

@@ -1,105 +1,108 @@
-import { DEFAULT_PK_FACTORY, emitWarningOnce, resolveOptions } from './utils';
-import { ReadPreference, ReadPreferenceLike } from './read_preference';
-import {
-  normalizeHintField,
-  checkCollectionName,
-  MongoDBNamespace,
-  Callback,
-  getTopology
-} from './utils';
-import { Document, BSONSerializeOptions, resolveBSONOptions } from './bson';
-import { MongoInvalidArgumentError } from './error';
-import { UnorderedBulkOperation } from './bulk/unordered';
+import { BSONSerializeOptions, Document, resolveBSONOptions } from './bson';
+import type { AnyBulkWriteOperation, BulkWriteOptions, BulkWriteResult } from './bulk/common';
 import { OrderedBulkOperation } from './bulk/ordered';
+import { UnorderedBulkOperation } from './bulk/unordered';
 import { ChangeStream, ChangeStreamOptions } from './change_stream';
-import { WriteConcern, WriteConcernOptions } from './write_concern';
-import { ReadConcern, ReadConcernLike } from './read_concern';
 import { AggregationCursor } from './cursor/aggregation_cursor';
+import { FindCursor } from './cursor/find_cursor';
+import type { Db } from './db';
+import { MongoInvalidArgumentError } from './error';
+import type { Logger, LoggerOptions } from './logger';
+import type { PkFactory } from './mongo_client';
+import type {
+  Filter,
+  Flatten,
+  OptionalUnlessRequiredId,
+  TODO_NODE_3286,
+  UpdateFilter,
+  WithId,
+  WithoutId
+} from './mongo_types';
 import type { AggregateOptions } from './operations/aggregate';
 import { BulkWriteOperation } from './operations/bulk_write';
+import type { IndexInformationOptions } from './operations/common_functions';
+import type { CountOptions } from './operations/count';
 import { CountDocumentsOperation, CountDocumentsOptions } from './operations/count_documents';
 import {
-  CreateIndexesOperation,
-  CreateIndexOperation,
-  DropIndexOperation,
-  DropIndexesOperation,
-  IndexesOperation,
-  IndexExistsOperation,
-  IndexInformationOperation,
-  CreateIndexesOptions,
-  DropIndexesOptions,
-  ListIndexesOptions,
-  IndexSpecification,
-  IndexDescription,
-  ListIndexesCursor
-} from './operations/indexes';
+  DeleteManyOperation,
+  DeleteOneOperation,
+  DeleteOptions,
+  DeleteResult
+} from './operations/delete';
 import { DistinctOperation, DistinctOptions } from './operations/distinct';
 import { DropCollectionOperation, DropCollectionOptions } from './operations/drop';
 import {
   EstimatedDocumentCountOperation,
   EstimatedDocumentCountOptions
 } from './operations/estimated_document_count';
+import { executeOperation } from './operations/execute_operation';
 import type { FindOptions } from './operations/find';
 import {
   FindOneAndDeleteOperation,
-  FindOneAndReplaceOperation,
-  FindOneAndUpdateOperation,
   FindOneAndDeleteOptions,
+  FindOneAndReplaceOperation,
   FindOneAndReplaceOptions,
+  FindOneAndUpdateOperation,
   FindOneAndUpdateOptions
 } from './operations/find_and_modify';
 import {
+  CreateIndexesOperation,
+  CreateIndexesOptions,
+  CreateIndexOperation,
+  DropIndexesOperation,
+  DropIndexesOptions,
+  DropIndexOperation,
+  IndexDescription,
+  IndexesOperation,
+  IndexExistsOperation,
+  IndexInformationOperation,
+  IndexSpecification,
+  ListIndexesCursor,
+  ListIndexesOptions
+} from './operations/indexes';
+import {
+  InsertManyOperation,
+  InsertManyResult,
   InsertOneOperation,
   InsertOneOptions,
-  InsertOneResult,
-  InsertManyOperation,
-  InsertManyResult
+  InsertOneResult
 } from './operations/insert';
-import {
-  UpdateOneOperation,
-  UpdateManyOperation,
-  UpdateOptions,
-  UpdateResult,
-  ReplaceOneOperation,
-  ReplaceOptions
-} from './operations/update';
-import {
-  DeleteOneOperation,
-  DeleteManyOperation,
-  DeleteOptions,
-  DeleteResult
-} from './operations/delete';
 import { IsCappedOperation } from './operations/is_capped';
 import {
-  MapReduceOperation,
   MapFunction,
-  ReduceFunction,
-  MapReduceOptions
+  MapReduceOperation,
+  MapReduceOptions,
+  ReduceFunction
 } from './operations/map_reduce';
+import type { Hint, OperationOptions } from './operations/operation';
 import { OptionsOperation } from './operations/options_operation';
 import { RenameOperation, RenameOptions } from './operations/rename';
 import { CollStats, CollStatsOperation, CollStatsOptions } from './operations/stats';
-import { executeOperation } from './operations/execute_operation';
-import type { Db } from './db';
-import type { OperationOptions, Hint } from './operations/operation';
-import type { IndexInformationOptions } from './operations/common_functions';
-import type { BulkWriteResult, BulkWriteOptions, AnyBulkWriteOperation } from './bulk/common';
-import type { PkFactory } from './mongo_client';
-import type { Logger, LoggerOptions } from './logger';
-import { FindCursor } from './cursor/find_cursor';
-import type { CountOptions } from './operations/count';
-import type {
-  Filter,
-  TODO_NODE_3286,
-  UpdateFilter,
-  WithId,
-  OptionalId,
-  Flatten
-} from './mongo_types';
+import {
+  ReplaceOneOperation,
+  ReplaceOptions,
+  UpdateManyOperation,
+  UpdateOneOperation,
+  UpdateOptions,
+  UpdateResult
+} from './operations/update';
+import { ReadConcern, ReadConcernLike } from './read_concern';
+import { ReadPreference, ReadPreferenceLike } from './read_preference';
+import {
+  Callback,
+  checkCollectionName,
+  DEFAULT_PK_FACTORY,
+  emitWarningOnce,
+  getTopology,
+  MongoDBNamespace,
+  normalizeHintField,
+  resolveOptions
+} from './utils';
+import { WriteConcern, WriteConcernOptions } from './write_concern';
 
 /** @public */
 export interface ModifyResult<TSchema = Document> {
-  value: TSchema | null;
+  value: WithId<TSchema> | null;
   lastErrorObject?: Document;
   ok: 0 | 1;
 }
@@ -109,6 +112,9 @@ export interface CollectionOptions
   extends BSONSerializeOptions,
     WriteConcernOptions,
     LoggerOptions {
+  /**
+   * @deprecated Use readPreference instead
+   */
   slaveOk?: boolean;
   /** Specify a read concern for the collection. (only MongoDB 3.2 or higher supported) */
   readConcern?: ReadConcernLike;
@@ -124,7 +130,6 @@ export interface CollectionPrivate {
   namespace: MongoDBNamespace;
   readPreference?: ReadPreference;
   bsonOptions: BSONSerializeOptions;
-  slaveOk?: boolean;
   collectionHint?: Hint;
   readConcern?: ReadConcern;
   writeConcern?: WriteConcern;
@@ -178,8 +183,7 @@ export class Collection<TSchema extends Document = Document> {
       readPreference: ReadPreference.fromOptions(options),
       bsonOptions: resolveBSONOptions(options, db),
       readConcern: ReadConcern.fromOptions(options),
-      writeConcern: WriteConcern.fromOptions(options),
-      slaveOk: options == null || options.slaveOk == null ? db.slaveOk : options.slaveOk
+      writeConcern: WriteConcern.fromOptions(options)
     };
   }
 
@@ -261,16 +265,22 @@ export class Collection<TSchema extends Document = Document> {
    * @param options - Optional settings for the command
    * @param callback - An optional callback, a Promise will be returned if none is provided
    */
-  insertOne(doc: OptionalId<TSchema>): Promise<InsertOneResult<TSchema>>;
-  insertOne(doc: OptionalId<TSchema>, callback: Callback<InsertOneResult<TSchema>>): void;
-  insertOne(doc: OptionalId<TSchema>, options: InsertOneOptions): Promise<InsertOneResult<TSchema>>;
+  insertOne(doc: OptionalUnlessRequiredId<TSchema>): Promise<InsertOneResult<TSchema>>;
+  insertOne(
+    doc: OptionalUnlessRequiredId<TSchema>,
+    callback: Callback<InsertOneResult<TSchema>>
+  ): void;
+  insertOne(
+    doc: OptionalUnlessRequiredId<TSchema>,
+    options: InsertOneOptions
+  ): Promise<InsertOneResult<TSchema>>;
   insertOne(
-    doc: OptionalId<TSchema>,
+    doc: OptionalUnlessRequiredId<TSchema>,
     options: InsertOneOptions,
     callback: Callback<InsertOneResult<TSchema>>
   ): void;
   insertOne(
-    doc: OptionalId<TSchema>,
+    doc: OptionalUnlessRequiredId<TSchema>,
     options?: InsertOneOptions | Callback<InsertOneResult<TSchema>>,
     callback?: Callback<InsertOneResult<TSchema>>
   ): Promise<InsertOneResult<TSchema>> | void {
@@ -305,19 +315,22 @@ export class Collection<TSchema extends Document = Document> {
    * @param options - Optional settings for the command
    * @param callback - An optional callback, a Promise will be returned if none is provided
    */
-  insertMany(docs: OptionalId<TSchema>[]): Promise<InsertManyResult<TSchema>>;
-  insertMany(docs: OptionalId<TSchema>[], callback: Callback<InsertManyResult<TSchema>>): void;
+  insertMany(docs: OptionalUnlessRequiredId<TSchema>[]): Promise<InsertManyResult<TSchema>>;
   insertMany(
-    docs: OptionalId<TSchema>[],
+    docs: OptionalUnlessRequiredId<TSchema>[],
+    callback: Callback<InsertManyResult<TSchema>>
+  ): void;
+  insertMany(
+    docs: OptionalUnlessRequiredId<TSchema>[],
     options: BulkWriteOptions
   ): Promise<InsertManyResult<TSchema>>;
   insertMany(
-    docs: OptionalId<TSchema>[],
+    docs: OptionalUnlessRequiredId<TSchema>[],
     options: BulkWriteOptions,
     callback: Callback<InsertManyResult<TSchema>>
   ): void;
   insertMany(
-    docs: OptionalId<TSchema>[],
+    docs: OptionalUnlessRequiredId<TSchema>[],
     options?: BulkWriteOptions | Callback<InsertManyResult<TSchema>>,
     callback?: Callback<InsertManyResult<TSchema>>
   ): Promise<InsertManyResult<TSchema>> | void {
@@ -459,26 +472,29 @@ export class Collection<TSchema extends Document = Document> {
    * @param options - Optional settings for the command
    * @param callback - An optional callback, a Promise will be returned if none is provided
    */
-  replaceOne(filter: Filter<TSchema>, replacement: TSchema): Promise<UpdateResult | Document>;
   replaceOne(
     filter: Filter<TSchema>,
-    replacement: TSchema,
+    replacement: WithoutId<TSchema>
+  ): Promise<UpdateResult | Document>;
+  replaceOne(
+    filter: Filter<TSchema>,
+    replacement: WithoutId<TSchema>,
     callback: Callback<UpdateResult | Document>
   ): void;
   replaceOne(
     filter: Filter<TSchema>,
-    replacement: TSchema,
+    replacement: WithoutId<TSchema>,
     options: ReplaceOptions
   ): Promise<UpdateResult | Document>;
   replaceOne(
     filter: Filter<TSchema>,
-    replacement: TSchema,
+    replacement: WithoutId<TSchema>,
     options: ReplaceOptions,
     callback: Callback<UpdateResult | Document>
   ): void;
   replaceOne(
     filter: Filter<TSchema>,
-    replacement: TSchema,
+    replacement: WithoutId<TSchema>,
     options?: ReplaceOptions | Callback<UpdateResult | Document>,
     callback?: Callback<UpdateResult | Document>
   ): Promise<UpdateResult | Document> | void {
@@ -730,9 +746,9 @@ export class Collection<TSchema extends Document = Document> {
    * @param filter - The filter predicate. If unspecified, then all documents in the collection will match the predicate
    */
   find(): FindCursor<WithId<TSchema>>;
-  find(filter: Filter<WithId<TSchema>>, options?: FindOptions): FindCursor<WithId<TSchema>>;
-  find<T>(filter: Filter<WithId<TSchema>>, options?: FindOptions): FindCursor<T>;
-  find(filter?: Filter<WithId<TSchema>>, options?: FindOptions): FindCursor<WithId<TSchema>> {
+  find(filter: Filter<TSchema>, options?: FindOptions): FindCursor<WithId<TSchema>>;
+  find<T>(filter: Filter<TSchema>, options?: FindOptions): FindCursor<T>;
+  find(filter?: Filter<TSchema>, options?: FindOptions): FindCursor<WithId<TSchema>> {
     if (arguments.length > 2) {
       throw new MongoInvalidArgumentError(
         'Method "collection.find()" accepts at most two arguments'
@@ -1279,26 +1295,29 @@ export class Collection<TSchema extends Document = Document> {
    * @param options - Optional settings for the command
    * @param callback - An optional callback, a Promise will be returned if none is provided
    */
-  findOneAndReplace(filter: Filter<TSchema>, replacement: Document): Promise<ModifyResult<TSchema>>;
   findOneAndReplace(
     filter: Filter<TSchema>,
-    replacement: Document,
+    replacement: WithoutId<TSchema>
+  ): Promise<ModifyResult<TSchema>>;
+  findOneAndReplace(
+    filter: Filter<TSchema>,
+    replacement: WithoutId<TSchema>,
     callback: Callback<ModifyResult<TSchema>>
   ): void;
   findOneAndReplace(
     filter: Filter<TSchema>,
-    replacement: Document,
+    replacement: WithoutId<TSchema>,
     options: FindOneAndReplaceOptions
   ): Promise<ModifyResult<TSchema>>;
   findOneAndReplace(
     filter: Filter<TSchema>,
-    replacement: Document,
+    replacement: WithoutId<TSchema>,
     options: FindOneAndReplaceOptions,
     callback: Callback<ModifyResult<TSchema>>
   ): void;
   findOneAndReplace(
     filter: Filter<TSchema>,
-    replacement: Document,
+    replacement: WithoutId<TSchema>,
     options?: FindOneAndReplaceOptions | Callback<ModifyResult<TSchema>>,
     callback?: Callback<ModifyResult<TSchema>>
   ): Promise<ModifyResult<TSchema>> | void {
@@ -1517,7 +1536,7 @@ export class Collection<TSchema extends Document = Document> {
    * @param callback - An optional callback, a Promise will be returned if none is provided
    */
   insert(
-    docs: OptionalId<TSchema>[],
+    docs: OptionalUnlessRequiredId<TSchema>[],
     options: BulkWriteOptions,
     callback: Callback<InsertManyResult<TSchema>>
   ): Promise<InsertManyResult<TSchema>> | void {

package/src/connection_string.ts

@@ -2,22 +2,14 @@ import * as dns from 'dns';
 import * as fs from 'fs';
 import ConnectionString from 'mongodb-connection-string-url';
 import { URLSearchParams } from 'url';
-import { AuthMechanism } from './cmap/auth/defaultAuthProviders';
-import { ReadPreference, ReadPreferenceMode } from './read_preference';
-import { ReadConcern, ReadConcernLevel } from './read_concern';
-import { W, WriteConcern } from './write_concern';
-import { MongoAPIError, MongoInvalidArgumentError, MongoParseError } from './error';
-import {
-  AnyOptions,
-  Callback,
-  DEFAULT_PK_FACTORY,
-  isRecord,
-  makeClientMetadata,
-  setDifference,
-  HostAddress,
-  emitWarning
-} from './utils';
+
 import type { Document } from './bson';
+import { MongoCredentials } from './cmap/auth/mongo_credentials';
+import { AUTH_MECHS_AUTH_SRC_EXTERNAL, AuthMechanism } from './cmap/auth/providers';
+import { Compressor, CompressorName } from './cmap/wire_protocol/compression';
+import { Encrypter } from './encrypter';
+import { MongoAPIError, MongoInvalidArgumentError, MongoParseError } from './error';
+import { Logger, LoggerLevel } from './logger';
 import {
   DriverInfo,
   MongoClient,
@@ -27,12 +19,21 @@ import {
   ServerApi,
   ServerApiVersion
 } from './mongo_client';
-import { MongoCredentials } from './cmap/auth/mongo_credentials';
-import type { TagSet } from './sdam/server_description';
-import { Logger, LoggerLevel } from './logger';
 import { PromiseProvider } from './promise_provider';
-import { Encrypter } from './encrypter';
-import { Compressor, CompressorName } from './cmap/wire_protocol/compression';
+import { ReadConcern, ReadConcernLevel } from './read_concern';
+import { ReadPreference, ReadPreferenceMode } from './read_preference';
+import type { TagSet } from './sdam/server_description';
+import {
+  AnyOptions,
+  Callback,
+  DEFAULT_PK_FACTORY,
+  emitWarning,
+  HostAddress,
+  isRecord,
+  makeClientMetadata,
+  setDifference
+} from './utils';
+import { W, WriteConcern } from './write_concern';
 
 const VALID_TXT_RECORDS = ['authSource', 'replicaSet', 'loadBalanced'];
 
@@ -124,7 +125,12 @@ export function resolveSRVRecord(options: MongoOptions, callback: Callback<HostA
         const replicaSet = txtRecordOptions.get('replicaSet') ?? undefined;
         const loadBalanced = txtRecordOptions.get('loadBalanced') ?? undefined;
 
-        if (!options.userSpecifiedAuthSource && source) {
+        if (
+          !options.userSpecifiedAuthSource &&
+          source &&
+          options.credentials &&
+          !AUTH_MECHS_AUTH_SRC_EXTERNAL.has(options.credentials.mechanism)
+        ) {
           options.credentials = MongoCredentials.merge(options.credentials, { source });
         }
 
@@ -291,11 +297,6 @@ export function parseOptions(
     }
   }
 
-  if (urlOptions.has('authSource')) {
-    // If authSource is an explicit key in the urlOptions we need to remove the dbName
-    urlOptions.delete('dbName');
-  }
-
   const objectOptions = new CaseInsensitiveMap(
     Object.entries(options).filter(([, v]) => v != null)
   );
@@ -453,6 +454,31 @@ export function parseOptions(
     }
   }
 
+  if (
+    !mongoOptions.proxyHost &&
+    (mongoOptions.proxyPort || mongoOptions.proxyUsername || mongoOptions.proxyPassword)
+  ) {
+    throw new MongoParseError('Must specify proxyHost if other proxy options are passed');
+  }
+
+  if (
+    (mongoOptions.proxyUsername && !mongoOptions.proxyPassword) ||
+    (!mongoOptions.proxyUsername && mongoOptions.proxyPassword)
+  ) {
+    throw new MongoParseError('Can only specify both of proxy username/password or neither');
+  }
+
+  if (
+    urlOptions.get('proxyHost')?.length > 1 ||
+    urlOptions.get('proxyPort')?.length > 1 ||
+    urlOptions.get('proxyUsername')?.length > 1 ||
+    urlOptions.get('proxyPassword')?.length > 1
+  ) {
+    throw new MongoParseError(
+      'Proxy options cannot be specified multiple times in the connection string'
+    );
+  }
+
   return mongoOptions;
 }
 
@@ -574,9 +600,7 @@ export const OPTIONS = {
       let source = options.credentials?.source;
       if (
         mechanism === AuthMechanism.MONGODB_PLAIN ||
-        mechanism === AuthMechanism.MONGODB_GSSAPI ||
-        mechanism === AuthMechanism.MONGODB_AWS ||
-        mechanism === AuthMechanism.MONGODB_X509
+        AUTH_MECHS_AUTH_SRC_EXTERNAL.has(mechanism)
       ) {
         // some mechanisms have '$external' as the Auth Source
         source = '$external';
@@ -693,6 +717,7 @@ export const OPTIONS = {
       });
     }
   },
+  enableUtf8Validation: { type: 'boolean', default: true },
   family: {
     transform({ name, values: [value] }): 4 | 6 {
       const transformValue = getInt(name, value);
@@ -860,6 +885,18 @@ export const OPTIONS = {
   promoteValues: {
     type: 'boolean'
   },
+  proxyHost: {
+    type: 'string'
+  },
+  proxyPassword: {
+    type: 'string'
+  },
+  proxyPort: {
+    type: 'uint'
+  },
+  proxyUsername: {
+    type: 'string'
+  },
   raw: {
     default: false,
     type: 'boolean'

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,22 +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 { 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 { 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 { ReadConcern, ReadConcernLike } from '../read_concern';
-import { TODO_NODE_3286, TypedEventEmitter } from '../mongo_types';
+import { ClientSession, maybeClearPinnedConnection } from '../sessions';
+import { Callback, maybePromise, MongoDBNamespace, ns } from '../utils';
 
 /** @internal */
 const kId = Symbol('id');
@@ -610,16 +612,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);
   }
 }