mongodb 4.1.4 → 4.3.0

package/src/operations/execute_operation.ts

@@ -1,22 +1,26 @@
-import { ReadPreference } from '../read_preference';
+import type { Document } from '../bson';
 import {
-  MongoError,
   isRetryableError,
+  MongoCompatibilityError,
   MONGODB_ERROR_CODES,
-  MongoRuntimeError,
+  MongoError,
+  MongoExpiredSessionError,
   MongoNetworkError,
-  MongoCompatibilityError,
+  MongoRuntimeError,
   MongoServerError,
-  MongoExpiredSessionError,
   MongoTransactionError
 } from '../error';
-import { Aspect, AbstractOperation } from './operation';
-import { maxWireVersion, maybePromise, Callback } from '../utils';
+import { ReadPreference } from '../read_preference';
 import type { Server } from '../sdam/server';
+import {
+  sameServerSelector,
+  secondaryWritableServerSelector,
+  ServerSelector
+} from '../sdam/server_selection';
 import type { Topology } from '../sdam/topology';
 import type { ClientSession } from '../sessions';
-import type { Document } from '../bson';
-import { supportsRetryableWrites } from '../utils';
+import { Callback, maxWireVersion, maybePromise, supportsRetryableWrites } from '../utils';
+import { AbstractOperation, Aspect } from './operation';
 
 const MMAPv1_RETRY_WRITES_ERROR_CODE = MONGODB_ERROR_CODES.IllegalOperation;
 const MMAPv1_RETRY_WRITES_ERROR_MESSAGE =
@@ -150,6 +154,21 @@ function executeWithServerSelection(
     session.unpin();
   }
 
+  let selector: ReadPreference | ServerSelector;
+
+  if (operation.hasAspect(Aspect.CURSOR_ITERATING)) {
+    // Get more operations must always select the same server, but run through
+    // server selection to potentially force monitor checks if the server is
+    // in an unknown state.
+    selector = sameServerSelector(operation.server?.description);
+  } else if (operation.trySecondaryWrite) {
+    // If operation should try to write to secondary use the custom server selector
+    // otherwise provide the read preference.
+    selector = secondaryWritableServerSelector(topology.commonWireVersion, readPreference);
+  } else {
+    selector = readPreference;
+  }
+
   const serverSelectionOptions = { session };
   function callbackWithRetry(err?: any, result?: any) {
     if (err == null) {
@@ -182,7 +201,7 @@ function executeWithServerSelection(
     }
 
     // select a new server, and attempt to retry the operation
-    topology.selectServer(readPreference, serverSelectionOptions, (e?: any, server?: any) => {
+    topology.selectServer(selector, serverSelectionOptions, (e?: any, server?: any) => {
       if (
         e ||
         (operation.hasAspect(Aspect.READ_OPERATION) && !supportsRetryableReads(server)) ||
@@ -227,7 +246,7 @@ function executeWithServerSelection(
   }
 
   // select a server, and execute the operation against it
-  topology.selectServer(readPreference, serverSelectionOptions, (err?: any, server?: any) => {
+  topology.selectServer(selector, serverSelectionOptions, (err?: any, server?: any) => {
     if (err) {
       callback(err);
       return;

package/src/operations/find.ts

@@ -1,20 +1,20 @@
-import { Aspect, defineAspects, Hint } from './operation';
-import {
-  maxWireVersion,
-  MongoDBNamespace,
-  Callback,
-  normalizeHintField,
-  decorateWithExplain
-} from '../utils';
-import { MongoInvalidArgumentError, MongoCompatibilityError } from '../error';
 import type { Document } from '../bson';
-import type { Server } from '../sdam/server';
-import type { Collection } from '../collection';
-import { CommandOperation, CommandOperationOptions, CollationOptions } from './command';
-import { Sort, formatSort } from '../sort';
 import { isSharded } from '../cmap/wire_protocol/shared';
+import type { Collection } from '../collection';
+import { MongoCompatibilityError, MongoInvalidArgumentError } from '../error';
 import { ReadConcern } from '../read_concern';
+import type { Server } from '../sdam/server';
 import type { ClientSession } from '../sessions';
+import { formatSort, Sort } from '../sort';
+import {
+  Callback,
+  decorateWithExplain,
+  maxWireVersion,
+  MongoDBNamespace,
+  normalizeHintField
+} from '../utils';
+import { CollationOptions, CommandOperation, CommandOperationOptions } from './command';
+import { Aspect, defineAspects, Hint } from './operation';
 
 /**
  * @public
@@ -36,7 +36,7 @@ export interface FindOptions<TSchema extends Document = Document> extends Comman
   timeout?: boolean;
   /** Specify if the cursor is tailable. */
   tailable?: boolean;
-  /** Specify if the cursor is a a tailable-await cursor. Requires `tailable` to be true */
+  /** Specify if the cursor is a tailable-await cursor. Requires `tailable` to be true */
   awaitData?: boolean;
   /** Set the batchSize for the getMoreCommand when iterating over the query results. */
   batchSize?: number;

package/src/operations/find_and_modify.ts

@@ -1,14 +1,14 @@
-import { ReadPreference } from '../read_preference';
-import { maxWireVersion, decorateWithCollation, hasAtomicOperators, Callback } from '../utils';
-import { MongoInvalidArgumentError, MongoCompatibilityError } from '../error';
-import { CommandOperation, CommandOperationOptions } from './command';
-import { defineAspects, Aspect } from './operation';
 import type { Document } from '../bson';
-import type { Server } from '../sdam/server';
 import type { Collection } from '../collection';
-import { Sort, SortForCmd, formatSort } from '../sort';
+import { MongoCompatibilityError, MongoInvalidArgumentError } from '../error';
+import { ReadPreference } from '../read_preference';
+import type { Server } from '../sdam/server';
 import type { ClientSession } from '../sessions';
+import { formatSort, Sort, SortForCmd } from '../sort';
+import { Callback, decorateWithCollation, hasAtomicOperators, maxWireVersion } from '../utils';
 import type { WriteConcern, WriteConcernSettings } from '../write_concern';
+import { CommandOperation, CommandOperationOptions } from './command';
+import { Aspect, defineAspects } from './operation';
 
 /** @public */
 export const ReturnDocument = Object.freeze({

package/src/operations/get_more.ts

@@ -0,0 +1,49 @@
+import type { Document, Long } from '../bson';
+import { MongoRuntimeError } from '../error';
+import type { Server } from '../sdam/server';
+import type { ClientSession } from '../sessions';
+import type { Callback, MongoDBNamespace } from '../utils';
+import { AbstractOperation, Aspect, defineAspects, OperationOptions } from './operation';
+
+/**
+ * @public
+ */
+// eslint-disable-next-line @typescript-eslint/no-unused-vars
+export interface GetMoreOptions extends OperationOptions {
+  /** Set the batchSize for the getMoreCommand when iterating over the query results. */
+  batchSize?: number;
+  /** You can put a $comment field on a query to make looking in the profiler logs simpler. */
+  comment?: string | Document;
+  /** Number of milliseconds to wait before aborting the query. */
+  maxTimeMS?: number;
+}
+
+/** @internal */
+export class GetMoreOperation extends AbstractOperation {
+  cursorId: Long;
+  options: GetMoreOptions;
+  server: Server;
+
+  constructor(ns: MongoDBNamespace, cursorId: Long, server: Server, options: GetMoreOptions = {}) {
+    super(options);
+    this.options = options;
+    this.ns = ns;
+    this.cursorId = cursorId;
+    this.server = server;
+  }
+
+  /**
+   * Although there is a server already associated with the get more operation, the signature
+   * for execute passes a server so we will just use that one.
+   */
+  execute(server: Server, session: ClientSession, callback: Callback<Document>): void {
+    if (server !== this.server) {
+      return callback(
+        new MongoRuntimeError('Getmore must run on the same server operation began on')
+      );
+    }
+    server.getMore(this.ns, this.cursorId, this.options, callback);
+  }
+}
+
+defineAspects(GetMoreOperation, [Aspect.READ_OPERATION, Aspect.CURSOR_ITERATING]);

package/src/operations/indexes.ts

@@ -1,28 +1,28 @@
-import { indexInformation, IndexInformationOptions } from './common_functions';
-import { AbstractOperation, Aspect, defineAspects } from './operation';
-import { MONGODB_ERROR_CODES, MongoServerError, MongoCompatibilityError } from '../error';
+import type { Document } from '../bson';
+import type { Collection } from '../collection';
+import { AbstractCursor } from '../cursor/abstract_cursor';
+import type { Db } from '../db';
+import { MongoCompatibilityError, MONGODB_ERROR_CODES, MongoServerError } from '../error';
+import type { OneOrMore } from '../mongo_types';
+import { ReadPreference } from '../read_preference';
+import type { Server } from '../sdam/server';
+import type { ClientSession } from '../sessions';
 import {
+  Callback,
+  getTopology,
   maxWireVersion,
-  parseIndexOptions,
   MongoDBNamespace,
-  Callback,
-  getTopology
+  parseIndexOptions
 } from '../utils';
 import {
+  CollationOptions,
   CommandOperation,
   CommandOperationOptions,
-  OperationParent,
-  CollationOptions
+  OperationParent
 } from './command';
-import { ReadPreference } from '../read_preference';
-import type { Server } from '../sdam/server';
-import type { Document } from '../bson';
-import type { Collection } from '../collection';
-import type { Db } from '../db';
-import { AbstractCursor } from '../cursor/abstract_cursor';
-import type { ClientSession } from '../sessions';
+import { indexInformation, IndexInformationOptions } from './common_functions';
 import { executeOperation, ExecutionResult } from './execute_operation';
-import type { OneOrMore } from '../mongo_types';
+import { AbstractOperation, Aspect, defineAspects } from './operation';
 
 const LIST_INDEXES_WIRE_VERSION = 3;
 const VALID_INDEX_OPTIONS = new Set([

package/src/operations/insert.ts

@@ -1,16 +1,16 @@
-import { MongoServerError, MongoInvalidArgumentError } from '../error';
-import { defineAspects, Aspect, AbstractOperation } from './operation';
-import { CommandOperation, CommandOperationOptions } from './command';
-import { prepareDocs } from './common_functions';
-import type { Callback, MongoDBNamespace } from '../utils';
-import type { Server } from '../sdam/server';
-import type { Collection } from '../collection';
 import type { Document } from '../bson';
 import type { BulkWriteOptions } from '../bulk/common';
-import { WriteConcern } from '../write_concern';
+import type { Collection } from '../collection';
+import { MongoInvalidArgumentError, MongoServerError } from '../error';
+import type { InferIdType } from '../mongo_types';
+import type { Server } from '../sdam/server';
 import type { ClientSession } from '../sessions';
+import type { Callback, MongoDBNamespace } from '../utils';
+import { WriteConcern } from '../write_concern';
 import { BulkWriteOperation } from './bulk_write';
-import type { InferIdType } from '../mongo_types';
+import { CommandOperation, CommandOperationOptions } from './command';
+import { prepareDocs } from './common_functions';
+import { AbstractOperation, Aspect, defineAspects } from './operation';
 
 /** @internal */
 export class InsertOperation extends CommandOperation<Document> {

package/src/operations/is_capped.ts

@@ -1,9 +1,9 @@
-import type { Callback } from '../utils';
 import type { Collection } from '../collection';
-import { OperationOptions, AbstractOperation } from './operation';
+import { MongoAPIError } from '../error';
 import type { Server } from '../sdam/server';
 import type { ClientSession } from '../sessions';
-import { MongoAPIError } from '../error';
+import type { Callback } from '../utils';
+import { AbstractOperation, OperationOptions } from './operation';
 
 /** @internal */
 export class IsCappedOperation extends AbstractOperation<boolean> {

package/src/operations/list_collections.ts

@@ -1,13 +1,13 @@
-import { CommandOperation, CommandOperationOptions } from './command';
-import { Aspect, defineAspects } from './operation';
-import { maxWireVersion, Callback, getTopology, MongoDBNamespace } from '../utils';
-import * as CONSTANTS from '../constants';
 import type { Binary, Document } from '../bson';
-import type { Server } from '../sdam/server';
-import type { Db } from '../db';
+import * as CONSTANTS from '../constants';
 import { AbstractCursor } from '../cursor/abstract_cursor';
+import type { Db } from '../db';
+import type { Server } from '../sdam/server';
 import type { ClientSession } from '../sessions';
+import { Callback, getTopology, maxWireVersion, MongoDBNamespace } from '../utils';
+import { CommandOperation, CommandOperationOptions } from './command';
 import { executeOperation, ExecutionResult } from './execute_operation';
+import { Aspect, defineAspects } from './operation';
 
 const LIST_COLLECTIONS_WIRE_VERSION = 3;
 
@@ -15,6 +15,8 @@ const LIST_COLLECTIONS_WIRE_VERSION = 3;
 export interface ListCollectionsOptions extends CommandOperationOptions {
   /** Since 4.0: If true, will only return the collection name in the response, and will omit additional info */
   nameOnly?: boolean;
+  /** Since 4.0: If true and nameOnly is true, allows a user without the required privilege (i.e. listCollections action on the database) to run the command when access control is enforced. */
+  authorizedCollections?: boolean;
   /** The batchSize for the returned command cursor or if pre 2.8 the systems batch collection */
   batchSize?: number;
 }
@@ -25,6 +27,7 @@ export class ListCollectionsOperation extends CommandOperation<string[]> {
   db: Db;
   filter: Document;
   nameOnly: boolean;
+  authorizedCollections: boolean;
   batchSize?: number;
 
   constructor(db: Db, filter: Document, options?: ListCollectionsOptions) {
@@ -34,6 +37,7 @@ export class ListCollectionsOperation extends CommandOperation<string[]> {
     this.db = db;
     this.filter = filter;
     this.nameOnly = !!this.options.nameOnly;
+    this.authorizedCollections = !!this.options.authorizedCollections;
 
     if (typeof this.options.batchSize === 'number') {
       this.batchSize = this.options.batchSize;
@@ -90,14 +94,18 @@ export class ListCollectionsOperation extends CommandOperation<string[]> {
       return;
     }
 
-    const command = {
+    return super.executeCommand(server, session, this.generateCommand(), callback);
+  }
+
+  /* This is here for the purpose of unit testing the final command that gets sent. */
+  generateCommand(): Document {
+    return {
       listCollections: 1,
       filter: this.filter,
       cursor: this.batchSize ? { batchSize: this.batchSize } : {},
-      nameOnly: this.nameOnly
+      nameOnly: this.nameOnly,
+      authorizedCollections: this.authorizedCollections
     };
-
-    return super.executeCommand(server, session, command, callback);
   }
 }
 

package/src/operations/list_databases.ts

@@ -1,10 +1,10 @@
-import { CommandOperation, CommandOperationOptions } from './command';
-import { Aspect, defineAspects } from './operation';
-import { MongoDBNamespace, Callback } from '../utils';
 import type { Document } from '../bson';
-import type { Server } from '../sdam/server';
 import type { Db } from '../db';
+import type { Server } from '../sdam/server';
 import type { ClientSession } from '../sessions';
+import { Callback, MongoDBNamespace } from '../utils';
+import { CommandOperation, CommandOperationOptions } from './command';
+import { Aspect, defineAspects } from './operation';
 
 /** @public */
 export interface ListDatabasesResult {

package/src/operations/map_reduce.ts

@@ -1,22 +1,22 @@
+import type { ObjectId } from '../bson';
 import { Code, Document } from '../bson';
+import type { Collection } from '../collection';
+import { Db } from '../db';
+import { MongoCompatibilityError, MongoServerError } from '../error';
+import { ReadPreference, ReadPreferenceMode } from '../read_preference';
+import type { Server } from '../sdam/server';
+import type { ClientSession } from '../sessions';
+import type { Sort } from '../sort';
 import {
   applyWriteConcern,
+  Callback,
   decorateWithCollation,
   decorateWithReadConcern,
   isObject,
-  Callback,
   maxWireVersion
 } from '../utils';
-import { ReadPreference, ReadPreferenceMode } from '../read_preference';
 import { CommandOperation, CommandOperationOptions } from './command';
-import type { Server } from '../sdam/server';
-import type { Collection } from '../collection';
-import type { Sort } from '../sort';
-import { MongoServerError, MongoCompatibilityError } from '../error';
-import type { ObjectId } from '../bson';
 import { Aspect, defineAspects } from './operation';
-import type { ClientSession } from '../sessions';
-import { Db } from '../db';
 
 const exclusionList = [
   'explain',
@@ -33,6 +33,7 @@ const exclusionList = [
   'bsonRegExp',
   'serializeFunctions',
   'ignoreUndefined',
+  'enableUtf8Validation',
   'scope' // this option is reformatted thus exclude the original
 ];
 

package/src/operations/operation.ts

@@ -1,8 +1,8 @@
+import { BSONSerializeOptions, Document, resolveBSONOptions } from '../bson';
 import { ReadPreference, ReadPreferenceLike } from '../read_preference';
-import type { ClientSession } from '../sessions';
-import { Document, BSONSerializeOptions, resolveBSONOptions } from '../bson';
-import type { MongoDBNamespace, Callback } from '../utils';
 import type { Server } from '../sdam/server';
+import type { ClientSession } from '../sessions';
+import type { Callback, MongoDBNamespace } from '../utils';
 
 export const Aspect = {
   READ_OPERATION: Symbol('READ_OPERATION'),
@@ -10,7 +10,8 @@ export const Aspect = {
   RETRYABLE: Symbol('RETRYABLE'),
   EXPLAINABLE: Symbol('EXPLAINABLE'),
   SKIP_COLLATION: Symbol('SKIP_COLLATION'),
-  CURSOR_CREATING: Symbol('CURSOR_CREATING')
+  CURSOR_CREATING: Symbol('CURSOR_CREATING'),
+  CURSOR_ITERATING: Symbol('CURSOR_ITERATING')
 } as const;
 
 /** @public */
@@ -31,6 +32,7 @@ export interface OperationOptions extends BSONSerializeOptions {
 
   /** @internal Hints to `executeOperation` that this operation should not unpin on an ended transaction */
   bypassPinningCheck?: boolean;
+  omitReadPreference?: boolean;
 }
 
 /** @internal */
@@ -49,6 +51,7 @@ export abstract class AbstractOperation<TResult = any> {
   readPreference: ReadPreference;
   server!: Server;
   bypassPinningCheck: boolean;
+  trySecondaryWrite: boolean;
 
   // BSON serialization options
   bsonOptions?: BSONSerializeOptions;
@@ -72,6 +75,7 @@ export abstract class AbstractOperation<TResult = any> {
 
     this.options = options;
     this.bypassPinningCheck = !!options.bypassPinningCheck;
+    this.trySecondaryWrite = false;
   }
 
   abstract execute(server: Server, session: ClientSession, callback: Callback<TResult>): void;

package/src/operations/options_operation.ts

@@ -1,10 +1,10 @@
-import { AbstractOperation, OperationOptions } from './operation';
-import { MongoAPIError } from '../error';
-import type { Callback } from '../utils';
 import type { Document } from '../bson';
 import type { Collection } from '../collection';
+import { MongoAPIError } from '../error';
 import type { Server } from '../sdam/server';
 import type { ClientSession } from '../sessions';
+import type { Callback } from '../utils';
+import { AbstractOperation, OperationOptions } from './operation';
 
 /** @internal */
 export class OptionsOperation extends AbstractOperation<Document> {

package/src/operations/profiling_level.ts

@@ -1,9 +1,9 @@
-import { CommandOperation, CommandOperationOptions } from './command';
-import type { Callback } from '../utils';
-import type { Server } from '../sdam/server';
 import type { Db } from '../db';
-import type { ClientSession } from '../sessions';
 import { MongoRuntimeError } from '../error';
+import type { Server } from '../sdam/server';
+import type { ClientSession } from '../sessions';
+import type { Callback } from '../utils';
+import { CommandOperation, CommandOperationOptions } from './command';
 
 /** @public */
 export type ProfilingLevelOptions = CommandOperationOptions;

package/src/operations/remove_user.ts

@@ -1,9 +1,9 @@
-import { Aspect, defineAspects } from './operation';
-import { CommandOperation, CommandOperationOptions } from './command';
-import type { Callback } from '../utils';
-import type { Server } from '../sdam/server';
 import type { Db } from '../db';
+import type { Server } from '../sdam/server';
 import type { ClientSession } from '../sessions';
+import type { Callback } from '../utils';
+import { CommandOperation, CommandOperationOptions } from './command';
+import { Aspect, defineAspects } from './operation';
 
 /** @public */
 export type RemoveUserOptions = CommandOperationOptions;

package/src/operations/rename.ts

@@ -1,12 +1,12 @@
-import { checkCollectionName, Callback } from '../utils';
-import { RunAdminCommandOperation } from './run_command';
-import { defineAspects, Aspect } from './operation';
-import type { Server } from '../sdam/server';
+import type { Document } from '../bson';
 import { Collection } from '../collection';
-import type { CommandOperationOptions } from './command';
 import { MongoServerError } from '../error';
+import type { Server } from '../sdam/server';
 import type { ClientSession } from '../sessions';
-import type { Document } from 'bson';
+import { Callback, checkCollectionName } from '../utils';
+import type { CommandOperationOptions } from './command';
+import { Aspect, defineAspects } from './operation';
+import { RunAdminCommandOperation } from './run_command';
 
 /** @public */
 export interface RenameOptions extends CommandOperationOptions {

package/src/operations/run_command.ts

@@ -1,8 +1,8 @@
-import { CommandOperation, CommandOperationOptions, OperationParent } from './command';
-import { MongoDBNamespace, Callback } from '../utils';
-import type { Server } from '../sdam/server';
 import type { Document } from '../bson';
+import type { Server } from '../sdam/server';
 import type { ClientSession } from '../sessions';
+import { Callback, MongoDBNamespace } from '../utils';
+import { CommandOperation, CommandOperationOptions, OperationParent } from './command';
 
 /** @public */
 export type RunCommandOptions = CommandOperationOptions;

package/src/operations/set_profiling_level.ts

@@ -1,10 +1,11 @@
-import { CommandOperation, CommandOperationOptions } from './command';
-import type { Callback } from '../utils';
-import { enumToString } from '../utils';
-import type { Server } from '../sdam/server';
 import type { Db } from '../db';
+import { MongoInvalidArgumentError, MongoRuntimeError } from '../error';
+import type { Server } from '../sdam/server';
 import type { ClientSession } from '../sessions';
-import { MongoRuntimeError, MongoInvalidArgumentError } from '../error';
+import type { Callback } from '../utils';
+import { enumToString } from '../utils';
+import { CommandOperation, CommandOperationOptions } from './command';
+
 const levelValues = new Set(['off', 'slow_only', 'all']);
 
 /** @public */

package/src/operations/stats.ts

@@ -1,11 +1,11 @@
-import { Aspect, defineAspects } from './operation';
-import { CommandOperation, CommandOperationOptions } from './command';
-import type { Callback } from '../utils';
 import type { Document } from '../bson';
-import type { Server } from '../sdam/server';
 import type { Collection } from '../collection';
 import type { Db } from '../db';
+import type { Server } from '../sdam/server';
 import type { ClientSession } from '../sessions';
+import type { Callback } from '../utils';
+import { CommandOperation, CommandOperationOptions } from './command';
+import { Aspect, defineAspects } from './operation';
 
 /** @public */
 export interface CollStatsOptions extends CommandOperationOptions {

package/src/operations/update.ts

@@ -1,17 +1,17 @@
-import { defineAspects, Aspect, Hint } from './operation';
+import type { Document, ObjectId } from '../bson';
+import type { Collection } from '../collection';
+import { MongoCompatibilityError, MongoInvalidArgumentError, MongoServerError } from '../error';
+import type { Server } from '../sdam/server';
+import type { ClientSession } from '../sessions';
 import {
-  hasAtomicOperators,
-  MongoDBNamespace,
   Callback,
   collationNotSupported,
-  maxWireVersion
+  hasAtomicOperators,
+  maxWireVersion,
+  MongoDBNamespace
 } from '../utils';
-import { CommandOperation, CommandOperationOptions, CollationOptions } from './command';
-import type { Server } from '../sdam/server';
-import type { Collection } from '../collection';
-import type { ObjectId, Document } from '../bson';
-import type { ClientSession } from '../sessions';
-import { MongoServerError, MongoInvalidArgumentError, MongoCompatibilityError } from '../error';
+import { CollationOptions, CommandOperation, CommandOperationOptions } from './command';
+import { Aspect, defineAspects, Hint } from './operation';
 
 /** @public */
 export interface UpdateOptions extends CommandOperationOptions {

package/src/operations/validate_collection.ts

@@ -1,10 +1,10 @@
-import { CommandOperation, CommandOperationOptions } from './command';
-import type { Callback } from '../utils';
+import type { Admin } from '../admin';
 import type { Document } from '../bson';
+import { MongoRuntimeError } from '../error';
 import type { Server } from '../sdam/server';
-import type { Admin } from '../admin';
 import type { ClientSession } from '../sessions';
-import { MongoRuntimeError } from '../error';
+import type { Callback } from '../utils';
+import { CommandOperation, CommandOperationOptions } from './command';
 
 /** @public */
 export interface ValidateCollectionOptions extends CommandOperationOptions {