feat(NODE-5513)!: remove callbacks from ClientEncryption encrypt, decrypt, and createDataKey

Author: nbbeeken

src/client-side-encryption/client_encryption.ts

@@ -4,6 +4,7 @@ import type {
   MongoCryptConstructor,
   MongoCryptOptions
 } from 'mongodb-client-encryption';
+import { promisify } from 'util';
 
 import { type Binary, type Document, type Long, serialize } from '../bson';
 import { type AnyBulkWriteOperation, type BulkWriteResult } from '../bulk/common';
@@ -16,8 +17,7 @@ import { type MongoClient } from '../mongo_client';
 import { type Filter } from '../mongo_types';
 import { type CreateCollectionOptions } from '../operations/create_collection';
 import { type DeleteResult } from '../operations/delete';
-import { type Callback, MongoDBCollectionNamespace } from '../utils';
-import { maybeCallback, promiseOrCallback } from './common';
+import { MongoDBCollectionNamespace } from '../utils';
 import * as cryptoCallbacks from './crypto_callbacks';
 import {
   MongoCryptCreateDataKeyError,
@@ -125,18 +125,6 @@ export class ClientEncryption implements StateMachineExecutable {
    *
    * @example
    * ```ts
-   * // Using callbacks to create a local key
-   * clientEncryption.createDataKey('local', (err, dataKey) => {
-   *   if (err) {
-   *     // This means creating the key failed.
-   *   } else {
-   *     // key creation succeeded
-   *   }
-   * });
-   * ```
-   *
-   * @example
-   * ```ts
    * // Using async/await to create a local key
    * const dataKeyId = await clientEncryption.createDataKey('local');
    * ```
@@ -164,19 +152,10 @@ export class ClientEncryption implements StateMachineExecutable {
    * });
    * ```
    */
-  createDataKey(
+  async createDataKey(
     provider: KMSProvider,
-    options?: ClientEncryptionCreateDataKeyProviderOptions,
-    callback?: Callback<DataKey>
-  ) {
-    if (typeof options === 'function') {
-      callback = options;
-      options = {};
-    }
-    if (options == null) {
-      options = {};
-    }
-
+    options: ClientEncryptionCreateDataKeyProviderOptions = {}
+  ): Promise<Binary> {
     const dataKey = Object.assign({ provider }, options.masterKey);
 
     if (options.keyAltNames && !Array.isArray(options.keyAltNames)) {
@@ -213,8 +192,8 @@ export class ClientEncryption implements StateMachineExecutable {
       tlsOptions: this._tlsOptions
     });
 
-    // @ts-expect-error We did not convert promiseOrCallback to TS
-    return promiseOrCallback(callback, cb => {
+    return promisify<Binary>(callback => {
+      const cb: (err: any, result: Binary | null) => void = callback as any;
       stateMachine.execute<DataKey>(this, context, (err, dataKey) => {
         if (err || !dataKey) {
           cb(err, null);
@@ -238,7 +217,7 @@ export class ClientEncryption implements StateMachineExecutable {
             }
           );
       });
-    });
+    })();
   }
 
   /**
@@ -590,21 +569,7 @@ export class ClientEncryption implements StateMachineExecutable {
    *
    * @param value - The value that you wish to serialize. Must be of a type that can be serialized into BSON
    * @param options -
-   * @param callback - Optional callback to invoke when value is encrypted
-   * @returns If no callback is provided, returns a Promise that either resolves with the encrypted value, or rejects with an error. If a callback is provided, returns nothing.
-   *
-   * @example
-   * ```ts
-   * // Encryption with callback API
-   * function encryptMyData(value, callback) {
-   *   clientEncryption.createDataKey('local', (err, keyId) => {
-   *     if (err) {
-   *       return callback(err);
-   *     }
-   *     clientEncryption.encrypt(value, { keyId, algorithm: 'AEAD_AES_256_CBC_HMAC_SHA_512-Deterministic' }, callback);
-   *   });
-   * }
-   * ```
+   * @returns a Promise that either resolves with the encrypted value, or rejects with an error.
    *
    * @example
    * ```ts
@@ -624,12 +589,8 @@ export class ClientEncryption implements StateMachineExecutable {
    * }
    * ```
    */
-  encrypt(
-    value: unknown,
-    options: ClientEncryptionEncryptOptions,
-    callback: Callback<Binary>
-  ): Promise<Binary> | void {
-    return maybeCallback(() => this._encrypt(value, false, options), callback);
+  async encrypt(value: unknown, options: ClientEncryptionEncryptOptions): Promise<Binary> {
+    return this._encrypt(value, false, options);
   }
 
   /**
@@ -661,16 +622,7 @@ export class ClientEncryption implements StateMachineExecutable {
    * Explicitly decrypt a provided encrypted value
    *
    * @param value - An encrypted value
-   * @param callback - Optional callback to invoke when value is decrypted
-   * @returns If no callback is provided, returns a Promise that either resolves with the decrypted value, or rejects with an error. If a callback is provided, returns nothing.
-   *
-   * ```ts
-   * @example
-   * // Decrypting value with callback API
-   * function decryptMyValue(value, callback) {
-   *   clientEncryption.decrypt(value, callback);
-   * }
-   * ```
+   * @returns a Promise that either resolves with the decrypted value, or rejects with an error
    *
    * @example
    * ```ts
@@ -680,7 +632,7 @@ export class ClientEncryption implements StateMachineExecutable {
    * }
    * ```
    */
-  decrypt<T = any>(value: Binary, callback?: Callback<T>): Promise<T> | void {
+  async decrypt<T = any>(value: Binary): Promise<T> {
     const valueBuffer = serialize({ v: value });
     const context = this._mongoCrypt.makeExplicitDecryptionContext(valueBuffer);
 
@@ -689,8 +641,8 @@ export class ClientEncryption implements StateMachineExecutable {
       tlsOptions: this._tlsOptions
     });
 
-    // @ts-expect-error We did not convert promiseOrCallback to TS
-    return promiseOrCallback(callback, cb => {
+    return promisify<T>(callback => {
+      const cb: (error: Error | null | undefined, v: T | null) => void = callback as any;
       stateMachine.execute<{ v: T }>(this, context, (err, result) => {
         if (err || !result) {
           cb(err, null);
@@ -699,7 +651,7 @@ export class ClientEncryption implements StateMachineExecutable {
 
         cb(null, result.v);
       });
-    });
+    })();
   }
 
   /**

test/integration/client-side-encryption/client_side_encryption.prose.12.deadlock.test.ts

@@ -138,11 +138,8 @@ describe('Connection Pool Deadlock Prevention', function () {
       keyVaultClient: this.keyVaultClient,
       extraOptions: getEncryptExtraOptions()
     });
-    this.clientEncryption.encryptPromisified = util.promisify(
-      this.clientEncryption.encrypt.bind(this.clientEncryption)
-    );
 
-    this.ciphertext = await this.clientEncryption.encryptPromisified('string0', {
+    this.ciphertext = await this.clientEncryption.encrypt('string0', {
       algorithm: 'AEAD_AES_256_CBC_HMAC_SHA_512-Deterministic',
       keyAltName: 'local'
     });

test/integration/node-specific/client_encryption.test.ts

@@ -157,7 +157,7 @@ describe('ClientEncryption integration tests', function () {
       }
     );
 
-    it('should fail to create a data key if keyMaterial is wrong', metadata, function (done) {
+    it('should fail to create a data key if keyMaterial is wrong', metadata, async function () {
       const encryption = new ClientEncryption(client, {
         keyVaultNamespace: 'client.encryption',
         kmsProviders: { local: { key: 'A'.repeat(128) } }
@@ -166,13 +166,8 @@ describe('ClientEncryption integration tests', function () {
       const dataKeyOptions = {
         keyMaterial: new Binary(Buffer.alloc(97))
       };
-      try {
-        encryption.createDataKey('local', dataKeyOptions);
-        expect.fail('missed exception');
-      } catch (err) {
-        expect(err.message).to.equal('keyMaterial should have length 96, but has length 97');
-        done();
-      }
+      const error = await encryption.createDataKey('local', dataKeyOptions).catch(error => error);
+      expect(error.message).to.equal('keyMaterial should have length 96, but has length 97');
     });
 
     it(
@@ -536,23 +531,21 @@ describe('ClientEncryption integration tests', function () {
     }
 
     describe('errors', function () {
-      [42, 'hello', { keyAltNames: 'foobar' }, /foobar/].forEach(val => {
-        it(`should fail if typeof keyAltNames = ${typeof val}`, metadata, function () {
+      for (const val of [42, 'hello', { keyAltNames: 'foobar' }, /foobar/]) {
+        it(`should fail if typeof keyAltNames = ${typeof val}`, metadata, async function () {
           const options = makeOptions(val);
-          expect(() => clientEncryption.createDataKey('aws', options, () => undefined)).to.throw(
-            MongoCryptInvalidArgumentError
-          );
+          const error = await clientEncryption.createDataKey('aws', options).catch(error => error);
+          expect(error).to.be.instanceOf(MongoCryptInvalidArgumentError);
         });
-      });
+      }
 
-      [undefined, null, 42, { keyAltNames: 'foobar' }, ['foobar'], /foobar/].forEach(val => {
-        it(`should fail if typeof keyAltNames[x] = ${typeof val}`, metadata, function () {
+      for (const val of [undefined, null, 42, { keyAltNames: 'foobar' }, ['foobar'], /foobar/]) {
+        it(`should fail if typeof keyAltNames[x] = ${typeof val}`, metadata, async function () {
           const options = makeOptions([val]);
-          expect(() => clientEncryption.createDataKey('aws', options, () => undefined)).to.throw(
-            MongoCryptInvalidArgumentError
-          );
+          const error = await clientEncryption.createDataKey('aws', options).catch(error => error);
+          expect(error).to.be.instanceOf(MongoCryptInvalidArgumentError);
         });
-      });
+      }
     });
 
     it('should create a key with keyAltNames', metadata, async function () {