mongodb 4.3.0 → 4.4.1

package/src/deps.ts

@@ -174,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 */
@@ -234,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
@@ -264,6 +297,14 @@ export interface AutoEncryptionOptions {
     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/error.ts

@@ -625,6 +625,8 @@ export class MongoSystemError extends MongoError {
     if (reason) {
       this.reason = reason;
     }
+
+    this.code = reason.error?.code;
   }
 
   get name(): string {

package/src/index.ts

@@ -62,6 +62,7 @@ export {
   MongoServerError,
   MongoServerSelectionError,
   MongoSystemError,
+  MongoTailableCursorError,
   MongoTopologyClosedError,
   MongoTransactionError,
   MongoWriteConcernError
@@ -86,6 +87,7 @@ export {
 
 // enums
 export { BatchType } from './bulk/common';
+export { GSSAPICanonicalizationValue } from './cmap/auth/gssapi';
 export { AuthMechanism } from './cmap/auth/providers';
 export { Compressor } from './cmap/wire_protocol/compression';
 export { CURSOR_FLAGS } from './cursor/abstract_cursor';
@@ -229,7 +231,7 @@ export type {
 export type { InternalAbstractCursorOptions } from './cursor/abstract_cursor';
 export type { AggregationCursorOptions } from './cursor/aggregation_cursor';
 export type { DbOptions, DbPrivate } from './db';
-export type { AutoEncrypter, AutoEncryptionOptions } from './deps';
+export type { AutoEncrypter, AutoEncryptionOptions, AutoEncryptionTlsOptions } from './deps';
 export type { Encrypter, EncrypterOptions } from './encrypter';
 export type { AnyError, ErrorDescription, MongoNetworkErrorOptions } from './error';
 export type { Explain, ExplainOptions, ExplainVerbosityLike } from './explain';

package/src/mongo_types.ts

@@ -65,11 +65,13 @@ export type EnhancedOmit<TRecordOrUnion, KeyUnion> = string extends keyof TRecor
 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> = {
-  [Property in Join<NestedPaths<WithId<TSchema>>, '.'>]?: Condition<
-    PropertyType<WithId<TSchema>, Property>
-  >;
-} & RootFilterOperators<WithId<TSchema>>;
+export type Filter<TSchema> =
+  | Partial<TSchema>
+  | ({
+      [Property in Join<NestedPaths<WithId<TSchema>>, '.'>]?: Condition<
+        PropertyType<WithId<TSchema>, Property>
+      >;
+    } & RootFilterOperators<WithId<TSchema>>);
 
 /** @public */
 export type Condition<T> = AlternativeType<T> | FilterOperators<AlternativeType<T>>;
@@ -477,8 +479,11 @@ export type PropertyType<Type, Property extends string> = string extends Propert
     : unknown
   : unknown;
 
-// We dont't support nested circular references
-/** @public */
+/**
+ * @public
+ * returns tuple of strings (keys to be joined on '.') that represent every path into a schema
+ * https://docs.mongodb.com/manual/tutorial/query-embedded-documents/
+ */
 export type NestedPaths<Type> = Type extends
   | string
   | number
@@ -497,6 +502,21 @@ export type NestedPaths<Type> = Type extends
   : // eslint-disable-next-line @typescript-eslint/ban-types
   Type extends object
   ? {
-      [Key in Extract<keyof Type, string>]: [Key, ...NestedPaths<Type[Key]>];
+      [Key in Extract<keyof Type, string>]: Type[Key] extends Type // type of value extends the parent
+        ? [Key]
+        : // for a recursive union type, the child will never extend the parent type.
+        // but the parent will still extend the child
+        Type extends Type[Key]
+        ? [Key]
+        : Type[Key] extends ReadonlyArray<infer ArrayType> // handling recursive types with arrays
+        ? Type extends ArrayType // is the type of the parent the same as the type of the array?
+          ? [Key] // yes, it's a recursive array type
+          : // for unions, the child type extends the parent
+          ArrayType extends Type
+          ? [Key] // we have a recursive array union
+          : // child is an array, but it's not a recursive array
+            [Key, ...NestedPaths<Type[Key]>]
+        : // child is not structured the same as the parent
+          [Key, ...NestedPaths<Type[Key]>];
     }[Extract<keyof Type, string>]
   : [];

package/src/operations/add_user.ts

@@ -75,7 +75,7 @@ export class AddUserOperation extends CommandOperation<Document> {
       roles = Array.isArray(options.roles) ? options.roles : [options.roles];
     }
 
-    const digestPassword = getTopology(db).lastIsMaster().maxWireVersion >= 7;
+    const digestPassword = getTopology(db).lastHello().maxWireVersion >= 7;
 
     let userPassword = password;
 

package/src/operations/update.ts

@@ -222,6 +222,8 @@ export interface ReplaceOptions extends CommandOperationOptions {
   hint?: string | Document;
   /** When true, creates a new document if no document matches the query */
   upsert?: boolean;
+  /** Map of parameter names and values that can be accessed using $$var (requires MongoDB 5.0). */
+  let?: Document;
 }
 
 /** @internal */

package/src/sdam/events.ts

@@ -123,8 +123,8 @@ export class TopologyClosedEvent {
 }
 
 /**
- * Emitted when the server monitor’s ismaster command is started - immediately before
- * the ismaster command is serialized into raw BSON and written to the socket.
+ * Emitted when the server monitor’s hello command is started - immediately before
+ * the hello command is serialized into raw BSON and written to the socket.
  *
  * @public
  * @category Event
@@ -140,7 +140,7 @@ export class ServerHeartbeatStartedEvent {
 }
 
 /**
- * Emitted when the server monitor’s ismaster succeeds.
+ * Emitted when the server monitor’s hello succeeds.
  * @public
  * @category Event
  */
@@ -161,7 +161,7 @@ export class ServerHeartbeatSucceededEvent {
 }
 
 /**
- * Emitted when the server monitor’s ismaster fails, either with an “ok: 0” or a socket exception.
+ * Emitted when the server monitor’s hello fails, either with an “ok: 0” or a socket exception.
  * @public
  * @category Event
  */

package/src/sdam/monitor.ts

@@ -1,6 +1,7 @@
 import { Document, Long } from '../bson';
 import { connect } from '../cmap/connect';
 import { Connection, ConnectionOptions } from '../cmap/connection';
+import { LEGACY_HELLO_COMMAND } from '../constants';
 import { AnyError, MongoNetworkError } from '../error';
 import { CancellationToken, TypedEventEmitter } from '../mongo_types';
 import type { Callback, InterruptibleAsyncInterval } from '../utils';
@@ -233,7 +234,7 @@ function checkServer(monitor: Monitor, callback: Callback<Document>) {
     const isAwaitable = topologyVersion != null;
 
     const cmd = {
-      [serverApi?.version || helloOk ? 'hello' : 'ismaster']: true,
+      [serverApi?.version || helloOk ? 'hello' : LEGACY_HELLO_COMMAND]: true,
       ...(isAwaitable && topologyVersion
         ? { maxAwaitTimeMS, topologyVersion: makeTopologyVersion(topologyVersion) }
         : {})
@@ -256,14 +257,15 @@ function checkServer(monitor: Monitor, callback: Callback<Document>) {
       );
     }
 
-    connection.command(ns('admin.$cmd'), cmd, options, (err, isMaster) => {
+    connection.command(ns('admin.$cmd'), cmd, options, (err, hello) => {
       if (err) {
         failureHandler(err);
         return;
       }
-      if ('isWritablePrimary' in isMaster) {
-        // Provide pre-hello-style response document.
-        isMaster.ismaster = isMaster.isWritablePrimary;
+
+      if (!('isWritablePrimary' in hello)) {
+        // Provide hello-style response document.
+        hello.isWritablePrimary = hello[LEGACY_HELLO_COMMAND];
       }
 
       const rttPinger = monitor[kRTTPinger];
@@ -272,12 +274,12 @@ function checkServer(monitor: Monitor, callback: Callback<Document>) {
 
       monitor.emit(
         Server.SERVER_HEARTBEAT_SUCCEEDED,
-        new ServerHeartbeatSucceededEvent(monitor.address, duration, isMaster)
+        new ServerHeartbeatSucceededEvent(monitor.address, duration, hello)
       );
 
       // if we are using the streaming protocol then we immediately issue another `started`
       // event, otherwise the "check" is complete and return to the main monitor loop
-      if (isAwaitable && isMaster.topologyVersion) {
+      if (isAwaitable && hello.topologyVersion) {
         monitor.emit(
           Server.SERVER_HEARTBEAT_STARTED,
           new ServerHeartbeatStartedEvent(monitor.address)
@@ -287,14 +289,14 @@ function checkServer(monitor: Monitor, callback: Callback<Document>) {
         monitor[kRTTPinger]?.close();
         monitor[kRTTPinger] = undefined;
 
-        callback(undefined, isMaster);
+        callback(undefined, hello);
       }
     });
 
     return;
   }
 
-  // connecting does an implicit `ismaster`
+  // connecting does an implicit `hello`
   connect(monitor.connectOptions, (err, conn) => {
     if (err) {
       monitor[kConnection] = undefined;
@@ -317,14 +319,10 @@ function checkServer(monitor: Monitor, callback: Callback<Document>) {
       monitor[kConnection] = conn;
       monitor.emit(
         Server.SERVER_HEARTBEAT_SUCCEEDED,
-        new ServerHeartbeatSucceededEvent(
-          monitor.address,
-          calculateDurationInMs(start),
-          conn.ismaster
-        )
+        new ServerHeartbeatSucceededEvent(monitor.address, calculateDurationInMs(start), conn.hello)
       );
 
-      callback(undefined, conn.ismaster);
+      callback(undefined, conn.hello);
     }
   });
 }
@@ -340,7 +338,7 @@ function monitorServer(monitor: Monitor) {
       callback();
     }
 
-    checkServer(monitor, (err, isMaster) => {
+    checkServer(monitor, (err, hello) => {
       if (err) {
         // otherwise an error occurred on initial discovery, also bail
         if (monitor[kServer].description.type === ServerType.Unknown) {
@@ -350,7 +348,7 @@ function monitorServer(monitor: Monitor) {
       }
 
       // if the check indicates streaming is supported, immediately reschedule monitoring
-      if (isMaster && isMaster.topologyVersion) {
+      if (hello && hello.topologyVersion) {
         setTimeout(() => {
           if (!isInCloseState(monitor)) {
             monitor[kMonitorId]?.wake();
@@ -452,7 +450,7 @@ function measureRoundTripTime(rttPinger: RTTPinger, options: RTTPingerOptions) {
     return;
   }
 
-  connection.command(ns('admin.$cmd'), { ismaster: 1 }, undefined, err => {
+  connection.command(ns('admin.$cmd'), { [LEGACY_HELLO_COMMAND]: 1 }, undefined, err => {
     if (err) {
       rttPinger[kConnection] = undefined;
       rttPinger[kRoundTripTime] = 0;

package/src/sdam/server.ts

@@ -118,7 +118,7 @@ export class Server extends TypedEventEmitter<ServerEvents> {
   /** @internal */
   s: ServerPrivate;
   serverApi?: ServerApi;
-  ismaster?: Document;
+  hello?: Document;
   [kMonitor]: Monitor;
 
   /** @event */

package/src/sdam/server_description.ts

@@ -44,7 +44,7 @@ export interface ServerDescriptionOptions {
 }
 
 /**
- * The client's view of a single server, based on the most recent ismaster outcome.
+ * The client's view of a single server, based on the most recent hello outcome.
  *
  * Internal type, not meant to be directly instantiated
  * @public
@@ -81,13 +81,9 @@ export class ServerDescription {
    * @internal
    *
    * @param address - The address of the server
-   * @param ismaster - An optional ismaster response for this server
+   * @param hello - An optional hello response for this server
    */
-  constructor(
-    address: HostAddress | string,
-    ismaster?: Document,
-    options?: ServerDescriptionOptions
-  ) {
+  constructor(address: HostAddress | string, hello?: Document, options?: ServerDescriptionOptions) {
     if (typeof address === 'string') {
       this._hostAddress = new HostAddress(address);
       this.address = this._hostAddress.toString();
@@ -95,53 +91,53 @@ export class ServerDescription {
       this._hostAddress = address;
       this.address = this._hostAddress.toString();
     }
-    this.type = parseServerType(ismaster, options);
-    this.hosts = ismaster?.hosts?.map((host: string) => host.toLowerCase()) ?? [];
-    this.passives = ismaster?.passives?.map((host: string) => host.toLowerCase()) ?? [];
-    this.arbiters = ismaster?.arbiters?.map((host: string) => host.toLowerCase()) ?? [];
-    this.tags = ismaster?.tags ?? {};
-    this.minWireVersion = ismaster?.minWireVersion ?? 0;
-    this.maxWireVersion = ismaster?.maxWireVersion ?? 0;
+    this.type = parseServerType(hello, options);
+    this.hosts = hello?.hosts?.map((host: string) => host.toLowerCase()) ?? [];
+    this.passives = hello?.passives?.map((host: string) => host.toLowerCase()) ?? [];
+    this.arbiters = hello?.arbiters?.map((host: string) => host.toLowerCase()) ?? [];
+    this.tags = hello?.tags ?? {};
+    this.minWireVersion = hello?.minWireVersion ?? 0;
+    this.maxWireVersion = hello?.maxWireVersion ?? 0;
     this.roundTripTime = options?.roundTripTime ?? -1;
     this.lastUpdateTime = now();
-    this.lastWriteDate = ismaster?.lastWrite?.lastWriteDate ?? 0;
+    this.lastWriteDate = hello?.lastWrite?.lastWriteDate ?? 0;
 
     if (options?.topologyVersion) {
       this.topologyVersion = options.topologyVersion;
-    } else if (ismaster?.topologyVersion) {
-      this.topologyVersion = ismaster.topologyVersion;
+    } else if (hello?.topologyVersion) {
+      this.topologyVersion = hello.topologyVersion;
     }
 
     if (options?.error) {
       this.error = options.error;
     }
 
-    if (ismaster?.primary) {
-      this.primary = ismaster.primary;
+    if (hello?.primary) {
+      this.primary = hello.primary;
     }
 
-    if (ismaster?.me) {
-      this.me = ismaster.me.toLowerCase();
+    if (hello?.me) {
+      this.me = hello.me.toLowerCase();
     }
 
-    if (ismaster?.setName) {
-      this.setName = ismaster.setName;
+    if (hello?.setName) {
+      this.setName = hello.setName;
     }
 
-    if (ismaster?.setVersion) {
-      this.setVersion = ismaster.setVersion;
+    if (hello?.setVersion) {
+      this.setVersion = hello.setVersion;
     }
 
-    if (ismaster?.electionId) {
-      this.electionId = ismaster.electionId;
+    if (hello?.electionId) {
+      this.electionId = hello.electionId;
     }
 
-    if (ismaster?.logicalSessionTimeoutMinutes) {
-      this.logicalSessionTimeoutMinutes = ismaster.logicalSessionTimeoutMinutes;
+    if (hello?.logicalSessionTimeoutMinutes) {
+      this.logicalSessionTimeoutMinutes = hello.logicalSessionTimeoutMinutes;
     }
 
-    if (ismaster?.$clusterTime) {
-      this.$clusterTime = ismaster.$clusterTime;
+    if (hello?.$clusterTime) {
+      this.$clusterTime = hello.$clusterTime;
     }
   }
 
@@ -210,35 +206,32 @@ export class ServerDescription {
   }
 }
 
-// Parses an `ismaster` message and determines the server type
-export function parseServerType(
-  ismaster?: Document,
-  options?: ServerDescriptionOptions
-): ServerType {
+// Parses a `hello` message and determines the server type
+export function parseServerType(hello?: Document, options?: ServerDescriptionOptions): ServerType {
   if (options?.loadBalanced) {
     return ServerType.LoadBalancer;
   }
 
-  if (!ismaster || !ismaster.ok) {
+  if (!hello || !hello.ok) {
     return ServerType.Unknown;
   }
 
-  if (ismaster.isreplicaset) {
+  if (hello.isreplicaset) {
     return ServerType.RSGhost;
   }
 
-  if (ismaster.msg && ismaster.msg === 'isdbgrid') {
+  if (hello.msg && hello.msg === 'isdbgrid') {
     return ServerType.Mongos;
   }
 
-  if (ismaster.setName) {
-    if (ismaster.hidden) {
+  if (hello.setName) {
+    if (hello.hidden) {
       return ServerType.RSOther;
-    } else if (ismaster.ismaster || ismaster.isWritablePrimary) {
+    } else if (hello.isWritablePrimary) {
       return ServerType.RSPrimary;
-    } else if (ismaster.secondary) {
+    } else if (hello.secondary) {
       return ServerType.RSSecondary;
-    } else if (ismaster.arbiterOnly) {
+    } else if (hello.arbiterOnly) {
       return ServerType.RSArbiter;
     } else {
       return ServerType.RSOther;

package/src/sdam/topology.ts

@@ -198,7 +198,7 @@ export class Topology extends TypedEventEmitter<TopologyEvents> {
   /** @internal */
   [kWaitQueue]: Denque<ServerSelectionRequest>;
   /** @internal */
-  ismaster?: Document;
+  hello?: Document;
   /** @internal */
   _type?: string;
 
@@ -403,7 +403,7 @@ export class Topology extends TypedEventEmitter<TopologyEvents> {
   }
 
   get capabilities(): ServerCapabilities {
-    return new ServerCapabilities(this.lastIsMaster());
+    return new ServerCapabilities(this.lastHello());
   }
 
   /** Initiate server connect */
@@ -791,10 +791,10 @@ export class Topology extends TypedEventEmitter<TopologyEvents> {
     emitWarning('`unref` is a noop and will be removed in the next major version');
   }
 
-  // NOTE: There are many places in code where we explicitly check the last isMaster
+  // NOTE: There are many places in code where we explicitly check the last hello
   //       to do feature support detection. This should be done any other way, but for
-  //       now we will just return the first isMaster seen, which should suffice.
-  lastIsMaster(): Document {
+  //       now we will just return the first hello seen, which should suffice.
+  lastHello(): Document {
     const serverDescriptions = Array.from(this.description.servers.values());
     if (serverDescriptions.length === 0) return {};
     const sd = serverDescriptions.filter(
@@ -1066,9 +1066,9 @@ export class ServerCapabilities {
   maxWireVersion: number;
   minWireVersion: number;
 
-  constructor(ismaster: Document) {
-    this.minWireVersion = ismaster.minWireVersion || 0;
-    this.maxWireVersion = ismaster.maxWireVersion || 0;
+  constructor(hello: Document) {
+    this.minWireVersion = hello.minWireVersion || 0;
+    this.maxWireVersion = hello.maxWireVersion || 0;
   }
 
   get hasAggregationCursor(): boolean {

package/src/sdam/topology_description.ts

@@ -106,7 +106,7 @@ export class TopologyDescription {
       }
     }
 
-    // Whenever a client updates the TopologyDescription from an ismaster response, it MUST set
+    // Whenever a client updates the TopologyDescription from a hello response, it MUST set
     // TopologyDescription.logicalSessionTimeoutMinutes to the smallest logicalSessionTimeoutMinutes
     // value among ServerDescriptions of all data-bearing server types. If any have a null
     // logicalSessionTimeoutMinutes, then TopologyDescription.logicalSessionTimeoutMinutes MUST be

package/src/utils.ts

@@ -656,14 +656,14 @@ export function maxWireVersion(topologyOrServer?: Connection | Topology | Server
       // application that a feature is avaiable that is actually not.
       return MAX_SUPPORTED_WIRE_VERSION;
     }
-    if (topologyOrServer.ismaster) {
-      return topologyOrServer.ismaster.maxWireVersion;
+    if (topologyOrServer.hello) {
+      return topologyOrServer.hello.maxWireVersion;
     }
 
-    if ('lastIsMaster' in topologyOrServer && typeof topologyOrServer.lastIsMaster === 'function') {
-      const lastIsMaster = topologyOrServer.lastIsMaster();
-      if (lastIsMaster) {
-        return lastIsMaster.maxWireVersion;
+    if ('lastHello' in topologyOrServer && typeof topologyOrServer.lastHello === 'function') {
+      const lastHello = topologyOrServer.lastHello();
+      if (lastHello) {
+        return lastHello.maxWireVersion;
       }
     }