mongodb 6.5.0-dev.20240418.sha.af18c53 → 6.5.0-dev.20240420.sha.eece8c1

package/src/timeout.ts

@@ -0,0 +1,100 @@
+import { clearTimeout, setTimeout } from 'timers';
+
+import { MongoInvalidArgumentError } from './error';
+import { noop } from './utils';
+
+/** @internal */
+export class TimeoutError extends Error {
+  override get name(): 'TimeoutError' {
+    return 'TimeoutError';
+  }
+
+  constructor(message: string, options?: { cause?: Error }) {
+    super(message, options);
+  }
+
+  static is(error: unknown): error is TimeoutError {
+    return (
+      error != null && typeof error === 'object' && 'name' in error && error.name === 'TimeoutError'
+    );
+  }
+}
+
+type Executor = ConstructorParameters<typeof Promise<never>>[0];
+type Reject = Parameters<ConstructorParameters<typeof Promise<never>>[0]>[1];
+/**
+ * @internal
+ * This class is an abstraction over timeouts
+ * The Timeout class can only be in the pending or rejected states. It is guaranteed not to resolve
+ * if interacted with exclusively through its public API
+ * */
+export class Timeout extends Promise<never> {
+  get [Symbol.toStringTag](): 'MongoDBTimeout' {
+    return 'MongoDBTimeout';
+  }
+
+  private timeoutError: TimeoutError;
+  private id?: NodeJS.Timeout;
+
+  public readonly start: number;
+  public ended: number | null = null;
+  public duration: number;
+  public timedOut = false;
+
+  /** Create a new timeout that expires in `duration` ms */
+  private constructor(executor: Executor = () => null, duration: number) {
+    let reject!: Reject;
+
+    if (duration < 0) {
+      throw new MongoInvalidArgumentError('Cannot create a Timeout with a negative duration');
+    }
+
+    super((_, promiseReject) => {
+      reject = promiseReject;
+
+      executor(noop, promiseReject);
+    });
+
+    // NOTE: Construct timeout error at point of Timeout instantiation to preserve stack traces
+    this.timeoutError = new TimeoutError(`Expired after ${duration}ms`);
+
+    this.duration = duration;
+    this.start = Math.trunc(performance.now());
+
+    if (this.duration > 0) {
+      this.id = setTimeout(() => {
+        this.ended = Math.trunc(performance.now());
+        this.timedOut = true;
+        reject(this.timeoutError);
+      }, this.duration);
+      // Ensure we do not keep the Node.js event loop running
+      if (typeof this.id.unref === 'function') {
+        this.id.unref();
+      }
+    }
+  }
+
+  /**
+   * Clears the underlying timeout. This method is idempotent
+   */
+  clear(): void {
+    clearTimeout(this.id);
+    this.id = undefined;
+  }
+
+  public static expires(durationMS: number): Timeout {
+    return new Timeout(undefined, durationMS);
+  }
+
+  static is(timeout: unknown): timeout is Timeout {
+    return (
+      typeof timeout === 'object' &&
+      timeout != null &&
+      Symbol.toStringTag in timeout &&
+      timeout[Symbol.toStringTag] === 'MongoDBTimeout' &&
+      'then' in timeout &&
+      // eslint-disable-next-line github/no-then
+      typeof timeout.then === 'function'
+    );
+  }
+}

package/src/utils.ts

@@ -3,7 +3,6 @@ import type { SrvRecord } from 'dns';
 import { type EventEmitter } from 'events';
 import { promises as fs } from 'fs';
 import * as http from 'http';
-import { clearTimeout, setTimeout } from 'timers';
 import * as url from 'url';
 import { URL } from 'url';
 import { promisify } from 'util';
@@ -1203,33 +1202,6 @@ export async function request(
   });
 }
 
-/**
- * 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;
-  }
-}
-
 /** @internal */
 export const DOCUMENT_DB_CHECK = /(\.docdb\.amazonaws\.com$)|(\.docdb-elastic\.amazonaws\.com$)/;
 /** @internal */
@@ -1344,3 +1316,7 @@ export async function fileIsAccessible(fileName: string, mode?: number) {
     return false;
   }
 }
+
+export function noop() {
+  return;
+}