mongodb 5.0.1 → 5.2.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "mongodb",
-  "version": "5.0.1",
+  "version": "5.2.0",
   "description": "The official MongoDB driver for Node.js",
   "main": "lib/index.js",
   "files": [
@@ -25,7 +25,7 @@
     "email": "dbx-node@mongodb.com"
   },
   "dependencies": {
-    "bson": "^5.0.0",
+    "bson": "^5.2.0",
     "mongodb-connection-string-url": "^2.6.0",
     "socks": "^2.7.1"
   },
@@ -49,54 +49,53 @@
     }
   },
   "devDependencies": {
-    "@aws-sdk/credential-providers": "^3.201.0",
     "@iarna/toml": "^2.2.5",
     "@istanbuljs/nyc-config-typescript": "^1.0.2",
-    "@microsoft/api-extractor": "^7.33.7",
+    "@microsoft/api-extractor": "^7.34.4",
     "@microsoft/tsdoc-config": "^0.16.2",
-    "@mongodb-js/zstd": "^1.0.0",
-    "@types/chai": "^4.3.3",
+    "@mongodb-js/zstd": "^1.1.0",
+    "@types/chai": "^4.3.4",
     "@types/chai-subset": "^1.3.3",
-    "@types/express": "^4.17.14",
+    "@types/express": "^4.17.17",
     "@types/kerberos": "^1.1.1",
-    "@types/mocha": "^10.0.0",
-    "@types/node": "^18.11.0",
+    "@types/mocha": "^10.0.1",
+    "@types/node": "^18.11.19",
     "@types/saslprep": "^1.0.1",
-    "@types/semver": "^7.3.12",
+    "@types/semver": "^7.3.13",
     "@types/sinon": "^10.0.13",
-    "@types/sinon-chai": "^3.2.8",
+    "@types/sinon-chai": "^3.2.9",
     "@types/whatwg-url": "^11.0.0",
-    "@typescript-eslint/eslint-plugin": "^5.48.0",
-    "@typescript-eslint/parser": "^5.48.0",
-    "chai": "^4.3.6",
+    "@typescript-eslint/eslint-plugin": "^5.55.0",
+    "@typescript-eslint/parser": "^5.55.0",
+    "chai": "^4.3.7",
     "chai-subset": "^1.6.0",
     "chalk": "^4.1.2",
-    "eslint": "^8.31.0",
-    "eslint-config-prettier": "^8.5.0",
-    "eslint-plugin-import": "^2.26.0",
+    "eslint": "^8.36.0",
+    "eslint-config-prettier": "^8.7.0",
+    "eslint-plugin-import": "^2.27.5",
     "eslint-plugin-prettier": "^4.2.1",
-    "eslint-plugin-simple-import-sort": "^8.0.0",
+    "eslint-plugin-simple-import-sort": "^10.0.0",
     "eslint-plugin-tsdoc": "^0.2.17",
     "express": "^4.18.2",
     "js-yaml": "^4.1.0",
-    "mocha": "^9.2.2",
+    "mocha": "^10.2.0",
     "mocha-sinon": "^2.1.2",
-    "mongodb-legacy": "^4.0.0",
+    "mongodb-legacy": "^5.0.0",
     "nyc": "^15.1.0",
-    "prettier": "^2.7.1",
-    "rimraf": "^3.0.2",
+    "prettier": "^2.8.4",
     "semver": "^7.3.8",
-    "sinon": "^13.0.1",
+    "sinon": "^15.0.2",
     "sinon-chai": "^3.7.0",
     "snappy": "^7.2.2",
     "source-map-support": "^0.5.21",
     "standard-version": "^9.5.0",
     "ts-node": "^10.9.1",
-    "tsd": "^0.25.0",
-    "typescript": "^4.9.4",
+    "tsd": "^0.27.0",
+    "typescript": "^4.9.5",
     "typescript-cached-transpile": "^0.0.6",
+    "v8-heapsnapshot": "^1.2.0",
     "xml2js": "^0.4.23",
-    "yargs": "^17.6.0"
+    "yargs": "^17.7.1"
   },
   "license": "Apache-2.0",
   "engines": {
@@ -109,7 +108,7 @@
   "scripts": {
     "build:evergreen": "node .evergreen/generate_evergreen_tasks.js",
     "build:ts": "node ./node_modules/typescript/bin/tsc",
-    "build:dts": "npm run build:ts && api-extractor run && rimraf 'lib/**/*.d.ts*'",
+    "build:dts": "npm run build:ts && api-extractor run && node etc/clean_definition_files.cjs",
     "build:docs": "./etc/docs/build.ts",
     "build:typedoc": "typedoc",
     "check:bench": "node test/benchmarks/driverBench",
@@ -127,11 +126,12 @@
     "check:ts": "node ./node_modules/typescript/bin/tsc -v && node ./node_modules/typescript/bin/tsc --noEmit",
     "check:atlas": "mocha --config test/manual/mocharc.json test/manual/atlas_connectivity.test.js",
     "check:adl": "mocha --config test/mocha_mongodb.json test/manual/atlas-data-lake-testing",
-    "check:aws": "mocha --config test/mocha_mongodb.json test/integration/auth/mongodb_aws.test.ts",
+    "check:aws": "nyc mocha --config test/mocha_mongodb.json test/integration/auth/mongodb_aws.test.ts",
+    "check:oidc": "mocha --config test/manual/mocharc.json test/manual/mongodb_oidc.prose.test.ts",
     "check:ocsp": "mocha --config test/manual/mocharc.json test/manual/ocsp_support.test.js",
-    "check:kerberos": "mocha --config test/manual/mocharc.json test/manual/kerberos.test.js",
+    "check:kerberos": "nyc mocha --config test/manual/mocharc.json test/manual/kerberos.test.ts",
     "check:tls": "mocha --config test/manual/mocharc.json test/manual/tls_support.test.js",
-    "check:ldap": "mocha --config test/manual/mocharc.json test/manual/ldap.test.js",
+    "check:ldap": "nyc mocha --config test/manual/mocharc.json test/manual/ldap.test.js",
     "check:socks5": "mocha --config test/manual/mocharc.json test/manual/socks5.test.ts",
     "check:csfle": "mocha --config test/mocha_mongodb.json test/integration/client-side-encryption",
     "check:snappy": "mocha test/unit/assorted/snappy.test.js",

package/src/bson.ts

@@ -36,7 +36,6 @@ export interface BSONSerializeOptions
       | 'allowObjectSmallerThanBufferSize'
       | 'index'
       | 'validation'
-      | 'useBigInt64'
     > {
   /**
    * Enabling the raw option will return a [Node.js Buffer](https://nodejs.org/api/buffer.html)
@@ -67,6 +66,7 @@ export interface BSONSerializeOptions
 export function pluckBSONSerializeOptions(options: BSONSerializeOptions): BSONSerializeOptions {
   const {
     fieldsAsRaw,
+    useBigInt64,
     promoteValues,
     promoteBuffers,
     promoteLongs,
@@ -78,6 +78,7 @@ export function pluckBSONSerializeOptions(options: BSONSerializeOptions): BSONSe
   } = options;
   return {
     fieldsAsRaw,
+    useBigInt64,
     promoteValues,
     promoteBuffers,
     promoteLongs,
@@ -102,6 +103,7 @@ export function resolveBSONOptions(
   const parentOptions = parent?.bsonOptions;
   return {
     raw: options?.raw ?? parentOptions?.raw ?? false,
+    useBigInt64: options?.useBigInt64 ?? parentOptions?.useBigInt64 ?? false,
     promoteLongs: options?.promoteLongs ?? parentOptions?.promoteLongs ?? true,
     promoteValues: options?.promoteValues ?? parentOptions?.promoteValues ?? true,
     promoteBuffers: options?.promoteBuffers ?? parentOptions?.promoteBuffers ?? false,

package/src/bulk/common.ts

@@ -39,7 +39,7 @@ export const BatchType = Object.freeze({
 } as const);
 
 /** @public */
-export type BatchType = typeof BatchType[keyof typeof BatchType];
+export type BatchType = (typeof BatchType)[keyof typeof BatchType];
 
 /** @public */
 export interface InsertOneModel<TSchema extends Document = Document> {

package/src/change_stream.ts

@@ -74,7 +74,7 @@ export type ResumeToken = unknown;
 /**
  * Represents a specific point in time on a server. Can be retrieved by using `db.command()`
  * @public
- * @see https://docs.mongodb.com/manual/reference/method/db.runCommand/#response
+ * @see https://www.mongodb.com/docs/manual/reference/method/db.runCommand/#response
  */
 export type OperationTime = Timestamp;
 
@@ -82,7 +82,7 @@ export type OperationTime = Timestamp;
  * Options that can be passed to a ChangeStream. Note that startAfter, resumeAfter, and startAtOperationTime are all mutually exclusive, and the server will error if more than one is specified.
  * @public
  */
-export interface ChangeStreamOptions extends AggregateOptions {
+export interface ChangeStreamOptions extends Omit<AggregateOptions, 'writeConcern'> {
   /**
    * Allowed values: 'updateLookup', 'whenAvailable', 'required'.
    *
@@ -117,19 +117,19 @@ export interface ChangeStreamOptions extends AggregateOptions {
   maxAwaitTimeMS?: number;
   /**
    * Allows you to start a changeStream after a specified event.
-   * @see https://docs.mongodb.com/manual/changeStreams/#resumeafter-for-change-streams
+   * @see https://www.mongodb.com/docs/manual/changeStreams/#resumeafter-for-change-streams
    */
   resumeAfter?: ResumeToken;
   /**
    * Similar to resumeAfter, but will allow you to start after an invalidated event.
-   * @see https://docs.mongodb.com/manual/changeStreams/#startafter-for-change-streams
+   * @see https://www.mongodb.com/docs/manual/changeStreams/#startafter-for-change-streams
    */
   startAfter?: ResumeToken;
   /** Will start the changeStream after the specified operationTime. */
   startAtOperationTime?: OperationTime;
   /**
    * The number of documents to return per batch.
-   * @see https://docs.mongodb.com/manual/reference/command/aggregate
+   * @see https://www.mongodb.com/docs/manual/reference/command/aggregate
    */
   batchSize?: number;
 
@@ -533,7 +533,14 @@ export class ChangeStream<
   TChange extends Document = ChangeStreamDocument<TSchema>
 > extends TypedEventEmitter<ChangeStreamEvents<TSchema, TChange>> {
   pipeline: Document[];
-  options: ChangeStreamOptions;
+  /**
+   * @remarks WriteConcern can still be present on the options because
+   * we inherit options from the client/db/collection.  The
+   * key must be present on the options in order to delete it.
+   * This allows typescript to delete the key but will
+   * not allow a writeConcern to be assigned as a property on options.
+   */
+  options: ChangeStreamOptions & { writeConcern?: never };
   parent: MongoClient | Db | Collection;
   namespace: MongoDBNamespace;
   type: symbol;
@@ -576,7 +583,7 @@ export class ChangeStream<
    * @internal
    *
    * @param parent - The parent object that created this change stream
-   * @param pipeline - An array of {@link https://docs.mongodb.com/manual/reference/operator/aggregation-pipeline/|aggregation pipeline stages} through which to pass change stream documents
+   * @param pipeline - An array of {@link https://www.mongodb.com/docs/manual/reference/operator/aggregation-pipeline/|aggregation pipeline stages} through which to pass change stream documents
    */
   constructor(
     parent: OperationParent,
@@ -586,7 +593,8 @@ export class ChangeStream<
     super();
 
     this.pipeline = pipeline;
-    this.options = options;
+    this.options = { ...options };
+    delete this.options.writeConcern;
 
     if (parent instanceof Collection) {
       this.type = CHANGE_DOMAIN_TYPES.COLLECTION;

package/src/cmap/auth/auth_provider.ts

@@ -1,20 +1,22 @@
 import type { Document } from '../../bson';
 import { MongoRuntimeError } from '../../error';
-import type { Callback, ClientMetadataOptions } from '../../utils';
 import type { HandshakeDocument } from '../connect';
 import type { Connection, ConnectionOptions } from '../connection';
 import type { MongoCredentials } from './mongo_credentials';
 
-export type AuthContextOptions = ConnectionOptions & ClientMetadataOptions;
-
-/** Context used during authentication */
+/**
+ * Context used during authentication
+ * @internal
+ */
 export class AuthContext {
   /** The connection to authenticate */
   connection: Connection;
   /** The credentials to use for authentication */
   credentials?: MongoCredentials;
+  /** If the context is for reauthentication. */
+  reauthenticating = false;
   /** The options passed to the `connect` method */
-  options: AuthContextOptions;
+  options: ConnectionOptions;
 
   /** A response from an initial auth attempt, only some mechanisms use this (e.g, SCRAM) */
   response?: Document;
@@ -24,7 +26,7 @@ export class AuthContext {
   constructor(
     connection: Connection,
     credentials: MongoCredentials | undefined,
-    options: AuthContextOptions
+    options: ConnectionOptions
   ) {
     this.connection = connection;
     this.credentials = credentials;
@@ -32,29 +34,40 @@ export class AuthContext {
   }
 }
 
-export class AuthProvider {
+export abstract class AuthProvider {
   /**
    * Prepare the handshake document before the initial handshake.
    *
    * @param handshakeDoc - The document used for the initial handshake on a connection
    * @param authContext - Context for authentication flow
    */
-  prepare(
+  async prepare(
     handshakeDoc: HandshakeDocument,
-    authContext: AuthContext,
-    callback: Callback<HandshakeDocument>
-  ): void {
-    callback(undefined, handshakeDoc);
+    _authContext: AuthContext
+  ): Promise<HandshakeDocument> {
+    return handshakeDoc;
   }
 
   /**
    * Authenticate
    *
    * @param context - A shared context for authentication flow
-   * @param callback - The callback to return the result from the authentication
    */
-  auth(context: AuthContext, callback: Callback): void {
-    // TODO(NODE-3483): Replace this with MongoMethodOverrideError
-    callback(new MongoRuntimeError('`auth` method must be overridden by subclass'));
+  abstract auth(context: AuthContext): Promise<void>;
+
+  /**
+   * Reauthenticate.
+   * @param context - The shared auth context.
+   */
+  async reauth(context: AuthContext): Promise<void> {
+    if (context.reauthenticating) {
+      throw new MongoRuntimeError('Reauthentication already in progress.');
+    }
+    try {
+      context.reauthenticating = true;
+      await this.auth(context);
+    } finally {
+      context.reauthenticating = false;
+    }
   }
 }

package/src/cmap/auth/gssapi.ts

@@ -1,15 +1,9 @@
 import * as dns from 'dns';
 
-import type { Document } from '../../bson';
 import { Kerberos, KerberosClient } from '../../deps';
-import {
-  MongoError,
-  MongoInvalidArgumentError,
-  MongoMissingCredentialsError,
-  MongoMissingDependencyError,
-  MongoRuntimeError
-} from '../../error';
-import { Callback, ns } from '../../utils';
+import { MongoInvalidArgumentError, MongoMissingCredentialsError } from '../../error';
+import { ns } from '../../utils';
+import type { Connection } from '../connection';
 import { AuthContext, AuthProvider } from './auth_provider';
 
 /** @public */
@@ -23,7 +17,7 @@ export const GSSAPICanonicalizationValue = Object.freeze({
 
 /** @public */
 export type GSSAPICanonicalizationValue =
-  typeof GSSAPICanonicalizationValue[keyof typeof GSSAPICanonicalizationValue];
+  (typeof GSSAPICanonicalizationValue)[keyof typeof GSSAPICanonicalizationValue];
 
 type MechanismProperties = {
   CANONICALIZE_HOST_NAME?: GSSAPICanonicalizationValue;
@@ -32,70 +26,59 @@ type MechanismProperties = {
   SERVICE_REALM?: string;
 };
 
+async function externalCommand(
+  connection: Connection,
+  command: ReturnType<typeof saslStart> | ReturnType<typeof saslContinue>
+): Promise<{ payload: string; conversationId: any }> {
+  return connection.commandAsync(ns('$external.$cmd'), command, undefined) as Promise<{
+    payload: string;
+    conversationId: any;
+  }>;
+}
+
 export class GSSAPI extends AuthProvider {
-  override auth(authContext: AuthContext, callback: Callback): void {
+  override async auth(authContext: AuthContext): Promise<void> {
     const { connection, credentials } = authContext;
-    if (credentials == null)
-      return callback(
-        new MongoMissingCredentialsError('Credentials required for GSSAPI authentication')
-      );
-    const { username } = credentials;
-    function externalCommand(
-      command: Document,
-      cb: Callback<{ payload: string; conversationId: any }>
-    ) {
-      return connection.command(ns('$external.$cmd'), command, undefined, cb);
+    if (credentials == null) {
+      throw new MongoMissingCredentialsError('Credentials required for GSSAPI authentication');
     }
-    makeKerberosClient(authContext, (err, client) => {
-      if (err) return callback(err);
-      if (client == null) return callback(new MongoMissingDependencyError('GSSAPI client missing'));
-      client.step('', (err, payload) => {
-        if (err) return callback(err);
-
-        externalCommand(saslStart(payload), (err, result) => {
-          if (err) return callback(err);
-          if (result == null) return callback();
-          negotiate(client, 10, result.payload, (err, payload) => {
-            if (err) return callback(err);
-
-            externalCommand(saslContinue(payload, result.conversationId), (err, result) => {
-              if (err) return callback(err);
-              if (result == null) return callback();
-              finalize(client, username, result.payload, (err, payload) => {
-                if (err) return callback(err);
-
-                externalCommand(
-                  {
-                    saslContinue: 1,
-                    conversationId: result.conversationId,
-                    payload
-                  },
-                  (err, result) => {
-                    if (err) return callback(err);
-
-                    callback(undefined, result);
-                  }
-                );
-              });
-            });
-          });
-        });
-      });
+
+    const { username } = credentials;
+
+    const client = await makeKerberosClient(authContext);
+
+    const payload = await client.step('');
+
+    const saslStartResponse = await externalCommand(connection, saslStart(payload));
+
+    const negotiatedPayload = await negotiate(client, 10, saslStartResponse.payload);
+
+    const saslContinueResponse = await externalCommand(
+      connection,
+      saslContinue(negotiatedPayload, saslStartResponse.conversationId)
+    );
+
+    const finalizePayload = await finalize(client, username, saslContinueResponse.payload);
+
+    await externalCommand(connection, {
+      saslContinue: 1,
+      conversationId: saslContinueResponse.conversationId,
+      payload: finalizePayload
     });
   }
 }
 
-function makeKerberosClient(authContext: AuthContext, callback: Callback<KerberosClient>): void {
+async function makeKerberosClient(authContext: AuthContext): Promise<KerberosClient> {
   const { hostAddress } = authContext.options;
   const { credentials } = authContext;
   if (!hostAddress || typeof hostAddress.host !== 'string' || !credentials) {
-    return callback(
-      new MongoInvalidArgumentError('Connection must have host and port and credentials defined.')
+    throw new MongoInvalidArgumentError(
+      'Connection must have host and port and credentials defined.'
     );
   }
 
   if ('kModuleError' in Kerberos) {
-    return callback(Kerberos['kModuleError']);
+    throw Kerberos['kModuleError'];
   }
   const { initializeClient } = Kerberos;
 
@@ -104,95 +87,71 @@ function makeKerberosClient(authContext: AuthContext, callback: Callback<Kerbero
 
   const serviceName = mechanismProperties.SERVICE_NAME ?? 'mongodb';
 
-  performGSSAPICanonicalizeHostName(
-    hostAddress.host,
-    mechanismProperties,
-    (err?: Error | MongoError, host?: string) => {
-      if (err) return callback(err);
-
-      const initOptions = {};
-      if (password != null) {
-        Object.assign(initOptions, { user: username, password: password });
-      }
-
-      const spnHost = mechanismProperties.SERVICE_HOST ?? host;
-      let spn = `${serviceName}${process.platform === 'win32' ? '/' : '@'}${spnHost}`;
-      if ('SERVICE_REALM' in mechanismProperties) {
-        spn = `${spn}@${mechanismProperties.SERVICE_REALM}`;
-      }
-
-      initializeClient(spn, initOptions, (err: string, client: KerberosClient): void => {
-        // TODO(NODE-3483)
-        if (err) return callback(new MongoRuntimeError(err));
-        callback(undefined, client);
-      });
-    }
-  );
+  const host = await performGSSAPICanonicalizeHostName(hostAddress.host, mechanismProperties);
+
+  const initOptions = {};
+  if (password != null) {
+    // TODO(NODE-5139): These do not match the typescript options in initializeClient
+    Object.assign(initOptions, { user: username, password: password });
+  }
+
+  const spnHost = mechanismProperties.SERVICE_HOST ?? host;
+  let spn = `${serviceName}${process.platform === 'win32' ? '/' : '@'}${spnHost}`;
+  if ('SERVICE_REALM' in mechanismProperties) {
+    spn = `${spn}@${mechanismProperties.SERVICE_REALM}`;
+  }
+
+  return initializeClient(spn, initOptions);
 }
 
-function saslStart(payload?: string): Document {
+function saslStart(payload: string) {
   return {
     saslStart: 1,
     mechanism: 'GSSAPI',
     payload,
     autoAuthorize: 1
-  };
+  } as const;
 }
 
-function saslContinue(payload?: string, conversationId?: number): Document {
+function saslContinue(payload: string, conversationId: number) {
   return {
     saslContinue: 1,
     conversationId,
     payload
-  };
+  } as const;
 }
 
-function negotiate(
+async function negotiate(
   client: KerberosClient,
   retries: number,
-  payload: string,
-  callback: Callback<string>
-): void {
-  client.step(payload, (err, response) => {
-    // Retries exhausted, raise error
-    if (err && retries === 0) return callback(err);
-
+  payload: string
+): Promise<string> {
+  try {
+    const response = await client.step(payload);
+    return response || '';
+  } catch (error) {
+    if (retries === 0) {
+      // Retries exhausted, raise error
+      throw error;
+    }
     // Adjust number of retries and call step again
-    if (err) return negotiate(client, retries - 1, payload, callback);
-
-    // Return the payload
-    callback(undefined, response || '');
-  });
+    return negotiate(client, retries - 1, payload);
+  }
 }
 
-function finalize(
-  client: KerberosClient,
-  user: string,
-  payload: string,
-  callback: Callback<string>
-): void {
+async function finalize(client: KerberosClient, user: string, payload: string): Promise<string> {
   // GSS Client Unwrap
-  client.unwrap(payload, (err, response) => {
-    if (err) return callback(err);
-
-    // Wrap the response
-    client.wrap(response || '', { user }, (err, wrapped) => {
-      if (err) return callback(err);
-
-      // Return the payload
-      callback(undefined, wrapped);
-    });
-  });
+  const response = await client.unwrap(payload);
+  return client.wrap(response || '', { user });
 }
 
-export function performGSSAPICanonicalizeHostName(
+export async function performGSSAPICanonicalizeHostName(
   host: string,
-  mechanismProperties: MechanismProperties,
-  callback: Callback<string>
-): void {
+  mechanismProperties: MechanismProperties
+): Promise<string> {
   const mode = mechanismProperties.CANONICALIZE_HOST_NAME;
   if (!mode || mode === GSSAPICanonicalizationValue.none) {
-    return callback(undefined, host);
+    return host;
   }
 
   // If forward and reverse or true
@@ -201,39 +160,33 @@ export function performGSSAPICanonicalizeHostName(
     mode === GSSAPICanonicalizationValue.forwardAndReverse
   ) {
     // Perform the lookup of the ip address.
-    dns.lookup(host, (error, address) => {
-      // No ip found, return the error.
-      if (error) return callback(error);
+    const { address } = await dns.promises.lookup(host);
 
+    try {
       // Perform a reverse ptr lookup on the ip address.
-      dns.resolvePtr(address, (err, results) => {
-        // This can error as ptr records may not exist for all ips. In this case
-        // fallback to a cname lookup as dns.lookup() does not return the
-        // cname.
-        if (err) {
-          return resolveCname(host, callback);
-        }
-        // If the ptr did not error but had no results, return the host.
-        callback(undefined, results.length > 0 ? results[0] : host);
-      });
-    });
+      const results = await dns.promises.resolvePtr(address);
+      // If the ptr did not error but had no results, return the host.
+      return results.length > 0 ? results[0] : host;
+    } catch (error) {
+      // This can error as ptr records may not exist for all ips. In this case
+      // fallback to a cname lookup as dns.lookup() does not return the
+      // cname.
+      return resolveCname(host);
+    }
   } else {
     // The case for forward is just to resolve the cname as dns.lookup()
     // will not return it.
-    resolveCname(host, callback);
+    return resolveCname(host);
   }
 }
 
-export function resolveCname(host: string, callback: Callback<string>): void {
+export async function resolveCname(host: string): Promise<string> {
   // Attempt to resolve the host name
-  dns.resolveCname(host, (err, r) => {
-    if (err) return callback(undefined, host);
-
-    // Get the first resolve host id
-    if (r.length > 0) {
-      return callback(undefined, r[0]);
-    }
-
-    callback(undefined, host);
-  });
+  try {
+    const results = await dns.promises.resolveCname(host);
+    // Get the first resolved host id
+    return results.length > 0 ? results[0] : host;
+  } catch {
+    return host;
+  }
 }