mongodb 6.18.0 → 6.19.0-dev.20250828.sha.41034f16

package/src/index.ts

@@ -10,7 +10,6 @@ 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 { ExplainableCursor } from './explain';
 import { GridFSBucket } from './gridfs';
 import { GridFSBucketReadStream } from './gridfs/download';
 import { GridFSBucketWriteStream } from './gridfs/upload';
@@ -44,6 +43,7 @@ export {
 } from './bulk/common';
 export { ClientEncryption } from './client-side-encryption/client_encryption';
 export { ChangeStreamCursor } from './cursor/change_stream_cursor';
+export { ExplainableCursor } from './cursor/explainable_cursor';
 export {
   MongoAPIError,
   MongoAWSError,
@@ -98,7 +98,6 @@ export {
   ClientSession,
   Collection,
   Db,
-  ExplainableCursor,
   FindCursor,
   GridFSBucket,
   GridFSBucketReadStream,
@@ -243,7 +242,8 @@ export type {
   DataKey,
   GCPEncryptionKeyOptions,
   KMIPEncryptionKeyOptions,
-  RangeOptions
+  RangeOptions,
+  TextQueryOptions
 } from './client-side-encryption/client_encryption';
 export {
   MongoCryptAzureKMSRequestError,
@@ -523,7 +523,7 @@ export type { DeleteOptions, DeleteResult, DeleteStatement } from './operations/
 export type { DistinctOptions } from './operations/distinct';
 export type { DropCollectionOptions, DropDatabaseOptions } from './operations/drop';
 export type { EstimatedDocumentCountOptions } from './operations/estimated_document_count';
-export type { FindOptions } from './operations/find';
+export type { FindOneOptions, FindOptions } from './operations/find';
 export type {
   FindOneAndDeleteOptions,
   FindOneAndReplaceOptions,

package/src/mongo_client.ts

@@ -2,6 +2,7 @@ import { promises as fs } from 'fs';
 import type { TcpNetConnectOpts } from 'net';
 import type { ConnectionOptions as TLSConnectionOptions, TLSSocketOptions } from 'tls';
 
+import { type ServerCommandOptions, type TimeoutContext } from '.';
 import { type BSONSerializeOptions, type Document, resolveBSONOptions } from './bson';
 import { ChangeStream, type ChangeStreamDocument, type ChangeStreamOptions } from './change_stream';
 import type { AutoEncrypter, AutoEncryptionOptions } from './client-side-encryption/auto_encrypter';
@@ -20,6 +21,7 @@ import {
   makeClientMetadata
 } from './cmap/handshake/client_metadata';
 import type { CompressorName } from './cmap/wire_protocol/compression';
+import { MongoDBResponse } from './cmap/wire_protocol/responses';
 import { parseOptions, resolveSRVRecord } from './connection_string';
 import { MONGO_CLIENT_EVENTS } from './constants';
 import { type AbstractCursor } from './cursor/abstract_cursor';
@@ -42,7 +44,7 @@ import {
 } from './operations/client_bulk_write/common';
 import { ClientBulkWriteExecutor } from './operations/client_bulk_write/executor';
 import { executeOperation } from './operations/execute_operation';
-import { RunAdminCommandOperation } from './operations/run_command';
+import { AbstractOperation } from './operations/operation';
 import type { ReadConcern, ReadConcernLevel, ReadConcernLike } from './read_concern';
 import { ReadPreference, type ReadPreferenceMode } from './read_preference';
 import { type AsyncDisposable, configureResourceManagement } from './resource_management';
@@ -60,7 +62,7 @@ import {
   type HostAddress,
   hostMatchesWildcards,
   isHostMatch,
-  type MongoDBNamespace,
+  MongoDBNamespace,
   noop,
   ns,
   resolveOptions,
@@ -790,13 +792,26 @@ export class MongoClient extends TypedEventEmitter<MongoClientEvents> implements
       const endSessions = Array.from(this.s.sessionPool.sessions, ({ id }) => id);
       if (endSessions.length !== 0) {
         try {
-          await executeOperation(
-            this,
-            new RunAdminCommandOperation(
-              { endSessions },
-              { readPreference: ReadPreference.primaryPreferred, noResponse: true }
-            )
-          );
+          class EndSessionsOperation extends AbstractOperation<void> {
+            override ns = MongoDBNamespace.fromString('admin.$cmd');
+            override SERVER_COMMAND_RESPONSE_TYPE = MongoDBResponse;
+            override buildCommand(_connection: Connection, _session?: ClientSession): Document {
+              return {
+                endSessions
+              };
+            }
+            override buildOptions(timeoutContext: TimeoutContext): ServerCommandOptions {
+              return {
+                timeoutContext,
+                readPreference: ReadPreference.primaryPreferred,
+                noResponse: true
+              };
+            }
+            override get commandName(): string {
+              return 'endSessions';
+            }
+          }
+          await executeOperation(this, new EndSessionsOperation());
         } catch (error) {
           squashError(error);
         }

package/src/operations/aggregate.ts

@@ -1,11 +1,9 @@
+import { type Connection } from '..';
 import type { Document } from '../bson';
 import { CursorResponse, ExplainedCursorResponse } from '../cmap/wire_protocol/responses';
 import { type CursorTimeoutMode } from '../cursor/abstract_cursor';
 import { MongoInvalidArgumentError } from '../error';
 import { type ExplainOptions } from '../explain';
-import type { Server } from '../sdam/server';
-import type { ClientSession } from '../sessions';
-import { type TimeoutContext } from '../timeout';
 import { maxWireVersion, type MongoDBNamespace } from '../utils';
 import { WriteConcern } from '../write_concern';
 import { type CollationOptions, CommandOperation, type CommandOperationOptions } from './command';
@@ -52,6 +50,7 @@ export interface AggregateOptions extends Omit<CommandOperationOptions, 'explain
 
 /** @internal */
 export class AggregateOperation extends CommandOperation<CursorResponse> {
+  override SERVER_COMMAND_RESPONSE_TYPE = CursorResponse;
   override options: AggregateOptions;
   target: string | typeof DB_AGGREGATE_COLLECTION;
   pipeline: Document[];
@@ -79,9 +78,7 @@ export class AggregateOperation extends CommandOperation<CursorResponse> {
       }
     }
 
-    if (this.hasWriteStage) {
-      this.trySecondaryWrite = true;
-    } else {
+    if (!this.hasWriteStage) {
       delete this.options.writeConcern;
     }
 
@@ -94,6 +91,8 @@ export class AggregateOperation extends CommandOperation<CursorResponse> {
     if (options?.cursor != null && typeof options.cursor !== 'object') {
       throw new MongoInvalidArgumentError('Cursor options must be an object');
     }
+
+    this.SERVER_COMMAND_RESPONSE_TYPE = this.explain ? ExplainedCursorResponse : CursorResponse;
   }
 
   override get commandName() {
@@ -108,13 +107,9 @@ export class AggregateOperation extends CommandOperation<CursorResponse> {
     this.pipeline.push(stage);
   }
 
-  override async execute(
-    server: Server,
-    session: ClientSession | undefined,
-    timeoutContext: TimeoutContext
-  ): Promise<CursorResponse> {
-    const options: AggregateOptions = this.options;
-    const serverWireVersion = maxWireVersion(server);
+  override buildCommandDocument(connection: Connection): Document {
+    const options = this.options;
+    const serverWireVersion = maxWireVersion(connection);
     const command: Document = { aggregate: this.target, pipeline: this.pipeline };
 
     if (this.hasWriteStage && serverWireVersion < MIN_WIRE_VERSION_$OUT_READ_CONCERN_SUPPORT) {
@@ -152,13 +147,13 @@ export class AggregateOperation extends CommandOperation<CursorResponse> {
       command.cursor.batchSize = options.batchSize;
     }
 
-    return await super.executeCommand(
-      server,
-      session,
-      command,
-      timeoutContext,
-      this.explain ? ExplainedCursorResponse : CursorResponse
-    );
+    return command;
+  }
+
+  override handleOk(
+    response: InstanceType<typeof this.SERVER_COMMAND_RESPONSE_TYPE>
+  ): CursorResponse {
+    return response;
   }
 }
 

package/src/operations/client_bulk_write/client_bulk_write.ts

@@ -1,12 +1,10 @@
-import { MongoClientBulkWriteExecutionError, ServerType } from '../../beta';
+import { type Connection } from '../../cmap/connection';
 import { ClientBulkWriteCursorResponse } from '../../cmap/wire_protocol/responses';
-import type { Server } from '../../sdam/server';
 import type { ClientSession } from '../../sessions';
-import { type TimeoutContext } from '../../timeout';
 import { MongoDBNamespace } from '../../utils';
 import { CommandOperation } from '../command';
 import { Aspect, defineAspects } from '../operation';
-import { type ClientBulkWriteCommandBuilder } from './command_builder';
+import { type ClientBulkWriteCommand, type ClientBulkWriteCommandBuilder } from './command_builder';
 import { type ClientBulkWriteOptions } from './common';
 
 /**
@@ -14,6 +12,8 @@ import { type ClientBulkWriteOptions } from './common';
  * @internal
  */
 export class ClientBulkWriteOperation extends CommandOperation<ClientBulkWriteCursorResponse> {
+  override SERVER_COMMAND_RESPONSE_TYPE = ClientBulkWriteCursorResponse;
+
   commandBuilder: ClientBulkWriteCommandBuilder;
   override options: ClientBulkWriteOptions;
 
@@ -36,72 +36,28 @@ export class ClientBulkWriteOperation extends CommandOperation<ClientBulkWriteCu
     return this.commandBuilder.isBatchRetryable;
   }
 
-  /**
-   * Execute the command. Superclass will handle write concern, etc.
-   * @param server - The server.
-   * @param session - The session.
-   * @returns The response.
-   */
-  override async execute(
-    server: Server,
-    session: ClientSession | undefined,
-    timeoutContext: TimeoutContext
-  ): Promise<ClientBulkWriteCursorResponse> {
-    let command;
+  override handleOk(
+    response: InstanceType<typeof this.SERVER_COMMAND_RESPONSE_TYPE>
+  ): ClientBulkWriteCursorResponse {
+    return response;
+  }
 
-    if (server.description.type === ServerType.LoadBalancer) {
-      if (session) {
-        let connection;
-        if (!session.pinnedConnection) {
-          // Checkout a connection to build the command.
-          connection = await server.pool.checkOut({ timeoutContext });
-          // Pin the connection to the session so it get used to execute the command and we do not
-          // perform a double check-in/check-out.
-          session.pin(connection);
-        } else {
-          connection = session.pinnedConnection;
-        }
-        command = this.commandBuilder.buildBatch(
-          connection.hello?.maxMessageSizeBytes,
-          connection.hello?.maxWriteBatchSize,
-          connection.hello?.maxBsonObjectSize
-        );
-      } else {
-        throw new MongoClientBulkWriteExecutionError(
-          'Session provided to the client bulk write operation must be present.'
-        );
-      }
-    } else {
-      // At this point we have a server and the auto connect code has already
-      // run in executeOperation, so the server description will be populated.
-      // We can use that to build the command.
-      if (
-        !server.description.maxWriteBatchSize ||
-        !server.description.maxMessageSizeBytes ||
-        !server.description.maxBsonObjectSize
-      ) {
-        throw new MongoClientBulkWriteExecutionError(
-          'In order to execute a client bulk write, both maxWriteBatchSize, maxMessageSizeBytes and maxBsonObjectSize must be provided by the servers hello response.'
-        );
-      }
-      command = this.commandBuilder.buildBatch(
-        server.description.maxMessageSizeBytes,
-        server.description.maxWriteBatchSize,
-        server.description.maxBsonObjectSize
-      );
-    }
+  override buildCommandDocument(
+    connection: Connection,
+    _session?: ClientSession
+  ): ClientBulkWriteCommand {
+    const command = this.commandBuilder.buildBatch(
+      connection.description.maxMessageSizeBytes,
+      connection.description.maxWriteBatchSize,
+      connection.description.maxBsonObjectSize
+    );
 
-    // Check after the batch is built if we cannot retry it and override the option.
+    // Check _after_ the batch is built if we cannot retry it and override the option.
     if (!this.canRetryWrite) {
       this.options.willRetryWrite = false;
     }
-    return await super.executeCommand(
-      server,
-      session,
-      command,
-      timeoutContext,
-      ClientBulkWriteCursorResponse
-    );
+
+    return command;
   }
 }
 

package/src/operations/command.ts

@@ -1,5 +1,5 @@
+import { type Connection } from '..';
 import type { BSONSerializeOptions, Document } from '../bson';
-import { type MongoDBResponseConstructor } from '../cmap/wire_protocol/responses';
 import { MongoInvalidArgumentError } from '../error';
 import {
   decorateWithExplain,
@@ -9,11 +9,10 @@ import {
 } from '../explain';
 import { ReadConcern } from '../read_concern';
 import type { ReadPreference } from '../read_preference';
-import type { Server } from '../sdam/server';
-import { MIN_SECONDARY_WRITE_WIRE_VERSION } from '../sdam/server_selection';
+import type { ServerCommandOptions } from '../sdam/server';
 import type { ClientSession } from '../sessions';
 import { type TimeoutContext } from '../timeout';
-import { commandSupportsReadConcern, maxWireVersion, MongoDBNamespace } from '../utils';
+import { commandSupportsReadConcern, MongoDBNamespace } from '../utils';
 import { WriteConcern, type WriteConcernOptions } from '../write_concern';
 import type { ReadConcernLike } from './../read_concern';
 import { AbstractOperation, Aspect, type OperationOptions } from './operation';
@@ -117,69 +116,47 @@ export abstract class CommandOperation<T> extends AbstractOperation<T> {
     return super.canRetryWrite;
   }
 
-  public async executeCommand<T extends MongoDBResponseConstructor>(
-    server: Server,
-    session: ClientSession | undefined,
-    cmd: Document,
-    timeoutContext: TimeoutContext,
-    responseType: T | undefined
-  ): Promise<typeof responseType extends undefined ? Document : InstanceType<T>>;
-
-  public async executeCommand(
-    server: Server,
-    session: ClientSession | undefined,
-    cmd: Document,
-    timeoutContext: TimeoutContext
-  ): Promise<Document>;
-
-  async executeCommand(
-    server: Server,
-    session: ClientSession | undefined,
-    cmd: Document,
-    timeoutContext: TimeoutContext,
-    responseType?: MongoDBResponseConstructor
-  ): Promise<Document> {
-    this.server = server;
-
-    const options = {
+  abstract buildCommandDocument(connection: Connection, session?: ClientSession): Document;
+
+  override buildOptions(timeoutContext: TimeoutContext): ServerCommandOptions {
+    return {
       ...this.options,
       ...this.bsonOptions,
       timeoutContext,
       readPreference: this.readPreference,
-      session
+      session: this.session
     };
+  }
 
-    const serverWireVersion = maxWireVersion(server);
-    const inTransaction = this.session && this.session.inTransaction();
+  override buildCommand(connection: Connection, session?: ClientSession): Document {
+    const command = this.buildCommandDocument(connection, session);
 
-    if (this.readConcern && commandSupportsReadConcern(cmd) && !inTransaction) {
-      Object.assign(cmd, { readConcern: this.readConcern });
-    }
+    const inTransaction = this.session && this.session.inTransaction();
 
-    if (this.trySecondaryWrite && serverWireVersion < MIN_SECONDARY_WRITE_WIRE_VERSION) {
-      options.omitReadPreference = true;
+    if (this.readConcern && commandSupportsReadConcern(command) && !inTransaction) {
+      Object.assign(command, { readConcern: this.readConcern });
     }
 
     if (this.writeConcern && this.hasAspect(Aspect.WRITE_OPERATION) && !inTransaction) {
-      WriteConcern.apply(cmd, this.writeConcern);
+      WriteConcern.apply(command, this.writeConcern);
     }
 
     if (
-      options.collation &&
-      typeof options.collation === 'object' &&
+      this.options.collation &&
+      typeof this.options.collation === 'object' &&
       !this.hasAspect(Aspect.SKIP_COLLATION)
     ) {
-      Object.assign(cmd, { collation: options.collation });
+      Object.assign(command, { collation: this.options.collation });
     }
 
-    if (typeof options.maxTimeMS === 'number') {
-      cmd.maxTimeMS = options.maxTimeMS;
+    if (typeof this.options.maxTimeMS === 'number') {
+      command.maxTimeMS = this.options.maxTimeMS;
     }
 
     if (this.hasAspect(Aspect.EXPLAINABLE) && this.explain) {
-      cmd = decorateWithExplain(cmd, this.explain);
+      return decorateWithExplain(command, this.explain);
     }
 
-    return await server.command(this.ns, cmd, options, responseType);
+    return command;
   }
 }

package/src/operations/count.ts

@@ -1,8 +1,8 @@
+import { type Connection } from '..';
 import type { Document } from '../bson';
+import { MongoDBResponse } from '../cmap/wire_protocol/responses';
 import type { Collection } from '../collection';
-import type { Server } from '../sdam/server';
 import type { ClientSession } from '../sessions';
-import { type TimeoutContext } from '../timeout';
 import type { MongoDBNamespace } from '../utils';
 import { CommandOperation, type CommandOperationOptions } from './command';
 import { Aspect, defineAspects } from './operation';
@@ -23,6 +23,7 @@ export interface CountOptions extends CommandOperationOptions {
 
 /** @internal */
 export class CountOperation extends CommandOperation<number> {
+  override SERVER_COMMAND_RESPONSE_TYPE = MongoDBResponse;
   override options: CountOptions;
   collectionName?: string;
   query: Document;
@@ -39,11 +40,7 @@ export class CountOperation extends CommandOperation<number> {
     return 'count' as const;
   }
 
-  override async execute(
-    server: Server,
-    session: ClientSession | undefined,
-    timeoutContext: TimeoutContext
-  ): Promise<number> {
+  override buildCommandDocument(_connection: Connection, _session?: ClientSession): Document {
     const options = this.options;
     const cmd: Document = {
       count: this.collectionName,
@@ -66,8 +63,11 @@ export class CountOperation extends CommandOperation<number> {
       cmd.maxTimeMS = options.maxTimeMS;
     }
 
-    const result = await super.executeCommand(server, session, cmd, timeoutContext);
-    return result ? result.n : 0;
+    return cmd;
+  }
+
+  override handleOk(response: InstanceType<typeof this.SERVER_COMMAND_RESPONSE_TYPE>): number {
+    return response.getNumber('n') ?? 0;
   }
 }
 

package/src/operations/create_collection.ts

@@ -1,16 +1,19 @@
+import { type Connection } from '..';
 import type { Document } from '../bson';
 import {
   MIN_SUPPORTED_QE_SERVER_VERSION,
   MIN_SUPPORTED_QE_WIRE_VERSION
 } from '../cmap/wire_protocol/constants';
+import { MongoDBResponse } from '../cmap/wire_protocol/responses';
 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';
-import { type TimeoutContext } from '../timeout';
+import { TimeoutContext } from '../timeout';
+import { maxWireVersion } from '../utils';
 import { CommandOperation, type CommandOperationOptions } from './command';
+import { executeOperation } from './execute_operation';
 import { CreateIndexesOperation } from './indexes';
 import { Aspect, defineAspects } from './operation';
 
@@ -110,6 +113,7 @@ const INVALID_QE_VERSION =
 
 /** @internal */
 export class CreateCollectionOperation extends CommandOperation<Collection> {
+  override SERVER_COMMAND_RESPONSE_TYPE = MongoDBResponse;
   override options: CreateCollectionOptions;
   db: Db;
   name: string;
@@ -126,88 +130,92 @@ export class CreateCollectionOperation extends CommandOperation<Collection> {
     return 'create' as const;
   }
 
-  override async execute(
-    server: Server,
-    session: ClientSession | undefined,
-    timeoutContext: TimeoutContext
-  ): Promise<Collection> {
-    const db = this.db;
-    const name = this.name;
-    const options = this.options;
-
-    const encryptedFields: Document | undefined =
-      options.encryptedFields ??
-      db.client.s.options.autoEncryption?.encryptedFieldsMap?.[`${db.databaseName}.${name}`];
-
-    if (encryptedFields) {
-      // Creating a QE collection required min server of 7.0.0
-      // TODO(NODE-5353): Get wire version information from connection.
-      if (
-        !server.loadBalanced &&
-        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 ecocCollection = encryptedFields.ecocCollection ?? `enxcol_.${name}.ecoc`;
-
-      for (const collectionName of [escCollection, ecocCollection]) {
-        const createOp = new CreateCollectionOperation(db, collectionName, {
-          clusteredIndex: {
-            key: { _id: 1 },
-            unique: true
-          }
-        });
-        await createOp.executeWithoutEncryptedFieldsCheck(server, session, timeoutContext);
-      }
+  override buildCommandDocument(_connection: Connection, _session?: ClientSession): Document {
+    const isOptionValid = ([k, v]: [k: string, v: unknown]) =>
+      v != null && typeof v !== 'function' && !ILLEGAL_COMMAND_FIELDS.has(k);
+    return {
+      create: this.name,
+      ...Object.fromEntries(Object.entries(this.options).filter(isOptionValid))
+    };
+  }
+
+  override handleOk(
+    _response: InstanceType<typeof this.SERVER_COMMAND_RESPONSE_TYPE>
+  ): Collection<Document> {
+    return new Collection(this.db, this.name, this.options);
+  }
+}
 
-      if (!options.encryptedFields) {
-        this.options = { ...this.options, encryptedFields };
+export async function createCollections<TSchema extends Document>(
+  db: Db,
+  name: string,
+  options: CreateCollectionOptions
+): Promise<Collection<TSchema>> {
+  const timeoutContext = TimeoutContext.create({
+    session: options.session,
+    serverSelectionTimeoutMS: db.client.s.options.serverSelectionTimeoutMS,
+    waitQueueTimeoutMS: db.client.s.options.waitQueueTimeoutMS,
+    timeoutMS: options.timeoutMS
+  });
+
+  const encryptedFields: Document | undefined =
+    options.encryptedFields ??
+    db.client.s.options.autoEncryption?.encryptedFieldsMap?.[`${db.databaseName}.${name}`];
+
+  if (encryptedFields) {
+    class CreateSupportingFLEv2CollectionOperation extends CreateCollectionOperation {
+      override buildCommandDocument(connection: Connection, session?: ClientSession): Document {
+        if (
+          !connection.description.loadBalanced &&
+          maxWireVersion(connection) < MIN_SUPPORTED_QE_WIRE_VERSION
+        ) {
+          throw new MongoCompatibilityError(
+            `${INVALID_QE_VERSION} The minimum server version required is ${MIN_SUPPORTED_QE_SERVER_VERSION}`
+          );
+        }
+
+        return super.buildCommandDocument(connection, session);
       }
     }
 
-    const coll = await this.executeWithoutEncryptedFieldsCheck(server, session, timeoutContext);
-
-    if (encryptedFields) {
-      // Create the required index for queryable encryption support.
-      const createIndexOp = CreateIndexesOperation.fromIndexSpecification(
-        db,
-        name,
-        { __safeContent__: 1 },
-        {}
-      );
-      await createIndexOp.execute(server, session, timeoutContext);
+    // Create auxilliary collections for queryable encryption support.
+    const escCollection = encryptedFields.escCollection ?? `enxcol_.${name}.esc`;
+    const ecocCollection = encryptedFields.ecocCollection ?? `enxcol_.${name}.ecoc`;
+
+    for (const collectionName of [escCollection, ecocCollection]) {
+      const createOp = new CreateSupportingFLEv2CollectionOperation(db, collectionName, {
+        clusteredIndex: {
+          key: { _id: 1 },
+          unique: true
+        },
+        session: options.session
+      });
+      await executeOperation(db.client, createOp, timeoutContext);
     }
 
-    return coll;
+    if (!options.encryptedFields) {
+      options = { ...options, encryptedFields };
+    }
   }
 
-  private async executeWithoutEncryptedFieldsCheck(
-    server: Server,
-    session: ClientSession | undefined,
-    timeoutContext: TimeoutContext
-  ): Promise<Collection> {
-    const db = this.db;
-    const name = this.name;
-    const options = this.options;
-
-    const cmd: Document = { create: name };
-    for (const n in options) {
-      if (
-        (options as any)[n] != null &&
-        typeof (options as any)[n] !== 'function' &&
-        !ILLEGAL_COMMAND_FIELDS.has(n)
-      ) {
-        cmd[n] = (options as any)[n];
-      }
-    }
-    // otherwise just execute the command
-    await super.executeCommand(server, session, cmd, timeoutContext);
-    return new Collection(db, name, options);
+  const coll = await executeOperation(
+    db.client,
+    new CreateCollectionOperation(db, name, options),
+    timeoutContext
+  );
+
+  if (encryptedFields) {
+    // Create the required index for queryable encryption support.
+    const createIndexOp = CreateIndexesOperation.fromIndexSpecification(
+      db,
+      name,
+      { __safeContent__: 1 },
+      { session: options.session }
+    );
+    await executeOperation(db.client, createIndexOp, timeoutContext);
   }
+
+  return coll as unknown as Collection<TSchema>;
 }
 
 defineAspects(CreateCollectionOperation, [Aspect.WRITE_OPERATION]);