fix(NODE-4977): load snappy lazily (#3726)

Co-authored-by: Durran Jordan <durran@gmail.com>

Author: nbbeeken

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 { getZstdLibrary, Snappy, type ZStandard } from '../../deps';
+import { getSnappy, getZstdLibrary, type SnappyLib, type ZStandard } from '../../deps';
 import { MongoDecompressionError, MongoInvalidArgumentError } from '../../error';
 
 /** @public */
@@ -38,6 +38,17 @@ const zlibInflate = promisify(zlib.inflate.bind(zlib));
 const zlibDeflate = promisify(zlib.deflate.bind(zlib));
 
 let zstd: typeof ZStandard;
+let Snappy: SnappyLib | null = null;
+function loadSnappy() {
+ if (Snappy == null) {
+ const snappyImport = getSnappy();
+ if ('kModuleError' in snappyImport) {
+ throw snappyImport.kModuleError;
+ }
+ Snappy = snappyImport;
+ }
+ return Snappy;
+}
 
 // Facilitate compressing a message using an agreed compressor
 export async function compress(
@@ -47,9 +58,7 @@ export async function compress(
  const zlibOptions = {} as zlib.ZlibOptions;
  switch (options.agreedCompressor) {
  case 'snappy': {
- if ('kModuleError' in Snappy) {
- throw Snappy['kModuleError'];
- }
+ Snappy ??= loadSnappy();
  return Snappy.compress(dataToBeCompressed);
  }
  case 'zstd': {
@@ -88,9 +97,7 @@ export async function decompress(compressorID: number, compressedData: Buffer):
 
  switch (compressorID) {
  case Compressor.snappy: {
- if ('kModuleError' in Snappy) {
- throw Snappy['kModuleError'];
- }
+ Snappy ??= loadSnappy();
  return Snappy.uncompress(compressedData, { asBuffer: true });
  }
  case Compressor.zstd: {

src/deps.ts

@@ -97,7 +97,8 @@ export function getAwsCredentialProvider():
  }
 }
 
-type SnappyLib = {
+/** @internal */
+export type SnappyLib = {
  /**
  * In order to support both we must check the return value of the function
  * @param buf - Buffer to be compressed
@@ -111,16 +112,19 @@ type SnappyLib = {
  uncompress(buf: Buffer, opt: { asBuffer: true }): Promise<Buffer>;
 };
 
-export let Snappy: SnappyLib | { kModuleError: MongoMissingDependencyError } = makeErrorModule(
- new MongoMissingDependencyError(
- 'Optional module `snappy` not found. Please install it to enable snappy compression'
- )
-);
-
-try {
- // Ensure you always wrap an optional require in the try block NODE-3199
- Snappy = require('snappy');
-} catch {} // eslint-disable-line
+export function getSnappy(): SnappyLib | { kModuleError: MongoMissingDependencyError } {
+ try {
+ // Ensure you always wrap an optional require in the try block NODE-3199
+ const value = require('snappy');
+ return value;
+ } catch (cause) {
+ const kModuleError = new MongoMissingDependencyError(
+ 'Optional module `snappy` not found. Please install it to enable snappy compression',
+ { cause }
+ );
+ return { kModuleError };
+ }
+}
 
 export let saslprep: typeof import('saslprep') | { kModuleError: MongoMissingDependencyError } =
  makeErrorModule(

src/error.ts

@@ -692,8 +692,9 @@ export class MongoMissingCredentialsError extends MongoAPIError {
  * @category Error
  */
 export class MongoMissingDependencyError extends MongoAPIError {
- constructor(message: string) {
+ constructor(message: string, { cause }: { cause?: Error } = {}) {
  super(message);
+ if (cause) this.cause = cause;
  }
 
  override get name(): string {

test/action/dependency.test.ts

@@ -5,6 +5,7 @@ import * as path from 'node:path';
 import { expect } from 'chai';
 
 import { dependencies, peerDependencies, peerDependenciesMeta } from '../../package.json';
+import { itInNodeProcess } from '../tools/utils';
 
 const EXPECTED_DEPENDENCIES = ['bson', 'mongodb-connection-string-url', 'socks'];
 const EXPECTED_PEER_DEPENDENCIES = [
@@ -65,11 +66,24 @@ describe('package.json', function () {
 
  expect(result).to.include('import success!');
  });
+
+ if (depName === 'snappy') {
+ itInNodeProcess(
+ 'getSnappy returns rejected import',
+ async function ({ expect, mongodb }) {
+ const snappyImport = mongodb.getSnappy();
+ expect(snappyImport).to.have.nested.property(
+ 'kModuleError.name',
+ 'MongoMissingDependencyError'
+ );
+ }
+ );
+ }
  });
 
  context(`when ${depName} is installed`, () => {
  beforeEach(async () => {
- execSync(`npm install --no-save "${depName}"@${depMajor}`);
+ execSync(`npm install --no-save "${depName}"@"${depMajor}"`);
  });
 
  it(`driver is importable`, () => {
@@ -81,7 +95,66 @@ describe('package.json', function () {
 
  expect(result).to.include('import success!');
  });
+
+ if (depName === 'snappy') {
+ itInNodeProcess(
+ 'getSnappy returns fulfilled import',
+ async function ({ expect, mongodb }) {
+ const snappyImport = mongodb.getSnappy();
+ expect(snappyImport).to.have.property('compress').that.is.a('function');
+ expect(snappyImport).to.have.property('uncompress').that.is.a('function');
+ }
+ );
+ }
  });
  }
  });
+
+ const EXPECTED_IMPORTS = [
+ 'bson',
+ 'saslprep',
+ 'sparse-bitfield',
+ 'memory-pager',
+ 'mongodb-connection-string-url',
+ 'whatwg-url',
+ 'webidl-conversions',
+ 'tr46',
+ 'socks',
+ 'ip',
+ 'smart-buffer'
+ ];
+
+ describe('mongodb imports', () => {
+ let imports: string[];
+ beforeEach(async function () {
+ for (const key of Object.keys(require.cache)) delete require.cache[key];
+ require('../../src');
+ imports = Array.from(
+ new Set(
+ Object.entries(require.cache)
+ .filter(([modKey]) => modKey.includes('/node_modules/'))
+ .map(([modKey]) => {
+ const leadingPkgName = modKey.split('/node_modules/')[1];
+ const [orgName, pkgName] = leadingPkgName.split('/');
+ if (orgName.startsWith('@')) {
+ return `${orgName}/${pkgName}`;
+ }
+ return orgName;
+ })
+ )
+ );
+ });
+
+ context('when importing mongodb', () => {
+ it('only contains the expected imports', function () {
+ expect(imports).to.deep.equal(EXPECTED_IMPORTS);
+ });
+
+ it('does not import optional dependencies', () => {
+ for (const peerDependency of EXPECTED_PEER_DEPENDENCIES) {
+ expect(imports).to.not.include(peerDependency);
+ }
+ });
+ });
+ });
 });

test/tools/utils.ts

@@ -1,3 +1,8 @@
+import * as child_process from 'node:child_process';
+import { once } from 'node:events';
+import * as fs from 'node:fs/promises';
+import * as path from 'node:path';
+
 import { EJSON } from 'bson';
 import * as BSON from 'bson';
 import { expect } from 'chai';
@@ -499,3 +504,63 @@ export function topologyWithPlaceholderClient(
  options as TopologyOptions
  );
 }
+
+export async function itInNodeProcess(
+ title: string,
+ fn: (d: { expect: typeof import('chai').expect; mongodb: typeof import('../mongodb') }) => void
+) {
+ it(title, async () => {
+ const script = `
+ import { expect } from 'chai';
+ import * as mongodb from './test/mongodb';
+ const run = ${fn};
+ run({ expect, mongodb }).then(
+ () => {
+ process.exitCode = 0;
+ },
+ error => {
+ console.error(error)
+ process.exitCode = 1;
+ }
+ );\n`;
+
+ const scriptName = `./testing_${title.split(/\s/).join('_')}_script.cts`;
+ const cwd = path.resolve(__dirname, '..', '..');
+ const tsNode = path.resolve(__dirname, '..', '..', 'node_modules', '.bin', 'ts-node');
+ try {
+ await fs.writeFile(scriptName, script, { encoding: 'utf8' });
+ const scriptInstance = child_process.fork(scriptName, {
+ signal: AbortSignal.timeout(50_000),
+ cwd,
+ stdio: 'pipe',
+ execArgv: [tsNode]
+ });
+
+ scriptInstance.stdout?.setEncoding('utf8');
+ scriptInstance.stderr?.setEncoding('utf8');
+
+ let stdout = '';
+ scriptInstance.stdout?.addListener('data', data => {
+ stdout += data;
+ });
+
+ let stderr = '';
+ scriptInstance.stderr?.addListener('data', (data: string) => {
+ stderr += data;
+ });
+
+ // do not fail the test if the debugger is running
+ stderr = stderr
+ .split('\n')
+ .filter(line => !line.startsWith('Debugger') && !line.startsWith('For help'))
+ .join('\n');
+
+ const [exitCode] = await once(scriptInstance, 'close');
+
+ if (stderr.length) console.log(stderr);
+ expect({ exitCode, stdout, stderr }).to.deep.equal({ exitCode: 0, stdout: '', stderr: '' });
+ } finally {
+ await fs.unlink(scriptName);
+ }
+ });
+}

test/unit/error.test.ts

@@ -16,6 +16,7 @@ import {
  MONGODB_ERROR_CODES,
  MongoError,
  MongoErrorLabel,
+ MongoMissingDependencyError,
  MongoNetworkError,
  MongoNetworkTimeoutError,
  MongoParseError,
@@ -155,6 +156,22 @@ describe('MongoErrors', () => {
  });
  });
 
+ describe('MongoMissingDependencyError#constructor', () => {
+ context('when options.cause is set', () => {
+ it('attaches the cause property to the instance', () => {
+ const error = new MongoMissingDependencyError('missing!', { cause: new Error('hello') });
+ expect(error).to.have.property('cause');
+ });
+ });
+
+ context('when options.cause is not set', () => {
+ it('attaches the cause property to the instance', () => {
+ const error = new MongoMissingDependencyError('missing!', { cause: undefined });
+ expect(error).to.not.have.property('cause');
+ });
+ });
+ });
+
  describe('#isSDAMUnrecoverableError', function () {
  context('when the error is a MongoParseError', function () {
  it('returns true', function () {