mongodb 7.7.0 → 7.8.0

package/src/cursor/abstract_cursor.ts

@@ -67,32 +67,8 @@ function removeActiveCursor(this: AbstractCursor) {
 
 /**
  * @public
- * @experimental
- * Specifies how `timeoutMS` is applied to the cursor. Can be either `'cursorLifeTime'` or `'iteration'`
- * When set to `'iteration'`, the deadline specified by `timeoutMS` applies to each call of
- * `cursor.next()`.
- * When set to `'cursorLifetime'`, the deadline applies to the life of the entire cursor.
- *
- * Depending on the type of cursor being used, this option has different default values.
- * For non-tailable cursors, this value defaults to `'cursorLifetime'`
- * For tailable cursors, this value defaults to `'iteration'` since tailable cursors, by
- * definition can have an arbitrarily long lifetime.
- *
- * @example
- * ```ts
- * const cursor = collection.find({}, {timeoutMS: 100, timeoutMode: 'iteration'});
- * for await (const doc of cursor) {
- *  // process doc
- *  // This will throw a timeout error if any of the iterator's `next()` calls takes more than 100ms, but
- *  // will continue to iterate successfully otherwise, regardless of the number of batches.
- * }
- * ```
- *
- * @example
- * ```ts
- * const cursor = collection.find({}, { timeoutMS: 1000, timeoutMode: 'cursorLifetime' });
- * const docs = await cursor.toArray(); // This entire line will throw a timeout error if all batches are not fetched and returned within 1000ms.
- * ```
+ * Specifies how `timeoutMS` is applied to the cursor.
+ * @deprecated `timeoutMode` has no effect and will be removed in a future release.
  */
 export const CursorTimeoutMode = Object.freeze({
   ITERATION: 'iteration',
@@ -101,7 +77,7 @@ export const CursorTimeoutMode = Object.freeze({
 
 /**
  * @public
- * @experimental
+ * @deprecated `timeoutMode` has no effect and will be removed in a future release.
  */
 export type CursorTimeoutMode = (typeof CursorTimeoutMode)[keyof typeof CursorTimeoutMode];
 
@@ -143,36 +119,14 @@ export interface AbstractCursorOptions extends BSONSerializeOptions {
    */
   awaitData?: boolean;
   noCursorTimeout?: boolean;
-  /** Specifies the time an operation will run until it throws a timeout error. See {@link AbstractCursorOptions.timeoutMode} for more details on how this option applies to cursors. */
+  /**
+   * Specifies the time an operation will run until it throws a timeout error.
+   * @deprecated `timeoutMS` has no effect and will be removed in a future release.
+   */
   timeoutMS?: number;
   /**
-   * @public
-   * @experimental
-   * Specifies how `timeoutMS` is applied to the cursor. Can be either `'cursorLifeTime'` or `'iteration'`
-   * When set to `'iteration'`, the deadline specified by `timeoutMS` applies to each call of
-   * `cursor.next()`.
-   * When set to `'cursorLifetime'`, the deadline applies to the life of the entire cursor.
-   *
-   * Depending on the type of cursor being used, this option has different default values.
-   * For non-tailable cursors, this value defaults to `'cursorLifetime'`
-   * For tailable cursors, this value defaults to `'iteration'` since tailable cursors, by
-   * definition can have an arbitrarily long lifetime.
-   *
-   * @example
-   * ```ts
-   * const cursor = collection.find({}, {timeoutMS: 100, timeoutMode: 'iteration'});
-   * for await (const doc of cursor) {
-   *  // process doc
-   *  // This will throw a timeout error if any of the iterator's `next()` calls takes more than 100ms, but
-   *  // will continue to iterate successfully otherwise, regardless of the number of batches.
-   * }
-   * ```
-   *
-   * @example
-   * ```ts
-   * const cursor = collection.find({}, { timeoutMS: 1000, timeoutMode: 'cursorLifetime' });
-   * const docs = await cursor.toArray(); // This entire line will throw a timeout error if all batches are not fetched and returned within 1000ms.
-   * ```
+   * Specifies how `timeoutMS` is applied to the cursor.
+   * @deprecated `timeoutMode` has no effect and will be removed in a future release.
    */
   timeoutMode?: CursorTimeoutMode;
 
@@ -258,6 +212,10 @@ export abstract class AbstractCursor<
     super();
     this.on('error', noop);
 
+    // timeoutMS and timeoutMode are no-ops, so they must never reach the operations built from these options
+    options.timeoutMS = undefined;
+    options.timeoutMode = undefined;
+
     if (!client.s.isMongoClient) {
       throw new MongoRuntimeError('Cursor must be constructed with MongoClient');
     }
@@ -273,50 +231,10 @@ export abstract class AbstractCursor<
           ? options.readPreference
           : ReadPreference.primary,
       ...pluckBSONSerializeOptions(options),
-      timeoutMS: options?.timeoutContext?.csotEnabled()
-        ? options.timeoutContext.timeoutMS
-        : options.timeoutMS,
       tailable: options.tailable,
       awaitData: options.awaitData
     };
 
-    if (this.cursorOptions.timeoutMS != null) {
-      if (options.timeoutMode == null) {
-        if (options.tailable) {
-          if (options.awaitData) {
-            if (
-              options.maxAwaitTimeMS != null &&
-              options.maxAwaitTimeMS >= this.cursorOptions.timeoutMS
-            )
-              throw new MongoInvalidArgumentError(
-                'Cannot specify maxAwaitTimeMS >= timeoutMS for a tailable awaitData cursor'
-              );
-          }
-
-          this.cursorOptions.timeoutMode = CursorTimeoutMode.ITERATION;
-        } else {
-          this.cursorOptions.timeoutMode = CursorTimeoutMode.LIFETIME;
-        }
-      } else {
-        if (options.tailable && options.timeoutMode === CursorTimeoutMode.LIFETIME) {
-          throw new MongoInvalidArgumentError(
-            "Cannot set tailable cursor's timeoutMode to LIFETIME"
-          );
-        }
-        this.cursorOptions.timeoutMode = options.timeoutMode;
-      }
-    } else {
-      if (options.timeoutMode != null)
-        throw new MongoInvalidArgumentError('Cannot set timeoutMode without setting timeoutMS');
-    }
-
-    // Set for initial command
-    this.cursorOptions.omitMaxTimeMS =
-      this.cursorOptions.timeoutMS != null &&
-      ((this.cursorOptions.timeoutMode === CursorTimeoutMode.ITERATION &&
-        !this.cursorOptions.tailable) ||
-        (this.cursorOptions.tailable && !this.cursorOptions.awaitData));
-
     const readConcern = ReadConcern.fromOptions(options);
     if (readConcern) {
       this.cursorOptions.readConcern = readConcern;
@@ -635,9 +553,14 @@ export abstract class AbstractCursor<
 
   /**
    * Frees any client-side resources used by the cursor.
+   *
+   * @param _options - `timeoutMS` is deprecated and has no effect
    */
-  async close(options?: { timeoutMS?: number }): Promise<void> {
-    await this.cleanup(options?.timeoutMS);
+  async close(_options?: {
+    /** @deprecated `timeoutMS` has no effect and will be removed in a future release. */
+    timeoutMS?: number;
+  }): Promise<void> {
+    await this.cleanup();
   }
 
   /**

package/src/cursor/aggregation_cursor.ts

@@ -1,11 +1,6 @@
 import type { Document } from '../bson';
 import { MongoAPIError } from '../error';
-import {
-  Explain,
-  type ExplainCommandOptions,
-  type ExplainVerbosityLike,
-  validateExplainTimeoutOptions
-} from '../explain';
+import { type ExplainCommandOptions, type ExplainVerbosityLike } from '../explain';
 import type { MongoClient } from '../mongo_client';
 import { type Abortable } from '../mongo_types';
 import { AggregateOperation, type AggregateOptions } from '../operations/aggregate';
@@ -77,16 +72,6 @@ export class AggregationCursor<TSchema = any> extends ExplainableCursor<TSchema>
       session,
       signal: this.signal
     };
-    if (options.explain) {
-      try {
-        validateExplainTimeoutOptions(options, Explain.fromOptions(options));
-      } catch {
-        throw new MongoAPIError(
-          'timeoutMS cannot be used with explain when explain is specified in aggregateOptions'
-        );
-      }
-    }
-
     const aggregateOperation = new AggregateOperation(this.namespace, this.pipeline, options);
 
     const response = await executeOperation(this.client, aggregateOperation, this.timeoutContext);

package/src/cursor/find_cursor.ts

@@ -1,12 +1,7 @@
 import { type Document } from '../bson';
 import { CursorResponse } from '../cmap/wire_protocol/responses';
-import { MongoAPIError, MongoInvalidArgumentError, MongoTailableCursorError } from '../error';
-import {
-  Explain,
-  type ExplainCommandOptions,
-  type ExplainVerbosityLike,
-  validateExplainTimeoutOptions
-} from '../explain';
+import { MongoInvalidArgumentError, MongoTailableCursorError } from '../error';
+import { type ExplainCommandOptions, type ExplainVerbosityLike } from '../explain';
 import type { MongoClient } from '../mongo_client';
 import { type Abortable } from '../mongo_types';
 import type { CollationOptions } from '../operations/command';
@@ -77,16 +72,6 @@ export class FindCursor<TSchema = any> extends ExplainableCursor<TSchema> {
       signal: this.signal
     };
 
-    if (options.explain) {
-      try {
-        validateExplainTimeoutOptions(options, Explain.fromOptions(options));
-      } catch {
-        throw new MongoAPIError(
-          'timeoutMS cannot be used with explain when explain is specified in findOptions'
-        );
-      }
-    }
-
     const findOperation = new FindOperation(this.namespace, this.cursorFilter, options);
 
     const response = await executeOperation(this.client, findOperation, this.timeoutContext);

package/src/cursor/list_collections_cursor.ts

@@ -21,7 +21,7 @@ export class ListCollectionsCursor<
   options?: ListCollectionsOptions & Abortable;
 
   constructor(db: Db, filter: Document, options?: ListCollectionsOptions & Abortable) {
-    super(db.client, db.s.namespace, options);
+    super(db.client, db.s.namespace, { ...options });
     this.parent = db;
     this.filter = filter;
     this.options = options;

package/src/cursor/list_indexes_cursor.ts

@@ -10,7 +10,7 @@ export class ListIndexesCursor extends AbstractCursor {
   options?: ListIndexesOptions;
 
   constructor(collection: Collection, options?: ListIndexesOptions) {
-    super(collection.client, collection.s.namespace, options);
+    super(collection.client, collection.s.namespace, { ...options });
     this.parent = collection;
     this.options = options;
   }

package/src/cursor/run_command_cursor.ts

@@ -20,40 +20,13 @@ export type RunCursorCommandOptions = {
   readPreference?: ReadPreferenceLike;
   session?: ClientSession;
   /**
-   * @experimental
-   * Specifies the time an operation will run until it throws a timeout error. Note that if
-   * `maxTimeMS` is provided in the command in addition to setting `timeoutMS` in the options, then
-   * the original value of `maxTimeMS` will be overwritten.
+   * Specifies the time an operation will run until it throws a timeout error.
+   * @deprecated `timeoutMS` has no effect and will be removed in a future release.
    */
   timeoutMS?: number;
   /**
-   * @public
-   * @experimental
-   * Specifies how `timeoutMS` is applied to the cursor. Can be either `'cursorLifeTime'` or `'iteration'`
-   * When set to `'iteration'`, the deadline specified by `timeoutMS` applies to each call of
-   * `cursor.next()`.
-   * When set to `'cursorLifetime'`, the deadline applies to the life of the entire cursor.
-   *
-   * Depending on the type of cursor being used, this option has different default values.
-   * For non-tailable cursors, this value defaults to `'cursorLifetime'`
-   * For tailable cursors, this value defaults to `'iteration'` since tailable cursors, by
-   * definition can have an arbitrarily long lifetime.
-   *
-   * @example
-   * ```ts
-   * const cursor = collection.find({}, {timeoutMS: 100, timeoutMode: 'iteration'});
-   * for await (const doc of cursor) {
-   *  // process doc
-   *  // This will throw a timeout error if any of the iterator's `next()` calls takes more than 100ms, but
-   *  // will continue to iterate successfully otherwise, regardless of the number of batches.
-   * }
-   * ```
-   *
-   * @example
-   * ```ts
-   * const cursor = collection.find({}, { timeoutMS: 1000, timeoutMode: 'cursorLifetime' });
-   * const docs = await cursor.toArray(); // This entire line will throw a timeout error if all batches are not fetched and returned within 1000ms.
-   * ```
+   * Specifies how `timeoutMS` is applied to the cursor.
+   * @deprecated `timeoutMode` has no effect and will be removed in a future release.
    */
   timeoutMode?: CursorTimeoutMode;
   tailable?: boolean;

package/src/db.ts

@@ -64,8 +64,7 @@ const DB_OPTIONS_ALLOW_LIST = [
   'enableUtf8Validation',
   'promoteValues',
   'compression',
-  'retryWrites',
-  'timeoutMS'
+  'retryWrites'
 ];
 
 /** @internal */
@@ -94,8 +93,8 @@ export interface DbOptions extends BSONSerializeOptions, WriteConcernOptions {
   /** Should retry failed writes */
   retryWrites?: boolean;
   /**
-   * @experimental
    * Specifies the time an operation will run until it throws a timeout error
+   * @deprecated `timeoutMS` has no effect and will be removed in a future release.
    */
   timeoutMS?: number;
 }
@@ -224,8 +223,9 @@ export class Db {
     return this.s.namespace.toString();
   }
 
+  /** @deprecated `timeoutMS` has no effect and will be removed in a future release. */
   public get timeoutMS(): number | undefined {
-    return this.s.options?.timeoutMS;
+    return undefined;
   }
 
   /**
@@ -454,7 +454,14 @@ export class Db {
   ): Promise<string> {
     const indexes = await executeOperation(
       this.client,
-      CreateIndexesOperation.fromIndexSpecification(this, name, indexSpec, options)
+      CreateIndexesOperation.fromIndexSpecification(
+        this,
+        name,
+        indexSpec,
+        false,
+        options ?? {},
+        undefined
+      )
     );
     return indexes[0];
   }
@@ -535,59 +542,6 @@ export class Db {
    * watch() accepts two generic arguments for distinct use cases:
    * - The first is to provide the schema that may be defined for all the collections within this database
    * - The second is to override the shape of the change stream document entirely, if it is not provided the type will default to ChangeStreamDocument of the first argument
-   *
-   * @remarks
-   * When `timeoutMS` is configured for a change stream, it will have different behaviour depending
-   * on whether the change stream is in iterator mode or emitter mode. In both cases, a change
-   * stream will time out if it does not receive a change event within `timeoutMS` of the last change
-   * event.
-   *
-   * Note that if a change stream is consistently timing out when watching a collection, database or
-   * client that is being changed, then this may be due to the server timing out before it can finish
-   * processing the existing oplog. To address this, restart the change stream with a higher
-   * `timeoutMS`.
-   *
-   * If the change stream times out the initial aggregate operation to establish the change stream on
-   * the server, then the client will close the change stream. If the getMore calls to the server
-   * time out, then the change stream will be left open, but will throw a MongoOperationTimeoutError
-   * when in iterator mode and emit an error event that returns a MongoOperationTimeoutError in
-   * emitter mode.
-   *
-   * To determine whether or not the change stream is still open following a timeout, check the
-   * {@link ChangeStream.closed} getter.
-   *
-   * @example
-   * In iterator mode, if a next() call throws a timeout error, it will attempt to resume the change stream.
-   * The next call can just be retried after this succeeds.
-   * ```ts
-   * const changeStream = collection.watch([], { timeoutMS: 100 });
-   * try {
-   *     await changeStream.next();
-   * } catch (e) {
-   *     if (e instanceof MongoOperationTimeoutError && !changeStream.closed) {
-   *       await changeStream.next();
-   *     }
-   *     throw e;
-   * }
-   * ```
-   *
-   * @example
-   * In emitter mode, if the change stream goes `timeoutMS` without emitting a change event, it will
-   * emit an error event that returns a MongoOperationTimeoutError, but will not close the change
-   * stream unless the resume attempt fails. There is no need to re-establish change listeners as
-   * this will automatically continue emitting change events once the resume attempt completes.
-   *
-   * ```ts
-   * const changeStream = collection.watch([], { timeoutMS: 100 });
-   * changeStream.on('change', console.log);
-   * changeStream.on('error', e => {
-   *     if (e instanceof MongoOperationTimeoutError && !changeStream.closed) {
-   *         // do nothing
-   *     } else {
-   *         changeStream.close();
-   *     }
-   * });
-   * ```
    * @param pipeline - An array of {@link https://www.mongodb.com/docs/manual/reference/operator/aggregation-pipeline/|aggregation pipeline stages} through which to pass change stream documents. This allows for filtering (using $match) and manipulating the change stream documents.
    * @param options - Optional settings for the command
    * @typeParam TSchema - Type of the data being detected by the change stream
@@ -616,6 +570,6 @@ export class Db {
    * @param options - Configurations for running the command, bson options will apply to getMores
    */
   runCursorCommand(command: Document, options?: RunCursorCommandOptions): RunCommandCursor {
-    return new RunCommandCursor(this, command, options);
+    return new RunCommandCursor(this, command, { ...options });
   }
 }

package/src/deps.ts

@@ -1,3 +1,5 @@
+import * as zlib from 'zlib';
+
 import { type Stream } from './cmap/connect';
 import { MongoMissingDependencyError } from './error';
 import type { Callback } from './utils';
@@ -60,7 +62,42 @@ type ZStandardLib = {
 
 export type ZStandard = ZStandardLib | { kModuleError: MongoMissingDependencyError };
 
+/**
+ * Returns Node.js' built-in zstd (available since Node.js 22.15.0), or null when unavailable.
+ */
+function getBuiltInZstdLibrary(): ZStandardLib | null {
+  if (typeof zlib.zstdCompress !== 'function' || typeof zlib.zstdDecompress !== 'function') {
+    return null;
+  }
+
+  return {
+    compress(buf: Uint8Array, level?: number): Promise<Uint8Array> {
+      const options =
+        level == null ? {} : { params: { [zlib.constants.ZSTD_c_compressionLevel]: level } };
+      return new Promise((resolve, reject) => {
+        zlib.zstdCompress(buf, options, (error, result) => {
+          if (error) return reject(error);
+          resolve(result);
+        });
+      });
+    },
+    decompress(buf: Uint8Array): Promise<Uint8Array> {
+      return new Promise((resolve, reject) => {
+        zlib.zstdDecompress(buf, (error, result) => {
+          if (error) return reject(error);
+          resolve(result);
+        });
+      });
+    }
+  };
+}
+
 export function getZstdLibrary(): ZStandardLib | { kModuleError: MongoMissingDependencyError } {
+  const builtInZstd = getBuiltInZstdLibrary();
+  if (builtInZstd != null) {
+    return builtInZstd;
+  }
+
   let ZStandard: ZStandardLib | { kModuleError: MongoMissingDependencyError };
   try {
     // eslint-disable-next-line @typescript-eslint/no-require-imports
@@ -68,7 +105,7 @@ export function getZstdLibrary(): ZStandardLib | { kModuleError: MongoMissingDep
   } catch (error) {
     ZStandard = makeErrorModule(
       new MongoMissingDependencyError(
-        'Optional module `@mongodb-js/zstd` not found. Please install it to enable zstd compression',
+        'Built-in zstd is unavailable (requires Node.js 22.15.0 or later) and optional module `@mongodb-js/zstd` not found. Please upgrade Node.js or install `@mongodb-js/zstd` to enable zstd compression',
         { cause: error, dependencyName: 'zstd' }
       )
     );

package/src/explain.ts

@@ -1,5 +1,4 @@
 import { type Document } from './bson';
-import { MongoAPIError } from './error';
 
 /** @public */
 export const ExplainVerbosity = Object.freeze({
@@ -90,13 +89,6 @@ export class Explain {
   }
 }
 
-export function validateExplainTimeoutOptions(options: Document, explain?: Explain) {
-  const { maxTimeMS, timeoutMS } = options;
-  if (timeoutMS != null && (maxTimeMS != null || explain?.maxTimeMS != null)) {
-    throw new MongoAPIError('Cannot use maxTimeMS with timeoutMS for explain commands.');
-  }
-}
-
 /**
  * Applies an explain to a given command.
  * @internal

package/src/gridfs/download.ts

@@ -2,7 +2,6 @@ import { Readable } from 'stream';
 
 import { ByteUtils, type Document, type ObjectId } from '../bson';
 import type { Collection } from '../collection';
-import { CursorTimeoutMode } from '../cursor/abstract_cursor';
 import type { FindCursor } from '../cursor/find_cursor';
 import {
   MongoGridFSChunkError,
@@ -13,7 +12,7 @@ import {
 import type { FindOptions } from '../operations/find';
 import type { ReadPreference } from '../read_preference';
 import type { Sort } from '../sort';
-import { CSOTTimeoutContext } from '../timeout';
+import { type CSOTTimeoutContext } from '../timeout';
 import type { Callback } from '../utils';
 import type { GridFSChunk } from './upload';
 
@@ -31,8 +30,8 @@ export interface GridFSBucketReadStreamOptions {
    */
   end?: number;
   /**
-   * @experimental
    * Specifies the time an operation will run until it throws a timeout error
+   * @deprecated `timeoutMS` has no effect and will be removed in a future release.
    */
   timeoutMS?: number;
 }
@@ -83,7 +82,7 @@ export interface GridFSBucketReadStreamPrivate {
   expected: number;
 
   /**
-   * The filter used to search in the _files_ collection (i.e., `{ _id: <> }`)
+   * The filter used to search in the _files_ collection (i.e., `{ _id: { $eq: <> } }`)
    * This is not the same filter used when reading chunks from the chunks collection.
    */
   filter: Document;
@@ -151,11 +150,7 @@ export class GridFSBucketReadStream extends Readable {
         end: 0,
         ...options
       },
-      readPreference,
-      timeoutContext:
-        options?.timeoutMS != null
-          ? new CSOTTimeoutContext({ timeoutMS: options.timeoutMS, serverSelectionTimeoutMS: 0 })
-          : undefined
+      readPreference
     };
   }
 
@@ -318,9 +313,8 @@ function init(stream: GridFSBucketReadStream): void {
     if (stream.destroyed) return;
 
     if (!doc) {
-      const identifier = stream.s.filter._id
-        ? stream.s.filter._id.toString()
-        : stream.s.filter.filename;
+      const identifier =
+        stream.s.filter._id != null ? stream.s.filter._id.$eq : stream.s.filter.filename;
       const errmsg = `FileNotFound: file ${identifier} was not found`;
       // TODO(NODE-3483)
       const err = new MongoRuntimeError(errmsg);
@@ -349,7 +343,7 @@ function init(stream: GridFSBucketReadStream): void {
       return stream.destroy(error);
     }
 
-    const filter: Document = { files_id: doc._id };
+    const filter: Document = { files_id: { $eq: doc._id } };
 
     // Currently the skip function does not support the index,
     // it needs to retrieve all the documents first and then skip them. (CS-25811)
@@ -372,7 +366,6 @@ function init(stream: GridFSBucketReadStream): void {
 
     stream.s.cursor = stream.s.chunks
       .find(filter, {
-        timeoutMode: stream.s.options.timeoutMS != null ? CursorTimeoutMode.LIFETIME : undefined,
         timeoutMS: remainingTimeMS
       })
       .sort({ n: 1 });

package/src/gridfs/index.ts

@@ -39,9 +39,9 @@ export interface GridFSBucketOptions extends WriteConcernOptions {
   /** Read preference to be passed to read operations */
   readPreference?: ReadPreference;
   /**
-   * @experimental
    * Specifies the lifetime duration of a gridFS stream. If any async operations are in progress
    * when this timeout expires, the stream will throw a timeout error.
+   * @deprecated `timeoutMS` has no effect and will be removed in a future release.
    */
   timeoutMS?: number;
 }
@@ -149,7 +149,7 @@ export class GridFSBucket extends TypedEventEmitter<GridFSBucketEvents> {
       this.s._chunksCollection,
       this.s._filesCollection,
       this.s.options.readPreference,
-      { _id: id },
+      { _id: { $eq: id } },
       { timeoutMS: this.s.options.timeoutMS, ...options }
     );
   }
@@ -159,7 +159,13 @@ export class GridFSBucket extends TypedEventEmitter<GridFSBucketEvents> {
    *
    * @param id - The id of the file doc
    */
-  async delete(id: ObjectId, options?: { timeoutMS: number }): Promise<void> {
+  async delete(
+    id: ObjectId,
+    options?: {
+      /** @deprecated `timeoutMS` has no effect and will be removed in a future release. */
+      timeoutMS?: number;
+    }
+  ): Promise<void> {
     const { timeoutMS } = resolveOptions(this.s.db, options);
     let timeoutContext: CSOTTimeoutContext | undefined = undefined;
 
@@ -171,7 +177,7 @@ export class GridFSBucket extends TypedEventEmitter<GridFSBucketEvents> {
     }
 
     const { deletedCount } = await this.s._filesCollection.deleteOne(
-      { _id: id },
+      { _id: { $eq: id } },
       { timeoutMS: timeoutContext?.remainingTimeMS }
     );
 
@@ -179,7 +185,10 @@ export class GridFSBucket extends TypedEventEmitter<GridFSBucketEvents> {
     if (remainingTimeMS != null && remainingTimeMS <= 0)
       throw new MongoOperationTimeoutError(`Timed out after ${timeoutMS}ms`);
     // Delete orphaned chunks before returning FileNotFound
-    await this.s._chunksCollection.deleteMany({ files_id: id }, { timeoutMS: remainingTimeMS });
+    await this.s._chunksCollection.deleteMany(
+      { files_id: { $eq: id } },
+      { timeoutMS: remainingTimeMS }
+    );
 
     if (deletedCount === 0) {
       // TODO(NODE-3483): Replace with more appropriate error
@@ -229,8 +238,15 @@ export class GridFSBucket extends TypedEventEmitter<GridFSBucketEvents> {
    * @param id - the id of the file to rename
    * @param filename - new name for the file
    */
-  async rename(id: ObjectId, filename: string, options?: { timeoutMS: number }): Promise<void> {
-    const filter = { _id: id };
+  async rename(
+    id: ObjectId,
+    filename: string,
+    options?: {
+      /** @deprecated `timeoutMS` has no effect and will be removed in a future release. */
+      timeoutMS?: number;
+    }
+  ): Promise<void> {
+    const filter = { _id: { $eq: id } };
     const update = { $set: { filename } };
     const { matchedCount } = await this.s._filesCollection.updateOne(filter, update, options);
     if (matchedCount === 0) {
@@ -239,7 +255,10 @@ export class GridFSBucket extends TypedEventEmitter<GridFSBucketEvents> {
   }
 
   /** Removes this bucket's files collection, followed by its chunks collection. */
-  async drop(options?: { timeoutMS: number }): Promise<void> {
+  async drop(options?: {
+    /** @deprecated `timeoutMS` has no effect and will be removed in a future release. */
+    timeoutMS?: number;
+  }): Promise<void> {
     const { timeoutMS } = resolveOptions(this.s.db, options);
     let timeoutContext: CSOTTimeoutContext | undefined = undefined;