wrangler 0.0.0-e88a54e → 0.0.0-e8e684c7

package/src/miniflare-cli/index.ts

@@ -1,37 +1,207 @@
-import { Log, LogLevel, Miniflare } from "miniflare";
+import { fetch } from "@miniflare/core";
+import {
+	DurableObjectNamespace,
+	DurableObjectStub,
+} from "@miniflare/durable-objects";
+import {
+	Log,
+	LogLevel,
+	Miniflare,
+	Response as MiniflareResponse,
+	Request as MiniflareRequest,
+} from "miniflare";
 import yargs from "yargs";
 import { hideBin } from "yargs/helpers";
+import { FatalError } from "../errors";
+import generateASSETSBinding from "./assets";
 import { enumKeys } from "./enum-keys";
+import { getRequestContextCheckOptions } from "./request-context";
+import type { Options } from "./assets";
+import type { AddressInfo } from "net";
+
+export interface EnablePagesAssetsServiceBindingOptions {
+	proxyPort?: number;
+	directory?: string;
+}
+
+// miniflare defines this but importing it throws:
+// Dynamic require of "path" is not supported
+class NoOpLog extends Log {
+	log(): void {}
+
+	error(message: Error): void {
+		throw message;
+	}
+}
 
 async function main() {
-  const args = await yargs(hideBin(process.argv))
-    .help(false)
-    .version(false)
-    .option("log", {
-      choices: enumKeys(LogLevel),
-    }).argv;
-
-  const logLevel = LogLevel[args.log ?? "INFO"];
-  const config = {
-    ...JSON.parse((args._[0] as string) ?? "{}"),
-    log: new Log(logLevel),
-  };
-
-  if (logLevel > LogLevel.INFO) {
-    console.log("OPTIONS:\n", JSON.stringify(config, null, 2));
-  }
-
-  const mf = new Miniflare(config);
-
-  try {
-    // Start Miniflare development server
-    await mf.startServer();
-  } catch (e) {
-    mf.log.error(e as Error);
-    process.exitCode = 1;
-    // Unmount any mounted workers
-    await mf.dispose();
-  }
+	const args = await yargs(hideBin(process.argv))
+		.help(false)
+		.version(false)
+		.option("log", {
+			choices: enumKeys(LogLevel),
+		}).argv;
+
+	const logLevel = LogLevel[args.log ?? "INFO"];
+	const requestContextCheckOptions = await getRequestContextCheckOptions();
+	const config = {
+		...JSON.parse((args._[0] as string) ?? "{}"),
+		...requestContextCheckOptions,
+	};
+	//miniflare's logLevel 0 still logs routes, so lets override the logger
+	config.log = config.disableLogs
+		? new NoOpLog()
+		: new Log(logLevel, config.logOptions);
+
+	if (logLevel > LogLevel.INFO) {
+		console.log("OPTIONS:\n", JSON.stringify(config, null, 2));
+	}
+
+	config.bindings = {
+		...config.bindings,
+		...Object.fromEntries(
+			Object.entries(
+				config.externalDurableObjects as Record<
+					string,
+					{ name: string; host: string; port: number }
+				>
+			).map(([binding, { name, host, port }]) => {
+				const factory = () => {
+					throw new FatalError(
+						"An external Durable Object instance's state has somehow been attempted to be accessed.",
+						1
+					);
+				};
+				const namespace = new DurableObjectNamespace(name as string, factory);
+				namespace.get = (id) => {
+					const stub = new DurableObjectStub(factory, id);
+					stub.fetch = (...reqArgs) => {
+						const requestFromArgs = new MiniflareRequest(...reqArgs);
+						const url = new URL(requestFromArgs.url);
+						url.host = host;
+						if (port !== undefined) url.port = port.toString();
+						const request = new MiniflareRequest(
+							url.toString(),
+							requestFromArgs
+						);
+						request.headers.set("x-miniflare-durable-object-name", name);
+						request.headers.set("x-miniflare-durable-object-id", id.toString());
+
+						return fetch(request);
+					};
+					return stub;
+				};
+				return [binding, namespace];
+			})
+		),
+	};
+
+	let mf: Miniflare | undefined;
+	let durableObjectsMf: Miniflare | undefined = undefined;
+	let durableObjectsMfPort: number | undefined = undefined;
+
+	try {
+		if (args._[1]) {
+			const opts: EnablePagesAssetsServiceBindingOptions = JSON.parse(
+				args._[1] as string
+			);
+
+			if (isNaN(opts.proxyPort || NaN) && !opts.directory) {
+				throw new Error(
+					"MiniflareCLIOptions: built in service bindings set to true, but no port or directory provided"
+				);
+			}
+
+			const options: Options = {
+				log: config.log,
+				proxyPort: opts.proxyPort,
+				directory: opts.directory,
+			};
+
+			config.serviceBindings = {
+				...config.serviceBindings,
+				ASSETS: await generateASSETSBinding(options),
+			};
+		}
+		mf = new Miniflare(config);
+		// Start Miniflare development server
+		await mf.startServer();
+		await mf.startScheduler();
+
+		const internalDurableObjectClassNames = Object.values(
+			config.durableObjects as Record<string, string>
+		);
+
+		if (internalDurableObjectClassNames.length > 0) {
+			durableObjectsMf = new Miniflare({
+				host: config.host,
+				port: 0,
+				script: `
+				export default {
+					fetch(request, env) {
+						return env.DO.fetch(request)
+					}
+				}`,
+				serviceBindings: {
+					DO: async (request: MiniflareRequest) => {
+						request = new MiniflareRequest(request);
+
+						const name = request.headers.get("x-miniflare-durable-object-name");
+						const idString = request.headers.get(
+							"x-miniflare-durable-object-id"
+						);
+						request.headers.delete("x-miniflare-durable-object-name");
+						request.headers.delete("x-miniflare-durable-object-id");
+
+						if (!name || !idString) {
+							return new MiniflareResponse(
+								"[durable-object-proxy-err] Missing `x-miniflare-durable-object-name` or `x-miniflare-durable-object-id` headers.",
+								{ status: 400 }
+							);
+						}
+
+						const namespace = await mf?.getDurableObjectNamespace(name);
+						const id = namespace?.idFromString(idString);
+
+						if (!id) {
+							return new MiniflareResponse(
+								"[durable-object-proxy-err] Could not generate an ID. Possibly due to a mismatched DO name and ID?",
+								{ status: 500 }
+							);
+						}
+
+						const stub = namespace?.get(id);
+
+						if (!stub) {
+							return new MiniflareResponse(
+								"[durable-object-proxy-err] Could not generate a stub. Possibly due to a mismatched DO name and ID?",
+								{ status: 500 }
+							);
+						}
+
+						return stub.fetch(request);
+					},
+				},
+				modules: true,
+			});
+			const server = await durableObjectsMf.startServer();
+			durableObjectsMfPort = (server.address() as AddressInfo).port;
+		}
+
+		process.send &&
+			process.send(
+				JSON.stringify({
+					ready: true,
+					durableObjectsPort: durableObjectsMfPort,
+				})
+			);
+	} catch (e) {
+		mf?.log.error(e as Error);
+		process.exitCode = 1;
+		// Unmount any mounted workers
+		await mf?.dispose();
+		await durableObjectsMf?.dispose();
+	}
 }
 
 await main();

package/src/miniflare-cli/request-context.ts

@@ -0,0 +1,40 @@
+import type { MiniflareOptions } from "miniflare";
+
+/**
+ * Certain runtime APIs are only available to workers during the "request context",
+ * which is any code that returns after receiving a request and before returning
+ * a response.
+ *
+ * Miniflare emulates this behavior by using an [`AsyncLocalStorage`](https://nodejs.org/api/async_context.html#class-asynclocalstorage) and
+ * [checking at runtime](https://github.com/cloudflare/miniflare/blob/master/packages/shared/src/context.ts#L21-L36)
+ * to see if you're using those APIs during the request context.
+ *
+ * In certain environments `AsyncLocalStorage` is unavailable, such as in a
+ * [webcontainer](https://github.com/stackblitz/webcontainer-core).
+ * This function figures out if we're able to run those "request context" checks
+ * and returns [a set of options](https://miniflare.dev/core/standards#global-functionality-limits)
+ * that indicate to miniflare whether to run the checks or not.
+ */
+export const getRequestContextCheckOptions = async (): Promise<
+	Pick<MiniflareOptions, "globalAsyncIO" | "globalTimers" | "globalRandom">
+> => {
+	// check that there's an implementation of AsyncLocalStorage
+	let hasAsyncLocalStorage = true;
+	try {
+		// ripped from  the example here https://nodejs.org/api/async_context.html#class-asynclocalstorage
+		const { AsyncLocalStorage } = await import("node:async_hooks");
+		const storage = new AsyncLocalStorage<string>();
+
+		hasAsyncLocalStorage = storage.run("some-value", () => {
+			return storage.getStore() === "some-value";
+		});
+	} catch (e) {
+		hasAsyncLocalStorage = false;
+	}
+
+	return {
+		globalAsyncIO: hasAsyncLocalStorage,
+		globalRandom: hasAsyncLocalStorage,
+		globalTimers: hasAsyncLocalStorage,
+	};
+};