mongodb 5.2.0 → 5.4.0

package/src/cmap/handshake/client_metadata.ts

@@ -0,0 +1,272 @@
+import * as os from 'os';
+import * as process from 'process';
+
+import { BSON, Int32 } from '../../bson';
+import { MongoInvalidArgumentError } from '../../error';
+import type { MongoOptions } from '../../mongo_client';
+
+// eslint-disable-next-line @typescript-eslint/no-var-requires
+const NODE_DRIVER_VERSION = require('../../../package.json').version;
+
+/**
+ * @public
+ * @see https://github.com/mongodb/specifications/blob/master/source/mongodb-handshake/handshake.rst#hello-command
+ */
+export interface ClientMetadata {
+  driver: {
+    name: string;
+    version: string;
+  };
+  os: {
+    type: string;
+    name?: NodeJS.Platform;
+    architecture?: string;
+    version?: string;
+  };
+  platform: string;
+  application?: {
+    name: string;
+  };
+  /** FaaS environment information */
+  env?: {
+    name: 'aws.lambda' | 'gcp.func' | 'azure.func' | 'vercel';
+    timeout_sec?: Int32;
+    memory_mb?: Int32;
+    region?: string;
+    url?: string;
+  };
+}
+
+/** @public */
+export interface ClientMetadataOptions {
+  driverInfo?: {
+    name?: string;
+    version?: string;
+    platform?: string;
+  };
+  appName?: string;
+}
+
+/** @internal */
+export class LimitedSizeDocument {
+  private document = new Map();
+  /** BSON overhead: Int32 + Null byte */
+  private documentSize = 5;
+  constructor(private maxSize: number) {}
+
+  /** Only adds key/value if the bsonByteLength is less than MAX_SIZE */
+  public ifItFitsItSits(key: string, value: Record<string, any> | string): boolean {
+    // The BSON byteLength of the new element is the same as serializing it to its own document
+    // subtracting the document size int32 and the null terminator.
+    const newElementSize = BSON.serialize(new Map().set(key, value)).byteLength - 5;
+
+    if (newElementSize + this.documentSize > this.maxSize) {
+      return false;
+    }
+
+    this.documentSize += newElementSize;
+
+    this.document.set(key, value);
+
+    return true;
+  }
+
+  toObject(): ClientMetadata {
+    return BSON.deserialize(BSON.serialize(this.document), {
+      promoteLongs: false,
+      promoteBuffers: false,
+      promoteValues: false,
+      useBigInt64: false
+    }) as ClientMetadata;
+  }
+}
+
+type MakeClientMetadataOptions = Pick<MongoOptions, 'appName' | 'driverInfo'>;
+/**
+ * From the specs:
+ * Implementors SHOULD cumulatively update fields in the following order until the document is under the size limit:
+ * 1. Omit fields from `env` except `env.name`.
+ * 2. Omit fields from `os` except `os.type`.
+ * 3. Omit the `env` document entirely.
+ * 4. Truncate `platform`. -- special we do not truncate this field
+ */
+export function makeClientMetadata(options: MakeClientMetadataOptions): ClientMetadata {
+  const metadataDocument = new LimitedSizeDocument(512);
+
+  const { appName = '' } = options;
+  // Add app name first, it must be sent
+  if (appName.length > 0) {
+    const name =
+      Buffer.byteLength(appName, 'utf8') <= 128
+        ? options.appName
+        : Buffer.from(appName, 'utf8').subarray(0, 128).toString('utf8');
+    metadataDocument.ifItFitsItSits('application', { name });
+  }
+
+  const { name = '', version = '', platform = '' } = options.driverInfo;
+
+  const driverInfo = {
+    name: name.length > 0 ? `nodejs|${name}` : 'nodejs',
+    version: version.length > 0 ? `${NODE_DRIVER_VERSION}|${version}` : NODE_DRIVER_VERSION
+  };
+
+  if (!metadataDocument.ifItFitsItSits('driver', driverInfo)) {
+    throw new MongoInvalidArgumentError(
+      'Unable to include driverInfo name and version, metadata cannot exceed 512 bytes'
+    );
+  }
+
+  let runtimeInfo = getRuntimeInfo();
+  if (platform.length > 0) {
+    runtimeInfo = `${runtimeInfo}|${platform}`;
+  }
+
+  if (!metadataDocument.ifItFitsItSits('platform', runtimeInfo)) {
+    throw new MongoInvalidArgumentError(
+      'Unable to include driverInfo platform, metadata cannot exceed 512 bytes'
+    );
+  }
+
+  // Note: order matters, os.type is last so it will be removed last if we're at maxSize
+  const osInfo = new Map()
+    .set('name', process.platform)
+    .set('architecture', process.arch)
+    .set('version', os.release())
+    .set('type', os.type());
+
+  if (!metadataDocument.ifItFitsItSits('os', osInfo)) {
+    for (const key of osInfo.keys()) {
+      osInfo.delete(key);
+      if (osInfo.size === 0) break;
+      if (metadataDocument.ifItFitsItSits('os', osInfo)) break;
+    }
+  }
+
+  const faasEnv = getFAASEnv();
+  if (faasEnv != null) {
+    if (!metadataDocument.ifItFitsItSits('env', faasEnv)) {
+      for (const key of faasEnv.keys()) {
+        faasEnv.delete(key);
+        if (faasEnv.size === 0) break;
+        if (metadataDocument.ifItFitsItSits('env', faasEnv)) break;
+      }
+    }
+  }
+
+  return metadataDocument.toObject();
+}
+
+/**
+ * Collects FaaS metadata.
+ * - `name` MUST be the last key in the Map returned.
+ */
+export function getFAASEnv(): Map<string, string | Int32> | null {
+  const {
+    AWS_EXECUTION_ENV = '',
+    AWS_LAMBDA_RUNTIME_API = '',
+    FUNCTIONS_WORKER_RUNTIME = '',
+    K_SERVICE = '',
+    FUNCTION_NAME = '',
+    VERCEL = '',
+    AWS_LAMBDA_FUNCTION_MEMORY_SIZE = '',
+    AWS_REGION = '',
+    FUNCTION_MEMORY_MB = '',
+    FUNCTION_REGION = '',
+    FUNCTION_TIMEOUT_SEC = '',
+    VERCEL_REGION = ''
+  } = process.env;
+
+  const isAWSFaaS = AWS_EXECUTION_ENV.length > 0 || AWS_LAMBDA_RUNTIME_API.length > 0;
+  const isAzureFaaS = FUNCTIONS_WORKER_RUNTIME.length > 0;
+  const isGCPFaaS = K_SERVICE.length > 0 || FUNCTION_NAME.length > 0;
+  const isVercelFaaS = VERCEL.length > 0;
+
+  // Note: order matters, name must always be the last key
+  const faasEnv = new Map();
+
+  // When isVercelFaaS is true so is isAWSFaaS; Vercel inherits the AWS env
+  if (isVercelFaaS && !(isAzureFaaS || isGCPFaaS)) {
+    if (VERCEL_REGION.length > 0) {
+      faasEnv.set('region', VERCEL_REGION);
+    }
+
+    faasEnv.set('name', 'vercel');
+    return faasEnv;
+  }
+
+  if (isAWSFaaS && !(isAzureFaaS || isGCPFaaS || isVercelFaaS)) {
+    if (AWS_REGION.length > 0) {
+      faasEnv.set('region', AWS_REGION);
+    }
+
+    if (
+      AWS_LAMBDA_FUNCTION_MEMORY_SIZE.length > 0 &&
+      Number.isInteger(+AWS_LAMBDA_FUNCTION_MEMORY_SIZE)
+    ) {
+      faasEnv.set('memory_mb', new Int32(AWS_LAMBDA_FUNCTION_MEMORY_SIZE));
+    }
+
+    faasEnv.set('name', 'aws.lambda');
+    return faasEnv;
+  }
+
+  if (isAzureFaaS && !(isGCPFaaS || isAWSFaaS || isVercelFaaS)) {
+    faasEnv.set('name', 'azure.func');
+    return faasEnv;
+  }
+
+  if (isGCPFaaS && !(isAzureFaaS || isAWSFaaS || isVercelFaaS)) {
+    if (FUNCTION_REGION.length > 0) {
+      faasEnv.set('region', FUNCTION_REGION);
+    }
+
+    if (FUNCTION_MEMORY_MB.length > 0 && Number.isInteger(+FUNCTION_MEMORY_MB)) {
+      faasEnv.set('memory_mb', new Int32(FUNCTION_MEMORY_MB));
+    }
+
+    if (FUNCTION_TIMEOUT_SEC.length > 0 && Number.isInteger(+FUNCTION_TIMEOUT_SEC)) {
+      faasEnv.set('timeout_sec', new Int32(FUNCTION_TIMEOUT_SEC));
+    }
+
+    faasEnv.set('name', 'gcp.func');
+    return faasEnv;
+  }
+
+  return null;
+}
+
+/**
+ * @internal
+ * This type represents the global Deno object and the minimal type contract we expect it to satisfy.
+ */
+declare const Deno: { version?: { deno?: string } } | undefined;
+
+/**
+ * @internal
+ * This type represents the global Bun object and the minimal type contract we expect it to satisfy.
+ */
+declare const Bun: { (): void; version?: string } | undefined;
+
+/**
+ * @internal
+ * Get current JavaScript runtime platform
+ *
+ * NOTE: The version information fetching is intentionally written defensively
+ * to avoid having a released driver version that becomes incompatible
+ * with a future change to these global objects.
+ */
+function getRuntimeInfo(): string {
+  if ('Deno' in globalThis) {
+    const version = typeof Deno?.version?.deno === 'string' ? Deno?.version?.deno : '0.0.0-unknown';
+
+    return `Deno v${version}, ${os.endianness()}`;
+  }
+
+  if ('Bun' in globalThis) {
+    const version = typeof Bun?.version === 'string' ? Bun?.version : '0.0.0-unknown';
+
+    return `Bun v${version}, ${os.endianness()}`;
+  }
+
+  return `Node.js ${process.version}, ${os.endianness()}`;
+}

package/src/cmap/wire_protocol/constants.ts

@@ -1,7 +1,7 @@
 export const MIN_SUPPORTED_SERVER_VERSION = '3.6';
-export const MAX_SUPPORTED_SERVER_VERSION = '6.0';
+export const MAX_SUPPORTED_SERVER_VERSION = '7.0';
 export const MIN_SUPPORTED_WIRE_VERSION = 6;
-export const MAX_SUPPORTED_WIRE_VERSION = 17;
+export const MAX_SUPPORTED_WIRE_VERSION = 21;
 export const OP_REPLY = 1;
 export const OP_UPDATE = 2001;
 export const OP_INSERT = 2002;

package/src/cmap/wire_protocol/shared.ts

@@ -1,4 +1,3 @@
-import type { Document } from '../../bson';
 import { MongoInvalidArgumentError } from '../../error';
 import type { ReadPreferenceLike } from '../../read_preference';
 import { ReadPreference } from '../../read_preference';
@@ -13,9 +12,9 @@ export interface ReadPreferenceOption {
   readPreference?: ReadPreferenceLike;
 }
 
-export function getReadPreference(cmd: Document, options?: ReadPreferenceOption): ReadPreference {
+export function getReadPreference(options?: ReadPreferenceOption): ReadPreference {
   // Default to command version of the readPreference
-  let readPreference = cmd.readPreference || ReadPreference.primary;
+  let readPreference = options?.readPreference ?? ReadPreference.primary;
   // If we have an option readPreference override the command one
   if (options?.readPreference) {
     readPreference = options.readPreference;

package/src/collection.ts

@@ -334,7 +334,7 @@ export class Collection<TSchema extends Document = Document> {
     filter: Filter<TSchema>,
     update: UpdateFilter<TSchema> | Partial<TSchema>,
     options?: UpdateOptions
-  ): Promise<UpdateResult> {
+  ): Promise<UpdateResult<TSchema>> {
     return executeOperation(
       this.s.db.s.client,
       new UpdateOneOperation(
@@ -357,7 +357,7 @@ export class Collection<TSchema extends Document = Document> {
     filter: Filter<TSchema>,
     replacement: WithoutId<TSchema>,
     options?: ReplaceOptions
-  ): Promise<UpdateResult | Document> {
+  ): Promise<UpdateResult<TSchema> | Document> {
     return executeOperation(
       this.s.db.s.client,
       new ReplaceOneOperation(
@@ -380,7 +380,7 @@ export class Collection<TSchema extends Document = Document> {
     filter: Filter<TSchema>,
     update: UpdateFilter<TSchema>,
     options?: UpdateOptions
-  ): Promise<UpdateResult> {
+  ): Promise<UpdateResult<TSchema>> {
     return executeOperation(
       this.s.db.s.client,
       new UpdateManyOperation(
@@ -784,6 +784,9 @@ export class Collection<TSchema extends Document = Document> {
   /**
    * Get all the collection statistics.
    *
+   * @deprecated the `collStats` operation will be removed in the next major release.  Please
+   * use an aggregation pipeline with the [`$collStats`](https://www.mongodb.com/docs/manual/reference/operator/aggregation/collStats/) stage instead
+   *
    * @param options - Optional settings for the command
    */
   async stats(options?: CollStatsOptions): Promise<CollStats> {

package/src/connection_string.ts

@@ -6,6 +6,7 @@ import { URLSearchParams } from 'url';
 import type { Document } from './bson';
 import { MongoCredentials } from './cmap/auth/mongo_credentials';
 import { AUTH_MECHS_AUTH_SRC_EXTERNAL, AuthMechanism } from './cmap/auth/providers';
+import { makeClientMetadata } from './cmap/handshake/client_metadata';
 import { Compressor, CompressorName } from './cmap/wire_protocol/compression';
 import { Encrypter } from './encrypter';
 import {
@@ -32,7 +33,7 @@ import {
   emitWarningOnce,
   HostAddress,
   isRecord,
-  makeClientMetadata,
+  matchesParentDomain,
   parseInteger,
   setDifference
 } from './utils';
@@ -45,21 +46,6 @@ const LB_REPLICA_SET_ERROR = 'loadBalanced option not supported with a replicaSe
 const LB_DIRECT_CONNECTION_ERROR =
   'loadBalanced option not supported when directConnection is provided';
 
-/**
- * Determines whether a provided address matches the provided parent domain in order
- * to avoid certain attack vectors.
- *
- * @param srvAddress - The address to check against a domain
- * @param parentDomain - The domain to check the provided address against
- * @returns Whether the provided address matches the parent domain
- */
-function matchesParentDomain(srvAddress: string, parentDomain: string): boolean {
-  const regex = /^.*?\./;
-  const srv = `.${srvAddress.replace(regex, '')}`;
-  const parent = `.${parentDomain.replace(regex, '')}`;
-  return srv.endsWith(parent);
-}
-
 /**
  * Lookup a `mongodb+srv` connection string, combine the parts and reparse it as a normal
  * connection string.
@@ -277,7 +263,7 @@ export function parseOptions(
 
   mongoOptions.hosts = isSRV ? [] : hosts.map(HostAddress.fromString);
 
-  const urlOptions = new CaseInsensitiveMap<any[]>();
+  const urlOptions = new CaseInsensitiveMap<unknown[]>();
 
   if (url.pathname !== '/' && url.pathname !== '') {
     const dbName = decodeURIComponent(
@@ -312,7 +298,7 @@ export function parseOptions(
     }
   }
 
-  const objectOptions = new CaseInsensitiveMap(
+  const objectOptions = new CaseInsensitiveMap<unknown>(
     Object.entries(options).filter(([, v]) => v != null)
   );
 
@@ -324,54 +310,59 @@ export function parseOptions(
     );
   }
 
+  const uriMechanismProperties = urlOptions.get('authMechanismProperties');
+  if (uriMechanismProperties) {
+    for (const property of uriMechanismProperties) {
+      if (/(^|,)ALLOWED_HOSTS:/.test(property as string)) {
+        throw new MongoParseError(
+          'Auth mechanism property ALLOWED_HOSTS is not allowed in the connection string.'
+        );
+      }
+    }
+  }
+
   if (objectOptions.has('loadBalanced')) {
     throw new MongoParseError('loadBalanced is only a valid option in the URI');
   }
 
   // All option collection
 
-  const allOptions = new CaseInsensitiveMap();
+  const allProvidedOptions = new CaseInsensitiveMap<unknown[]>();
 
-  const allKeys = new Set<string>([
-    ...urlOptions.keys(),
-    ...objectOptions.keys(),
-    ...DEFAULT_OPTIONS.keys()
-  ]);
+  const allProvidedKeys = new Set<string>([...urlOptions.keys(), ...objectOptions.keys()]);
 
-  for (const key of allKeys) {
+  for (const key of allProvidedKeys) {
     const values = [];
     const objectOptionValue = objectOptions.get(key);
     if (objectOptionValue != null) {
       values.push(objectOptionValue);
     }
-    const urlValue = urlOptions.get(key);
-    if (urlValue != null) {
-      values.push(...urlValue);
-    }
-    const defaultOptionsValue = DEFAULT_OPTIONS.get(key);
-    if (defaultOptionsValue != null) {
-      values.push(defaultOptionsValue);
-    }
-    allOptions.set(key, values);
+
+    const urlValues = urlOptions.get(key) ?? [];
+    values.push(...urlValues);
+    allProvidedOptions.set(key, values);
   }
 
-  if (allOptions.has('tlsCertificateKeyFile') && !allOptions.has('tlsCertificateFile')) {
-    allOptions.set('tlsCertificateFile', allOptions.get('tlsCertificateKeyFile'));
+  if (
+    allProvidedOptions.has('tlsCertificateKeyFile') &&
+    !allProvidedOptions.has('tlsCertificateFile')
+  ) {
+    allProvidedOptions.set('tlsCertificateFile', allProvidedOptions.get('tlsCertificateKeyFile'));
   }
 
-  if (allOptions.has('tls') || allOptions.has('ssl')) {
-    const tlsAndSslOpts = (allOptions.get('tls') || [])
-      .concat(allOptions.get('ssl') || [])
+  if (allProvidedOptions.has('tls') || allProvidedOptions.has('ssl')) {
+    const tlsAndSslOpts = (allProvidedOptions.get('tls') || [])
+      .concat(allProvidedOptions.get('ssl') || [])
       .map(getBoolean.bind(null, 'tls/ssl'));
     if (new Set(tlsAndSslOpts).size !== 1) {
       throw new MongoParseError('All values of tls/ssl must be the same.');
     }
   }
 
-  checkTLSOptions(allOptions);
+  checkTLSOptions(allProvidedOptions);
 
   const unsupportedOptions = setDifference(
-    allKeys,
+    allProvidedKeys,
     Array.from(Object.keys(OPTIONS)).map(s => s.toLowerCase())
   );
   if (unsupportedOptions.size !== 0) {
@@ -385,9 +376,20 @@ 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;
-    setOption(mongoOptions, key, descriptor, values);
+    const values = allProvidedOptions.get(key);
+    if (!values || values.length === 0) {
+      if (DEFAULT_OPTIONS.has(key)) {
+        setOption(mongoOptions, key, descriptor, [DEFAULT_OPTIONS.get(key)]);
+      }
+    } else {
+      const { deprecated } = descriptor;
+      if (deprecated) {
+        const deprecatedMsg = typeof deprecated === 'string' ? `: ${deprecated}` : '';
+        emitWarning(`${key} is a deprecated option${deprecatedMsg}`);
+      }
+
+      setOption(mongoOptions, key, descriptor, values);
+    }
   }
 
   if (mongoOptions.credentials) {
@@ -397,7 +399,7 @@ export function parseOptions(
     const isOidc = mongoOptions.credentials.mechanism === AuthMechanism.MONGODB_OIDC;
     if (
       (isGssapi || isX509) &&
-      allOptions.has('authSource') &&
+      allProvidedOptions.has('authSource') &&
       mongoOptions.credentials.source !== '$external'
     ) {
       // If authSource was explicitly given and its incorrect, we error
@@ -409,7 +411,7 @@ export function parseOptions(
     if (
       !(isGssapi || isX509 || isAws || isOidc) &&
       mongoOptions.dbName &&
-      !allOptions.has('authSource')
+      !allProvidedOptions.has('authSource')
     ) {
       // inherit the dbName unless GSSAPI or X509, then silently ignore dbName
       // and there was no specific authSource given
@@ -585,14 +587,9 @@ function setOption(
   descriptor: OptionDescriptor,
   values: unknown[]
 ) {
-  const { target, type, transform, deprecated } = descriptor;
+  const { target, type, transform } = descriptor;
   const name = target ?? key;
 
-  if (deprecated) {
-    const deprecatedMsg = typeof deprecated === 'string' ? `: ${deprecated}` : '';
-    emitWarning(`${key} is a deprecated option${deprecatedMsg}`);
-  }
-
   switch (type) {
     case 'boolean':
       mongoOptions[name] = getBoolean(name, values[0]);
@@ -866,11 +863,13 @@ export const OPTIONS = {
   },
   keepAlive: {
     default: true,
-    type: 'boolean'
+    type: 'boolean',
+    deprecated: 'Will not be able to turn off in the future.'
   },
   keepAliveInitialDelay: {
     default: 120000,
-    type: 'uint'
+    type: 'uint',
+    deprecated: 'Will not be configurable in the future.'
   },
   loadBalanced: {
     default: false,
@@ -1292,5 +1291,6 @@ export const DEFAULT_OPTIONS = new CaseInsensitiveMap(
  */
 export const FEATURE_FLAGS = new Set([
   Symbol.for('@@mdb.skipPingOnConnect'),
-  Symbol.for('@@mdb.enableMongoLogger')
+  Symbol.for('@@mdb.enableMongoLogger'),
+  Symbol.for('@@mdb.internalLoggerConfig')
 ]);

package/src/constants.ts

@@ -23,16 +23,27 @@ 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;
+/** @internal */
 export const CONNECTION_POOL_CREATED = 'connectionPoolCreated' as const;
+/** @internal */
 export const CONNECTION_POOL_CLOSED = 'connectionPoolClosed' as const;
+/** @internal */
 export const CONNECTION_POOL_CLEARED = 'connectionPoolCleared' as const;
+/** @internal */
 export const CONNECTION_POOL_READY = 'connectionPoolReady' as const;
+/** @internal */
 export const CONNECTION_CREATED = 'connectionCreated' as const;
+/** @internal */
 export const CONNECTION_READY = 'connectionReady' as const;
+/** @internal */
 export const CONNECTION_CLOSED = 'connectionClosed' as const;
+/** @internal */
 export const CONNECTION_CHECK_OUT_STARTED = 'connectionCheckOutStarted' as const;
+/** @internal */
 export const CONNECTION_CHECK_OUT_FAILED = 'connectionCheckOutFailed' as const;
+/** @internal */
 export const CONNECTION_CHECKED_OUT = 'connectionCheckedOut' as const;
+/** @internal */
 export const CONNECTION_CHECKED_IN = 'connectionCheckedIn' as const;
 export const CLUSTER_TIME_RECEIVED = 'clusterTimeReceived' as const;
 export const COMMAND_STARTED = 'commandStarted' as const;

package/src/cursor/abstract_cursor.ts

@@ -397,6 +397,7 @@ export abstract class AbstractCursor<
    * If the iterator returns `false`, iteration will stop.
    *
    * @param iterator - The iteration callback.
+   * @deprecated - Will be removed in a future release. Use for await...of instead.
    */
   async forEach(iterator: (doc: TSchema) => boolean | void): Promise<void> {
     if (typeof iterator !== 'function') {

package/src/db.ts

@@ -232,6 +232,22 @@ export class Db {
    * @remarks
    * This command does not inherit options from the MongoClient.
    *
+   * The driver will ensure the following fields are attached to the command sent to the server:
+   * - `lsid` - sourced from an implicit session or options.session
+   * - `$readPreference` - defaults to primary or can be configured by options.readPreference
+   * - `$db` - sourced from the name of this database
+   *
+   * If the client has a serverApi setting:
+   * - `apiVersion`
+   * - `apiStrict`
+   * - `apiDeprecationErrors`
+   *
+   * When in a transaction:
+   * - `readConcern` - sourced from readConcern set on the TransactionOptions
+   * - `writeConcern` - sourced from writeConcern set on the TransactionOptions
+   *
+   * Attaching any of the above fields to the command will have no effect as the driver will overwrite the value.
+   *
    * @param command - The command to run
    * @param options - Optional settings for the command
    */
@@ -405,6 +421,8 @@ export class Db {
    * @param username - The username for the new user
    * @param passwordOrOptions - An optional password for the new user, or the options for the command
    * @param options - Optional settings for the command
+   * @deprecated Use the createUser command in `db.command()` instead.
+   * @see https://www.mongodb.com/docs/manual/reference/command/createUser/
    */
   async addUser(
     username: string,

package/src/index.ts

@@ -204,10 +204,11 @@ export type {
   MongoCredentialsOptions
 } from './cmap/auth/mongo_credentials';
 export type {
-  OIDCMechanismServerStep1,
+  IdPServerInfo,
+  IdPServerResponse,
+  OIDCCallbackContext,
   OIDCRefreshFunction,
-  OIDCRequestFunction,
-  OIDCRequestTokenResult
+  OIDCRequestFunction
 } from './cmap/auth/mongodb_oidc';
 export type {
   BinMsg,
@@ -238,6 +239,7 @@ export type {
   WaitQueueMember,
   WithConnectionCallback
 } from './cmap/connection_pool';
+export type { ClientMetadata, ClientMetadataOptions } from './cmap/handshake/client_metadata';
 export type {
   MessageStream,
   MessageStreamOptions,
@@ -247,7 +249,20 @@ export type { ConnectionPoolMetrics } from './cmap/metrics';
 export type { StreamDescription, StreamDescriptionOptions } from './cmap/stream_description';
 export type { CompressorName } from './cmap/wire_protocol/compression';
 export type { CollectionOptions, CollectionPrivate, ModifyResult } from './collection';
-export type { MONGO_CLIENT_EVENTS } from './constants';
+export type {
+  CONNECTION_CHECK_OUT_FAILED,
+  CONNECTION_CHECK_OUT_STARTED,
+  CONNECTION_CHECKED_IN,
+  CONNECTION_CHECKED_OUT,
+  CONNECTION_CLOSED,
+  CONNECTION_CREATED,
+  CONNECTION_POOL_CLEARED,
+  CONNECTION_POOL_CLOSED,
+  CONNECTION_POOL_CREATED,
+  CONNECTION_POOL_READY,
+  CONNECTION_READY,
+  MONGO_CLIENT_EVENTS
+} from './constants';
 export type {
   AbstractCursorEvents,
   AbstractCursorOptions,
@@ -289,6 +304,11 @@ export type {
   WithSessionCallback
 } from './mongo_client';
 export type {
+  Log,
+  LogConvertible,
+  Loggable,
+  LoggableEvent,
+  MongoDBLogWritable,
   MongoLoggableComponent,
   MongoLogger,
   MongoLoggerEnvOptions,
@@ -463,8 +483,6 @@ export type { Transaction, TransactionOptions, TxnState } from './transactions';
 export type {
   BufferPool,
   Callback,
-  ClientMetadata,
-  ClientMetadataOptions,
   EventEmitterWithState,
   HostAddress,
   List,