mongodb 4.1.4 → 4.3.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "mongodb",
-  "version": "4.1.4",
+  "version": "4.3.0",
   "description": "The official MongoDB driver for Node.js",
   "main": "lib/index.js",
   "files": [
@@ -32,54 +32,55 @@
     "email": "dbx-node@mongodb.com"
   },
   "dependencies": {
-    "bson": "^4.5.4",
+    "bson": "^4.6.1",
     "denque": "^2.0.1",
-    "mongodb-connection-string-url": "^2.1.0"
+    "mongodb-connection-string-url": "^2.3.2",
+    "socks": "^2.6.1"
   },
   "devDependencies": {
-    "@istanbuljs/nyc-config-typescript": "^1.0.1",
-    "@microsoft/api-extractor": "^7.18.14",
+    "@istanbuljs/nyc-config-typescript": "^1.0.2",
+    "@microsoft/api-extractor": "^7.18.21",
     "@microsoft/tsdoc-config": "^0.15.2",
-    "@types/chai": "^4.2.22",
+    "@types/chai": "^4.3.0",
     "@types/chai-subset": "^1.3.3",
     "@types/kerberos": "^1.1.1",
     "@types/mocha": "^9.0.0",
-    "@types/node": "^16.10.3",
+    "@types/node": "^16.11.12",
     "@types/saslprep": "^1.0.1",
-    "@types/semver": "^7.3.8",
+    "@types/semver": "^7.3.9",
+    "@types/sinon": "^10.0.6",
     "@types/whatwg-url": "^8.2.1",
-    "@typescript-eslint/eslint-plugin": "^4.33.0",
-    "@typescript-eslint/parser": "^4.33.0",
+    "@typescript-eslint/eslint-plugin": "^5.6.0",
+    "@typescript-eslint/parser": "^5.6.0",
     "bluebird": "^3.7.2",
     "chai": "^4.3.4",
     "chai-subset": "^1.6.0",
     "chalk": "^4.1.2",
-    "co": "4.6.0",
     "downlevel-dts": "^0.7.0",
-    "eslint": "^7.32.0",
+    "eslint": "^8.4.1",
     "eslint-config-prettier": "^8.3.0",
+    "eslint-plugin-import": "^2.25.3",
     "eslint-plugin-prettier": "^4.0.0",
+    "eslint-plugin-simple-import-sort": "^7.0.0",
     "eslint-plugin-tsdoc": "^0.2.14",
     "js-yaml": "^4.1.0",
     "lodash.camelcase": "^4.3.0",
-    "mocha": "^9.1.2",
+    "mocha": "^9.1.3",
     "mocha-sinon": "^2.1.2",
-    "mongodb-mock-server": "^2.0.1",
     "nyc": "^15.1.0",
-    "prettier": "^2.4.1",
+    "prettier": "^2.5.1",
     "rimraf": "^3.0.2",
     "semver": "^7.3.5",
-    "sinon": "^11.1.2",
+    "sinon": "^12.0.1",
     "sinon-chai": "^3.7.0",
-    "source-map-support": "^0.5.20",
-    "standard-version": "^9.3.1",
-    "ts-node": "^10.2.1",
-    "tsd": "^0.17.0",
-    "typedoc": "^0.22.5",
-    "typescript": "4.4.3",
+    "source-map-support": "^0.5.21",
+    "standard-version": "^9.3.2",
+    "ts-node": "^10.4.0",
+    "tsd": "^0.19.0",
+    "typescript": "^4.5.2",
     "typescript-cached-transpile": "^0.0.6",
     "xml2js": "^0.4.23",
-    "yargs": "^17.2.1"
+    "yargs": "^17.3.0"
   },
   "license": "Apache-2.0",
   "engines": {
@@ -113,7 +114,8 @@
     "check:kerberos": "mocha --config \"test/manual/mocharc.json\" test/manual/kerberos.test.js",
     "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:csfle": "mocha --file test/tools/runner test/functional/client_side_encryption",
+    "check:socks5": "mocha --config \"test/manual/mocharc.json\" test/manual/socks5.test.ts",
+    "check:csfle": "mocha --file test/tools/runner test/integration/client-side-encryption",
     "check:snappy": "mocha --file test/tools/runner test/functional/unit_snappy.test.js",
     "prepare": "node etc/prepare.js",
     "release": "standard-version -i HISTORY.md",

package/src/admin.ts

@@ -1,20 +1,20 @@
+import type { Document } from './bson';
+import type { Db } from './db';
 import { AddUserOperation, AddUserOptions } from './operations/add_user';
-import { RemoveUserOperation, RemoveUserOptions } from './operations/remove_user';
-import {
-  ValidateCollectionOperation,
-  ValidateCollectionOptions
-} from './operations/validate_collection';
+import type { CommandOperationOptions } from './operations/command';
+import { executeOperation } from './operations/execute_operation';
 import {
   ListDatabasesOperation,
   ListDatabasesOptions,
   ListDatabasesResult
 } from './operations/list_databases';
-import { executeOperation } from './operations/execute_operation';
+import { RemoveUserOperation, RemoveUserOptions } from './operations/remove_user';
 import { RunCommandOperation, RunCommandOptions } from './operations/run_command';
+import {
+  ValidateCollectionOperation,
+  ValidateCollectionOptions
+} from './operations/validate_collection';
 import { Callback, getTopology } from './utils';
-import type { Document } from './bson';
-import type { CommandOperationOptions } from './operations/command';
-import type { Db } from './db';
 
 /** @internal */
 export interface AdminPrivate {

package/src/bson.ts

@@ -1,11 +1,14 @@
 import type {
-  serialize as serializeFn,
+  calculateObjectSize as calculateObjectSizeFn,
   deserialize as deserializeFn,
-  calculateObjectSize as calculateObjectSizeFn
+  DeserializeOptions,
+  serialize as serializeFn,
+  SerializeOptions
 } from 'bson';
 
 // eslint-disable-next-line @typescript-eslint/no-var-requires
 let BSON = require('bson');
+
 try {
   // Ensure you always wrap an optional require in the try block NODE-3199
   BSON = require('bson-ext');
@@ -19,25 +22,23 @@ export const serialize = BSON.serialize as typeof serializeFn;
 export const calculateObjectSize = BSON.calculateObjectSize as typeof calculateObjectSizeFn;
 
 export {
-  Long,
   Binary,
-  ObjectId,
-  Timestamp,
+  BSONRegExp,
+  BSONSymbol,
   Code,
-  MinKey,
-  MaxKey,
+  DBRef,
   Decimal128,
-  Int32,
+  Document,
   Double,
-  DBRef,
-  BSONRegExp,
-  BSONSymbol,
+  Int32,
+  Long,
   Map,
-  Document
+  MaxKey,
+  MinKey,
+  ObjectId,
+  Timestamp
 } from 'bson';
 
-import type { DeserializeOptions, SerializeOptions } from 'bson';
-
 /**
  * BSON Serialization options.
  * @public
@@ -51,9 +52,13 @@ export interface BSONSerializeOptions
       | 'cacheFunctionsCrc32'
       | 'allowObjectSmallerThanBufferSize'
       | 'index'
+      | 'validation'
     > {
   /** Return BSON filled buffers from operations */
   raw?: boolean;
+
+  /** Enable utf8 validation when deserializing BSON documents.  Defaults to true. */
+  enableUtf8Validation?: boolean;
 }
 
 export function pluckBSONSerializeOptions(options: BSONSerializeOptions): BSONSerializeOptions {
@@ -65,7 +70,8 @@ export function pluckBSONSerializeOptions(options: BSONSerializeOptions): BSONSe
     serializeFunctions,
     ignoreUndefined,
     bsonRegExp,
-    raw
+    raw,
+    enableUtf8Validation
   } = options;
   return {
     fieldsAsRaw,
@@ -75,7 +81,8 @@ export function pluckBSONSerializeOptions(options: BSONSerializeOptions): BSONSe
     serializeFunctions,
     ignoreUndefined,
     bsonRegExp,
-    raw
+    raw,
+    enableUtf8Validation
   };
 }
 
@@ -98,6 +105,8 @@ export function resolveBSONOptions(
     ignoreUndefined: options?.ignoreUndefined ?? parentOptions?.ignoreUndefined ?? false,
     bsonRegExp: options?.bsonRegExp ?? parentOptions?.bsonRegExp ?? false,
     serializeFunctions: options?.serializeFunctions ?? parentOptions?.serializeFunctions ?? false,
-    fieldsAsRaw: options?.fieldsAsRaw ?? parentOptions?.fieldsAsRaw ?? {}
+    fieldsAsRaw: options?.fieldsAsRaw ?? parentOptions?.fieldsAsRaw ?? {},
+    enableUtf8Validation:
+      options?.enableUtf8Validation ?? parentOptions?.enableUtf8Validation ?? true
   };
 }

package/src/bulk/common.ts

@@ -1,39 +1,39 @@
-import { PromiseProvider } from '../promise_provider';
 import {
+  BSONSerializeOptions,
+  Document,
   Long,
   ObjectId,
-  Document,
-  BSONSerializeOptions,
   resolveBSONOptions,
   Timestamp
 } from '../bson';
+import type { Collection } from '../collection';
 import {
-  MongoWriteConcernError,
   AnyError,
+  MongoBatchReExecutionError,
   MONGODB_ERROR_CODES,
-  MongoServerError,
   MongoInvalidArgumentError,
-  MongoBatchReExecutionError
+  MongoServerError,
+  MongoWriteConcernError
 } from '../error';
+import type { Filter, OneOrMore, OptionalId, UpdateFilter, WithoutId } from '../mongo_types';
+import type { CollationOptions, CommandOperationOptions } from '../operations/command';
+import { DeleteOperation, DeleteStatement, makeDeleteStatement } from '../operations/delete';
+import { executeOperation } from '../operations/execute_operation';
+import { InsertOperation } from '../operations/insert';
+import type { Hint } from '../operations/operation';
+import { makeUpdateStatement, UpdateOperation, UpdateStatement } from '../operations/update';
+import { PromiseProvider } from '../promise_provider';
+import type { Topology } from '../sdam/topology';
 import {
   applyRetryableWrites,
+  Callback,
   executeLegacyOperation,
+  getTopology,
   hasAtomicOperators,
-  Callback,
   MongoDBNamespace,
-  getTopology,
   resolveOptions
 } from '../utils';
-import { executeOperation } from '../operations/execute_operation';
-import { InsertOperation } from '../operations/insert';
-import { UpdateOperation, UpdateStatement, makeUpdateStatement } from '../operations/update';
-import { DeleteOperation, DeleteStatement, makeDeleteStatement } from '../operations/delete';
 import { WriteConcern } from '../write_concern';
-import type { Collection } from '../collection';
-import type { Topology } from '../sdam/topology';
-import type { CommandOperationOptions, CollationOptions } from '../operations/command';
-import type { Hint } from '../operations/operation';
-import type { Filter, OneOrMore, OptionalId, UpdateFilter } from '../mongo_types';
 
 /** @internal */
 const kServerError = Symbol('serverError');
@@ -79,7 +79,7 @@ export interface ReplaceOneModel<TSchema extends Document = Document> {
   /** The filter to limit the replaced document. */
   filter: Filter<TSchema>;
   /** The document with which to replace the matched document. */
-  replacement: TSchema;
+  replacement: WithoutId<TSchema>;
   /** Specifies a collation. */
   collation?: CollationOptions;
   /** The index to use. If specified, then the query system will only consider plans using the hinted index. */
@@ -1216,9 +1216,15 @@ export abstract class BulkOperationBase {
     return batches;
   }
 
-  /** An internal helper method. Do not invoke directly. Will be going away in the future */
+  execute(options?: BulkWriteOptions): Promise<BulkWriteResult>;
+  execute(callback: Callback<BulkWriteResult>): void;
+  execute(options: BulkWriteOptions | undefined, callback: Callback<BulkWriteResult>): void;
+  execute(
+    options?: BulkWriteOptions | Callback<BulkWriteResult>,
+    callback?: Callback<BulkWriteResult>
+  ): Promise<BulkWriteResult> | void;
   execute(
-    options?: BulkWriteOptions,
+    options?: BulkWriteOptions | Callback<BulkWriteResult>,
     callback?: Callback<BulkWriteResult>
   ): Promise<BulkWriteResult> | void {
     if (typeof options === 'function') (callback = options), (options = {});

package/src/bulk/ordered.ts

@@ -1,10 +1,10 @@
-import * as BSON from '../bson';
-import { BulkOperationBase, Batch, BatchType, BulkWriteOptions } from './common';
 import type { Document } from '../bson';
+import * as BSON from '../bson';
 import type { Collection } from '../collection';
-import type { UpdateStatement } from '../operations/update';
-import type { DeleteStatement } from '../operations/delete';
 import { MongoInvalidArgumentError } from '../error';
+import type { DeleteStatement } from '../operations/delete';
+import type { UpdateStatement } from '../operations/update';
+import { Batch, BatchType, BulkOperationBase, BulkWriteOptions } from './common';
 
 /** @public */
 export class OrderedBulkOperation extends BulkOperationBase {

package/src/bulk/unordered.ts

@@ -1,11 +1,11 @@
-import * as BSON from '../bson';
-import { BulkOperationBase, Batch, BatchType, BulkWriteOptions, BulkWriteResult } from './common';
-import type { Callback } from '../utils';
 import type { Document } from '../bson';
+import * as BSON from '../bson';
 import type { Collection } from '../collection';
-import type { UpdateStatement } from '../operations/update';
-import type { DeleteStatement } from '../operations/delete';
 import { MongoInvalidArgumentError } from '../error';
+import type { DeleteStatement } from '../operations/delete';
+import type { UpdateStatement } from '../operations/update';
+import type { Callback } from '../utils';
+import { Batch, BatchType, BulkOperationBase, BulkWriteOptions, BulkWriteResult } from './common';
 
 /** @public */
 export class UnorderedBulkOperation extends BulkOperationBase {

package/src/change_stream.ts

@@ -1,39 +1,40 @@
 import Denque = require('denque');
+import type { Readable } from 'stream';
+
+import type { Document, Timestamp } from './bson';
+import { Collection } from './collection';
+import {
+  AbstractCursor,
+  AbstractCursorEvents,
+  AbstractCursorOptions,
+  CursorStreamOptions
+} from './cursor/abstract_cursor';
+import { Db } from './db';
 import {
-  MongoError,
   AnyError,
   isResumableError,
-  MongoRuntimeError,
   MongoAPIError,
-  MongoChangeStreamError
+  MongoChangeStreamError,
+  MongoError,
+  MongoRuntimeError
 } from './error';
+import { MongoClient } from './mongo_client';
+import { InferIdType, Nullable, TypedEventEmitter } from './mongo_types';
 import { AggregateOperation, AggregateOptions } from './operations/aggregate';
+import type { CollationOptions, OperationParent } from './operations/command';
+import { executeOperation, ExecutionResult } from './operations/execute_operation';
+import type { ReadPreference } from './read_preference';
+import type { Topology } from './sdam/topology';
+import type { ClientSession } from './sessions';
 import {
-  maxWireVersion,
   calculateDurationInMs,
-  now,
+  Callback,
+  getTopology,
+  maxWireVersion,
   maybePromise,
   MongoDBNamespace,
-  Callback,
-  getTopology
+  now
 } from './utils';
-import type { ReadPreference } from './read_preference';
-import type { Timestamp, Document } from './bson';
-import type { Topology } from './sdam/topology';
-import type { OperationParent, CollationOptions } from './operations/command';
-import { MongoClient } from './mongo_client';
-import { Db } from './db';
-import { Collection } from './collection';
-import type { Readable } from 'stream';
-import {
-  AbstractCursor,
-  AbstractCursorEvents,
-  AbstractCursorOptions,
-  CursorStreamOptions
-} from './cursor/abstract_cursor';
-import type { ClientSession } from './sessions';
-import { executeOperation, ExecutionResult } from './operations/execute_operation';
-import { InferIdType, Nullable, TypedEventEmitter } from './mongo_types';
 
 /** @internal */
 const kResumeQueue = Symbol('resumeQueue');
@@ -184,23 +185,23 @@ export interface UpdateDescription<TSchema extends Document = Document> {
 }
 
 /** @public */
-export type ChangeStreamEvents = {
+export type ChangeStreamEvents<TSchema extends Document = Document> = {
   resumeTokenChanged(token: ResumeToken): void;
-  init(response: Document): void;
-  more(response?: Document | undefined): void;
+  init(response: TSchema): void;
+  more(response?: TSchema | undefined): void;
   response(): void;
   end(): void;
   error(error: Error): void;
-  change(change: ChangeStreamDocument): void;
+  change(change: ChangeStreamDocument<TSchema>): void;
 } & AbstractCursorEvents;
 
 /**
  * Creates a new Change Stream instance. Normally created using {@link Collection#watch|Collection.watch()}.
  * @public
  */
-export class ChangeStream<
-  TSchema extends Document = Document
-> extends TypedEventEmitter<ChangeStreamEvents> {
+export class ChangeStream<TSchema extends Document = Document> extends TypedEventEmitter<
+  ChangeStreamEvents<TSchema>
+> {
   pipeline: Document[];
   options: ChangeStreamOptions;
   parent: MongoClient | Db | Collection;
@@ -310,7 +311,9 @@ export class ChangeStream<
   }
 
   /** Check if there is any document still available in the Change Stream */
-  hasNext(callback?: Callback): Promise<void> | void {
+  hasNext(): Promise<boolean>;
+  hasNext(callback: Callback<boolean>): void;
+  hasNext(callback?: Callback): Promise<boolean> | void {
     setIsIterator(this);
     return maybePromise(callback, cb => {
       getCursor(this, (err, cursor) => {

package/src/cmap/auth/auth_provider.ts

@@ -1,9 +1,9 @@
 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';
-import type { HandshakeDocument } from '../connect';
-import type { ClientMetadataOptions, Callback } from '../../utils';
-import { MongoRuntimeError } from '../../error';
 
 export type AuthContextOptions = ConnectionOptions & ClientMetadataOptions;
 

package/src/cmap/auth/gssapi.ts

@@ -1,14 +1,16 @@
-import { AuthProvider, AuthContext } from './auth_provider';
+import * as dns from 'dns';
+
+import type { Document } from '../../bson';
+import { Kerberos, KerberosClient } from '../../deps';
 import {
-  MongoRuntimeError,
+  MongoError,
   MongoInvalidArgumentError,
   MongoMissingCredentialsError,
-  MongoError,
-  MongoMissingDependencyError
+  MongoMissingDependencyError,
+  MongoRuntimeError
 } from '../../error';
-import { Kerberos, KerberosClient } from '../../deps';
 import { Callback, ns } from '../../utils';
-import type { Document } from '../../bson';
+import { AuthContext, AuthProvider } from './auth_provider';
 
 type MechanismProperties = {
   gssapiCanonicalizeHostName?: boolean;
@@ -16,8 +18,6 @@ type MechanismProperties = {
   SERVICE_REALM?: string;
 };
 
-import * as dns from 'dns';
-
 export class GSSAPI extends AuthProvider {
   auth(authContext: AuthContext, callback: Callback): void {
     const { connection, credentials } = authContext;

package/src/cmap/auth/mongo_credentials.ts

@@ -2,7 +2,7 @@
 
 import type { Document } from '../../bson';
 import { MongoAPIError, MongoMissingCredentialsError } from '../../error';
-import { AuthMechanism } from './defaultAuthProviders';
+import { AUTH_MECHS_AUTH_SRC_EXTERNAL, AuthMechanism } from './providers';
 
 // https://github.com/mongodb/specifications/blob/master/source/auth/auth.rst
 function getDefaultAuthMechanism(ismaster?: Document): AuthMechanism {
@@ -136,11 +136,7 @@ export class MongoCredentials {
       throw new MongoMissingCredentialsError(`Username required for mechanism '${this.mechanism}'`);
     }
 
-    if (
-      this.mechanism === AuthMechanism.MONGODB_GSSAPI ||
-      this.mechanism === AuthMechanism.MONGODB_AWS ||
-      this.mechanism === AuthMechanism.MONGODB_X509
-    ) {
+    if (AUTH_MECHS_AUTH_SRC_EXTERNAL.has(this.mechanism)) {
       if (this.source != null && this.source !== '$external') {
         // TODO(NODE-3485): Replace this with a MongoAuthValidationError
         throw new MongoAPIError(

package/src/cmap/auth/mongocr.ts

@@ -1,7 +1,8 @@
 import * as crypto from 'crypto';
-import { AuthProvider, AuthContext } from './auth_provider';
-import { Callback, ns } from '../../utils';
+
 import { MongoMissingCredentialsError } from '../../error';
+import { Callback, ns } from '../../utils';
+import { AuthContext, AuthProvider } from './auth_provider';
 
 export class MongoCR extends AuthProvider {
   auth(authContext: AuthContext, callback: Callback): void {

package/src/cmap/auth/mongodb_aws.ts

@@ -1,20 +1,19 @@
-import * as http from 'http';
 import * as crypto from 'crypto';
+import * as http from 'http';
 import * as url from 'url';
+
+import type { Binary, BSONSerializeOptions } from '../../bson';
 import * as BSON from '../../bson';
-import { AuthProvider, AuthContext } from './auth_provider';
-import { MongoCredentials } from './mongo_credentials';
+import { aws4 } from '../../deps';
 import {
-  MongoRuntimeError,
+  MongoCompatibilityError,
   MongoMissingCredentialsError,
-  MongoCompatibilityError
+  MongoRuntimeError
 } from '../../error';
-import { maxWireVersion, Callback, ns } from '../../utils';
-import type { BSONSerializeOptions } from '../../bson';
-
-import { aws4 } from '../../deps';
-import { AuthMechanism } from './defaultAuthProviders';
-import type { Binary } from 'bson';
+import { Callback, maxWireVersion, ns } from '../../utils';
+import { AuthContext, AuthProvider } from './auth_provider';
+import { MongoCredentials } from './mongo_credentials';
+import { AuthMechanism } from './providers';
 
 const ASCII_N = 110;
 const AWS_RELATIVE_URI = 'http://169.254.170.2';

package/src/cmap/auth/plain.ts

@@ -1,7 +1,7 @@
 import { Binary } from '../../bson';
-import { AuthProvider, AuthContext } from './auth_provider';
 import { MongoMissingCredentialsError } from '../../error';
 import { Callback, ns } from '../../utils';
+import { AuthContext, AuthProvider } from './auth_provider';
 
 export class Plain extends AuthProvider {
   auth(authContext: AuthContext, callback: Callback): void {

package/src/cmap/auth/providers.ts

@@ -0,0 +1,21 @@
+/** @public */
+export const AuthMechanism = Object.freeze({
+  MONGODB_AWS: 'MONGODB-AWS',
+  MONGODB_CR: 'MONGODB-CR',
+  MONGODB_DEFAULT: 'DEFAULT',
+  MONGODB_GSSAPI: 'GSSAPI',
+  MONGODB_PLAIN: 'PLAIN',
+  MONGODB_SCRAM_SHA1: 'SCRAM-SHA-1',
+  MONGODB_SCRAM_SHA256: 'SCRAM-SHA-256',
+  MONGODB_X509: 'MONGODB-X509'
+} as const);
+
+/** @public */
+export type AuthMechanism = typeof AuthMechanism[keyof typeof AuthMechanism];
+
+/** @internal */
+export const AUTH_MECHS_AUTH_SRC_EXTERNAL = new Set<AuthMechanism>([
+  AuthMechanism.MONGODB_GSSAPI,
+  AuthMechanism.MONGODB_AWS,
+  AuthMechanism.MONGODB_X509
+]);

package/src/cmap/auth/scram.ts

@@ -1,19 +1,19 @@
 import * as crypto from 'crypto';
+
 import { Binary, Document } from '../../bson';
+import { saslprep } from '../../deps';
 import {
   AnyError,
-  MongoRuntimeError,
-  MongoServerError,
   MongoInvalidArgumentError,
-  MongoMissingCredentialsError
+  MongoMissingCredentialsError,
+  MongoRuntimeError,
+  MongoServerError
 } from '../../error';
-import { AuthProvider, AuthContext } from './auth_provider';
-import { Callback, ns, emitWarning } from '../../utils';
-import type { MongoCredentials } from './mongo_credentials';
+import { Callback, emitWarning, ns } from '../../utils';
 import type { HandshakeDocument } from '../connect';
-
-import { saslprep } from '../../deps';
-import { AuthMechanism } from './defaultAuthProviders';
+import { AuthContext, AuthProvider } from './auth_provider';
+import type { MongoCredentials } from './mongo_credentials';
+import { AuthMechanism } from './providers';
 
 type CryptoMethod = 'sha1' | 'sha256';
 

package/src/cmap/auth/x509.ts

@@ -1,9 +1,9 @@
-import { AuthProvider, AuthContext } from './auth_provider';
-import { MongoMissingCredentialsError } from '../../error';
 import type { Document } from '../../bson';
+import { MongoMissingCredentialsError } from '../../error';
 import { Callback, ns } from '../../utils';
-import type { MongoCredentials } from './mongo_credentials';
 import type { HandshakeDocument } from '../connect';
+import { AuthContext, AuthProvider } from './auth_provider';
+import type { MongoCredentials } from './mongo_credentials';
 
 export class X509 extends AuthProvider {
   prepare(handshakeDoc: HandshakeDocument, authContext: AuthContext, callback: Callback): void {

package/src/cmap/command_monitoring_events.ts

@@ -1,7 +1,7 @@
-import { GetMore, KillCursor, Msg, WriteProtocolMessageType } from './commands';
+import type { Document, ObjectId } from '../bson';
 import { calculateDurationInMs, deepCopy } from '../utils';
+import { GetMore, KillCursor, Msg, WriteProtocolMessageType } from './commands';
 import type { Connection } from './connection';
-import type { Document, ObjectId } from '../bson';
 
 /**
  * An event indicating the start of a given