mongodb 6.10.0 → 6.11.0

package/src/gridfs/index.ts

@@ -2,10 +2,12 @@ import type { ObjectId } from '../bson';
 import type { Collection } from '../collection';
 import type { FindCursor } from '../cursor/find_cursor';
 import type { Db } from '../db';
-import { MongoRuntimeError } from '../error';
+import { MongoOperationTimeoutError, MongoRuntimeError } from '../error';
 import { type Filter, TypedEventEmitter } from '../mongo_types';
 import type { ReadPreference } from '../read_preference';
 import type { Sort } from '../sort';
+import { CSOTTimeoutContext } from '../timeout';
+import { resolveOptions } from '../utils';
 import { WriteConcern, type WriteConcernOptions } from '../write_concern';
 import type { FindOptions } from './../operations/find';
 import {
@@ -36,7 +38,11 @@ export interface GridFSBucketOptions extends WriteConcernOptions {
   chunkSizeBytes?: number;
   /** Read preference to be passed to read operations */
   readPreference?: ReadPreference;
-  /** @internal TODO(NODE-5688): make this public */
+  /**
+   * @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.
+   */
   timeoutMS?: number;
 }
 
@@ -48,6 +54,7 @@ export interface GridFSBucketPrivate {
     chunkSizeBytes: number;
     readPreference?: ReadPreference;
     writeConcern: WriteConcern | undefined;
+    timeoutMS?: number;
   };
   _chunksCollection: Collection<GridFSChunk>;
   _filesCollection: Collection<GridFSFile>;
@@ -81,11 +88,11 @@ export class GridFSBucket extends TypedEventEmitter<GridFSBucketEvents> {
   constructor(db: Db, options?: GridFSBucketOptions) {
     super();
     this.setMaxListeners(0);
-    const privateOptions = {
+    const privateOptions = resolveOptions(db, {
       ...DEFAULT_GRIDFS_BUCKET_OPTIONS,
       ...options,
       writeConcern: WriteConcern.fromOptions(options)
-    };
+    });
     this.s = {
       db,
       options: privateOptions,
@@ -109,7 +116,10 @@ export class GridFSBucket extends TypedEventEmitter<GridFSBucketEvents> {
     filename: string,
     options?: GridFSBucketWriteStreamOptions
   ): GridFSBucketWriteStream {
-    return new GridFSBucketWriteStream(this, filename, options);
+    return new GridFSBucketWriteStream(this, filename, {
+      timeoutMS: this.s.options.timeoutMS,
+      ...options
+    });
   }
 
   /**
@@ -122,7 +132,11 @@ export class GridFSBucket extends TypedEventEmitter<GridFSBucketEvents> {
     filename: string,
     options?: GridFSBucketWriteStreamOptions
   ): GridFSBucketWriteStream {
-    return new GridFSBucketWriteStream(this, filename, { ...options, id });
+    return new GridFSBucketWriteStream(this, filename, {
+      timeoutMS: this.s.options.timeoutMS,
+      ...options,
+      id
+    });
   }
 
   /** Returns a readable stream (GridFSBucketReadStream) for streaming file data from GridFS. */
@@ -135,7 +149,7 @@ export class GridFSBucket extends TypedEventEmitter<GridFSBucketEvents> {
       this.s._filesCollection,
       this.s.options.readPreference,
       { _id: id },
-      options
+      { timeoutMS: this.s.options.timeoutMS, ...options }
     );
   }
 
@@ -144,11 +158,27 @@ export class GridFSBucket extends TypedEventEmitter<GridFSBucketEvents> {
    *
    * @param id - The id of the file doc
    */
-  async delete(id: ObjectId): Promise<void> {
-    const { deletedCount } = await this.s._filesCollection.deleteOne({ _id: id });
+  async delete(id: ObjectId, options?: { timeoutMS: number }): Promise<void> {
+    const { timeoutMS } = resolveOptions(this.s.db, options);
+    let timeoutContext: CSOTTimeoutContext | undefined = undefined;
 
+    if (timeoutMS) {
+      timeoutContext = new CSOTTimeoutContext({
+        timeoutMS,
+        serverSelectionTimeoutMS: this.s.db.client.s.options.serverSelectionTimeoutMS
+      });
+    }
+
+    const { deletedCount } = await this.s._filesCollection.deleteOne(
+      { _id: id },
+      { timeoutMS: timeoutContext?.remainingTimeMS }
+    );
+
+    const remainingTimeMS = timeoutContext?.remainingTimeMS;
+    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 });
+    await this.s._chunksCollection.deleteMany({ files_id: id }, { timeoutMS: remainingTimeMS });
 
     if (deletedCount === 0) {
       // TODO(NODE-3483): Replace with more appropriate error
@@ -188,7 +218,7 @@ export class GridFSBucket extends TypedEventEmitter<GridFSBucketEvents> {
       this.s._filesCollection,
       this.s.options.readPreference,
       { filename },
-      { ...options, sort, skip }
+      { timeoutMS: this.s.options.timeoutMS, ...options, sort, skip }
     );
   }
 
@@ -198,18 +228,36 @@ 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): Promise<void> {
+  async rename(id: ObjectId, filename: string, options?: { timeoutMS: number }): Promise<void> {
     const filter = { _id: id };
     const update = { $set: { filename } };
-    const { matchedCount } = await this.s._filesCollection.updateOne(filter, update);
+    const { matchedCount } = await this.s._filesCollection.updateOne(filter, update, options);
     if (matchedCount === 0) {
       throw new MongoRuntimeError(`File with id ${id} not found`);
     }
   }
 
   /** Removes this bucket's files collection, followed by its chunks collection. */
-  async drop(): Promise<void> {
-    await this.s._filesCollection.drop();
-    await this.s._chunksCollection.drop();
+  async drop(options?: { timeoutMS: number }): Promise<void> {
+    const { timeoutMS } = resolveOptions(this.s.db, options);
+    let timeoutContext: CSOTTimeoutContext | undefined = undefined;
+
+    if (timeoutMS) {
+      timeoutContext = new CSOTTimeoutContext({
+        timeoutMS,
+        serverSelectionTimeoutMS: this.s.db.client.s.options.serverSelectionTimeoutMS
+      });
+    }
+
+    if (timeoutContext) {
+      await this.s._filesCollection.drop({ timeoutMS: timeoutContext.remainingTimeMS });
+      const remainingTimeMS = timeoutContext.getRemainingTimeMSOrThrow(
+        `Timed out after ${timeoutMS}ms`
+      );
+      await this.s._chunksCollection.drop({ timeoutMS: remainingTimeMS });
+    } else {
+      await this.s._filesCollection.drop();
+      await this.s._chunksCollection.drop();
+    }
   }
 }

package/src/gridfs/upload.ts

@@ -2,8 +2,15 @@ import { Writable } from 'stream';
 
 import { type Document, ObjectId } from '../bson';
 import type { Collection } from '../collection';
-import { MongoAPIError, MONGODB_ERROR_CODES, MongoError } from '../error';
-import { type Callback, squashError } from '../utils';
+import { CursorTimeoutMode } from '../cursor/abstract_cursor';
+import {
+  MongoAPIError,
+  MONGODB_ERROR_CODES,
+  MongoError,
+  MongoOperationTimeoutError
+} from '../error';
+import { CSOTTimeoutContext } from '../timeout';
+import { type Callback, resolveTimeoutOptions, squashError } from '../utils';
 import type { WriteConcernOptions } from '../write_concern';
 import { WriteConcern } from './../write_concern';
 import type { GridFSFile } from './download';
@@ -35,7 +42,10 @@ export interface GridFSBucketWriteStreamOptions extends WriteConcernOptions {
    * @deprecated Will be removed in the next major version. Add an aliases field to the metadata document instead.
    */
   aliases?: string[];
-  /** @internal TODO(NODE-5688): make this public */
+  /**
+   * @experimental
+   * Specifies the time an operation will run until it throws a timeout error
+   */
   timeoutMS?: number;
 }
 
@@ -97,6 +107,8 @@ export class GridFSBucketWriteStream extends Writable {
    * ```
    */
   gridFSFile: GridFSFile | null = null;
+  /** @internal */
+  timeoutContext?: CSOTTimeoutContext;
 
   /**
    * @param bucket - Handle for this stream's corresponding bucket
@@ -131,14 +143,12 @@ export class GridFSBucketWriteStream extends Writable {
       aborted: false
     };
 
-    if (!this.bucket.s.calledOpenUploadStream) {
-      this.bucket.s.calledOpenUploadStream = true;
-
-      checkIndexes(this).then(() => {
-        this.bucket.s.checkedIndexes = true;
-        this.bucket.emit('index');
-      }, squashError);
-    }
+    if (options.timeoutMS != null)
+      this.timeoutContext = new CSOTTimeoutContext({
+        timeoutMS: options.timeoutMS,
+        serverSelectionTimeoutMS: resolveTimeoutOptions(this.bucket.s.db.client, {})
+          .serverSelectionTimeoutMS
+      });
   }
 
   /**
@@ -147,10 +157,26 @@ export class GridFSBucketWriteStream extends Writable {
    * The stream is considered constructed when the indexes are done being created
    */
   override _construct(callback: (error?: Error | null) => void): void {
-    if (this.bucket.s.checkedIndexes) {
+    if (!this.bucket.s.calledOpenUploadStream) {
+      this.bucket.s.calledOpenUploadStream = true;
+
+      checkIndexes(this).then(
+        () => {
+          this.bucket.s.checkedIndexes = true;
+          this.bucket.emit('index');
+          callback();
+        },
+        error => {
+          if (error instanceof MongoOperationTimeoutError) {
+            return handleError(this, error, callback);
+          }
+          squashError(error);
+          callback();
+        }
+      );
+    } else {
       return process.nextTick(callback);
     }
-    this.bucket.once('index', callback);
   }
 
   /**
@@ -194,7 +220,11 @@ export class GridFSBucketWriteStream extends Writable {
     }
 
     this.state.aborted = true;
-    await this.chunks.deleteMany({ files_id: this.id });
+    const remainingTimeMS = this.timeoutContext?.getRemainingTimeMSOrThrow(
+      `Upload timed out after ${this.timeoutContext?.timeoutMS}ms`
+    );
+
+    await this.chunks.deleteMany({ files_id: this.id }, { timeoutMS: remainingTimeMS });
   }
 }
 
@@ -219,9 +249,19 @@ function createChunkDoc(filesId: ObjectId, n: number, data: Buffer): GridFSChunk
 async function checkChunksIndex(stream: GridFSBucketWriteStream): Promise<void> {
   const index = { files_id: 1, n: 1 };
 
+  let remainingTimeMS;
+  remainingTimeMS = stream.timeoutContext?.getRemainingTimeMSOrThrow(
+    `Upload timed out after ${stream.timeoutContext?.timeoutMS}ms`
+  );
+
   let indexes;
   try {
-    indexes = await stream.chunks.listIndexes().toArray();
+    indexes = await stream.chunks
+      .listIndexes({
+        timeoutMode: remainingTimeMS != null ? CursorTimeoutMode.LIFETIME : undefined,
+        timeoutMS: remainingTimeMS
+      })
+      .toArray();
   } catch (error) {
     if (error instanceof MongoError && error.code === MONGODB_ERROR_CODES.NamespaceNotFound) {
       indexes = [];
@@ -239,10 +279,14 @@ async function checkChunksIndex(stream: GridFSBucketWriteStream): Promise<void>
   });
 
   if (!hasChunksIndex) {
+    remainingTimeMS = stream.timeoutContext?.getRemainingTimeMSOrThrow(
+      `Upload timed out after ${stream.timeoutContext?.timeoutMS}ms`
+    );
     await stream.chunks.createIndex(index, {
       ...stream.writeConcern,
       background: true,
-      unique: true
+      unique: true,
+      timeoutMS: remainingTimeMS
     });
   }
 }
@@ -270,13 +314,28 @@ function checkDone(stream: GridFSBucketWriteStream, callback: Callback): void {
       return;
     }
 
-    stream.files.insertOne(gridFSFile, { writeConcern: stream.writeConcern }).then(
-      () => {
-        stream.gridFSFile = gridFSFile;
-        callback();
-      },
-      error => handleError(stream, error, callback)
-    );
+    const remainingTimeMS = stream.timeoutContext?.remainingTimeMS;
+    if (remainingTimeMS != null && remainingTimeMS <= 0) {
+      return handleError(
+        stream,
+        new MongoOperationTimeoutError(
+          `Upload timed out after ${stream.timeoutContext?.timeoutMS}ms`
+        ),
+        callback
+      );
+    }
+
+    stream.files
+      .insertOne(gridFSFile, { writeConcern: stream.writeConcern, timeoutMS: remainingTimeMS })
+      .then(
+        () => {
+          stream.gridFSFile = gridFSFile;
+          callback();
+        },
+        error => {
+          return handleError(stream, error, callback);
+        }
+      );
     return;
   }
 
@@ -284,7 +343,16 @@ function checkDone(stream: GridFSBucketWriteStream, callback: Callback): void {
 }
 
 async function checkIndexes(stream: GridFSBucketWriteStream): Promise<void> {
-  const doc = await stream.files.findOne({}, { projection: { _id: 1 } });
+  let remainingTimeMS = stream.timeoutContext?.getRemainingTimeMSOrThrow(
+    `Upload timed out after ${stream.timeoutContext?.timeoutMS}ms`
+  );
+  const doc = await stream.files.findOne(
+    {},
+    {
+      projection: { _id: 1 },
+      timeoutMS: remainingTimeMS
+    }
+  );
   if (doc != null) {
     // If at least one document exists assume the collection has the required index
     return;
@@ -293,8 +361,15 @@ async function checkIndexes(stream: GridFSBucketWriteStream): Promise<void> {
   const index = { filename: 1, uploadDate: 1 };
 
   let indexes;
+  remainingTimeMS = stream.timeoutContext?.getRemainingTimeMSOrThrow(
+    `Upload timed out after ${stream.timeoutContext?.timeoutMS}ms`
+  );
+  const listIndexesOptions = {
+    timeoutMode: remainingTimeMS != null ? CursorTimeoutMode.LIFETIME : undefined,
+    timeoutMS: remainingTimeMS
+  };
   try {
-    indexes = await stream.files.listIndexes().toArray();
+    indexes = await stream.files.listIndexes(listIndexesOptions).toArray();
   } catch (error) {
     if (error instanceof MongoError && error.code === MONGODB_ERROR_CODES.NamespaceNotFound) {
       indexes = [];
@@ -312,7 +387,11 @@ async function checkIndexes(stream: GridFSBucketWriteStream): Promise<void> {
   });
 
   if (!hasFileIndex) {
-    await stream.files.createIndex(index, { background: false });
+    remainingTimeMS = stream.timeoutContext?.getRemainingTimeMSOrThrow(
+      `Upload timed out after ${stream.timeoutContext?.timeoutMS}ms`
+    );
+
+    await stream.files.createIndex(index, { background: false, timeoutMS: remainingTimeMS });
   }
 
   await checkChunksIndex(stream);
@@ -386,6 +465,18 @@ function doWrite(
     let doc: GridFSChunk;
     if (spaceRemaining === 0) {
       doc = createChunkDoc(stream.id, stream.n, Buffer.from(stream.bufToStore));
+
+      const remainingTimeMS = stream.timeoutContext?.remainingTimeMS;
+      if (remainingTimeMS != null && remainingTimeMS <= 0) {
+        return handleError(
+          stream,
+          new MongoOperationTimeoutError(
+            `Upload timed out after ${stream.timeoutContext?.timeoutMS}ms`
+          ),
+          callback
+        );
+      }
+
       ++stream.state.outstandingRequests;
       ++outstandingRequests;
 
@@ -393,17 +484,21 @@ function doWrite(
         return;
       }
 
-      stream.chunks.insertOne(doc, { writeConcern: stream.writeConcern }).then(
-        () => {
-          --stream.state.outstandingRequests;
-          --outstandingRequests;
-
-          if (!outstandingRequests) {
-            checkDone(stream, callback);
+      stream.chunks
+        .insertOne(doc, { writeConcern: stream.writeConcern, timeoutMS: remainingTimeMS })
+        .then(
+          () => {
+            --stream.state.outstandingRequests;
+            --outstandingRequests;
+
+            if (!outstandingRequests) {
+              checkDone(stream, callback);
+            }
+          },
+          error => {
+            return handleError(stream, error, callback);
           }
-        },
-        error => handleError(stream, error, callback)
-      );
+        );
 
       spaceRemaining = stream.chunkSizeBytes;
       stream.pos = 0;
@@ -420,8 +515,6 @@ function writeRemnant(stream: GridFSBucketWriteStream, callback: Callback): void
     return checkDone(stream, callback);
   }
 
-  ++stream.state.outstandingRequests;
-
   // Create a new buffer to make sure the buffer isn't bigger than it needs
   // to be.
   const remnant = Buffer.alloc(stream.pos);
@@ -433,13 +526,28 @@ function writeRemnant(stream: GridFSBucketWriteStream, callback: Callback): void
     return;
   }
 
-  stream.chunks.insertOne(doc, { writeConcern: stream.writeConcern }).then(
-    () => {
-      --stream.state.outstandingRequests;
-      checkDone(stream, callback);
-    },
-    error => handleError(stream, error, callback)
-  );
+  const remainingTimeMS = stream.timeoutContext?.remainingTimeMS;
+  if (remainingTimeMS != null && remainingTimeMS <= 0) {
+    return handleError(
+      stream,
+      new MongoOperationTimeoutError(
+        `Upload timed out after ${stream.timeoutContext?.timeoutMS}ms`
+      ),
+      callback
+    );
+  }
+  ++stream.state.outstandingRequests;
+  stream.chunks
+    .insertOne(doc, { writeConcern: stream.writeConcern, timeoutMS: remainingTimeMS })
+    .then(
+      () => {
+        --stream.state.outstandingRequests;
+        checkDone(stream, callback);
+      },
+      error => {
+        return handleError(stream, error, callback);
+      }
+    );
 }
 
 function isAborted(stream: GridFSBucketWriteStream, callback: Callback<void>): boolean {

package/src/index.ts

@@ -10,6 +10,7 @@ import { ListCollectionsCursor } from './cursor/list_collections_cursor';
 import { ListIndexesCursor } from './cursor/list_indexes_cursor';
 import type { RunCommandCursor } from './cursor/run_command_cursor';
 import { Db } from './db';
+import { ExplainableCursor } from './explain';
 import { GridFSBucket } from './gridfs';
 import { GridFSBucketReadStream } from './gridfs/download';
 import { GridFSBucketWriteStream } from './gridfs/upload';
@@ -36,7 +37,11 @@ export {
   Timestamp,
   UUID
 } from './bson';
-export { AnyBulkWriteOperation, BulkWriteOptions, MongoBulkWriteError } from './bulk/common';
+export {
+  type AnyBulkWriteOperation,
+  type BulkWriteOptions,
+  MongoBulkWriteError
+} from './bulk/common';
 export { ClientEncryption } from './client-side-encryption/client_encryption';
 export { ChangeStreamCursor } from './cursor/change_stream_cursor';
 export {
@@ -66,6 +71,7 @@ export {
   MongoNetworkTimeoutError,
   MongoNotConnectedError,
   MongoOIDCError,
+  MongoOperationTimeoutError,
   MongoParseError,
   MongoRuntimeError,
   MongoServerClosedError,
@@ -90,6 +96,7 @@ export {
   ClientSession,
   Collection,
   Db,
+  ExplainableCursor,
   FindCursor,
   GridFSBucket,
   GridFSBucketReadStream,
@@ -108,7 +115,7 @@ export { AutoEncryptionLoggerLevel } from './client-side-encryption/auto_encrypt
 export { GSSAPICanonicalizationValue } from './cmap/auth/gssapi';
 export { AuthMechanism } from './cmap/auth/providers';
 export { Compressor } from './cmap/wire_protocol/compression';
-export { CURSOR_FLAGS } from './cursor/abstract_cursor';
+export { CURSOR_FLAGS, CursorTimeoutMode } from './cursor/abstract_cursor';
 export { MongoErrorLabel } from './error';
 export { ExplainVerbosity } from './explain';
 export { ServerApiVersion } from './mongo_client';
@@ -358,6 +365,7 @@ export type {
   CursorStreamOptions
 } from './cursor/abstract_cursor';
 export type {
+  CursorTimeoutContext,
   InitialCursorResponse,
   InternalAbstractCursorOptions
 } from './cursor/abstract_cursor';
@@ -553,7 +561,7 @@ export type {
   ReadPreferenceOptions
 } from './read_preference';
 export type { AsyncDisposable } from './resource_management';
-export type { ClusterTime, TimerQueue } from './sdam/common';
+export type { ClusterTime } from './sdam/common';
 export type {
   Monitor,
   MonitorEvents,
@@ -566,7 +574,13 @@ export type {
   RTTSampler,
   ServerMonitoringMode
 } from './sdam/monitor';
-export type { Server, ServerEvents, ServerOptions, ServerPrivate } from './sdam/server';
+export type {
+  Server,
+  ServerCommandOptions,
+  ServerEvents,
+  ServerOptions,
+  ServerPrivate
+} from './sdam/server';
 export type {
   ServerDescription,
   ServerDescriptionOptions,
@@ -597,7 +611,15 @@ export type {
   WithTransactionCallback
 } from './sessions';
 export type { Sort, SortDirection, SortDirectionForCmd, SortForCmd } from './sort';
-export type { Timeout } from './timeout';
+export type {
+  CSOTTimeoutContext,
+  CSOTTimeoutContextOptions,
+  LegacyTimeoutContext,
+  LegacyTimeoutContextOptions,
+  Timeout,
+  TimeoutContext,
+  TimeoutContextOptions
+} from './timeout';
 export type { Transaction, TransactionOptions, TxnState } from './transactions';
 export type {
   BufferPool,