Add support for modules option

- If set to `true`, JavaScript is parsed and modules are collected
  automatically. Note if the specifier to a dynamic `import()` or
  `require()` is not a string literal, an exception will be raised.
- If set to an array, modules can be defined manually. This is
  intended for use by Wrangler (which has its own module collection
  logic) and end users needing dynamic specifiers.
- Otherwise, the script is assumed to be a service worker.

Author: mrbbot

packages/tre/src/helpers.ts

@@ -40,6 +40,15 @@ export class MiniflareError<
   }
 }
 
+export type MiniflareCoreErrorCode =
+  | "ERR_RUNTIME_UNSUPPORTED" // System doesn't support Cloudflare Workers runtime
+  | "ERR_DISPOSED" // Attempted to use Miniflare instance after calling dispose()
+  | "ERR_MODULE_PARSE" // SyntaxError when attempting to parse/locate modules
+  | "ERR_MODULE_STRING_SCRIPT" // Attempt to resolve module within string script
+  | "ERR_MODULE_DYNAMIC_SPEC" // Attempted to import/require a module without a literal spec
+  | "ERR_MODULE_RULE"; // No matching module rule for file
+export class MiniflareCoreError extends MiniflareError<MiniflareCoreErrorCode> {}
+
 export class HttpError extends MiniflareError<number> {
   constructor(code: number, message?: string, cause?: Error) {
     super(code, message, cause);

packages/tre/src/index.ts

@@ -1,16 +1,15 @@
 import assert from "assert";
 import http from "http";
 import path from "path";
-import util from "util";
 import getPort from "get-port";
-import { bold, dim, green, grey } from "kleur/colors";
+import { bold, green, grey } from "kleur/colors";
 import stoppable from "stoppable";
 import { HeadersInit, Request, Response } from "undici";
 import { z } from "zod";
 import {
   DeferredPromise,
   HttpError,
-  MiniflareError,
+  MiniflareCoreError,
   OptionalZodTypeOf,
   UnionToIntersection,
   ValueOf,
@@ -257,9 +256,6 @@ export class Miniflare {
       body: req.method === "GET" || req.method === "HEAD" ? undefined : req,
     });
 
-    console.log(request.method, req.url);
-    console.log(await request.clone().text());
-
     let response: Response | undefined;
     const customService = request.headers.get(HEADER_CUSTOM_SERVICE);
     if (customService !== null) {
@@ -359,15 +355,7 @@ export class Miniflare {
       }
     }
 
-    const config: Config = { services, sockets };
-    // const inspectedConfig = util.inspect(config, {
-    //   depth: null,
-    //   colors: true,
-    //   maxStringLength: 50,
-    // });
-    // console.log(grey("Assembled config:"), dim(inspectedConfig));
-
-    return config;
+    return { services, sockets };
   }
 
   get ready() {
@@ -376,7 +364,10 @@ export class Miniflare {
 
   #checkDisposed() {
     if (this.#disposeController.signal.aborted) {
-      throw new MiniflareError("ERR_DISPOSED", "Cannot use disposed instance");
+      throw new MiniflareCoreError(
+        "ERR_DISPOSED",
+        "Cannot use disposed instance"
+      );
     }
   }
 

packages/tre/src/plugins/core/index.ts

@@ -1,9 +1,17 @@
+import { readFileSync } from "fs";
 import fs from "fs/promises";
 import { Request, Response } from "undici";
 import { z } from "zod";
 import { Awaitable, JsonSchema } from "../../helpers";
-import { Service, Worker, Worker_Binding } from "../../runtime";
+import { Service, Worker_Binding, Worker_Module } from "../../runtime";
 import { BINDING_SERVICE_LOOPBACK, Plugin } from "../shared";
+import {
+  ModuleDefinitionSchema,
+  ModuleLocator,
+  ModuleRuleSchema,
+  STRING_SCRIPT_PATH,
+  convertModuleDefinition,
+} from "./modules";
 
 // (request: Request) => Awaitable<Response>
 export const ServiceFetch = z
@@ -15,7 +23,17 @@ export const CoreOptionsSchema = z.object({
   name: z.string().optional(),
   script: z.string().optional(),
   scriptPath: z.string().optional(),
-  modules: z.boolean().optional(),
+  modules: z
+    .union([
+      // Automatically collect modules by parsing `script`/`scriptPath`...
+      z.boolean(),
+      // ...or manually define modules
+      // (used by Wrangler which has its own module collection code)
+      z.array(ModuleDefinitionSchema),
+    ])
+    .optional(),
+  modulesRules: z.array(ModuleRuleSchema).optional(),
+
   compatibilityDate: z.string().optional(),
   compatibilityFlags: z.string().array().optional(),
 
@@ -144,20 +162,7 @@ export const CORE_PLUGIN: Plugin<
     ];
 
     // Define regular user worker if script is set
-    let workerScript: Partial<Worker> | undefined;
-    if (options.script !== undefined) {
-      workerScript = options.modules
-        ? { modules: [{ name: "<script>", esModule: options.script }] }
-        : { serviceWorkerScript: options.script };
-    } else if (options.scriptPath !== undefined) {
-      if (options.modules) {
-        // TODO: collect modules
-      } else {
-        const script = await fs.readFile(options.scriptPath, "utf8");
-        workerScript = { serviceWorkerScript: script };
-      }
-    }
-
+    const workerScript = getWorkerScript(options);
     if (workerScript !== undefined) {
       const name = `${SERVICE_USER_PREFIX}:${options.name ?? ""}`;
       services.push({
@@ -202,3 +207,37 @@ export const CORE_PLUGIN: Plugin<
     return services;
   },
 };
+
+function getWorkerScript(
+  options: z.infer<typeof CoreOptionsSchema>
+): { serviceWorkerScript: string } | { modules: Worker_Module[] } | undefined {
+  if (Array.isArray(options.modules)) {
+    // If `modules` is a manually defined modules array, use that
+    return { modules: options.modules.map(convertModuleDefinition) };
+  }
+
+  // Otherwise get code, preferring string `script` over `scriptPath`
+  let code;
+  if (options.script !== undefined) {
+    code = options.script;
+  } else if (options.scriptPath !== undefined) {
+    code = readFileSync(options.scriptPath, "utf8");
+  } else {
+    // If neither `script`, `scriptPath` nor `modules` is defined, this worker
+    // doesn't have any code
+    return;
+  }
+
+  if (options.modules) {
+    // If `modules` is `true`, automatically collect modules...
+    const locator = new ModuleLocator(options.modulesRules);
+    // If `script` and `scriptPath` are set, resolve modules in `script`
+    // against `scriptPath`.
+    locator.visitEntrypoint(code, options.scriptPath ?? STRING_SCRIPT_PATH);
+    return { modules: locator.modules };
+  } else {
+    // ...otherwise, `modules` will either be `false` or `undefined`, so treat
+    // `code` as a service worker
+    return { serviceWorkerScript: code };
+  }
+}