mongodb 4.1.1 → 4.2.0

package/src/connection_string.ts

@@ -32,7 +32,7 @@ import type { TagSet } from './sdam/server_description';
 import { Logger, LoggerLevel } from './logger';
 import { PromiseProvider } from './promise_provider';
 import { Encrypter } from './encrypter';
-import { Compressor } from './cmap/wire_protocol/compression';
+import { Compressor, CompressorName } from './cmap/wire_protocol/compression';
 
 const VALID_TXT_RECORDS = ['authSource', 'replicaSet', 'loadBalanced'];
 
@@ -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);
         }
@@ -176,7 +180,7 @@ function getBoolean(name: string, value: unknown): boolean {
   const valueString = String(value).toLowerCase();
   if (TRUTHS.has(valueString)) return true;
   if (FALSEHOODS.has(valueString)) return false;
-  throw new MongoParseError(`For ${name} Expected stringified boolean value, got: ${value}`);
+  throw new MongoParseError(`Expected ${name} to be stringified boolean value, got: ${value}`);
 }
 
 function getInt(name: string, value: unknown): number {
@@ -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,30 +286,34 @@ 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);
     }
   }
 
+  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)
   );
 
+  // 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>([
@@ -335,6 +336,19 @@ export function parseOptions(
     allOptions.set(key, values);
   }
 
+  if (allOptions.has('tlsCertificateKeyFile') && !allOptions.has('tlsCertificateFile')) {
+    allOptions.set('tlsCertificateFile', allOptions.get('tlsCertificateKeyFile'));
+  }
+
+  if (allOptions.has('tls') || allOptions.has('ssl')) {
+    const tlsAndSslOpts = (allOptions.get('tls') || [])
+      .concat(allOptions.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.');
+    }
+  }
+
   const unsupportedOptions = setDifference(
     allKeys,
     Array.from(Object.keys(OPTIONS)).map(s => s.toLowerCase())
@@ -347,6 +361,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;
@@ -384,41 +400,57 @@ export function parseOptions(
     mongoOptions.dbName = 'test';
   }
 
-  if (allOptions.has('tls')) {
-    if (new Set(allOptions.get('tls')?.map(getBoolean)).size !== 1) {
-      throw new MongoParseError('All values of tls must be the same.');
-    }
-  }
-
-  if (allOptions.has('ssl')) {
-    if (new Set(allOptions.get('ssl')?.map(getBoolean)).size !== 1) {
-      throw new MongoParseError('All values of ssl must be the same.');
-    }
-  }
-
   checkTLSOptions(mongoOptions);
 
   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;
@@ -426,7 +458,8 @@ export function parseOptions(
 
 function validateLoadBalancedOptions(
   hosts: HostAddress[] | string[],
-  mongoOptions: MongoOptions
+  mongoOptions: MongoOptions,
+  isSrv: boolean
 ): MongoParseError | undefined {
   if (mongoOptions.loadBalanced) {
     if (hosts.length > 1) {
@@ -438,6 +471,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');
+    }
   }
 }
 
@@ -612,8 +649,14 @@ export const OPTIONS = {
     target: 'compressors',
     transform({ values }) {
       const compressionList = new Set();
-      for (const compVal of values as string[]) {
-        for (const c of compVal.split(',')) {
+      for (const compVal of values as (CompressorName[] | string)[]) {
+        const compValArray = typeof compVal === 'string' ? compVal.split(',') : compVal;
+        if (!Array.isArray(compValArray)) {
+          throw new MongoInvalidArgumentError(
+            'compressors must be an array or a comma-delimited list of strings'
+          );
+        }
+        for (const c of compValArray) {
           if (Object.keys(Compressor).includes(String(c))) {
             compressionList.add(String(c));
           } else {
@@ -917,6 +960,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

@@ -418,9 +418,11 @@ export abstract class AbstractCursor<
           docs.push(doc);
 
           // these do need to be transformed since they are copying the rest of the batch
-          const internalDocs = (transform
-            ? this[kDocuments].splice(0, this[kDocuments].length).map(transform)
-            : this[kDocuments].splice(0, this[kDocuments].length)) as TSchema[]; // TODO(NODE-3283): Improve transform typing
+          const internalDocs = (
+            transform
+              ? this[kDocuments].splice(0, this[kDocuments].length).map(transform)
+              : this[kDocuments].splice(0, this[kDocuments].length)
+          ) as TSchema[]; // TODO(NODE-3283): Improve transform typing
 
           if (internalDocs) {
             docs.push(...internalDocs);
@@ -484,7 +486,7 @@ export abstract class AbstractCursor<
       this[kTransform] = transform;
     }
 
-    return (this as unknown) as AbstractCursor<T>;
+    return this as unknown as AbstractCursor<T>;
   }
 
   /**

package/src/cursor/aggregation_cursor.ts

@@ -120,8 +120,8 @@ export class AggregationCursor<TSchema = Document> extends AbstractCursor<TSchem
     return this;
   }
 
-  /** Add a out stage to the aggregation pipeline */
-  out($out: number): this {
+  /** Add an out stage to the aggregation pipeline */
+  out($out: { db: string; coll: string } | string): this {
     assertUninitialized(this);
     this[kPipeline].push({ $out });
     return this;
@@ -171,7 +171,7 @@ export class AggregationCursor<TSchema = Document> extends AbstractCursor<TSchem
   project<T extends Document = Document>($project: Document): AggregationCursor<T> {
     assertUninitialized(this);
     this[kPipeline].push({ $project });
-    return (this as unknown) as AggregationCursor<T>;
+    return this as unknown as AggregationCursor<T>;
   }
 
   /** Add a lookup stage to the aggregation pipeline */

package/src/cursor/find_cursor.ts

@@ -379,7 +379,7 @@ export class FindCursor<TSchema = Document> extends AbstractCursor<TSchema> {
   project<T extends Document = Document>(value: Document): FindCursor<T> {
     assertUninitialized(this);
     this[kBuiltOptions].projection = value;
-    return (this as unknown) as FindCursor<T>;
+    return this as unknown as FindCursor<T>;
   }
 
   /**

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/deps.ts

@@ -21,13 +21,12 @@ function makeErrorModule(error: any) {
   });
 }
 
-export let Kerberos:
-  | typeof import('kerberos')
-  | { kModuleError: MongoMissingDependencyError } = makeErrorModule(
-  new MongoMissingDependencyError(
-    'Optional module `kerberos` not found. Please install it to enable kerberos authentication'
-  )
-);
+export let Kerberos: typeof import('kerberos') | { kModuleError: MongoMissingDependencyError } =
+  makeErrorModule(
+    new MongoMissingDependencyError(
+      'Optional module `kerberos` not found. Please install it to enable kerberos authentication'
+    )
+  );
 
 try {
   // Ensure you always wrap an optional require in the try block NODE-3199
@@ -97,23 +96,60 @@ try {
   } catch {} // eslint-disable-line
 } catch {} // eslint-disable-line
 
-export let saslprep:
-  | typeof import('saslprep')
-  | { kModuleError: MongoMissingDependencyError } = makeErrorModule(
-  new MongoMissingDependencyError(
-    'Optional module `saslprep` not found.' +
-      ' Please install it to enable Stringprep Profile for User Names and Passwords'
-  )
-);
+export let saslprep: typeof import('saslprep') | { kModuleError: MongoMissingDependencyError } =
+  makeErrorModule(
+    new MongoMissingDependencyError(
+      'Optional module `saslprep` not found.' +
+        ' Please install it to enable Stringprep Profile for User Names and Passwords'
+    )
+  );
 
 try {
   // Ensure you always wrap an optional require in the try block NODE-3199
   saslprep = require('saslprep');
 } catch {} // eslint-disable-line
 
-export let aws4:
-  | typeof import('aws4')
-  | { kModuleError: MongoMissingDependencyError } = makeErrorModule(
+interface AWS4 {
+  /**
+   * Created these inline types to better assert future usage of this API
+   * @param options - options for request
+   * @param credentials - AWS credential details, sessionToken should be omitted entirely if its false-y
+   */
+  sign(
+    options: {
+      path: '/';
+      body: string;
+      host: string;
+      method: 'POST';
+      headers: {
+        'Content-Type': 'application/x-www-form-urlencoded';
+        'Content-Length': number;
+        'X-MongoDB-Server-Nonce': string;
+        'X-MongoDB-GS2-CB-Flag': 'n';
+      };
+      service: string;
+      region: string;
+    },
+    credentials:
+      | {
+          accessKeyId: string;
+          secretAccessKey: string;
+          sessionToken: string;
+        }
+      | {
+          accessKeyId: string;
+          secretAccessKey: string;
+        }
+      | undefined
+  ): {
+    headers: {
+      Authorization: string;
+      'X-Amz-Date': string;
+    };
+  };
+}
+
+export let aws4: AWS4 | { kModuleError: MongoMissingDependencyError } = makeErrorModule(
   new MongoMissingDependencyError(
     'Optional module `aws4` not found. Please install it to enable AWS authentication'
   )
@@ -134,7 +170,8 @@ export const AutoEncryptionLoggerLevel = Object.freeze({
 } as const);
 
 /** @public */
-export type AutoEncryptionLoggerLevel = typeof AutoEncryptionLoggerLevel[keyof typeof AutoEncryptionLoggerLevel];
+export type AutoEncryptionLoggerLevel =
+  typeof AutoEncryptionLoggerLevel[keyof typeof AutoEncryptionLoggerLevel];
 
 /** @public */
 export interface AutoEncryptionOptions {

package/src/gridfs/download.ts

@@ -73,7 +73,7 @@ export interface GridFSBucketReadStreamPrivate {
  * Do not instantiate this class directly. Use `openDownloadStream()` instead.
  * @public
  */
-export class GridFSBucketReadStream extends Readable {
+export class GridFSBucketReadStream extends Readable implements NodeJS.ReadableStream {
   /** @internal */
   s: GridFSBucketReadStreamPrivate;
 

package/src/gridfs/upload.ts

@@ -37,7 +37,7 @@ export interface GridFSBucketWriteStreamOptions extends WriteConcernOptions {
  * Do not instantiate this class directly. Use `openUploadStream()` instead.
  * @public
  */
-export class GridFSBucketWriteStream extends Writable {
+export class GridFSBucketWriteStream extends Writable implements NodeJS.WritableStream {
   bucket: GridFSBucket;
   chunks: Collection<GridFSChunk>;
   filename: string;
@@ -118,12 +118,16 @@ export class GridFSBucketWriteStream extends Writable {
    * @param callback - Function to call when the chunk was added to the buffer, or if the entire chunk was persisted to MongoDB if this chunk caused a flush.
    * @returns False if this write required flushing a chunk to MongoDB. True otherwise.
    */
-  write(chunk: Buffer): boolean;
-  write(chunk: Buffer, callback: Callback<void>): boolean;
-  write(chunk: Buffer, encoding: BufferEncoding | undefined): boolean;
-  write(chunk: Buffer, encoding: BufferEncoding | undefined, callback: Callback<void>): boolean;
+  write(chunk: Buffer | string): boolean;
+  write(chunk: Buffer | string, callback: Callback<void>): boolean;
+  write(chunk: Buffer | string, encoding: BufferEncoding | undefined): boolean;
   write(
-    chunk: Buffer,
+    chunk: Buffer | string,
+    encoding: BufferEncoding | undefined,
+    callback: Callback<void>
+  ): boolean;
+  write(
+    chunk: Buffer | string,
     encodingOrCallback?: Callback<void> | BufferEncoding,
     callback?: Callback<void>
   ): boolean {
@@ -417,7 +421,7 @@ function createFilesDoc(
 
 function doWrite(
   stream: GridFSBucketWriteStream,
-  chunk: Buffer,
+  chunk: Buffer | string,
   encoding?: BufferEncoding,
   callback?: Callback<void>
 ): boolean {

package/src/index.ts

@@ -29,6 +29,13 @@ export {
   Map
 } from './bson';
 
+import { ObjectId } from 'bson';
+/**
+ * @public
+ * @deprecated Please use `ObjectId`
+ */
+export const ObjectID = ObjectId;
+
 export {
   MongoError,
   MongoServerError,
@@ -160,7 +167,11 @@ export type {
   OperationTime,
   ResumeOptions
 } from './change_stream';
-export type { MongoCredentials, MongoCredentialsOptions } from './cmap/auth/mongo_credentials';
+export type {
+  MongoCredentials,
+  AuthMechanismProperties,
+  MongoCredentialsOptions
+} from './cmap/auth/mongo_credentials';
 export type {
   WriteProtocolMessageType,
   Query,

package/src/mongo_client.ts

@@ -27,7 +27,7 @@ import type { AuthMechanism } from './cmap/auth/defaultAuthProviders';
 import type { Topology, TopologyEvents } from './sdam/topology';
 import type { ClientSession, ClientSessionOptions } from './sessions';
 import type { TagSet } from './sdam/server_description';
-import type { MongoCredentials } from './cmap/auth/mongo_credentials';
+import type { AuthMechanismProperties, MongoCredentials } from './cmap/auth/mongo_credentials';
 import { parseOptions } from './connection_string';
 import type { CompressorName } from './cmap/wire_protocol/compression';
 import type { TLSSocketOptions, ConnectionOptions as TLSConnectionOptions } from 'tls';
@@ -112,7 +112,7 @@ export interface MongoClientOptions extends BSONSerializeOptions, SupportedNodeC
   ssl?: boolean;
   /** Specifies the location of a local TLS Certificate */
   tlsCertificateFile?: string;
-  /** Specifies the location of a local .pem file that contains either the client’s TLS/SSL certificate or the client’s TLS/SSL certificate and key. */
+  /** 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;
@@ -128,10 +128,20 @@ export interface MongoClientOptions extends BSONSerializeOptions, SupportedNodeC
   connectTimeoutMS?: number;
   /** The time in milliseconds to attempt a send or receive on a socket before the attempt times out. */
   socketTimeoutMS?: number;
-  /** Comma-delimited string of compressors to enable network compression for communication between this client and a mongod/mongos instance. */
-  compressors?: CompressorName[];
+  /** An array or comma-delimited string of compressors to enable network compression for communication between this client and a mongod/mongos instance. */
+  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. */
@@ -157,12 +167,7 @@ export interface MongoClientOptions extends BSONSerializeOptions, SupportedNodeC
   /** Specify the authentication mechanism that MongoDB will use to authenticate the connection. */
   authMechanism?: AuthMechanism;
   /** Specify properties for the specified authMechanism as a comma-separated list of colon-separated key-value pairs. */
-  authMechanismProperties?: {
-    SERVICE_NAME?: string;
-    CANONICALIZE_HOST_NAME?: boolean;
-    SERVICE_REALM?: string;
-    [key: string]: any;
-  };
+  authMechanismProperties?: AuthMechanismProperties;
   /** The size (in milliseconds) of the latency window for selecting among multiple suitable MongoDB instances. */
   localThresholdMS?: number;
   /** Specifies how long (in milliseconds) to block for server selection before throwing an exception.  */
@@ -625,7 +630,6 @@ export interface MongoOptions
       Pick<
         MongoClientOptions,
         | 'autoEncryption'
-        | 'compressors'
         | 'connectTimeoutMS'
         | 'directConnection'
         | 'driverInfo'
@@ -649,6 +653,8 @@ export interface MongoOptions
         | 'retryWrites'
         | 'serverSelectionTimeoutMS'
         | 'socketTimeoutMS'
+        | 'srvMaxHosts'
+        | 'srvServiceName'
         | 'tlsAllowInvalidCertificates'
         | 'tlsAllowInvalidHostnames'
         | 'tlsInsecure'
@@ -664,6 +670,7 @@ export interface MongoOptions
   readConcern: ReadConcern;
   loadBalanced: boolean;
   serverApi: ServerApi;
+  compressors: CompressorName[];
   writeConcern: WriteConcern;
   dbName: string;
   metadata: ClientMetadata;