refactor(NODE-5437): admin operations to use async syntax (#3773)

Author: malikj2000

src/operations/add_user.ts

@@ -6,7 +6,7 @@ import { MongoInvalidArgumentError } from '../error';
 import type { Server } from '../sdam/server';
 import type { ClientSession } from '../sessions';
 import { type Callback, emitWarningOnce, getTopology } from '../utils';
-import { CommandCallbackOperation, type CommandOperationOptions } from './command';
+import { CommandOperation, type CommandOperationOptions } from './command';
 import { Aspect, defineAspects } from './operation';
 
 /**
@@ -35,7 +35,7 @@ export interface AddUserOptions extends CommandOperationOptions {
 }
 
 /** @internal */
-export class AddUserOperation extends CommandCallbackOperation<Document> {
+export class AddUserOperation extends CommandOperation<Document> {
   override options: AddUserOptions;
   db: Db;
   username: string;
@@ -50,11 +50,7 @@ export class AddUserOperation extends CommandCallbackOperation<Document> {
     this.options = options ?? {};
   }
 
-  override executeCallback(
-    server: Server,
-    session: ClientSession | undefined,
-    callback: Callback<Document>
-  ): void {
+  override execute(server: Server, session: ClientSession | undefined): Promise<Document> {
     const db = this.db;
     const username = this.username;
     const password = this.password;
@@ -64,10 +60,8 @@ export class AddUserOperation extends CommandCallbackOperation<Document> {
     // v5 removed the digestPassword option from AddUserOptions but we still want to throw
     // an error when digestPassword is provided.
     if ('digestPassword' in options && options.digestPassword != null) {
-      return callback(
-        new MongoInvalidArgumentError(
-          'Option "digestPassword" not supported via addUser, use db.command(...) instead'
-        )
+      throw new MongoInvalidArgumentError(
+        'Option "digestPassword" not supported via addUser, use db.command(...) instead'
       );
     }
 
@@ -85,12 +79,7 @@ export class AddUserOperation extends CommandCallbackOperation<Document> {
       roles = Array.isArray(options.roles) ? options.roles : [options.roles];
     }
 
-    let topology;
-    try {
-      topology = getTopology(db);
-    } catch (error) {
-      return callback(error);
-    }
+    const topology = getTopology(db);
 
     const digestPassword = topology.lastHello().maxWireVersion >= 7;
 
@@ -117,7 +106,11 @@ export class AddUserOperation extends CommandCallbackOperation<Document> {
       command.pwd = userPassword;
     }
 
-    super.executeCommandCallback(server, session, command, callback);
+    return super.executeCommand(server, session, command);
+  }
+
+  executeCallback(_server: Server, _session: ClientSession | undefined, _callback: Callback): void {
+    throw new Error('Method not implemented');
   }
 }
 

src/operations/create_collection.ts

@@ -9,8 +9,8 @@ import { MongoCompatibilityError } from '../error';
 import type { PkFactory } from '../mongo_client';
 import type { Server } from '../sdam/server';
 import type { ClientSession } from '../sessions';
-import type { Callback } from '../utils';
-import { CommandCallbackOperation, type CommandOperationOptions } from './command';
+import { type Callback } from '../utils';
+import { CommandOperation, type CommandOperationOptions } from './command';
 import { CreateIndexOperation } from './indexes';
 import { Aspect, defineAspects } from './operation';
 
@@ -108,7 +108,7 @@ const INVALID_QE_VERSION =
   'Driver support of Queryable Encryption is incompatible with server. Upgrade server to use Queryable Encryption.';
 
 /** @internal */
-export class CreateCollectionOperation extends CommandCallbackOperation<Collection> {
+export class CreateCollectionOperation extends CommandOperation<Collection> {
   override options: CreateCollectionOptions;
   db: Db;
   name: string;
@@ -121,96 +121,85 @@ export class CreateCollectionOperation extends CommandCallbackOperation<Collecti
     this.name = name;
   }
 
-  override executeCallback(
-    server: Server,
-    session: ClientSession | undefined,
-    callback: Callback<Collection>
-  ): void {
-    (async () => {
-      const db = this.db;
-      const name = this.name;
-      const options = this.options;
-
-      const encryptedFields: Document | undefined =
-        options.encryptedFields ??
-        db.client.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);
-        }
-
-        if (!options.encryptedFields) {
-          this.options = { ...this.options, encryptedFields };
-        }
+  override async execute(server: Server, session: ClientSession | undefined): Promise<Collection> {
+    const db = this.db;
+    const name = this.name;
+    const options = this.options;
+
+    const encryptedFields: Document | undefined =
+      options.encryptedFields ??
+      db.client.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);
       }
 
-      const coll = await this.executeWithoutEncryptedFieldsCheck(server, session);
-
-      if (encryptedFields) {
-        // Create the required index for queryable encryption support.
-        const createIndexOp = new CreateIndexOperation(db, name, { __safeContent__: 1 }, {});
-        await createIndexOp.execute(server, session);
+      if (!options.encryptedFields) {
+        this.options = { ...this.options, encryptedFields };
       }
+    }
+
+    const coll = await this.executeWithoutEncryptedFieldsCheck(server, session);
 
-      return coll;
-    })().then(
-      coll => callback(undefined, coll),
-      err => callback(err)
-    );
+    if (encryptedFields) {
+      // Create the required index for queryable encryption support.
+      const createIndexOp = new CreateIndexOperation(db, name, { __safeContent__: 1 }, {});
+      await createIndexOp.execute(server, session);
+    }
+
+    return coll;
   }
 
-  private executeWithoutEncryptedFieldsCheck(
+  protected executeCallback(
+    _server: Server,
+    _session: ClientSession | undefined,
+    _callback: Callback<Collection>
+  ): void {
+    throw new Error('Method not implemented.');
+  }
+
+  private async executeWithoutEncryptedFieldsCheck(
     server: Server,
     session: ClientSession | undefined
   ): Promise<Collection> {
-    return new Promise<Collection>((resolve, reject) => {
-      const db = this.db;
-      const name = this.name;
-      const options = this.options;
-
-      const done: Callback = err => {
-        if (err) {
-          return reject(err);
-        }
-
-        resolve(new Collection(db, name, 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];
-        }
+    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
-      super.executeCommandCallback(server, session, cmd, done);
-    });
+    }
+    // otherwise just execute the command
+    await super.executeCommand(server, session, cmd);
+    return new Collection(db, name, options);
   }
 }