@depup/mongodb 7.1.0-depup.0

package/src/deps.ts

@@ -0,0 +1,227 @@
+import { type Stream } from './cmap/connect';
+import { MongoMissingDependencyError } from './error';
+import type { Callback } from './utils';
+
+function makeErrorModule(error: any) {
+  const props = error ? { kModuleError: error } : {};
+  return new Proxy(props, {
+    get: (_: any, key: any) => {
+      if (key === 'kModuleError') {
+        return error;
+      }
+      throw error;
+    },
+    set: () => {
+      throw error;
+    }
+  });
+}
+
+export type Kerberos = typeof import('kerberos') | { kModuleError: MongoMissingDependencyError };
+
+export function getKerberos(): Kerberos {
+  let kerberos: Kerberos;
+  try {
+    // Ensure you always wrap an optional require in the try block NODE-3199
+    // eslint-disable-next-line @typescript-eslint/no-require-imports
+    kerberos = require('kerberos');
+  } catch (error) {
+    kerberos = makeErrorModule(
+      new MongoMissingDependencyError(
+        'Optional module `kerberos` not found. Please install it to enable kerberos authentication',
+        { cause: error, dependencyName: 'kerberos' }
+      )
+    );
+  }
+  return kerberos;
+}
+
+export interface KerberosClient {
+  step(challenge: string): Promise<string>;
+  step(challenge: string, callback: Callback<string>): void;
+  wrap(challenge: string, options: { user: string }): Promise<string>;
+  wrap(challenge: string, options: { user: string }, callback: Callback<string>): void;
+  unwrap(challenge: string): Promise<string>;
+  unwrap(challenge: string, callback: Callback<string>): void;
+}
+
+type ZStandardLib = {
+  /**
+   * Compress using zstd.
+   * @param buf - Buffer to be compressed.
+   */
+  compress(buf: Buffer, level?: number): Promise<Buffer>;
+
+  /**
+   * Decompress using zstd.
+   */
+  decompress(buf: Buffer): Promise<Buffer>;
+};
+
+export type ZStandard = ZStandardLib | { kModuleError: MongoMissingDependencyError };
+
+export function getZstdLibrary(): ZStandardLib | { kModuleError: MongoMissingDependencyError } {
+  let ZStandard: ZStandardLib | { kModuleError: MongoMissingDependencyError };
+  try {
+    // eslint-disable-next-line @typescript-eslint/no-require-imports
+    ZStandard = require('@mongodb-js/zstd');
+  } catch (error) {
+    ZStandard = makeErrorModule(
+      new MongoMissingDependencyError(
+        'Optional module `@mongodb-js/zstd` not found. Please install it to enable zstd compression',
+        { cause: error, dependencyName: 'zstd' }
+      )
+    );
+  }
+
+  return ZStandard;
+}
+
+/**
+ * @public
+ * Copy of the AwsCredentialIdentityProvider interface from [`smithy/types`](https://socket.dev/npm/package/\@smithy/types/files/1.1.1/dist-types/identity/awsCredentialIdentity.d.ts),
+ * the return type of the aws-sdk's `fromNodeProviderChain().provider()`.
+ */
+export interface AWSCredentials {
+  accessKeyId: string;
+  secretAccessKey: string;
+  sessionToken?: string;
+  expiration?: Date;
+}
+
+type CredentialProvider = {
+  fromNodeProviderChain(
+    this: void,
+    options: { clientConfig: { region: string } }
+  ): () => Promise<AWSCredentials>;
+  fromNodeProviderChain(this: void): () => Promise<AWSCredentials>;
+};
+
+export function getAwsCredentialProvider():
+  | CredentialProvider
+  | { kModuleError: MongoMissingDependencyError } {
+  try {
+    // Ensure you always wrap an optional require in the try block NODE-3199
+    // eslint-disable-next-line @typescript-eslint/no-require-imports
+    const credentialProvider = require('@aws-sdk/credential-providers');
+    return credentialProvider;
+  } catch (error) {
+    return makeErrorModule(
+      new MongoMissingDependencyError(
+        'Optional module `@aws-sdk/credential-providers` not found.' +
+          ' Please install it to enable getting aws credentials via the official sdk.',
+        { cause: error, dependencyName: '@aws-sdk/credential-providers' }
+      )
+    );
+  }
+}
+
+/** @internal */
+export type GcpMetadata =
+  | typeof import('gcp-metadata')
+  | { kModuleError: MongoMissingDependencyError };
+
+export function getGcpMetadata(): GcpMetadata {
+  try {
+    // Ensure you always wrap an optional require in the try block NODE-3199
+    // eslint-disable-next-line @typescript-eslint/no-require-imports
+    const credentialProvider = require('gcp-metadata');
+    return credentialProvider;
+  } catch (error) {
+    return makeErrorModule(
+      new MongoMissingDependencyError(
+        'Optional module `gcp-metadata` not found.' +
+          ' Please install it to enable getting gcp credentials via the official sdk.',
+        { cause: error, dependencyName: 'gcp-metadata' }
+      )
+    );
+  }
+}
+
+/** @internal */
+export type SnappyLib = {
+  /**
+   * In order to support both we must check the return value of the function
+   * @param buf - Buffer to be compressed
+   */
+  compress(buf: Buffer): Promise<Buffer>;
+
+  /**
+   * In order to support both we must check the return value of the function
+   * @param buf - Buffer to be compressed
+   */
+  uncompress(buf: Buffer, opt: { asBuffer: true }): Promise<Buffer>;
+};
+
+export function getSnappy(): SnappyLib | { kModuleError: MongoMissingDependencyError } {
+  try {
+    // Ensure you always wrap an optional require in the try block NODE-3199
+    // eslint-disable-next-line @typescript-eslint/no-require-imports
+    const value = require('snappy');
+    return value;
+  } catch (error) {
+    const kModuleError = new MongoMissingDependencyError(
+      'Optional module `snappy` not found. Please install it to enable snappy compression',
+      { cause: error, dependencyName: 'snappy' }
+    );
+    return { kModuleError };
+  }
+}
+
+export type SocksLib = {
+  SocksClient: {
+    createConnection(options: {
+      command: 'connect';
+      destination: { host: string; port: number };
+      proxy: {
+        /** host and port are ignored because we pass existing_socket */
+        host: 'iLoveJavaScript';
+        port: 0;
+        type: 5;
+        userId?: string;
+        password?: string;
+      };
+      timeout?: number;
+      /** We always create our own socket, and pass it to this API for proxy negotiation */
+      existing_socket: Stream;
+    }): Promise<{ socket: Stream }>;
+  };
+};
+
+export function getSocks(): SocksLib | { kModuleError: MongoMissingDependencyError } {
+  try {
+    // Ensure you always wrap an optional require in the try block NODE-3199
+    // eslint-disable-next-line @typescript-eslint/no-require-imports
+    const value = require('socks');
+    return value;
+  } catch (error) {
+    const kModuleError = new MongoMissingDependencyError(
+      'Optional module `socks` not found. Please install it to connections over a SOCKS5 proxy',
+      { cause: error, dependencyName: 'socks' }
+    );
+    return { kModuleError };
+  }
+}
+
+/** A utility function to get the instance of mongodb-client-encryption, if it exists. */
+export function getMongoDBClientEncryption():
+  | typeof import('mongodb-client-encryption')
+  | { kModuleError: MongoMissingDependencyError } {
+  let mongodbClientEncryption = null;
+
+  try {
+    // NOTE(NODE-3199): Ensure you always wrap an optional require literally in the try block
+    // Cannot be moved to helper utility function, bundlers search and replace the actual require call
+    // in a way that makes this line throw at bundle time, not runtime, catching here will make bundling succeed
+    // eslint-disable-next-line @typescript-eslint/no-require-imports
+    mongodbClientEncryption = require('mongodb-client-encryption');
+  } catch (error) {
+    const kModuleError = new MongoMissingDependencyError(
+      'Optional module `mongodb-client-encryption` not found. Please install it to use auto encryption or ClientEncryption.',
+      { cause: error, dependencyName: 'mongodb-client-encryption' }
+    );
+    return { kModuleError };
+  }
+
+  return mongodbClientEncryption;
+}

package/src/encrypter.ts

@@ -0,0 +1,127 @@
+import { AutoEncrypter, type AutoEncryptionOptions } from './client-side-encryption/auto_encrypter';
+import { MONGO_CLIENT_EVENTS } from './constants';
+import { getMongoDBClientEncryption } from './deps';
+import { MongoInvalidArgumentError, MongoMissingDependencyError } from './error';
+import { MongoClient, type MongoClientOptions } from './mongo_client';
+
+/** @internal */
+export interface EncrypterOptions {
+  autoEncryption: AutoEncryptionOptions;
+  maxPoolSize?: number;
+}
+
+/** @internal */
+export class Encrypter {
+  private internalClient: MongoClient | null;
+  bypassAutoEncryption: boolean;
+  needsConnecting: boolean;
+  autoEncrypter: AutoEncrypter;
+
+  constructor(client: MongoClient, uri: string, options: MongoClientOptions) {
+    if (typeof options.autoEncryption !== 'object') {
+      throw new MongoInvalidArgumentError('Option "autoEncryption" must be specified');
+    }
+    // initialize to null, if we call getInternalClient, we may set this it is important to not overwrite those function calls.
+    this.internalClient = null;
+
+    this.bypassAutoEncryption = !!options.autoEncryption.bypassAutoEncryption;
+    this.needsConnecting = false;
+
+    if (options.maxPoolSize === 0 && options.autoEncryption.keyVaultClient == null) {
+      options.autoEncryption.keyVaultClient = client;
+    } else if (options.autoEncryption.keyVaultClient == null) {
+      options.autoEncryption.keyVaultClient = this.getInternalClient(client, uri, options);
+    }
+
+    if (this.bypassAutoEncryption) {
+      options.autoEncryption.metadataClient = undefined;
+    } else if (options.maxPoolSize === 0) {
+      options.autoEncryption.metadataClient = client;
+    } else {
+      options.autoEncryption.metadataClient = this.getInternalClient(client, uri, options);
+    }
+
+    if (options.proxyHost) {
+      options.autoEncryption.proxyOptions = {
+        proxyHost: options.proxyHost,
+        proxyPort: options.proxyPort,
+        proxyUsername: options.proxyUsername,
+        proxyPassword: options.proxyPassword
+      };
+    }
+
+    this.autoEncrypter = new AutoEncrypter(client, options.autoEncryption);
+  }
+
+  getInternalClient(client: MongoClient, uri: string, options: MongoClientOptions): MongoClient {
+    let internalClient = this.internalClient;
+    if (internalClient == null) {
+      const clonedOptions: MongoClientOptions = {};
+
+      for (const key of [
+        ...Object.getOwnPropertyNames(options),
+        ...Object.getOwnPropertySymbols(options)
+      ] as string[]) {
+        if (['autoEncryption', 'minPoolSize', 'servers', 'caseTranslate', 'dbName'].includes(key))
+          continue;
+        Reflect.set(clonedOptions, key, Reflect.get(options, key));
+      }
+
+      clonedOptions.minPoolSize = 0;
+
+      internalClient = new MongoClient(uri, clonedOptions);
+      this.internalClient = internalClient;
+
+      for (const eventName of MONGO_CLIENT_EVENTS) {
+        for (const listener of client.listeners(eventName)) {
+          internalClient.on(eventName, listener);
+        }
+      }
+
+      client.on('newListener', (eventName, listener) => {
+        internalClient?.on(eventName, listener);
+      });
+
+      this.needsConnecting = true;
+    }
+    return internalClient;
+  }
+
+  async connectInternalClient(): Promise<void> {
+    const internalClient = this.internalClient;
+    if (this.needsConnecting && internalClient != null) {
+      this.needsConnecting = false;
+      await internalClient.connect();
+    }
+  }
+
+  async close(client: MongoClient): Promise<void> {
+    let error;
+    try {
+      await this.autoEncrypter.close();
+    } catch (autoEncrypterError) {
+      error = autoEncrypterError;
+    }
+    const internalClient = this.internalClient;
+    if (internalClient != null && client !== internalClient) {
+      return await internalClient.close();
+    }
+    if (error != null) {
+      throw error;
+    }
+  }
+
+  static checkForMongoCrypt(): void {
+    const mongodbClientEncryption = getMongoDBClientEncryption();
+    if ('kModuleError' in mongodbClientEncryption) {
+      throw new MongoMissingDependencyError(
+        'Auto-encryption requested, but the module is not installed. ' +
+          'Please add `mongodb-client-encryption` as a dependency of your project',
+        {
+          cause: mongodbClientEncryption['kModuleError'],
+          dependencyName: 'mongodb-client-encryption'
+        }
+      );
+    }
+  }
+}