Implement scheduler.wait

Author: mrbbot

packages/core/src/plugins/core.ts

@@ -42,6 +42,7 @@ import {
   Request,
   Response,
   ScheduledEvent,
+  Scheduler,
   TextDecoder,
   WorkerGlobalScope,
   atob,
@@ -331,6 +332,7 @@ export class CorePlugin extends Plugin<CoreOptions> implements CoreOptions {
       clearTimeout,
       clearInterval,
       queueMicrotask,
+      scheduler: new Scheduler(),
 
       atob,
       btoa,

packages/core/src/standards/timers.ts

@@ -1,3 +1,4 @@
+import { DOMException } from "@miniflare/core";
 import { waitForOpenInputGate } from "@miniflare/shared";
 
 export function inputGatedSetTimeout<Args extends any[]>(
@@ -49,3 +50,27 @@ AbortSignal.timeout ??= (ms?: number) => {
   setTimeout(() => controller.abort(), ms);
   return controller.signal;
 };
+
+export interface SchedulerWaitOptions {
+  signal?: AbortSignal;
+}
+
+export class Scheduler {
+  wait(ms?: number, options?: SchedulerWaitOptions): Promise<void> {
+    if (typeof ms !== "number") {
+      throw new TypeError(
+        "Failed to execute 'wait' on 'Scheduler': parameter 1 is not of type 'integer'."
+      );
+    }
+    return new Promise((resolve, reject) => {
+      let resolved = false;
+      const timeout = setTimeout(() => (resolved = true) && resolve(), ms);
+      // @ts-expect-error AbortSignal in @types/node is missing EventTarget types
+      options?.signal?.addEventListener("abort", () => {
+        if (resolved) return;
+        clearTimeout(timeout);
+        reject(new DOMException("The operation was aborted", "AbortError"));
+      });
+    });
+  }
+}

packages/core/test/plugins/core.spec.ts

@@ -262,6 +262,7 @@ test("CorePlugin: setup: includes web standards", async (t) => {
   t.true(typeof globals.clearTimeout === "function");
   t.true(typeof globals.clearInterval === "function");
   t.true(typeof globals.queueMicrotask === "function");
+  t.true(typeof globals.scheduler.wait === "function");
 
   t.true(typeof globals.atob === "function");
   t.true(typeof globals.btoa === "function");

packages/core/test/standards/timers.spec.ts

@@ -1,5 +1,10 @@
 import { setTimeout } from "timers/promises";
-import { inputGatedSetInterval, inputGatedSetTimeout } from "@miniflare/core";
+import {
+  DOMException,
+  Scheduler,
+  inputGatedSetInterval,
+  inputGatedSetTimeout,
+} from "@miniflare/core";
 import {
   TestInputGate,
   triggerPromise,
@@ -120,3 +125,41 @@ test("AbortSignal.timeout: included on constructor obtained via AbortController#
   // @ts-expect-error `timeout` isn't included in Node.js yet
   t.is(constructor.timeout, AbortSignal.timeout);
 });
+
+const scheduler = new Scheduler();
+test("scheduler.wait: resolves after timeout", async (t) => {
+  let resolved = false;
+  scheduler.wait(100).then(() => (resolved = true));
+  t.false(resolved);
+  await setTimeout(10);
+  t.false(resolved);
+  await setTimeout(200);
+  t.true(resolved);
+});
+test("scheduler.wait: rejects on abort", async (t) => {
+  const controller = new AbortController();
+  const promise = scheduler.wait(1000, { signal: controller.signal });
+  await setTimeout(10);
+  controller.abort();
+  await t.throwsAsync(promise, {
+    instanceOf: DOMException,
+    name: "AbortError",
+    message: "The operation was aborted",
+  });
+});
+test("scheduler.wait: does nothing if aborted after resolve", async (t) => {
+  const controller = new AbortController();
+  await scheduler.wait(10, { signal: controller.signal });
+  controller.abort();
+  t.pass();
+});
+test("scheduler.wait: requires numeric timeout", (t) => {
+  const expectations: ThrowsExpectation = {
+    instanceOf: TypeError,
+    message:
+      "Failed to execute 'wait' on 'Scheduler': parameter 1 is not of type 'integer'.",
+  };
+  t.throws(() => scheduler.wait(), expectations);
+  // @ts-expect-error `timeout` isn't included in Node.js yet
+  t.throws(() => scheduler.wait("42"), expectations);
+});