Fix nested module names on Windows (#580)

Miniflare extracts a relative module "name" from module paths. On
Windows, this process lead to names with `\`s in them. This meant
imports had to look like `import { ... } from "dir\\thing.js"` which
isn't right. This change normalises all import names to contain
forward slashes instead. Source mapping code is unaffected, as Node
will automatically normalise `/` to `\`s on Windows.

Author: mrbbot

packages/miniflare/src/plugins/core/modules.ts

@@ -309,7 +309,8 @@ export function convertModuleDefinition(
   def: ModuleDefinition
 ): Worker_Module {
   // The runtime requires module identifiers to be relative paths
-  const name = path.relative(modulesRoot, def.path);
+  let name = path.relative(modulesRoot, def.path);
+  if (path.sep === "\\") name = name.replaceAll("\\", "/");
   const contents = def.contents ?? readFileSync(def.path);
   switch (def.type) {
     case "ESModule":

packages/miniflare/test/fixtures/source-maps/nested/dep.ts

@@ -0,0 +1,9 @@
+import { reduceError } from "../reduce";
+
+export function createErrorResponse() {
+  const error = new TypeError("Dependency error");
+  return Response.json(reduceError(error), {
+    status: 500,
+    headers: { "MF-Experimental-Error-Stack": "true" },
+  });
+}

packages/miniflare/test/index.spec.ts

@@ -270,3 +270,27 @@ test("Miniflare: `node:` and `cloudflare:` modules", async (t) => {
   const res = await mf.dispatchFetch("http://localhost");
   t.is(await res.text(), "dGVzdA==");
 });
+
+test("Miniflare: modules in sub-directories", async (t) => {
+  const mf = new Miniflare({
+    modules: [
+      {
+        type: "ESModule",
+        path: "index.js",
+        contents: `import { b } from "./sub1/index.js"; export default { fetch() { return new Response(String(b + 3)); } }`,
+      },
+      {
+        type: "ESModule",
+        path: "sub1/index.js",
+        contents: `import { c } from "./sub2/index.js"; export const b = c + 20;`,
+      },
+      {
+        type: "ESModule",
+        path: "sub1/sub2/index.js",
+        contents: `export const c = 100;`,
+      },
+    ],
+  });
+  const res = await mf.dispatchFetch("http://localhost");
+  t.is(await res.text(), "123");
+});

packages/miniflare/test/plugins/core/errors/index.spec.ts

@@ -18,19 +18,25 @@ const FIXTURES_PATH = path.resolve(
 );
 const SERVICE_WORKER_ENTRY_PATH = path.join(FIXTURES_PATH, "service-worker.ts");
 const MODULES_ENTRY_PATH = path.join(FIXTURES_PATH, "modules.ts");
+const DEP_ENTRY_PATH = path.join(FIXTURES_PATH, "nested/dep.ts");
 
 test("source maps workers", async (t) => {
   // Build fixtures
   const tmp = await useTmp(t);
   await esbuild.build({
-    entryPoints: [SERVICE_WORKER_ENTRY_PATH, MODULES_ENTRY_PATH],
+    entryPoints: [
+      SERVICE_WORKER_ENTRY_PATH,
+      MODULES_ENTRY_PATH,
+      DEP_ENTRY_PATH,
+    ],
     format: "esm",
     bundle: true,
     sourcemap: true,
     outdir: tmp,
   });
   const serviceWorkerPath = path.join(tmp, "service-worker.js");
   const modulesPath = path.join(tmp, "modules.js");
+  const depPath = path.join(tmp, "nested", "dep.js");
   const serviceWorkerContent = await fs.readFile(serviceWorkerPath, "utf8");
   const modulesContent = await fs.readFile(modulesPath, "utf8");
 
@@ -96,6 +102,19 @@ test("source maps workers", async (t) => {
         modulesRoot: tmp,
         modules: [{ type: "ESModule", path: modulesPath }],
       },
+      {
+        name: "e",
+        routes: ["*/e"],
+        modules: [
+          // Check importing module with source map (e.g. Wrangler no bundle with built dependencies)
+          {
+            type: "ESModule",
+            path: modulesPath,
+            contents: `import { createErrorResponse } from "./nested/dep.js"; export default { fetch: createErrorResponse };`,
+          },
+          { type: "ESModule", path: depPath },
+        ],
+      },
     ],
   });
   error = await t.throwsAsync(mf.dispatchFetch("http://localhost"), {
@@ -118,4 +137,9 @@ test("source maps workers", async (t) => {
     message: "d",
   });
   t.regex(String(error?.stack), /modules\.ts:5:19/);
+  error = await t.throwsAsync(mf.dispatchFetch("http://localhost/e"), {
+    instanceOf: TypeError,
+    message: "Dependency error",
+  });
+  t.regex(String(error?.stack), /nested\/dep\.ts:4:17/);
 });