global/WebSocket extend EventTarget, expose Event(Target), see #18

Author: mrbbot

package.json

@@ -19,8 +19,8 @@
     "vendor"
   ],
   "scripts": {
-    "build": "tsc",
-    "dev": "tsc -w",
+    "build": "tsc -p tsconfig.build.json",
+    "dev": "tsc -p tsconfig.build.json -w",
     "test": "npm run build:fixtures && ava",
     "build:fixtures": "node test/fixtures/build.js",
     "lint": "eslint '{src,test}/**/*.ts'",
@@ -41,7 +41,7 @@
     "cjstoesm": "^1.1.4",
     "dotenv": "^8.2.0",
     "env-paths": "^2.2.1",
-    "formdata-node": "^2.4.0",
+    "formdata-node": "^2.5.0",
     "html-rewriter-wasm": "^0.3.2",
     "http-cache-semantics": "^4.1.0",
     "ioredis": "^4.27.6",
@@ -56,11 +56,27 @@
     "typescript": "^4.3.4",
     "typeson": "^6.1.0",
     "typeson-registry": "^1.0.0-alpha.39",
-    "web-streams-polyfill": "^3.0.1",
+    "web-streams-polyfill": "^3.1.0",
     "ws": "^7.5.0",
     "yargs": "^16.2.0",
     "youch": "^2.2.2"
   },
+  "peerDependencies": {
+    "cjstoesm": "1",
+    "ioredis": "4",
+    "typescript": "4"
+  },
+  "peerDependenciesMeta": {
+    "ioredis": {
+      "optional": true
+    },
+    "typescript": {
+      "optional": true
+    },
+    "cjstoesm": {
+      "optional": true
+    }
+  },
   "devDependencies": {
     "@cloudflare/kv-asset-handler": "^0.1.3",
     "@types/http-cache-semantics": "^4.0.0",
@@ -77,19 +93,22 @@
     "@typescript-eslint/eslint-plugin": "^4.28.0",
     "@typescript-eslint/parser": "^4.28.0",
     "ava": "^3.15.0",
+    "cjstoesm": "^1.1.4",
     "esbuild": "^0.12.9",
     "eslint": "^7.18.0",
     "eslint-config-prettier": "^7.1.0",
     "eslint-plugin-import": "^2.22.1",
     "eslint-plugin-prettier": "^3.3.1",
+    "ioredis": "^4.27.6",
     "prettier": "^2.2.1",
     "rimraf": "^3.0.2",
     "ts-node": "^9.1.1",
+    "typescript": "^4.3.4",
     "vitepress": "^0.15.5",
     "which": "^2.0.2"
   },
   "engines": {
-    "node": ">=10.12.0"
+    "node": ">=16.5.0"
   },
   "repository": {
     "type": "git",
@@ -98,5 +117,8 @@
   "bugs": {
     "url": "https://github.com/mrbbot/miniflare/issues"
   },
-  "homepage": "https://miniflare.dev/"
+  "homepage": "https://miniflare.dev/",
+  "volta": {
+    "node": "16.6.0"
+  }
 }

src/error.ts

@@ -0,0 +1,36 @@
+export class MiniflareError extends Error {
+  constructor(message?: string) {
+    super(message);
+    // Restore prototype chain:
+    // https://www.typescriptlang.org/docs/handbook/release-notes/typescript-2-2.html#support-for-newtarget
+    Object.setPrototypeOf(this, new.target.prototype);
+    this.name = new.target.name;
+  }
+}
+
+export type TypedEventListener<Event> =
+  | ((e: Event) => void)
+  | { handleEvent(e: Event): void };
+
+export interface TypedEventTargetInterface<
+  EventMap extends Record<string, Event>
+> extends EventTarget {
+  addEventListener<EventType extends keyof EventMap>(
+    type: EventType,
+    listener: TypedEventListener<EventMap[EventType]> | null,
+    options?: AddEventListenerOptions | boolean
+  ): void;
+
+  removeEventListener<EventType extends keyof EventMap>(
+    type: EventType,
+    listener: TypedEventListener<EventMap[EventType]> | null,
+    options?: EventListenerOptions | boolean
+  ): void;
+}
+
+export function typedEventTarget<EventMap extends Record<string, Event>>(): {
+  prototype: TypedEventTargetInterface<EventMap>;
+  new (): TypedEventTargetInterface<EventMap>;
+} {
+  return EventTarget as any;
+}

src/helpers.ts

@@ -11,14 +11,22 @@ import {
 } from "@mrbbot/node-fetch";
 import cron from "node-cron";
 import sourceMap, { UrlAndMap } from "source-map-support";
-import WebSocket from "ws";
+import StandardWebSocket from "ws";
 import Youch from "youch";
-import { MiniflareError } from "./error";
+import { MiniflareError } from "./helpers";
 import { Cache, KVStorageNamespace } from "./kv";
 import { ConsoleLog, Log, NoOpLog, logResponse } from "./log";
 import { ResponseWaitUntil } from "./modules";
 import { DurableObjectConstructor, DurableObjectNamespace } from "./modules/do";
-import { ModuleFetchListener, ModuleScheduledListener } from "./modules/events";
+import {
+  ModuleFetchListener,
+  ModuleScheduledListener,
+  addModuleFetchListenerSymbol,
+  addModuleScheduledListenerSymbol,
+  dispatchFetchSymbol,
+  dispatchScheduledSymbol,
+} from "./modules/events";
+import { ServiceWorkerGlobalScope } from "./modules/events";
 import { Context } from "./modules/module";
 import * as modules from "./modules/modules";
 import { terminateWebSocket } from "./modules/ws";
@@ -28,6 +36,7 @@ import {
   ModuleScriptInstance,
   ScriptLinker,
   ScriptScriptInstance,
+  createScriptContext,
 } from "./scripts";
 
 type ModuleName = keyof typeof modules;
@@ -50,12 +59,11 @@ export class Miniflare {
   readonly #watcher: OptionsWatcher;
   #options?: ProcessedOptions;
 
-  #sandbox: Context;
-  #environment: Context;
+  #globalScope?: ServiceWorkerGlobalScope;
   #scheduledTasks?: cron.ScheduledTask[];
   #extraSourceMaps?: Map<string, string>;
 
-  readonly #wss: WebSocket.Server;
+  readonly #wss: StandardWebSocket.Server;
 
   constructor(options: Options = {}) {
     if (options.sourceMap) {
@@ -77,12 +85,8 @@ export class Miniflare {
       {} as Modules
     );
 
-    // Defaults never used, will be overridden in #watchCallback
-    this.#sandbox = {};
-    this.#environment = {};
-
     // Initialise web socket server
-    this.#wss = new WebSocket.Server({ noServer: true });
+    this.#wss = new StandardWebSocket.Server({ noServer: true });
     this.#wss.addListener(
       "connection",
       this.#webSocketConnectionListener.bind(this)
@@ -104,20 +108,20 @@ export class Miniflare {
     this.#options = options;
     // Build sandbox and environment
     const modules = Object.values(this.#modules);
-    this.#sandbox = modules.reduce(
+    const sandbox = modules.reduce(
       (sandbox, module) => Object.assign(sandbox, module.buildSandbox(options)),
       {} as Context
     );
-    this.#environment = modules.reduce(
+    const environment = modules.reduce(
       (environment, module) =>
         Object.assign(environment, module.buildEnvironment(options)),
       {} as Context
     );
     // Assign bindings last so they can override modules if required
-    Object.assign(this.#environment, options.bindings);
+    Object.assign(environment, options.bindings);
 
     this.#reloadScheduled();
-    await this.#reloadWorker();
+    await this.#reloadWorker(sandbox, environment);
   }
 
   #reloadScheduled(): void {
@@ -137,7 +141,7 @@ export class Miniflare {
     );
   }
 
-  async #reloadWorker(): Promise<void> {
+  async #reloadWorker(sandbox: Context, environment: Context): Promise<void> {
     // Only called in #watchCallback() after #options set and scripts and
     // processedModulesRules are always set in this
     assert(this.#options?.scripts && this.#options.processedModulesRules);
@@ -146,20 +150,20 @@ export class Miniflare {
     const linker = new ScriptLinker(this.#options.processedModulesRules);
     this.#extraSourceMaps = linker.extraSourceMaps;
 
+    // Build new global scope (sandbox), this inherits from EventTarget
+    const globalScope = new ServiceWorkerGlobalScope(
+      this.log,
+      sandbox,
+      environment,
+      this.#options.modules
+    );
+    this.#globalScope = globalScope;
+    const context = createScriptContext(globalScope);
+
     // Reset state
-    this.#modules.EventsModule.resetEventListeners();
     this.#modules.DurableObjectsModule.resetInstances();
     this.#modules.StandardsModule.resetWebSockets();
 
-    // Build sandbox with global self-references, only including environment
-    // in global scope if not using modules
-    const sandbox = this.#options.modules
-      ? { ...this.#sandbox }
-      : { ...this.#sandbox, ...this.#environment };
-    sandbox.global = sandbox;
-    sandbox.globalThis = sandbox;
-    sandbox.self = sandbox;
-
     // Parse and run all scripts
     const moduleExports: Record<string, ModuleExports> = {};
     for (const script of Object.values(this.#options.scripts)) {
@@ -169,8 +173,8 @@ export class Miniflare {
       let instance: ScriptScriptInstance | ModuleScriptInstance<ModuleExports>;
       try {
         instance = this.#options.modules
-          ? await script.buildModule(sandbox, linker.linker)
-          : await script.buildScript(sandbox);
+          ? await script.buildModule(context, linker.linker)
+          : await script.buildScript(context);
       } catch (e) {
         // If this is because --experimental-vm-modules disabled, rethrow
         if (e instanceof MiniflareError) throw e;
@@ -202,18 +206,12 @@ export class Miniflare {
       if (script.fileName === this.#options.scriptPath) {
         const fetchListener = instance.exports?.default?.fetch;
         if (fetchListener) {
-          this.#modules.EventsModule.addModuleFetchListener(
-            fetchListener,
-            this.#environment
-          );
+          globalScope[addModuleFetchListenerSymbol](fetchListener);
         }
 
         const scheduledListener = instance.exports?.default?.scheduled;
         if (scheduledListener) {
-          this.#modules.EventsModule.addModuleScheduledListener(
-            scheduledListener,
-            this.#environment
-          );
+          globalScope[addModuleScheduledListenerSymbol](scheduledListener);
         }
       }
     }
@@ -231,10 +229,7 @@ export class Miniflare {
         );
       }
     }
-    this.#modules.DurableObjectsModule.setContext(
-      constructors,
-      this.#environment
-    );
+    this.#modules.DurableObjectsModule.setContext(constructors, environment);
 
     // Watch module referenced paths
     assert(this.#watcher !== undefined);
@@ -263,7 +258,9 @@ export class Miniflare {
     init?: RequestInit
   ): Promise<ResponseWaitUntil<WaitUntil>> {
     await this.#watcher.initPromise;
-    return this.#modules.EventsModule.dispatchFetch<WaitUntil>(
+    const globalScope = this.#globalScope;
+    assert(globalScope);
+    return globalScope[dispatchFetchSymbol]<WaitUntil>(
       new Request(input, init),
       this.#options?.upstreamUrl
     );
@@ -274,10 +271,9 @@ export class Miniflare {
     cron?: string
   ): Promise<WaitUntil> {
     await this.#watcher.initPromise;
-    return this.#modules.EventsModule.dispatchScheduled<WaitUntil>(
-      scheduledTime,
-      cron
-    );
+    const globalScope = this.#globalScope;
+    assert(globalScope);
+    return globalScope[dispatchScheduledSymbol]<WaitUntil>(scheduledTime, cron);
   }
 
   async getOptions(): Promise<ProcessedOptions> {
@@ -448,7 +444,7 @@ export class Miniflare {
   }
 
   async #webSocketConnectionListener(
-    ws: WebSocket,
+    ws: StandardWebSocket,
     req: http.IncomingMessage
   ): Promise<void> {
     // Handle request in worker

src/index.ts

@@ -1,6 +1,6 @@
 import http from "http";
 import * as colors from "kleur/colors";
-import { MiniflareError } from "./error";
+import { MiniflareError } from "./helpers";
 
 export interface Log {
   log(data: string): void;

src/log.ts

@@ -1,5 +1,5 @@
 import path from "path";
-import { MiniflareError } from "../error";
+import { MiniflareError } from "../helpers";
 import { Cache, NoOpCache } from "../kv";
 import { KVStorageFactory } from "../kv/helpers";
 import { Log } from "../log";

src/modules/cache.ts

@@ -1,19 +1,15 @@
 import assert from "assert";
 import crypto from "crypto";
 import path from "path";
-import {
-  Request,
-  RequestInfo,
-  RequestInit,
-  Response,
-} from "@mrbbot/node-fetch";
-import { MiniflareError } from "../error";
+import { RequestInfo, RequestInit } from "@mrbbot/node-fetch";
+import { MiniflareError } from "../helpers";
 import { DurableObjectStorage } from "../kv";
 import { abortAllSymbol } from "../kv/do";
 import { KVStorageFactory } from "../kv/helpers";
 import { Log } from "../log";
 import { ProcessedOptions } from "../options";
 import { Context, Module } from "./module";
+import { Request, Response } from "./standards";
 
 // Ideally we would store the storage on the DurableObject instance itself,
 // but we don't know what the user's Durable Object code does, so we store it