wrangler 0.0.0-e978986 → 0.0.0-e98613f8

package/src/miniflare-cli/assets.ts

@@ -0,0 +1,220 @@
+import { existsSync, lstatSync, readFileSync } from "node:fs";
+import { join } from "node:path";
+import { createMetadataObject } from "@cloudflare/pages-shared/metadata-generator/createMetadataObject";
+import { parseHeaders } from "@cloudflare/pages-shared/metadata-generator/parseHeaders";
+import { parseRedirects } from "@cloudflare/pages-shared/metadata-generator/parseRedirects";
+import {
+	Response as MiniflareResponse,
+	Request as MiniflareRequest,
+} from "@miniflare/core";
+import { upgradingFetch as miniflareFetch } from "@miniflare/web-sockets";
+import { watch } from "chokidar";
+import { getType } from "mime";
+import { hashFile } from "../pages/hash";
+import type { Metadata } from "@cloudflare/pages-shared/asset-server/metadata";
+import type {
+	fetch,
+	Request,
+} from "@cloudflare/pages-shared/environment-polyfills/types";
+import type {
+	ParsedRedirects,
+	ParsedHeaders,
+} from "@cloudflare/pages-shared/metadata-generator/types";
+import type { RequestInfo, RequestInit, FetcherFetch } from "@miniflare/core";
+import type { Log } from "miniflare";
+
+export interface Options {
+	log: Log;
+	proxyPort?: number;
+	directory?: string;
+}
+
+export default async function generateASSETSBinding(options: Options) {
+	const assetsFetch =
+		options.directory !== undefined
+			? await generateAssetsFetch(options.directory, options.log)
+			: invalidAssetsFetch;
+
+	return async function (miniflareRequest: MiniflareRequest) {
+		if (options.proxyPort) {
+			try {
+				const url = new URL(miniflareRequest.url);
+				url.host = `localhost:${options.proxyPort}`;
+				const proxyRequest = new MiniflareRequest(url, miniflareRequest);
+				if (proxyRequest.headers.get("Upgrade") === "websocket") {
+					proxyRequest.headers.delete("Sec-WebSocket-Accept");
+					proxyRequest.headers.delete("Sec-WebSocket-Key");
+				}
+				return await miniflareFetch(proxyRequest);
+			} catch (thrown) {
+				options.log.error(new Error(`Could not proxy request: ${thrown}`));
+
+				// TODO: Pretty error page
+				return new MiniflareResponse(
+					`[wrangler] Could not proxy request: ${thrown}`,
+					{
+						status: 502,
+					}
+				);
+			}
+		} else {
+			try {
+				return await assetsFetch(miniflareRequest);
+			} catch (thrown) {
+				options.log.error(new Error(`Could not serve static asset: ${thrown}`));
+
+				// TODO: Pretty error page
+				return new MiniflareResponse(
+					`[wrangler] Could not serve static asset: ${thrown}`,
+					{ status: 502 }
+				);
+			}
+		}
+	} as FetcherFetch;
+}
+
+async function generateAssetsFetch(
+	directory: string,
+	log: Log
+): Promise<typeof fetch> {
+	// Defer importing miniflare until we really need it
+	await import("@cloudflare/pages-shared/environment-polyfills/miniflare");
+
+	const { generateHandler, parseQualityWeightedList } = await import(
+		"@cloudflare/pages-shared/asset-server/handler"
+	);
+
+	const headersFile = join(directory, "_headers");
+	const redirectsFile = join(directory, "_redirects");
+	const workerFile = join(directory, "_worker.js");
+
+	const ignoredFiles = [headersFile, redirectsFile, workerFile];
+
+	let redirects: ParsedRedirects | undefined;
+	if (existsSync(redirectsFile)) {
+		const contents = readFileSync(redirectsFile, "utf-8");
+		redirects = parseRedirects(contents);
+	}
+
+	let headers: ParsedHeaders | undefined;
+	if (existsSync(headersFile)) {
+		const contents = readFileSync(headersFile, "utf-8");
+		headers = parseHeaders(contents);
+	}
+
+	let metadata = createMetadataObject({
+		redirects,
+		headers,
+		logger: log.warn.bind(log),
+	});
+
+	watch([headersFile, redirectsFile], { persistent: true }).on(
+		"change",
+		(path) => {
+			switch (path) {
+				case headersFile: {
+					log.log("_headers modified. Re-evaluating...");
+					const contents = readFileSync(headersFile).toString();
+					headers = parseHeaders(contents);
+					break;
+				}
+				case redirectsFile: {
+					log.log("_redirects modified. Re-evaluating...");
+					const contents = readFileSync(redirectsFile).toString();
+					redirects = parseRedirects(contents);
+					break;
+				}
+			}
+
+			metadata = createMetadataObject({
+				redirects,
+				headers,
+				logger: log.warn,
+			});
+		}
+	);
+
+	const generateResponse = async (request: Request) => {
+		const assetKeyEntryMap = new Map<string, string>();
+
+		return await generateHandler<string>({
+			request,
+			metadata: metadata as Metadata,
+			xServerEnvHeader: "dev",
+			logError: console.error,
+			findAssetEntryForPath: async (path) => {
+				const filepath = join(directory, path);
+
+				if (
+					existsSync(filepath) &&
+					lstatSync(filepath).isFile() &&
+					!ignoredFiles.includes(filepath)
+				) {
+					const hash = hashFile(filepath);
+					assetKeyEntryMap.set(hash, filepath);
+					return hash;
+				}
+
+				return null;
+			},
+			getAssetKey: (assetEntry) => {
+				return assetEntry;
+			},
+			negotiateContent: (contentRequest) => {
+				let rawAcceptEncoding: string | undefined;
+				if (
+					contentRequest.cf &&
+					"clientAcceptEncoding" in contentRequest.cf &&
+					contentRequest.cf.clientAcceptEncoding
+				) {
+					rawAcceptEncoding = contentRequest.cf.clientAcceptEncoding as string;
+				} else {
+					rawAcceptEncoding =
+						contentRequest.headers.get("Accept-Encoding") || undefined;
+				}
+
+				const acceptEncoding = parseQualityWeightedList(rawAcceptEncoding);
+
+				if (
+					acceptEncoding["identity"] === 0 ||
+					(acceptEncoding["*"] === 0 &&
+						acceptEncoding["identity"] === undefined)
+				) {
+					throw new Error("No acceptable encodings available");
+				}
+
+				return { encoding: null };
+			},
+			fetchAsset: async (assetKey) => {
+				const filepath = assetKeyEntryMap.get(assetKey);
+				if (!filepath) {
+					throw new Error(
+						"Could not fetch asset. Please file an issue on GitHub (https://github.com/cloudflare/wrangler2/issues/new/choose) with reproduction steps."
+					);
+				}
+				const body = readFileSync(filepath) as unknown as ReadableStream;
+
+				let contentType = getType(filepath) || "application/octet-stream";
+				if (
+					contentType.startsWith("text/") &&
+					!contentType.includes("charset")
+				) {
+					contentType = `${contentType}; charset=utf-8`;
+				}
+
+				return { body, contentType };
+			},
+		});
+	};
+
+	return async (input: RequestInfo, init?: RequestInit) => {
+		const request = new MiniflareRequest(input, init);
+		return await generateResponse(request as unknown as Request);
+	};
+}
+
+const invalidAssetsFetch: typeof fetch = () => {
+	throw new Error(
+		"Trying to fetch assets directly when there is no `directory` option specified."
+	);
+};

package/src/miniflare-cli/index.ts

@@ -1,41 +1,213 @@
-import { Log, LogLevel, Miniflare } from "miniflare";
+import { fetch } from "@miniflare/core";
+import {
+	DurableObjectNamespace,
+	DurableObjectStub,
+} from "@miniflare/durable-objects";
+import {
+	Log as MiniflareLog,
+	LogLevel as MiniflareLogLevel,
+	Miniflare,
+	Request as MiniflareRequest,
+	Response as MiniflareResponse,
+} from "miniflare";
 import yargs from "yargs";
 import { hideBin } from "yargs/helpers";
-import { enumKeys } from "./enum-keys";
+import { FatalError } from "../errors";
+import generateASSETSBinding from "./assets";
 import { getRequestContextCheckOptions } from "./request-context";
+import type { LoggerLevel } from "../logger";
+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 MiniflareNoOpLog extends MiniflareLog {
+	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 requestContextCheckOptions = await getRequestContextCheckOptions();
-  const config = {
-    ...JSON.parse((args._[0] as string) ?? "{}"),
-    ...requestContextCheckOptions,
-    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();
-    await mf.startScheduler();
-  } 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)
+		.argv;
+
+	const requestContextCheckOptions = await getRequestContextCheckOptions();
+	const config = {
+		...JSON.parse((args._[0] as string) ?? "{}"),
+		...requestContextCheckOptions,
+	};
+
+	let logLevelString: Uppercase<LoggerLevel> = config.logLevel.toUpperCase();
+	if (logLevelString === "LOG") logLevelString = "INFO";
+	const logLevel = MiniflareLogLevel[logLevelString];
+
+	config.log =
+		logLevel === MiniflareLogLevel.NONE
+			? new MiniflareNoOpLog()
+			: new MiniflareLog(logLevel, config.logOptions);
+
+	if (logLevel === MiniflareLogLevel.DEBUG) {
+		console.log("MINIFLARE OPTIONS:\n", JSON.stringify(config, null, 2));
+	}
+
+	config.bindings = {
+		...config.bindings,
+		...(config.externalDurableObjects &&
+			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
+		const mfServer = await mf.startServer();
+		const mfPort = (mfServer.address() as AddressInfo).port;
+		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({
+					port: mfPort,
+					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

@@ -16,25 +16,25 @@ import type { MiniflareOptions } from "miniflare";
  * that indicate to miniflare whether to run the checks or not.
  */
 export const getRequestContextCheckOptions = async (): Promise<
-  Pick<MiniflareOptions, "globalAsyncIO" | "globalTimers" | "globalRandom">
+	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>();
+	// 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;
-  }
+		hasAsyncLocalStorage = storage.run("some-value", () => {
+			return storage.getStore() === "some-value";
+		});
+	} catch (e) {
+		hasAsyncLocalStorage = false;
+	}
 
-  return {
-    globalAsyncIO: hasAsyncLocalStorage,
-    globalRandom: hasAsyncLocalStorage,
-    globalTimers: hasAsyncLocalStorage,
-  };
+	return {
+		globalAsyncIO: hasAsyncLocalStorage,
+		globalRandom: hasAsyncLocalStorage,
+		globalTimers: hasAsyncLocalStorage,
+	};
 };