refactor: make timeout a thenable

Author: nbbeeken

src/timeout.ts

@@ -3,7 +3,7 @@ import { clearTimeout, setTimeout } from 'timers';
 import { type Document } from './bson';
 import { MongoInvalidArgumentError, MongoOperationTimeoutError, MongoRuntimeError } from './error';
 import { type ClientSession } from './sessions';
-import { csotMin, noop } from './utils';
+import { csotMin, promiseWithResolvers } from './utils';
 
 /** @internal */
 export class TimeoutError extends Error {
@@ -12,9 +12,9 @@ export class TimeoutError extends Error {
     return 'TimeoutError';
   }
 
-  constructor(message: string, options: { cause?: Error; duration: number }) {
+  constructor(message: string, options?: { cause?: Error; duration?: number }) {
     super(message, options);
-    this.duration = options.duration;
+    this.duration = options?.duration ?? 0;
   }
 
   static is(error: unknown): error is TimeoutError {
@@ -24,22 +24,21 @@ export class TimeoutError extends Error {
   }
 }
 
-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> {
+export class Timeout implements PromiseLike<never> {
   private id?: NodeJS.Timeout;
 
   public readonly start: number;
   public ended: number | null = null;
   public duration: number;
   private timedOut = false;
   public cleared = false;
+  private promise: Promise<never>;
 
   get remainingTime(): number {
     if (this.timedOut) return 0;
@@ -52,10 +51,7 @@ export class Timeout extends Promise<never> {
   }
 
   /** Create a new timeout that expires in `duration` ms */
-  private constructor(
-    executor: Executor = () => null,
-    options?: { duration: number; unref?: true; rejection?: Error }
-  ) {
+  private constructor(options?: { duration: number; unref?: true; rejection?: Error }) {
     const duration = options?.duration ?? 0;
     const unref = !!options?.unref;
     const rejection = options?.rejection;
@@ -64,13 +60,8 @@ export class Timeout extends Promise<never> {
       throw new MongoInvalidArgumentError('Cannot create a Timeout with a negative duration');
     }
 
-    let reject!: Reject;
-    super((_, promiseReject) => {
-      reject = promiseReject;
-
-      executor(noop, promiseReject);
-    });
-
+    const { promise, reject } = promiseWithResolvers<never>();
+    this.promise = promise;
     this.duration = duration;
     this.start = Math.trunc(performance.now());
 
@@ -91,6 +82,13 @@ export class Timeout extends Promise<never> {
     }
   }
 
+  then<_TResult1 = never, TResult2 = never>(
+    _?: undefined,
+    onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | undefined | null
+  ): PromiseLike<never> {
+    return this.promise.then<never, never>(undefined, onrejected as any);
+  }
+
   /**
    * Clears the underlying timeout. This method is idempotent
    */
@@ -106,11 +104,11 @@ export class Timeout extends Promise<never> {
   }
 
   public static expires(duration: number, unref?: true): Timeout {
-    return new Timeout(undefined, { duration, unref });
+    return new Timeout({ duration, unref });
   }
 
-  static override reject(rejection?: Error): Timeout {
-    return new Timeout(undefined, { duration: 0, unref: true, rejection });
+  static reject(rejection?: Error): Timeout {
+    return new Timeout({ duration: 0, unref: true, rejection });
   }
 }