mongodb 6.1.0 → 6.2.0

package/src/db.ts

@@ -6,7 +6,7 @@ import * as CONSTANTS from './constants';
 import { AggregationCursor } from './cursor/aggregation_cursor';
 import { ListCollectionsCursor } from './cursor/list_collections_cursor';
 import { RunCommandCursor, type RunCursorCommandOptions } from './cursor/run_command_cursor';
-import { MongoAPIError, MongoInvalidArgumentError } from './error';
+import { MongoInvalidArgumentError } from './error';
 import type { MongoClient, PkFactory } from './mongo_client';
 import type { TODO_NODE_3286 } from './mongo_types';
 import type { AggregateOptions } from './operations/aggregate';
@@ -134,11 +134,13 @@ export class Db {
   public static SYSTEM_JS_COLLECTION = CONSTANTS.SYSTEM_JS_COLLECTION;
 
   /**
-   * Creates a new Db instance
+   * Creates a new Db instance.
+   *
+   * Db name cannot contain a dot, the server may apply more restrictions when an operation is run.
    *
    * @param client - The MongoClient for the database.
    * @param databaseName - The name of the database this instance represents.
-   * @param options - Optional settings for Db construction
+   * @param options - Optional settings for Db construction.
    */
   constructor(client: MongoClient, databaseName: string, options?: DbOptions) {
     options = options ?? {};
@@ -146,8 +148,10 @@ export class Db {
     // Filter the options
     options = filterOptions(options, DB_OPTIONS_ALLOW_LIST);
 
-    // Ensure we have a valid db name
-    validateDatabaseName(databaseName);
+    // Ensure there are no dots in database name
+    if (typeof databaseName === 'string' && databaseName.includes('.')) {
+      throw new MongoInvalidArgumentError(`Database names cannot contain the character '.'`);
+    }
 
     // Internal state of the db object
     this.s = {
@@ -218,6 +222,8 @@ export class Db {
    * Create a new collection on a server with the specified options. Use this to create capped collections.
    * More information about command options available at https://www.mongodb.com/docs/manual/reference/command/create/
    *
+   * Collection namespace validation is performed server-side.
+   *
    * @param name - The name of the collection to create
    * @param options - Optional settings for the command
    */
@@ -294,6 +300,8 @@ export class Db {
   /**
    * Returns a reference to a MongoDB Collection. If it does not exist it will be created implicitly.
    *
+   * Collection namespace validation is performed server-side.
+   *
    * @param name - the collection name we wish to access.
    * @returns return the new Collection instance
    */
@@ -519,19 +527,3 @@ export class Db {
     return new RunCommandCursor(this, command, options);
   }
 }
-
-// TODO(NODE-3484): Refactor into MongoDBNamespace
-// Validate the database name
-function validateDatabaseName(databaseName: string) {
-  if (typeof databaseName !== 'string')
-    throw new MongoInvalidArgumentError('Database name must be a string');
-  if (databaseName.length === 0)
-    throw new MongoInvalidArgumentError('Database name cannot be the empty string');
-  if (databaseName === '$external') return;
-
-  const invalidChars = [' ', '.', '$', '/', '\\'];
-  for (let i = 0; i < invalidChars.length; i++) {
-    if (databaseName.indexOf(invalidChars[i]) !== -1)
-      throw new MongoAPIError(`database names cannot contain the character '${invalidChars[i]}'`);
-  }
-}

package/src/index.ts

@@ -524,6 +524,7 @@ export type {
   HostAddress,
   List,
   MongoDBCollectionNamespace,
-  MongoDBNamespace
+  MongoDBNamespace,
+  TimeoutController
 } from './utils';
 export type { W, WriteConcernOptions, WriteConcernSettings } from './write_concern';

package/src/operations/rename.ts

@@ -2,7 +2,7 @@ import type { Document } from '../bson';
 import { Collection } from '../collection';
 import type { Server } from '../sdam/server';
 import type { ClientSession } from '../sessions';
-import { checkCollectionName, MongoDBNamespace } from '../utils';
+import { MongoDBNamespace } from '../utils';
 import { CommandOperation, type CommandOperationOptions } from './command';
 import { Aspect, defineAspects } from './operation';
 
@@ -21,7 +21,6 @@ export class RenameOperation extends CommandOperation<Document> {
     public newName: string,
     public override options: RenameOptions
   ) {
-    checkCollectionName(newName);
     super(collection, options);
     this.ns = new MongoDBNamespace('admin', '$cmd');
   }

package/src/sdam/events.ts

@@ -132,10 +132,13 @@ export class TopologyClosedEvent {
 export class ServerHeartbeatStartedEvent {
   /** The connection id for the command */
   connectionId: string;
+  /** Is true when using the streaming protocol. */
+  awaited: boolean;
 
   /** @internal */
-  constructor(connectionId: string) {
+  constructor(connectionId: string, awaited: boolean) {
     this.connectionId = connectionId;
+    this.awaited = awaited;
   }
 }
 
@@ -151,12 +154,15 @@ export class ServerHeartbeatSucceededEvent {
   duration: number;
   /** The command reply */
   reply: Document;
+  /** Is true when using the streaming protocol. */
+  awaited: boolean;
 
   /** @internal */
-  constructor(connectionId: string, duration: number, reply: Document | null) {
+  constructor(connectionId: string, duration: number, reply: Document | null, awaited: boolean) {
     this.connectionId = connectionId;
     this.duration = duration;
     this.reply = reply ?? {};
+    this.awaited = awaited;
   }
 }
 
@@ -172,11 +178,14 @@ export class ServerHeartbeatFailedEvent {
   duration: number;
   /** The command failure */
   failure: Error;
+  /** Is true when using the streaming protocol. */
+  awaited: boolean;
 
   /** @internal */
-  constructor(connectionId: string, duration: number, failure: Error) {
+  constructor(connectionId: string, duration: number, failure: Error, awaited: boolean) {
     this.connectionId = connectionId;
     this.duration = duration;
     this.failure = failure;
+    this.awaited = awaited;
   }
 }

package/src/sdam/monitor.ts

@@ -209,7 +209,12 @@ function resetMonitorState(monitor: Monitor) {
 
 function checkServer(monitor: Monitor, callback: Callback<Document | null>) {
   let start = now();
-  monitor.emit(Server.SERVER_HEARTBEAT_STARTED, new ServerHeartbeatStartedEvent(monitor.address));
+  const topologyVersion = monitor[kServer].description.topologyVersion;
+  const isAwaitable = topologyVersion != null;
+  monitor.emit(
+    Server.SERVER_HEARTBEAT_STARTED,
+    new ServerHeartbeatStartedEvent(monitor.address, isAwaitable)
+  );
 
   function failureHandler(err: Error) {
     monitor[kConnection]?.destroy({ force: true });
@@ -217,7 +222,12 @@ function checkServer(monitor: Monitor, callback: Callback<Document | null>) {
 
     monitor.emit(
       Server.SERVER_HEARTBEAT_FAILED,
-      new ServerHeartbeatFailedEvent(monitor.address, calculateDurationInMs(start), err)
+      new ServerHeartbeatFailedEvent(
+        monitor.address,
+        calculateDurationInMs(start),
+        err,
+        isAwaitable
+      )
     );
 
     const error = !(err instanceof MongoError)
@@ -237,8 +247,6 @@ function checkServer(monitor: Monitor, callback: Callback<Document | null>) {
     const { serverApi, helloOk } = connection;
     const connectTimeoutMS = monitor.options.connectTimeoutMS;
     const maxAwaitTimeMS = monitor.options.heartbeatFrequencyMS;
-    const topologyVersion = monitor[kServer].description.topologyVersion;
-    const isAwaitable = topologyVersion != null;
 
     const cmd = {
       [serverApi?.version || helloOk ? 'hello' : LEGACY_HELLO_COMMAND]: 1,
@@ -278,17 +286,18 @@ function checkServer(monitor: Monitor, callback: Callback<Document | null>) {
       const duration =
         isAwaitable && rttPinger ? rttPinger.roundTripTime : calculateDurationInMs(start);
 
+      const awaited = isAwaitable && hello.topologyVersion != null;
       monitor.emit(
         Server.SERVER_HEARTBEAT_SUCCEEDED,
-        new ServerHeartbeatSucceededEvent(monitor.address, duration, hello)
+        new ServerHeartbeatSucceededEvent(monitor.address, duration, hello, awaited)
       );
 
       // if we are using the streaming protocol then we immediately issue another `started`
       // event, otherwise the "check" is complete and return to the main monitor loop
-      if (isAwaitable && hello.topologyVersion) {
+      if (awaited) {
         monitor.emit(
           Server.SERVER_HEARTBEAT_STARTED,
-          new ServerHeartbeatStartedEvent(monitor.address)
+          new ServerHeartbeatStartedEvent(monitor.address, true)
         );
         start = now();
       } else {
@@ -324,7 +333,12 @@ function checkServer(monitor: Monitor, callback: Callback<Document | null>) {
       monitor[kConnection] = conn;
       monitor.emit(
         Server.SERVER_HEARTBEAT_SUCCEEDED,
-        new ServerHeartbeatSucceededEvent(monitor.address, calculateDurationInMs(start), conn.hello)
+        new ServerHeartbeatSucceededEvent(
+          monitor.address,
+          calculateDurationInMs(start),
+          conn.hello,
+          false
+        )
       );
 
       callback(undefined, conn.hello);

package/src/sdam/topology.ts

@@ -1,4 +1,3 @@
-import { clearTimeout, setTimeout } from 'timers';
 import { promisify } from 'util';
 
 import type { BSONSerializeOptions, Document } from '../bson';
@@ -43,7 +42,8 @@ import {
   List,
   makeStateMachine,
   ns,
-  shuffle
+  shuffle,
+  TimeoutController
 } from '../utils';
 import {
   _advanceClusterTime,
@@ -94,8 +94,8 @@ export interface ServerSelectionRequest {
   serverSelector: ServerSelector;
   transaction?: Transaction;
   callback: ServerSelectionCallback;
-  timer?: NodeJS.Timeout;
   [kCancelled]?: boolean;
+  timeoutController: TimeoutController;
 }
 
 /** @internal */
@@ -556,22 +556,20 @@ export class Topology extends TypedEventEmitter<TopologyEvents> {
     const waitQueueMember: ServerSelectionRequest = {
       serverSelector,
       transaction,
-      callback
+      callback,
+      timeoutController: new TimeoutController(options.serverSelectionTimeoutMS)
     };
 
-    const serverSelectionTimeoutMS = options.serverSelectionTimeoutMS;
-    if (serverSelectionTimeoutMS) {
-      waitQueueMember.timer = setTimeout(() => {
-        waitQueueMember[kCancelled] = true;
-        waitQueueMember.timer = undefined;
-        const timeoutError = new MongoServerSelectionError(
-          `Server selection timed out after ${serverSelectionTimeoutMS} ms`,
-          this.description
-        );
+    waitQueueMember.timeoutController.signal.addEventListener('abort', () => {
+      waitQueueMember[kCancelled] = true;
+      waitQueueMember.timeoutController.clear();
+      const timeoutError = new MongoServerSelectionError(
+        `Server selection timed out after ${options.serverSelectionTimeoutMS} ms`,
+        this.description
+      );
 
-        waitQueueMember.callback(timeoutError);
-      }, serverSelectionTimeoutMS);
-    }
+      waitQueueMember.callback(timeoutError);
+    });
 
     this[kWaitQueue].push(waitQueueMember);
     processWaitQueue(this);
@@ -842,9 +840,7 @@ function drainWaitQueue(queue: List<ServerSelectionRequest>, err?: MongoDriverEr
       continue;
     }
 
-    if (waitQueueMember.timer) {
-      clearTimeout(waitQueueMember.timer);
-    }
+    waitQueueMember.timeoutController.clear();
 
     if (!waitQueueMember[kCancelled]) {
       waitQueueMember.callback(err);
@@ -878,9 +874,7 @@ function processWaitQueue(topology: Topology) {
         ? serverSelector(topology.description, serverDescriptions)
         : serverDescriptions;
     } catch (e) {
-      if (waitQueueMember.timer) {
-        clearTimeout(waitQueueMember.timer);
-      }
+      waitQueueMember.timeoutController.clear();
 
       waitQueueMember.callback(e);
       continue;
@@ -917,9 +911,7 @@ function processWaitQueue(topology: Topology) {
       transaction.pinServer(selectedServer);
     }
 
-    if (waitQueueMember.timer) {
-      clearTimeout(waitQueueMember.timer);
-    }
+    waitQueueMember.timeoutController.clear();
 
     waitQueueMember.callback(undefined, selectedServer);
   }

package/src/utils.ts

@@ -1,6 +1,7 @@
 import * as crypto from 'crypto';
 import type { SrvRecord } from 'dns';
 import * as http from 'http';
+import { clearTimeout, setTimeout } from 'timers';
 import * as url from 'url';
 import { URL } from 'url';
 
@@ -78,39 +79,6 @@ export function hostMatchesWildcards(host: string, wildcards: string[]): boolean
   return false;
 }
 
-/**
- * Throws if collectionName is not a valid mongodb collection namespace.
- * @internal
- */
-export function checkCollectionName(collectionName: string): void {
-  if ('string' !== typeof collectionName) {
-    throw new MongoInvalidArgumentError('Collection name must be a String');
-  }
-
-  if (!collectionName || collectionName.indexOf('..') !== -1) {
-    throw new MongoInvalidArgumentError('Collection names cannot be empty');
-  }
-
-  if (
-    collectionName.indexOf('$') !== -1 &&
-    collectionName.match(/((^\$cmd)|(oplog\.\$main))/) == null
-  ) {
-    // TODO(NODE-3483): Use MongoNamespace static method
-    throw new MongoInvalidArgumentError("Collection names must not contain '$'");
-  }
-
-  if (collectionName.match(/^\.|\.$/) != null) {
-    // TODO(NODE-3483): Use MongoNamespace static method
-    throw new MongoInvalidArgumentError("Collection names must not start or end with '.'");
-  }
-
-  // Validate that we are not passing 0x00 in the collection name
-  if (collectionName.indexOf('\x00') !== -1) {
-    // TODO(NODE-3483): Use MongoNamespace static method
-    throw new MongoInvalidArgumentError('Collection names cannot contain a null character');
-  }
-}
-
 /**
  * Ensure Hint field is in a shape we expect:
  * - object of index names mapping to 1 or -1
@@ -386,11 +354,6 @@ export function maybeCallback<T>(
   return;
 }
 
-/** @internal */
-export function databaseNamespace(ns: string): string {
-  return ns.split('.')[0];
-}
-
 /**
  * Synchronously Generate a UUIDv4
  * @internal
@@ -1292,3 +1255,30 @@ export async function request(
     req.end();
   });
 }
+
+/**
+ * A custom AbortController that aborts after a specified timeout.
+ *
+ * If `timeout` is undefined or \<=0, the abort controller never aborts.
+ *
+ * This class provides two benefits over the built-in AbortSignal.timeout() method.
+ * - This class provides a mechanism for cancelling the timeout
+ * - This class supports infinite timeouts by interpreting a timeout of 0 as infinite.  This is
+ *    consistent with existing timeout options in the Node driver (serverSelectionTimeoutMS, for example).
+ * @internal
+ */
+export class TimeoutController extends AbortController {
+  constructor(
+    timeout = 0,
+    private timeoutId = timeout > 0 ? setTimeout(() => this.abort(), timeout) : null
+  ) {
+    super();
+  }
+
+  clear() {
+    if (this.timeoutId != null) {
+      clearTimeout(this.timeoutId);
+    }
+    this.timeoutId = null;
+  }
+}