mongodb 6.12.0 → 6.13.0-dev.20250201.sha.35c703e3

package/src/collection.ts

@@ -14,6 +14,7 @@ import type { Db } from './db';
 import { MongoInvalidArgumentError, MongoOperationTimeoutError } from './error';
 import type { MongoClient, PkFactory } from './mongo_client';
 import type {
+  Abortable,
   Filter,
   Flatten,
   OptionalUnlessRequiredId,
@@ -505,7 +506,7 @@ export class Collection<TSchema extends Document = Document> {
   async findOne(filter: Filter<TSchema>): Promise<WithId<TSchema> | null>;
   async findOne(
     filter: Filter<TSchema>,
-    options: Omit<FindOptions, 'timeoutMode'>
+    options: Omit<FindOptions, 'timeoutMode'> & Abortable
   ): Promise<WithId<TSchema> | null>;
 
   // allow an override of the schema.
@@ -513,12 +514,12 @@ export class Collection<TSchema extends Document = Document> {
   async findOne<T = TSchema>(filter: Filter<TSchema>): Promise<T | null>;
   async findOne<T = TSchema>(
     filter: Filter<TSchema>,
-    options?: Omit<FindOptions, 'timeoutMode'>
+    options?: Omit<FindOptions, 'timeoutMode'> & Abortable
   ): Promise<T | null>;
 
   async findOne(
     filter: Filter<TSchema> = {},
-    options: FindOptions = {}
+    options: FindOptions & Abortable = {}
   ): Promise<WithId<TSchema> | null> {
     const cursor = this.find(filter, options).limit(-1).batchSize(1);
     const res = await cursor.next();
@@ -532,9 +533,15 @@ export class Collection<TSchema extends Document = Document> {
    * @param filter - The filter predicate. If unspecified, then all documents in the collection will match the predicate
    */
   find(): FindCursor<WithId<TSchema>>;
-  find(filter: Filter<TSchema>, options?: FindOptions): FindCursor<WithId<TSchema>>;
-  find<T extends Document>(filter: Filter<TSchema>, options?: FindOptions): FindCursor<T>;
-  find(filter: Filter<TSchema> = {}, options: FindOptions = {}): FindCursor<WithId<TSchema>> {
+  find(filter: Filter<TSchema>, options?: FindOptions & Abortable): FindCursor<WithId<TSchema>>;
+  find<T extends Document>(
+    filter: Filter<TSchema>,
+    options?: FindOptions & Abortable
+  ): FindCursor<T>;
+  find(
+    filter: Filter<TSchema> = {},
+    options: FindOptions & Abortable = {}
+  ): FindCursor<WithId<TSchema>> {
     return new FindCursor<WithId<TSchema>>(
       this.client,
       this.s.namespace,
@@ -792,7 +799,7 @@ export class Collection<TSchema extends Document = Document> {
    */
   async countDocuments(
     filter: Filter<TSchema> = {},
-    options: CountDocumentsOptions = {}
+    options: CountDocumentsOptions & Abortable = {}
   ): Promise<number> {
     const pipeline = [];
     pipeline.push({ $match: filter });
@@ -1006,7 +1013,7 @@ export class Collection<TSchema extends Document = Document> {
    */
   aggregate<T extends Document = Document>(
     pipeline: Document[] = [],
-    options?: AggregateOptions
+    options?: AggregateOptions & Abortable
   ): AggregationCursor<T> {
     if (!Array.isArray(pipeline)) {
       throw new MongoInvalidArgumentError(

package/src/connection_string.ts

@@ -22,13 +22,7 @@ import {
   type ServerApi,
   ServerApiVersion
 } from './mongo_client';
-import {
-  MongoLoggableComponent,
-  MongoLogger,
-  type MongoLoggerEnvOptions,
-  type MongoLoggerMongoClientOptions,
-  SeverityLevel
-} from './mongo_logger';
+import { MongoLoggableComponent, MongoLogger, SeverityLevel } from './mongo_logger';
 import { ReadConcern, type ReadConcernLevel } from './read_concern';
 import { ReadPreference, type ReadPreferenceMode } from './read_preference';
 import { ServerMonitoringMode } from './sdam/monitor';
@@ -52,6 +46,27 @@ const LB_REPLICA_SET_ERROR = 'loadBalanced option not supported with a replicaSe
 const LB_DIRECT_CONNECTION_ERROR =
   'loadBalanced option not supported when directConnection is provided';
 
+function retryDNSTimeoutFor(api: 'resolveSrv'): (a: string) => Promise<dns.SrvRecord[]>;
+function retryDNSTimeoutFor(api: 'resolveTxt'): (a: string) => Promise<string[][]>;
+function retryDNSTimeoutFor(
+  api: 'resolveSrv' | 'resolveTxt'
+): (a: string) => Promise<dns.SrvRecord[] | string[][]> {
+  return async function dnsReqRetryTimeout(lookupAddress: string) {
+    try {
+      return await dns.promises[api](lookupAddress);
+    } catch (firstDNSError) {
+      if (firstDNSError.code === dns.TIMEOUT) {
+        return await dns.promises[api](lookupAddress);
+      } else {
+        throw firstDNSError;
+      }
+    }
+  };
+}
+
+const resolveSrv = retryDNSTimeoutFor('resolveSrv');
+const resolveTxt = retryDNSTimeoutFor('resolveTxt');
+
 /**
  * Lookup a `mongodb+srv` connection string, combine the parts and reparse it as a normal
  * connection string.
@@ -67,14 +82,13 @@ export async function resolveSRVRecord(options: MongoOptions): Promise<HostAddre
   // Asynchronously start TXT resolution so that we do not have to wait until
   // the SRV record is resolved before starting a second DNS query.
   const lookupAddress = options.srvHost;
-  const txtResolutionPromise = dns.promises.resolveTxt(lookupAddress);
+  const txtResolutionPromise = resolveTxt(lookupAddress);
 
   txtResolutionPromise.then(undefined, squashError); // rejections will be handled later
 
+  const hostname = `_${options.srvServiceName}._tcp.${lookupAddress}`;
   // Resolve the SRV record and use the result as the list of hosts to connect to.
-  const addresses = await dns.promises.resolveSrv(
-    `_${options.srvServiceName}._tcp.${lookupAddress}`
-  );
+  const addresses = await resolveSrv(hostname);
 
   if (addresses.length === 0) {
     throw new MongoAPIError('No addresses found at host');
@@ -249,13 +263,6 @@ export function parseOptions(
 
   const mongoOptions = Object.create(null);
 
-  // Feature flags
-  for (const flag of Object.getOwnPropertySymbols(options)) {
-    if (FEATURE_FLAGS.has(flag)) {
-      mongoOptions[flag] = options[flag];
-    }
-  }
-
   mongoOptions.hosts = isSRV ? [] : hosts.map(HostAddress.fromString);
 
   const urlOptions = new CaseInsensitiveMap<unknown[]>();
@@ -515,13 +522,8 @@ export function parseOptions(
     );
   }
 
-  const loggerFeatureFlag = Symbol.for('@@mdb.enableMongoLogger');
-  mongoOptions[loggerFeatureFlag] = mongoOptions[loggerFeatureFlag] ?? false;
-
-  let loggerEnvOptions: MongoLoggerEnvOptions = {};
-  let loggerClientOptions: MongoLoggerMongoClientOptions = {};
-  if (mongoOptions[loggerFeatureFlag]) {
-    loggerEnvOptions = {
+  mongoOptions.mongoLoggerOptions = MongoLogger.resolveOptions(
+    {
       MONGODB_LOG_COMMAND: process.env.MONGODB_LOG_COMMAND,
       MONGODB_LOG_TOPOLOGY: process.env.MONGODB_LOG_TOPOLOGY,
       MONGODB_LOG_SERVER_SELECTION: process.env.MONGODB_LOG_SERVER_SELECTION,
@@ -529,18 +531,13 @@ export function parseOptions(
       MONGODB_LOG_CLIENT: process.env.MONGODB_LOG_CLIENT,
       MONGODB_LOG_ALL: process.env.MONGODB_LOG_ALL,
       MONGODB_LOG_MAX_DOCUMENT_LENGTH: process.env.MONGODB_LOG_MAX_DOCUMENT_LENGTH,
-      MONGODB_LOG_PATH: process.env.MONGODB_LOG_PATH,
-      ...mongoOptions[Symbol.for('@@mdb.internalLoggerConfig')]
-    };
-    loggerClientOptions = {
+      MONGODB_LOG_PATH: process.env.MONGODB_LOG_PATH
+    },
+    {
       mongodbLogPath: mongoOptions.mongodbLogPath,
       mongodbLogComponentSeverities: mongoOptions.mongodbLogComponentSeverities,
       mongodbLogMaxDocumentLength: mongoOptions.mongodbLogMaxDocumentLength
-    };
-  }
-  mongoOptions.mongoLoggerOptions = MongoLogger.resolveOptions(
-    loggerEnvOptions,
-    loggerClientOptions
+    }
   );
 
   mongoOptions.metadata = makeClientMetadata(mongoOptions);
@@ -1220,52 +1217,6 @@ export const OPTIONS = {
     default: 0,
     type: 'int'
   },
-  // Custom types for modifying core behavior
-  connectionType: { type: 'any' },
-  srvPoller: { type: 'any' },
-  // Accepted Node.js Options
-  allowPartialTrustChain: { type: 'any' },
-  minDHSize: { type: 'any' },
-  pskCallback: { type: 'any' },
-  secureContext: { type: 'any' },
-  enableTrace: { type: 'any' },
-  requestCert: { type: 'any' },
-  rejectUnauthorized: { type: 'any' },
-  checkServerIdentity: { type: 'any' },
-  ALPNProtocols: { type: 'any' },
-  SNICallback: { type: 'any' },
-  session: { type: 'any' },
-  requestOCSP: { type: 'any' },
-  localAddress: { type: 'any' },
-  localPort: { type: 'any' },
-  hints: { type: 'any' },
-  lookup: { type: 'any' },
-  ca: { type: 'any' },
-  cert: { type: 'any' },
-  ciphers: { type: 'any' },
-  crl: { type: 'any' },
-  ecdhCurve: { type: 'any' },
-  key: { type: 'any' },
-  passphrase: { type: 'any' },
-  pfx: { type: 'any' },
-  secureProtocol: { type: 'any' },
-  index: { type: 'any' },
-  // Legacy options from v3 era
-  useNewUrlParser: {
-    type: 'boolean',
-    deprecated:
-      'useNewUrlParser has no effect since Node.js Driver version 4.0.0 and will be removed in the next major version'
-  } as OptionDescriptor,
-  useUnifiedTopology: {
-    type: 'boolean',
-    deprecated:
-      'useUnifiedTopology has no effect since Node.js Driver version 4.0.0 and will be removed in the next major version'
-  } as OptionDescriptor,
-  // MongoLogger
-  /**
-   * @internal
-   * TODO: NODE-5671 - remove internal flag
-   */
   mongodbLogPath: {
     transform({ values: [value] }) {
       if (
@@ -1284,10 +1235,6 @@ export const OPTIONS = {
       return value;
     }
   },
-  /**
-   * @internal
-   * TODO: NODE-5671 - remove internal flag
-   */
   mongodbLogComponentSeverities: {
     transform({ values: [value] }) {
       if (typeof value !== 'object' || !value) {
@@ -1313,11 +1260,49 @@ export const OPTIONS = {
       return value;
     }
   },
-  /**
-   * @internal
-   * TODO: NODE-5671 - remove internal flag
-   */
-  mongodbLogMaxDocumentLength: { type: 'uint' }
+  mongodbLogMaxDocumentLength: { type: 'uint' },
+  // Custom types for modifying core behavior
+  connectionType: { type: 'any' },
+  srvPoller: { type: 'any' },
+  // Accepted Node.js Options
+  allowPartialTrustChain: { type: 'any' },
+  minDHSize: { type: 'any' },
+  pskCallback: { type: 'any' },
+  secureContext: { type: 'any' },
+  enableTrace: { type: 'any' },
+  requestCert: { type: 'any' },
+  rejectUnauthorized: { type: 'any' },
+  checkServerIdentity: { type: 'any' },
+  ALPNProtocols: { type: 'any' },
+  SNICallback: { type: 'any' },
+  session: { type: 'any' },
+  requestOCSP: { type: 'any' },
+  localAddress: { type: 'any' },
+  localPort: { type: 'any' },
+  hints: { type: 'any' },
+  lookup: { type: 'any' },
+  ca: { type: 'any' },
+  cert: { type: 'any' },
+  ciphers: { type: 'any' },
+  crl: { type: 'any' },
+  ecdhCurve: { type: 'any' },
+  key: { type: 'any' },
+  passphrase: { type: 'any' },
+  pfx: { type: 'any' },
+  secureProtocol: { type: 'any' },
+  index: { type: 'any' },
+  // Legacy options from v3 era
+  useNewUrlParser: {
+    type: 'boolean',
+    deprecated:
+      'useNewUrlParser has no effect since Node.js Driver version 4.0.0 and will be removed in the next major version'
+  } as OptionDescriptor,
+  useUnifiedTopology: {
+    type: 'boolean',
+    deprecated:
+      'useUnifiedTopology has no effect since Node.js Driver version 4.0.0 and will be removed in the next major version'
+  } as OptionDescriptor,
+  __skipPingOnConnect: { type: 'boolean' }
 } as Record<keyof MongoClientOptions, OptionDescriptor>;
 
 export const DEFAULT_OPTIONS = new CaseInsensitiveMap(
@@ -1325,13 +1310,3 @@ export const DEFAULT_OPTIONS = new CaseInsensitiveMap(
     .filter(([, descriptor]) => descriptor.default != null)
     .map(([k, d]) => [k, d.default])
 );
-
-/**
- * Set of permitted feature flags
- * @internal
- */
-export const FEATURE_FLAGS = new Set([
-  Symbol.for('@@mdb.skipPingOnConnect'),
-  Symbol.for('@@mdb.enableMongoLogger'),
-  Symbol.for('@@mdb.internalLoggerConfig')
-]);

package/src/cursor/abstract_cursor.ts

@@ -12,7 +12,7 @@ import {
   MongoTailableCursorError
 } from '../error';
 import type { MongoClient } from '../mongo_client';
-import { TypedEventEmitter } from '../mongo_types';
+import { type Abortable, TypedEventEmitter } from '../mongo_types';
 import { executeOperation } from '../operations/execute_operation';
 import { GetMoreOperation } from '../operations/get_more';
 import { KillCursorsOperation } from '../operations/kill_cursors';
@@ -22,7 +22,13 @@ import { type AsyncDisposable, configureResourceManagement } from '../resource_m
 import type { Server } from '../sdam/server';
 import { ClientSession, maybeClearPinnedConnection } from '../sessions';
 import { type CSOTTimeoutContext, type Timeout, TimeoutContext } from '../timeout';
-import { type MongoDBNamespace, squashError } from '../utils';
+import {
+  addAbortListener,
+  type Disposable,
+  kDispose,
+  type MongoDBNamespace,
+  squashError
+} from '../utils';
 
 /**
  * @internal
@@ -61,6 +67,10 @@ export interface CursorStreamOptions {
 /** @public */
 export type CursorFlag = (typeof CURSOR_FLAGS)[number];
 
+function removeActiveCursor(this: AbstractCursor) {
+  this.client.s.activeCursors.delete(this);
+}
+
 /**
  * @public
  * @experimental
@@ -247,12 +257,14 @@ export abstract class AbstractCursor<
 
   /** @internal */
   protected deserializationOptions: OnDemandDocumentDeserializeOptions;
+  protected signal: AbortSignal | undefined;
+  private abortListener: Disposable | undefined;
 
   /** @internal */
   protected constructor(
     client: MongoClient,
     namespace: MongoDBNamespace,
-    options: AbstractCursorOptions = {}
+    options: AbstractCursorOptions & Abortable = {}
   ) {
     super();
 
@@ -352,6 +364,12 @@ export abstract class AbstractCursor<
     };
 
     this.timeoutContext = options.timeoutContext;
+    this.signal = options.signal;
+    this.abortListener = addAbortListener(
+      this.signal,
+      () => void this.close().then(undefined, squashError)
+    );
+    this.trackCursor();
   }
 
   /**
@@ -431,6 +449,14 @@ export abstract class AbstractCursor<
     await this.close();
   }
 
+  /** Adds cursor to client's tracking so it will be closed by MongoClient.close() */
+  private trackCursor() {
+    this.cursorClient.s.activeCursors.add(this);
+    if (!this.listeners('close').includes(removeActiveCursor)) {
+      this.once('close', removeActiveCursor);
+    }
+  }
+
   /** Returns current buffered documents length */
   bufferedCount(): number {
     return this.documents?.length ?? 0;
@@ -455,6 +481,8 @@ export abstract class AbstractCursor<
   }
 
   async *[Symbol.asyncIterator](): AsyncGenerator<TSchema, void, void> {
+    this.signal?.throwIfAborted();
+
     if (this.closed) {
       return;
     }
@@ -481,6 +509,8 @@ export abstract class AbstractCursor<
         }
 
         yield document;
+
+        this.signal?.throwIfAborted();
       }
     } finally {
       // Only close the cursor if it has not already been closed. This finally clause handles
@@ -496,9 +526,16 @@ export abstract class AbstractCursor<
   }
 
   stream(options?: CursorStreamOptions): Readable & AsyncIterable<TSchema> {
+    const readable = new ReadableCursorStream(this);
+    const abortListener = addAbortListener(this.signal, function () {
+      readable.destroy(this.reason);
+    });
+    readable.once('end', () => {
+      abortListener?.[kDispose]();
+    });
+
     if (options?.transform) {
       const transform = options.transform;
-      const readable = new ReadableCursorStream(this);
 
       const transformedStream = readable.pipe(
         new Transform({
@@ -522,10 +559,12 @@ export abstract class AbstractCursor<
       return transformedStream;
     }
 
-    return new ReadableCursorStream(this);
+    return readable;
   }
 
   async hasNext(): Promise<boolean> {
+    this.signal?.throwIfAborted();
+
     if (this.cursorId === Long.ZERO) {
       return false;
     }
@@ -551,6 +590,8 @@ export abstract class AbstractCursor<
 
   /** Get the next available document from the cursor, returns null if no more documents are available. */
   async next(): Promise<TSchema | null> {
+    this.signal?.throwIfAborted();
+
     if (this.cursorId === Long.ZERO) {
       throw new MongoCursorExhaustedError();
     }
@@ -581,6 +622,8 @@ export abstract class AbstractCursor<
    * Try to get the next available document from the cursor or `null` if an empty batch is returned
    */
   async tryNext(): Promise<TSchema | null> {
+    this.signal?.throwIfAborted();
+
     if (this.cursorId === Long.ZERO) {
       throw new MongoCursorExhaustedError();
     }
@@ -620,6 +663,8 @@ export abstract class AbstractCursor<
    * @deprecated - Will be removed in a future release. Use for await...of instead.
    */
   async forEach(iterator: (doc: TSchema) => boolean | void): Promise<void> {
+    this.signal?.throwIfAborted();
+
     if (typeof iterator !== 'function') {
       throw new MongoInvalidArgumentError('Argument "iterator" must be a function');
     }
@@ -645,6 +690,8 @@ export abstract class AbstractCursor<
    * cursor.rewind() can be used to reset the cursor.
    */
   async toArray(): Promise<TSchema[]> {
+    this.signal?.throwIfAborted();
+
     const array: TSchema[] = [];
     // at the end of the loop (since readBufferedDocuments is called) the buffer will be empty
     // then, the 'await of' syntax will run a getMore call
@@ -824,16 +871,15 @@ export abstract class AbstractCursor<
     this.isClosed = false;
     this.isKilled = false;
     this.initialized = false;
+    this.hasEmittedClose = false;
+    this.trackCursor();
 
-    const session = this.cursorSession;
-    if (session) {
-      // We only want to end this session if we created it, and it hasn't ended yet
-      if (session.explicit === false) {
-        if (!session.hasEnded) {
-          session.endSession().then(undefined, squashError);
-        }
-        this.cursorSession = this.cursorClient.startSession({ owner: this, explicit: false });
+    // We only want to end this session if we created it, and it hasn't ended yet
+    if (this.cursorSession.explicit === false) {
+      if (!this.cursorSession.hasEnded) {
+        this.cursorSession.endSession().then(undefined, squashError);
       }
+      this.cursorSession = this.cursorClient.startSession({ owner: this, explicit: false });
     }
   }
 
@@ -968,8 +1014,8 @@ export abstract class AbstractCursor<
 
   /** @internal */
   private async cleanup(timeoutMS?: number, error?: Error) {
+    this.abortListener?.[kDispose]();
     this.isClosed = true;
-    const session = this.cursorSession;
     const timeoutContextForKillCursors = (): CursorTimeoutContext | undefined => {
       if (timeoutMS != null) {
         this.timeoutContext?.clear();
@@ -991,7 +1037,7 @@ export abstract class AbstractCursor<
         !this.cursorId.isZero() &&
         this.cursorNamespace &&
         this.selectedServer &&
-        !session.hasEnded
+        !this.cursorSession.hasEnded
       ) {
         this.isKilled = true;
         const cursorId = this.cursorId;
@@ -1000,7 +1046,7 @@ export abstract class AbstractCursor<
         await executeOperation(
           this.cursorClient,
           new KillCursorsOperation(cursorId, this.cursorNamespace, this.selectedServer, {
-            session
+            session: this.cursorSession
           }),
           timeoutContextForKillCursors()
         );
@@ -1008,14 +1054,16 @@ export abstract class AbstractCursor<
     } catch (error) {
       squashError(error);
     } finally {
-      if (session?.owner === this) {
-        await session.endSession({ error });
-      }
-      if (!session?.inTransaction()) {
-        maybeClearPinnedConnection(session, { error });
+      try {
+        if (this.cursorSession?.owner === this) {
+          await this.cursorSession.endSession({ error });
+        }
+        if (!this.cursorSession?.inTransaction()) {
+          maybeClearPinnedConnection(this.cursorSession, { error });
+        }
+      } finally {
+        this.emitClose();
       }
-
-      this.emitClose();
     }
   }
 

package/src/cursor/aggregation_cursor.ts

@@ -8,6 +8,7 @@ import {
   validateExplainTimeoutOptions
 } from '../explain';
 import type { MongoClient } from '../mongo_client';
+import { type Abortable } from '../mongo_types';
 import { AggregateOperation, type AggregateOptions } from '../operations/aggregate';
 import { executeOperation } from '../operations/execute_operation';
 import type { ClientSession } from '../sessions';
@@ -32,14 +33,14 @@ export interface AggregationCursorOptions extends AbstractCursorOptions, Aggrega
 export class AggregationCursor<TSchema = any> extends ExplainableCursor<TSchema> {
   public readonly pipeline: Document[];
   /** @internal */
-  private aggregateOptions: AggregateOptions;
+  private aggregateOptions: AggregateOptions & Abortable;
 
   /** @internal */
   constructor(
     client: MongoClient,
     namespace: MongoDBNamespace,
     pipeline: Document[] = [],
-    options: AggregateOptions = {}
+    options: AggregateOptions & Abortable = {}
   ) {
     super(client, namespace, options);
 
@@ -73,7 +74,8 @@ export class AggregationCursor<TSchema = any> extends ExplainableCursor<TSchema>
     const options = {
       ...this.aggregateOptions,
       ...this.cursorOptions,
-      session
+      session,
+      signal: this.signal
     };
     if (options.explain) {
       try {

package/src/cursor/find_cursor.ts

@@ -9,6 +9,7 @@ import {
   validateExplainTimeoutOptions
 } from '../explain';
 import type { MongoClient } from '../mongo_client';
+import { type Abortable } from '../mongo_types';
 import type { CollationOptions } from '../operations/command';
 import { CountOperation, type CountOptions } from '../operations/count';
 import { executeOperation } from '../operations/execute_operation';
@@ -36,14 +37,14 @@ export class FindCursor<TSchema = any> extends ExplainableCursor<TSchema> {
   /** @internal */
   private numReturned = 0;
   /** @internal */
-  private readonly findOptions: FindOptions;
+  private readonly findOptions: FindOptions & Abortable;
 
   /** @internal */
   constructor(
     client: MongoClient,
     namespace: MongoDBNamespace,
     filter: Document = {},
-    options: FindOptions = {}
+    options: FindOptions & Abortable = {}
   ) {
     super(client, namespace, options);
 
@@ -72,7 +73,8 @@ export class FindCursor<TSchema = any> extends ExplainableCursor<TSchema> {
     const options = {
       ...this.findOptions, // NOTE: order matters here, we may need to refine this
       ...this.cursorOptions,
-      session
+      session,
+      signal: this.signal
     };
 
     if (options.explain) {

package/src/cursor/list_collections_cursor.ts

@@ -1,5 +1,6 @@
 import type { Document } from '../bson';
 import type { Db } from '../db';
+import { type Abortable } from '../mongo_types';
 import { executeOperation } from '../operations/execute_operation';
 import {
   type CollectionInfo,
@@ -17,9 +18,9 @@ export class ListCollectionsCursor<
 > extends AbstractCursor<T> {
   parent: Db;
   filter: Document;
-  options?: ListCollectionsOptions;
+  options?: ListCollectionsOptions & Abortable;
 
-  constructor(db: Db, filter: Document, options?: ListCollectionsOptions) {
+  constructor(db: Db, filter: Document, options?: ListCollectionsOptions & Abortable) {
     super(db.client, db.s.namespace, options);
     this.parent = db;
     this.filter = filter;
@@ -38,7 +39,8 @@ export class ListCollectionsCursor<
     const operation = new ListCollectionsOperation(this.parent, this.filter, {
       ...this.cursorOptions,
       ...this.options,
-      session
+      session,
+      signal: this.signal
     });
 
     const response = await executeOperation(this.parent.client, operation, this.timeoutContext);