feat: make krb and zstd lazy

Author: durran

src/cmap/auth/gssapi.ts

@@ -1,6 +1,6 @@
 import * as dns from 'dns';
 
-import { Kerberos, KerberosClient } from '../../deps';
+import { getKerberos, Kerberos, KerberosClient } from '../../deps';
 import { MongoInvalidArgumentError, MongoMissingCredentialsError } from '../../error';
 import { ns } from '../../utils';
 import type { Connection } from '../connection';
@@ -36,6 +36,8 @@ async function externalCommand(
   }>;
 }
 
+let krb: typeof Kerberos;
+
 export class GSSAPI extends AuthProvider {
   override async auth(authContext: AuthContext): Promise<void> {
     const { connection, credentials } = authContext;
@@ -77,10 +79,11 @@ async function makeKerberosClient(authContext: AuthContext): Promise<KerberosCli
     );
   }
 
-  if ('kModuleError' in Kerberos) {
-    throw Kerberos['kModuleError'];
+  loadKrb();
+  if ('kModuleError' in krb) {
+    throw krb['kModuleError'];
   }
-  const { initializeClient } = Kerberos;
+  const { initializeClient } = krb;
 
   const { username, password } = credentials;
   const mechanismProperties = credentials.mechanismProperties as MechanismProperties;
@@ -190,3 +193,12 @@ export async function resolveCname(host: string): Promise<string> {
     return host;
   }
 }
+
+/**
+ * Load the Kerberos library.
+ */
+function loadKrb() {
+  if (!krb) {
+    krb = getKerberos();
+  }
+}

src/cmap/wire_protocol/compression.ts

@@ -2,7 +2,7 @@ import { promisify } from 'util';
 import * as zlib from 'zlib';
 
 import { LEGACY_HELLO_COMMAND } from '../../constants';
-import { Snappy, ZStandard } from '../../deps';
+import { getZstdLibrary, Snappy, ZStandard } from '../../deps';
 import { MongoDecompressionError, MongoInvalidArgumentError } from '../../error';
 
 /** @public */
@@ -37,35 +37,39 @@ const ZSTD_COMPRESSION_LEVEL = 3;
 const zlibInflate = promisify(zlib.inflate.bind(zlib));
 const zlibDeflate = promisify(zlib.deflate.bind(zlib));
 
+let zstd: typeof ZStandard;
+
 // Facilitate compressing a message using an agreed compressor
 export async function compress(
   options: { zlibCompressionLevel: number; agreedCompressor: CompressorName },
   dataToBeCompressed: Buffer
 ): Promise<Buffer> {
   const zlibOptions = {} as zlib.ZlibOptions;
   switch (options.agreedCompressor) {
-    case 'snappy':
+    case 'snappy': {
       if ('kModuleError' in Snappy) {
         throw Snappy['kModuleError'];
       }
       return Snappy.compress(dataToBeCompressed);
-
-    case 'zstd':
-      if ('kModuleError' in ZStandard) {
-        throw ZStandard['kModuleError'];
+    }
+    case 'zstd': {
+      loadZstd();
+      if ('kModuleError' in zstd) {
+        throw zstd['kModuleError'];
       }
-      return ZStandard.compress(dataToBeCompressed, ZSTD_COMPRESSION_LEVEL);
-
-    case 'zlib':
+      return zstd.compress(dataToBeCompressed, ZSTD_COMPRESSION_LEVEL);
+    }
+    case 'zlib': {
       if (options.zlibCompressionLevel) {
         zlibOptions.level = options.zlibCompressionLevel;
       }
       return zlibDeflate(dataToBeCompressed, zlibOptions);
-
-    default:
+    }
+    default: {
       throw new MongoInvalidArgumentError(
         `Unknown compressor ${options.agreedCompressor} failed to compress`
       );
+    }
   }
 }
 
@@ -83,22 +87,33 @@ export async function decompress(compressorID: number, compressedData: Buffer):
   }
 
   switch (compressorID) {
-    case Compressor.snappy:
+    case Compressor.snappy: {
       if ('kModuleError' in Snappy) {
         throw Snappy['kModuleError'];
       }
       return Snappy.uncompress(compressedData, { asBuffer: true });
-
-    case Compressor.zstd:
-      if ('kModuleError' in ZStandard) {
-        throw ZStandard['kModuleError'];
+    }
+    case Compressor.zstd: {
+      loadZstd();
+      if ('kModuleError' in zstd) {
+        throw zstd['kModuleError'];
       }
-      return ZStandard.decompress(compressedData);
-
-    case Compressor.zlib:
+      return zstd.decompress(compressedData);
+    }
+    case Compressor.zlib: {
       return zlibInflate(compressedData);
-
-    default:
+    }
+    default: {
       return compressedData;
+    }
+  }
+}
+
+/**
+ * Load ZStandard if it is not already set.
+ */
+function loadZstd() {
+  if (!zstd) {
+    zstd = getZstdLibrary();
   }
 }

src/deps.ts

@@ -28,10 +28,15 @@ export let Kerberos: typeof import('kerberos') | { kModuleError: MongoMissingDep
     )
   );
 
-try {
-  // Ensure you always wrap an optional require in the try block NODE-3199
-  Kerberos = require('kerberos');
-} catch {} // eslint-disable-line
+export function getKerberos(): typeof Kerberos | { kModuleError: MongoMissingDependencyError } {
+  try {
+    // Ensure you always wrap an optional require in the try block NODE-3199
+    Kerberos = require('kerberos');
+    return Kerberos;
+  } catch {
+    return Kerberos;
+  }
+}
 
 export interface KerberosClient {
   step(challenge: string): Promise<string>;
@@ -62,9 +67,14 @@ export let ZStandard: ZStandardLib | { kModuleError: MongoMissingDependencyError
     )
   );
 
-try {
-  ZStandard = require('@mongodb-js/zstd');
-} catch {} // eslint-disable-line
+export function getZstdLibrary(): typeof ZStandard | { kModuleError: MongoMissingDependencyError } {
+  try {
+    ZStandard = require('@mongodb-js/zstd');
+    return ZStandard;
+  } catch {
+    return ZStandard;
+  }
+}
 
 type CredentialProvider = {
   fromNodeProviderChain(this: void): () => Promise<AWSCredentials>;