mongodb 5.4.0 → 5.6.0

package/src/cursor/list_search_indexes_cursor.ts

@@ -0,0 +1,20 @@
+import type { Collection } from '../collection';
+import type { AggregateOptions } from '../operations/aggregate';
+import { AggregationCursor } from './aggregation_cursor';
+
+/** @internal */
+export type ListSearchIndexesOptions = AggregateOptions;
+
+/** @internal */
+export class ListSearchIndexesCursor extends AggregationCursor<{ name: string }> {
+  /** @internal */
+  constructor(
+    { fullNamespace: ns, client }: Collection,
+    name: string | null,
+    options: ListSearchIndexesOptions = {}
+  ) {
+    const pipeline =
+      name == null ? [{ $listSearchIndexes: {} }] : [{ $listSearchIndexes: { name } }];
+    super(client, ns, pipeline, options);
+  }
+}

package/src/cursor/run_command_cursor.ts

@@ -0,0 +1,140 @@
+import type { BSONSerializeOptions, Document, Long } from '../bson';
+import type { Db } from '../db';
+import { MongoAPIError, MongoUnexpectedServerResponseError } from '../error';
+import { executeOperation, ExecutionResult } from '../operations/execute_operation';
+import { GetMoreOperation } from '../operations/get_more';
+import { RunCommandOperation } from '../operations/run_command';
+import type { ReadConcernLike } from '../read_concern';
+import type { ReadPreferenceLike } from '../read_preference';
+import type { ClientSession } from '../sessions';
+import { Callback, ns } from '../utils';
+import { AbstractCursor } from './abstract_cursor';
+
+/** @public */
+export type RunCursorCommandOptions = {
+  readPreference?: ReadPreferenceLike;
+  session?: ClientSession;
+} & BSONSerializeOptions;
+
+/** @internal */
+type RunCursorCommandResponse = {
+  cursor: { id: bigint | Long | number; ns: string; firstBatch: Document[] };
+  ok: 1;
+};
+
+/** @public */
+export class RunCommandCursor extends AbstractCursor {
+  public readonly command: Readonly<Record<string, any>>;
+  public readonly getMoreOptions: {
+    comment?: any;
+    maxAwaitTimeMS?: number;
+    batchSize?: number;
+  } = {};
+
+  /**
+   * Controls the `getMore.comment` field
+   * @param comment - any BSON value
+   */
+  public setComment(comment: any): this {
+    this.getMoreOptions.comment = comment;
+    return this;
+  }
+
+  /**
+   * Controls the `getMore.maxTimeMS` field. Only valid when cursor is tailable await
+   * @param maxTimeMS - the number of milliseconds to wait for new data
+   */
+  public setMaxTimeMS(maxTimeMS: number): this {
+    this.getMoreOptions.maxAwaitTimeMS = maxTimeMS;
+    return this;
+  }
+
+  /**
+   * Controls the `getMore.batchSize` field
+   * @param maxTimeMS - the number documents to return in the `nextBatch`
+   */
+  public setBatchSize(batchSize: number): this {
+    this.getMoreOptions.batchSize = batchSize;
+    return this;
+  }
+
+  /** Unsupported for RunCommandCursor */
+  public override clone(): never {
+    throw new MongoAPIError('Clone not supported, create a new cursor with db.runCursorCommand');
+  }
+
+  /** Unsupported for RunCommandCursor: readConcern must be configured directly on command document */
+  public override withReadConcern(_: ReadConcernLike): never {
+    throw new MongoAPIError(
+      'RunCommandCursor does not support readConcern it must be attached to the command being run'
+    );
+  }
+
+  /** Unsupported for RunCommandCursor: various cursor flags must be configured directly on command document */
+  public override addCursorFlag(_: string, __: boolean): never {
+    throw new MongoAPIError(
+      'RunCommandCursor does not support cursor flags, they must be attached to the command being run'
+    );
+  }
+
+  /** Unsupported for RunCommandCursor: maxTimeMS must be configured directly on command document */
+  public override maxTimeMS(_: number): never {
+    throw new MongoAPIError(
+      'maxTimeMS must be configured on the command document directly, to configure getMore.maxTimeMS use cursor.setMaxTimeMS()'
+    );
+  }
+
+  /** Unsupported for RunCommandCursor: batchSize must be configured directly on command document */
+  public override batchSize(_: number): never {
+    throw new MongoAPIError(
+      'batchSize must be configured on the command document directly, to configure getMore.batchSize use cursor.setBatchSize()'
+    );
+  }
+
+  /** @internal */
+  private db: Db;
+
+  /** @internal */
+  constructor(db: Db, command: Document, options: RunCursorCommandOptions = {}) {
+    super(db.client, ns(db.namespace), options);
+    this.db = db;
+    this.command = Object.freeze({ ...command });
+  }
+
+  /** @internal */
+  protected _initialize(session: ClientSession, callback: Callback<ExecutionResult>) {
+    const operation = new RunCommandOperation<RunCursorCommandResponse>(this.db, this.command, {
+      ...this.cursorOptions,
+      session: session,
+      readPreference: this.cursorOptions.readPreference
+    });
+    executeOperation(this.client, operation).then(
+      response => {
+        if (response.cursor == null) {
+          callback(
+            new MongoUnexpectedServerResponseError('Expected server to respond with cursor')
+          );
+          return;
+        }
+        callback(undefined, {
+          server: operation.server,
+          session,
+          response
+        });
+      },
+      err => callback(err)
+    );
+  }
+
+  /** @internal */
+  override _getMore(_batchSize: number, callback: Callback<Document>) {
+    // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+    const getMoreOperation = new GetMoreOperation(this.namespace, this.id!, this.server!, {
+      ...this.cursorOptions,
+      session: this.session,
+      ...this.getMoreOptions
+    });
+
+    executeOperation(this.client, getMoreOperation, callback);
+  }
+}

package/src/db.ts

@@ -5,6 +5,7 @@ import { Collection, CollectionOptions } from './collection';
 import * as CONSTANTS from './constants';
 import { AggregationCursor } from './cursor/aggregation_cursor';
 import { ListCollectionsCursor } from './cursor/list_collections_cursor';
+import { RunCommandCursor, type RunCursorCommandOptions } from './cursor/run_command_cursor';
 import { MongoAPIError, MongoInvalidArgumentError } from './error';
 import type { MongoClient, PkFactory } from './mongo_client';
 import type { TODO_NODE_3286 } from './mongo_types';
@@ -69,7 +70,6 @@ const DB_OPTIONS_ALLOW_LIST = [
 
 /** @internal */
 export interface DbPrivate {
-  client: MongoClient;
   options?: DbOptions;
   readPreference?: ReadPreference;
   pkFactory: PkFactory;
@@ -121,6 +121,9 @@ export class Db {
   /** @internal */
   s: DbPrivate;
 
+  /** @internal */
+  readonly client: MongoClient;
+
   public static SYSTEM_NAMESPACE_COLLECTION = CONSTANTS.SYSTEM_NAMESPACE_COLLECTION;
   public static SYSTEM_INDEX_COLLECTION = CONSTANTS.SYSTEM_INDEX_COLLECTION;
   public static SYSTEM_PROFILE_COLLECTION = CONSTANTS.SYSTEM_PROFILE_COLLECTION;
@@ -146,8 +149,6 @@ export class Db {
 
     // Internal state of the db object
     this.s = {
-      // Client
-      client,
       // Options
       options,
       // Unpack read preference
@@ -162,6 +163,8 @@ export class Db {
       // Namespace
       namespace: new MongoDBNamespace(databaseName)
     };
+
+    this.client = client;
   }
 
   get databaseName(): string {
@@ -190,7 +193,7 @@ export class Db {
    */
   get readPreference(): ReadPreference {
     if (this.s.readPreference == null) {
-      return this.s.client.readPreference;
+      return this.client.readPreference;
     }
 
     return this.s.readPreference;
@@ -221,7 +224,7 @@ export class Db {
     options?: CreateCollectionOptions
   ): Promise<Collection<TSchema>> {
     return executeOperation(
-      this.s.client,
+      this.client,
       new CreateCollectionOperation(this, name, resolveOptions(this, options)) as TODO_NODE_3286
     );
   }
@@ -253,7 +256,7 @@ export class Db {
    */
   async command(command: Document, options?: RunCommandOptions): Promise<Document> {
     // Intentionally, we do not inherit options from parent for this operation.
-    return executeOperation(this.s.client, new RunCommandOperation(this, command, options));
+    return executeOperation(this.client, new RunCommandOperation(this, command, options));
   }
 
   /**
@@ -267,7 +270,7 @@ export class Db {
     options?: AggregateOptions
   ): AggregationCursor<T> {
     return new AggregationCursor(
-      this.s.client,
+      this.client,
       this.s.namespace,
       pipeline,
       resolveOptions(this, options)
@@ -301,10 +304,7 @@ export class Db {
    * @param options - Optional settings for the command
    */
   async stats(options?: DbStatsOptions): Promise<Document> {
-    return executeOperation(
-      this.s.client,
-      new DbStatsOperation(this, resolveOptions(this, options))
-    );
+    return executeOperation(this.client, new DbStatsOperation(this, resolveOptions(this, options)));
   }
 
   /**
@@ -351,7 +351,7 @@ export class Db {
   ): Promise<Collection<TSchema>> {
     // Intentionally, we do not inherit options from parent for this operation.
     return executeOperation(
-      this.s.client,
+      this.client,
       new RenameOperation(
         this.collection<TSchema>(fromCollection) as TODO_NODE_3286,
         toCollection,
@@ -368,7 +368,7 @@ export class Db {
    */
   async dropCollection(name: string, options?: DropCollectionOptions): Promise<boolean> {
     return executeOperation(
-      this.s.client,
+      this.client,
       new DropCollectionOperation(this, name, resolveOptions(this, options))
     );
   }
@@ -380,7 +380,7 @@ export class Db {
    */
   async dropDatabase(options?: DropDatabaseOptions): Promise<boolean> {
     return executeOperation(
-      this.s.client,
+      this.client,
       new DropDatabaseOperation(this, resolveOptions(this, options))
     );
   }
@@ -392,7 +392,7 @@ export class Db {
    */
   async collections(options?: ListCollectionsOptions): Promise<Collection[]> {
     return executeOperation(
-      this.s.client,
+      this.client,
       new CollectionsOperation(this, resolveOptions(this, options))
     );
   }
@@ -410,7 +410,7 @@ export class Db {
     options?: CreateIndexesOptions
   ): Promise<string> {
     return executeOperation(
-      this.s.client,
+      this.client,
       new CreateIndexOperation(this, name, indexSpec, resolveOptions(this, options))
     );
   }
@@ -437,7 +437,7 @@ export class Db {
         : undefined;
     const password = typeof passwordOrOptions === 'string' ? passwordOrOptions : undefined;
     return executeOperation(
-      this.s.client,
+      this.client,
       new AddUserOperation(this, username, password, resolveOptions(this, options))
     );
   }
@@ -450,7 +450,7 @@ export class Db {
    */
   async removeUser(username: string, options?: RemoveUserOptions): Promise<boolean> {
     return executeOperation(
-      this.s.client,
+      this.client,
       new RemoveUserOperation(this, username, resolveOptions(this, options))
     );
   }
@@ -466,7 +466,7 @@ export class Db {
     options?: SetProfilingLevelOptions
   ): Promise<ProfilingLevel> {
     return executeOperation(
-      this.s.client,
+      this.client,
       new SetProfilingLevelOperation(this, level, resolveOptions(this, options))
     );
   }
@@ -478,7 +478,7 @@ export class Db {
    */
   async profilingLevel(options?: ProfilingLevelOptions): Promise<string> {
     return executeOperation(
-      this.s.client,
+      this.client,
       new ProfilingLevelOperation(this, resolveOptions(this, options))
     );
   }
@@ -491,7 +491,7 @@ export class Db {
    */
   async indexInformation(name: string, options?: IndexInformationOptions): Promise<Document> {
     return executeOperation(
-      this.s.client,
+      this.client,
       new IndexInformationOperation(this, name, resolveOptions(this, options))
     );
   }
@@ -523,6 +523,19 @@ export class Db {
 
     return new ChangeStream<TSchema, TChange>(this, pipeline, resolveOptions(this, options));
   }
+
+  /**
+   * A low level cursor API providing basic driver functionality:
+   * - ClientSession management
+   * - ReadPreference for server selection
+   * - Running getMores automatically when a local batch is exhausted
+   *
+   * @param command - The command that will start a cursor on the server.
+   * @param options - Configurations for running the command, bson options will apply to getMores
+   */
+  runCursorCommand(command: Document, options?: RunCursorCommandOptions): RunCommandCursor {
+    return new RunCommandCursor(this, command, options);
+  }
 }
 
 // TODO(NODE-3484): Refactor into MongoDBNamespace

package/src/deps.ts

@@ -309,11 +309,11 @@ export interface AutoEncryptionOptions {
    * Other validation rules in the JSON schema will not be enforced by the driver and will result in an error.
    */
   schemaMap?: Document;
-  /** @experimental Public Technical Preview: Supply a schema for the encrypted fields in the document  */
+  /** Supply a schema for the encrypted fields in the document  */
   encryptedFieldsMap?: Document;
   /** Allows the user to bypass auto encryption, maintaining implicit decryption */
   bypassAutoEncryption?: boolean;
-  /** @experimental Public Technical Preview: Allows users to bypass query analysis */
+  /** Allows users to bypass query analysis */
   bypassQueryAnalysis?: boolean;
   options?: {
     /** An optional hook to catch logging messages from the underlying encryption engine */

package/src/error.ts

@@ -108,6 +108,10 @@ export interface ErrorDescription extends Document {
   errInfo?: Document;
 }
 
+function isAggregateError(e: Error): e is Error & { errors: Error[] } {
+  return 'errors' in e && Array.isArray(e.errors);
+}
+
 /**
  * @public
  * @category Error
@@ -131,15 +135,28 @@ export class MongoError extends Error {
   cause?: Error; // depending on the node version, this may or may not exist on the base
 
   constructor(message: string | Error) {
+    super(MongoError.buildErrorMessage(message));
     if (message instanceof Error) {
-      super(message.message);
       this.cause = message;
-    } else {
-      super(message);
     }
+
     this[kErrorLabels] = new Set();
   }
 
+  /** @internal */
+  private static buildErrorMessage(e: Error | string): string {
+    if (typeof e === 'string') {
+      return e;
+    }
+    if (isAggregateError(e) && e.message.length === 0) {
+      return e.errors.length === 0
+        ? 'AggregateError has an empty errors array. Please check the `cause` property for more information.'
+        : e.errors.map(({ message }) => message).join(', ');
+    }
+
+    return e.message;
+  }
+
   override get name(): string {
     return 'MongoError';
   }

package/src/index.ts

@@ -8,6 +8,7 @@ import { AggregationCursor } from './cursor/aggregation_cursor';
 import { FindCursor } from './cursor/find_cursor';
 import { ListCollectionsCursor } from './cursor/list_collections_cursor';
 import { ListIndexesCursor } from './cursor/list_indexes_cursor';
+import type { RunCommandCursor } from './cursor/run_command_cursor';
 import { Db } from './db';
 import { GridFSBucket } from './gridfs';
 import { GridFSBucketReadStream } from './gridfs/download';
@@ -87,6 +88,7 @@ export {
   ListIndexesCursor,
   MongoClient,
   OrderedBulkOperation,
+  RunCommandCursor,
   UnorderedBulkOperation
 };
 
@@ -275,6 +277,11 @@ export type {
   ChangeStreamAggregateRawResult,
   ChangeStreamCursorOptions
 } from './cursor/change_stream_cursor';
+export type {
+  ListSearchIndexesCursor,
+  ListSearchIndexesOptions
+} from './cursor/list_search_indexes_cursor';
+export type { RunCursorCommandOptions } from './cursor/run_command_cursor';
 export type { DbOptions, DbPrivate } from './db';
 export type { AutoEncrypter, AutoEncryptionOptions, AutoEncryptionTlsOptions } from './deps';
 export type { Encrypter, EncrypterOptions } from './encrypter';
@@ -415,6 +422,7 @@ export type { ProfilingLevelOptions } from './operations/profiling_level';
 export type { RemoveUserOptions } from './operations/remove_user';
 export type { RenameOptions } from './operations/rename';
 export type { RunCommandOptions } from './operations/run_command';
+export type { SearchIndexDescription } from './operations/search_indexes/create';
 export type { SetProfilingLevelOptions } from './operations/set_profiling_level';
 export type {
   CollStats,
@@ -486,6 +494,7 @@ export type {
   EventEmitterWithState,
   HostAddress,
   List,
+  MongoDBCollectionNamespace,
   MongoDBNamespace
 } from './utils';
 export type { W, WriteConcernOptions, WriteConcernSettings } from './write_concern';

package/src/mongo_client.ts

@@ -325,7 +325,7 @@ export class MongoClient extends TypedEventEmitter<MongoClientEvents> {
   /** @internal */
   topology?: Topology;
   /** @internal */
-  readonly mongoLogger: MongoLogger;
+  override readonly mongoLogger: MongoLogger;
   /** @internal */
   private connectionLock?: Promise<this>;
 
@@ -471,23 +471,21 @@ export class MongoClient extends TypedEventEmitter<MongoClientEvents> {
       }
     }
 
-    const topology = new Topology(options.hosts, options);
+    this.topology = new Topology(this, options.hosts, options);
     // Events can be emitted before initialization is complete so we have to
     // save the reference to the topology on the client ASAP if the event handlers need to access it
-    this.topology = topology;
-    topology.client = this;
 
-    topology.once(Topology.OPEN, () => this.emit('open', this));
+    this.topology.once(Topology.OPEN, () => this.emit('open', this));
 
     for (const event of MONGO_CLIENT_EVENTS) {
-      topology.on(event, (...args: any[]) => this.emit(event, ...(args as any)));
+      this.topology.on(event, (...args: any[]) => this.emit(event, ...(args as any)));
     }
 
     const topologyConnect = async () => {
       try {
-        await promisify(callback => topology.connect(options, callback))();
+        await promisify(callback => this.topology?.connect(options, callback))();
       } catch (error) {
-        topology.close({ force: true });
+        this.topology?.close({ force: true });
         throw error;
       }
     };
@@ -774,19 +772,29 @@ export interface MongoOptions
   /**
    * # NOTE ABOUT TLS Options
    *
-   * If set TLS enabled, equivalent to setting the ssl option.
+   * If `tls` is provided as an option, it is equivalent to setting the `ssl` option.
+   *
+   * NodeJS native TLS options are passed through to the socket and retain their original types.
    *
    * ### Additional options:
    *
-   * |    nodejs option     | MongoDB equivalent                                       | type                                   |
-   * |:---------------------|--------------------------------------------------------- |:---------------------------------------|
-   * | `ca`                 | `sslCA`, `tlsCAFile`                                     | `string \| Buffer \| Buffer[]`         |
-   * | `crl`                | `sslCRL`                                                 | `string \| Buffer \| Buffer[]`         |
-   * | `cert`               | `sslCert`, `tlsCertificateFile`, `tlsCertificateKeyFile` | `string \| Buffer \| Buffer[]`         |
-   * | `key`                | `sslKey`, `tlsCertificateKeyFile`                        | `string \| Buffer \| KeyObject[]`      |
-   * | `passphrase`         | `sslPass`, `tlsCertificateKeyFilePassword`               | `string`                               |
-   * | `rejectUnauthorized` | `sslValidate`                                            | `boolean`                              |
+   * | nodejs native option  | driver spec compliant option name             | legacy option name | driver option type |
+   * |:----------------------|:----------------------------------------------|:-------------------|:-------------------|
+   * | `ca`                  | `tlsCAFile`                                   | `sslCA`            | `string`           |
+   * | `crl`                 | N/A                                           | `sslCRL`           | `string`           |
+   * | `cert`                | `tlsCertificateFile`, `tlsCertificateKeyFile` | `sslCert`          | `string`           |
+   * | `key`                 | `tlsCertificateKeyFile`                       | `sslKey`           | `string`           |
+   * | `passphrase`          | `tlsCertificateKeyFilePassword`               | `sslPass`          | `string`           |
+   * | `rejectUnauthorized`  | `tlsAllowInvalidCertificates`                 | `sslValidate`      | `boolean`          |
+   * | `checkServerIdentity` | `tlsAllowInvalidHostnames`                    | N/A                | `boolean`          |
+   * | see note below        | `tlsInsecure`                                 | N/A                | `boolean`          |
+   *
+   * If `tlsInsecure` is set to `true`, then it will set the node native options `checkServerIdentity`
+   * to a no-op and `rejectUnauthorized` to `false`.
    *
+   * If `tlsInsecure` is set to `false`, then it will set the node native options `checkServerIdentity`
+   * to a no-op and `rejectUnauthorized` to the inverse value of `tlsAllowInvalidCertificates`. If
+   * `tlsAllowInvalidCertificates` is not set, then `rejectUnauthorized` will be set to `true`.
    */
   tls: boolean;
 

package/src/mongo_types.ts

@@ -12,6 +12,7 @@ import type {
   ObjectId,
   Timestamp
 } from './bson';
+import type { MongoLoggableComponent, MongoLogger } from './mongo_logger';
 import type { Sort } from './sort';
 
 /** @internal */
@@ -397,8 +398,21 @@ export declare interface TypedEventEmitter<Events extends EventsDescription> ext
  * Typescript type safe event emitter
  * @public
  */
-// eslint-disable-next-line @typescript-eslint/no-unused-vars
-export class TypedEventEmitter<Events extends EventsDescription> extends EventEmitter {}
+
+export class TypedEventEmitter<Events extends EventsDescription> extends EventEmitter {
+  /** @internal */
+  protected mongoLogger?: MongoLogger;
+  /** @internal */
+  protected component?: MongoLoggableComponent;
+  /** @internal */
+  protected emitAndLog<EventKey extends keyof Events>(
+    event: EventKey | symbol,
+    ...args: Parameters<Events[EventKey]>
+  ): void {
+    this.emit(event, ...args);
+    if (this.component) this.mongoLogger?.debug(this.component, args[0]);
+  }
+}
 
 /** @public */
 export class CancellationToken extends TypedEventEmitter<{ cancel(): void }> {}

package/src/operations/create_collection.ts

@@ -1,6 +1,11 @@
 import type { Document } from '../bson';
+import {
+  MIN_SUPPORTED_QE_SERVER_VERSION,
+  MIN_SUPPORTED_QE_WIRE_VERSION
+} from '../cmap/wire_protocol/constants';
 import { Collection } from '../collection';
 import type { Db } from '../db';
+import { MongoCompatibilityError } from '../error';
 import type { PkFactory } from '../mongo_client';
 import type { Server } from '../sdam/server';
 import type { ClientSession } from '../sessions';
@@ -41,6 +46,8 @@ export interface TimeSeriesCollectionOptions extends Document {
   timeField: string;
   metaField?: string;
   granularity?: 'seconds' | 'minutes' | 'hours' | string;
+  bucketMaxSpanSeconds?: number;
+  bucketRoundingSeconds?: number;
 }
 
 /** @public
@@ -55,8 +62,6 @@ export interface ClusteredCollectionOptions extends Document {
 
 /** @public */
 export interface CreateCollectionOptions extends CommandOperationOptions {
-  /** Returns an error if the collection does not exist */
-  strict?: boolean;
   /** Create a capped collection */
   capped?: boolean;
   /** @deprecated Create an index on the _id field of the document. This option is deprecated in MongoDB 3.2+ and will be removed once no longer supported by the server. */
@@ -98,6 +103,10 @@ export interface CreateCollectionOptions extends CommandOperationOptions {
   changeStreamPreAndPostImages?: { enabled: boolean };
 }
 
+/* @internal */
+const INVALID_QE_VERSION =
+  'Driver support of Queryable Encryption is incompatible with server. Upgrade server to use Queryable Encryption.';
+
 /** @internal */
 export class CreateCollectionOperation extends CommandOperation<Collection> {
   override options: CreateCollectionOptions;
@@ -124,15 +133,20 @@ export class CreateCollectionOperation extends CommandOperation<Collection> {
 
       const encryptedFields: Document | undefined =
         options.encryptedFields ??
-        db.s.client.options.autoEncryption?.encryptedFieldsMap?.[`${db.databaseName}.${name}`];
+        db.client.options.autoEncryption?.encryptedFieldsMap?.[`${db.databaseName}.${name}`];
 
       if (encryptedFields) {
+        // Creating a QE collection required min server of 7.0.0
+        if (server.description.maxWireVersion < MIN_SUPPORTED_QE_WIRE_VERSION) {
+          throw new MongoCompatibilityError(
+            `${INVALID_QE_VERSION} The minimum server version required is ${MIN_SUPPORTED_QE_SERVER_VERSION}`
+          );
+        }
         // Create auxilliary collections for queryable encryption support.
         const escCollection = encryptedFields.escCollection ?? `enxcol_.${name}.esc`;
-        const eccCollection = encryptedFields.eccCollection ?? `enxcol_.${name}.ecc`;
         const ecocCollection = encryptedFields.ecocCollection ?? `enxcol_.${name}.ecoc`;
 
-        for (const collectionName of [escCollection, eccCollection, ecocCollection]) {
+        for (const collectionName of [escCollection, ecocCollection]) {
           const createOp = new CreateCollectionOperation(db, collectionName, {
             clusteredIndex: {
               key: { _id: 1 },

package/src/operations/drop.ts

@@ -36,7 +36,7 @@ export class DropCollectionOperation extends CommandOperation<boolean> {
       const options = this.options;
       const name = this.name;
 
-      const encryptedFieldsMap = db.s.client.options.autoEncryption?.encryptedFieldsMap;
+      const encryptedFieldsMap = db.client.options.autoEncryption?.encryptedFieldsMap;
       let encryptedFields: Document | undefined =
         options.encryptedFields ?? encryptedFieldsMap?.[`${db.databaseName}.${name}`];
 
@@ -53,10 +53,9 @@ export class DropCollectionOperation extends CommandOperation<boolean> {
 
       if (encryptedFields) {
         const escCollection = encryptedFields.escCollection || `enxcol_.${name}.esc`;
-        const eccCollection = encryptedFields.eccCollection || `enxcol_.${name}.ecc`;
         const ecocCollection = encryptedFields.ecocCollection || `enxcol_.${name}.ecoc`;
 
-        for (const collectionName of [escCollection, eccCollection, ecocCollection]) {
+        for (const collectionName of [escCollection, ecocCollection]) {
           // Drop auxilliary collections, ignoring potential NamespaceNotFound errors.
           const dropOp = new DropCollectionOperation(db, collectionName);
           try {