wrangler 2.0.29 → 2.1.2

package/src/miniflare-cli/assets.ts

@@ -1,20 +1,27 @@
 import { existsSync, lstatSync, readFileSync } from "node:fs";
 import { join } from "node:path";
-import {
-	generateRulesMatcher,
-	replacer,
-} from "@cloudflare/pages-shared/src/asset-server/rulesEngine";
+import { createMetadataObject } from "@cloudflare/pages-shared/src/metadata-generator/createMetadataObject";
+import { parseHeaders } from "@cloudflare/pages-shared/src/metadata-generator/parseHeaders";
+import { parseRedirects } from "@cloudflare/pages-shared/src/metadata-generator/parseRedirects";
 import { fetch as miniflareFetch } from "@miniflare/core";
+import {
+	Response as MiniflareResponse,
+	Request as MiniflareRequest,
+} from "@miniflare/core";
 import { watch } from "chokidar";
 import { getType } from "mime";
-import { Response } from "miniflare";
-import type { Headers as MiniflareHeaders } from "@miniflare/core";
-import type { Log } from "miniflare";
+import { hashFile } from "../pages/hash";
+import type { Metadata } from "@cloudflare/pages-shared/src/asset-server/metadata";
 import type {
-	Request as MiniflareRequest,
-	RequestInfo,
-	RequestInit,
-} from "miniflare";
+	fetch,
+	Request,
+} from "@cloudflare/pages-shared/src/environment-polyfills/types";
+import type {
+	ParsedRedirects,
+	ParsedHeaders,
+} from "@cloudflare/pages-shared/src/metadata-generator/types";
+import type { RequestInfo, RequestInit, FetcherFetch } from "@miniflare/core";
+import type { Log } from "miniflare";
 
 export interface Options {
 	log: Log;
@@ -28,204 +35,49 @@ export default async function generateASSETSBinding(options: Options) {
 			? await generateAssetsFetch(options.directory, options.log)
 			: invalidAssetsFetch;
 
-	return async function (request: MiniflareRequest) {
+	return async function (miniflareRequest: MiniflareRequest) {
 		if (options.proxyPort) {
 			try {
-				const url = new URL(request.url);
+				const url = new URL(miniflareRequest.url);
 				url.host = `localhost:${options.proxyPort}`;
-				return await miniflareFetch(url, request);
+				return await miniflareFetch(url, miniflareRequest);
 			} catch (thrown) {
 				options.log.error(new Error(`Could not proxy request: ${thrown}`));
 
 				// TODO: Pretty error page
-				return new Response(`[wrangler] Could not proxy request: ${thrown}`, {
-					status: 502,
-				});
+				return new MiniflareResponse(
+					`[wrangler] Could not proxy request: ${thrown}`,
+					{
+						status: 502,
+					}
+				);
 			}
 		} else {
 			try {
-				return await assetsFetch(request);
+				return await assetsFetch(miniflareRequest);
 			} catch (thrown) {
 				options.log.error(new Error(`Could not serve static asset: ${thrown}`));
 
 				// TODO: Pretty error page
-				return new Response(
+				return new MiniflareResponse(
 					`[wrangler] Could not serve static asset: ${thrown}`,
 					{ status: 502 }
 				);
 			}
 		}
-	};
-}
-
-function generateHeadersMatcher(headersFile: string) {
-	if (existsSync(headersFile)) {
-		const contents = readFileSync(headersFile).toString();
-
-		// TODO: Log errors
-		const lines = contents
-			.split("\n")
-			.map((line) => line.trim())
-			.filter((line) => !line.startsWith("#") && line !== "");
-
-		const rules: Record<string, Record<string, string>> = {};
-		let rule: { path: string; headers: Record<string, string> } | undefined =
-			undefined;
-
-		for (const line of lines) {
-			if (/^([^\s]+:\/\/|^\/)/.test(line)) {
-				if (rule && Object.keys(rule.headers).length > 0) {
-					rules[rule.path] = rule.headers;
-				}
-
-				const path = validateURL(line);
-				if (path) {
-					rule = {
-						path,
-						headers: {},
-					};
-					continue;
-				}
-			}
-
-			if (!line.includes(":")) continue;
-
-			const [rawName, ...rawValue] = line.split(":");
-			const name = rawName.trim().toLowerCase();
-			const value = rawValue.join(":").trim();
-
-			if (name === "") continue;
-			if (!rule) continue;
-
-			const existingValues = rule.headers[name];
-			rule.headers[name] = existingValues
-				? `${existingValues}, ${value}`
-				: value;
-		}
-
-		if (rule && Object.keys(rule.headers).length > 0) {
-			rules[rule.path] = rule.headers;
-		}
-
-		const rulesMatcher = generateRulesMatcher(rules, (match, replacements) =>
-			Object.fromEntries(
-				Object.entries(match).map(([name, value]) => [
-					name,
-					replacer(value, replacements),
-				])
-			)
-		);
-
-		return (request: MiniflareRequest) => {
-			const matches = rulesMatcher({
-				request,
-			});
-			if (matches) return matches;
-		};
-	} else {
-		return () => undefined;
-	}
-}
-
-function generateRedirectsMatcher(redirectsFile: string) {
-	if (existsSync(redirectsFile)) {
-		const contents = readFileSync(redirectsFile).toString();
-
-		// TODO: Log errors
-		const lines = contents
-			.split("\n")
-			.map((line) => line.trim())
-			.filter((line) => !line.startsWith("#") && line !== "");
-
-		const rules = Object.fromEntries(
-			lines
-				.map((line) => line.split(" "))
-				.filter((tokens) => tokens.length === 2 || tokens.length === 3)
-				.map((tokens) => {
-					const from = validateURL(tokens[0], true, false, false);
-					const to = validateURL(tokens[1], false, true, true);
-					let status: number | undefined = parseInt(tokens[2]) || 302;
-					status = [301, 302, 303, 307, 308].includes(status)
-						? status
-						: undefined;
-
-					return from && to && status ? [from, { to, status }] : undefined;
-				})
-				.filter((rule) => rule !== undefined) as [
-				string,
-				{ to: string; status?: number }
-			][]
-		);
-
-		const rulesMatcher = generateRulesMatcher(
-			rules,
-			({ status, to }, replacements) => ({
-				status,
-				to: replacer(to, replacements),
-			})
-		);
-
-		return (request: MiniflareRequest) => {
-			const match = rulesMatcher({
-				request,
-			})[0];
-			if (match) return match;
-		};
-	} else {
-		return () => undefined;
-	}
-}
-
-function extractPathname(
-	path = "/",
-	includeSearch: boolean,
-	includeHash: boolean
-) {
-	if (!path.startsWith("/")) path = `/${path}`;
-	const url = new URL(`//${path}`, "relative://");
-	return `${url.pathname}${includeSearch ? url.search : ""}${
-		includeHash ? url.hash : ""
-	}`;
-}
-
-function validateURL(
-	token: string,
-	onlyRelative = false,
-	includeSearch = false,
-	includeHash = false
-) {
-	const host = /^https:\/\/+(?<host>[^/]+)\/?(?<path>.*)/.exec(token);
-	if (host && host.groups && host.groups.host) {
-		if (onlyRelative) return;
-
-		return `https://${host.groups.host}${extractPathname(
-			host.groups.path,
-			includeSearch,
-			includeHash
-		)}`;
-	} else {
-		if (!token.startsWith("/") && onlyRelative) token = `/${token}`;
-
-		const path = /^\//.exec(token);
-		if (path) {
-			try {
-				return extractPathname(token, includeSearch, includeHash);
-			} catch {}
-		}
-	}
-	return "";
-}
-
-function hasFileExtension(pathname: string) {
-	return /\/.+\.[a-z0-9]+$/i.test(pathname);
+	} as FetcherFetch;
 }
 
 async function generateAssetsFetch(
 	directory: string,
 	log: Log
-): Promise<typeof miniflareFetch> {
+): Promise<typeof fetch> {
 	// Defer importing miniflare until we really need it
-	const { Headers, Request } = await import("@miniflare/core");
+	await import("@cloudflare/pages-shared/src/environment-polyfills/miniflare");
+
+	const { generateHandler, parseQualityWeightedList } = await import(
+		"@cloudflare/pages-shared/src/asset-server/handler"
+	);
 
 	const headersFile = join(directory, "_headers");
 	const redirectsFile = join(directory, "_redirects");
@@ -233,260 +85,123 @@ async function generateAssetsFetch(
 
 	const ignoredFiles = [headersFile, redirectsFile, workerFile];
 
-	const assetExists = (path: string) => {
-		path = join(directory, path);
-		return (
-			existsSync(path) &&
-			lstatSync(path).isFile() &&
-			!ignoredFiles.includes(path)
-		);
-	};
-
-	const getAsset = (path: string) => {
-		if (assetExists(path)) {
-			return join(directory, path);
-		}
-	};
+	let redirects: ParsedRedirects | undefined;
+	if (existsSync(redirectsFile)) {
+		const contents = readFileSync(redirectsFile, "utf-8");
+		redirects = parseRedirects(contents);
+	}
 
-	let redirectsMatcher = generateRedirectsMatcher(redirectsFile);
-	let headersMatcher = generateHeadersMatcher(headersFile);
+	let headers: ParsedHeaders | undefined;
+	if (existsSync(headersFile)) {
+		const contents = readFileSync(headersFile, "utf-8");
+		headers = parseHeaders(contents);
+	}
 
-	watch([headersFile, redirectsFile], {
-		persistent: true,
-	}).on("change", (path) => {
-		switch (path) {
-			case headersFile: {
-				log.log("_headers modified. Re-evaluating...");
-				headersMatcher = generateHeadersMatcher(headersFile);
-				break;
-			}
-			case redirectsFile: {
-				log.log("_redirects modified. Re-evaluating...");
-				redirectsMatcher = generateRedirectsMatcher(redirectsFile);
-				break;
-			}
-		}
+	let metadata = createMetadataObject({
+		redirects,
+		headers,
+		logger: log.warn.bind(log),
 	});
 
-	const serveAsset = (file: string) => {
-		return readFileSync(file);
-	};
-
-	const generateResponse = (request: MiniflareRequest) => {
-		const url = new URL(request.url);
-		let assetName = url.pathname;
-		try {
-			//it's possible for someone to send a URL like http://fakehost/abc%2 which would fail to decode
-			assetName = decodeURIComponent(url.pathname);
-		} catch {}
-
-		const deconstructedResponse: {
-			status: number;
-			headers: MiniflareHeaders;
-			body?: Buffer;
-		} = {
-			status: 200,
-			headers: new Headers(),
-			body: undefined,
-		};
-
-		const match = redirectsMatcher(request);
-		if (match) {
-			const { status, to } = match;
-
-			let location = to;
-			let search;
-
-			if (to.startsWith("/")) {
-				search = new URL(location, "http://fakehost").search;
-			} else {
-				search = new URL(location).search;
-			}
-
-			location = `${location}${search ? "" : url.search}`;
-
-			if (status && [301, 302, 303, 307, 308].includes(status)) {
-				deconstructedResponse.status = status;
-			} else {
-				deconstructedResponse.status = 302;
-			}
-
-			deconstructedResponse.headers.set("Location", location);
-			return deconstructedResponse;
-		}
-
-		if (!request.method?.match(/^(get|head)$/i)) {
-			deconstructedResponse.status = 405;
-			return deconstructedResponse;
-		}
-
-		const notFound = () => {
-			let cwd = assetName;
-			while (cwd) {
-				cwd = cwd.slice(0, cwd.lastIndexOf("/"));
-
-				if ((asset = getAsset(`${cwd}/404.html`))) {
-					deconstructedResponse.status = 404;
-					deconstructedResponse.body = serveAsset(asset);
-					deconstructedResponse.headers.set(
-						"Content-Type",
-						getType(asset) || "application/octet-stream"
-					);
-					return deconstructedResponse;
+	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;
 				}
 			}
 
-			if ((asset = getAsset(`/index.html`))) {
-				deconstructedResponse.body = serveAsset(asset);
-				deconstructedResponse.headers.set(
-					"Content-Type",
-					getType(asset) || "application/octet-stream"
-				);
-				return deconstructedResponse;
-			}
-
-			deconstructedResponse.status = 404;
-			return deconstructedResponse;
-		};
-
-		let asset;
-
-		if (assetName.endsWith("/")) {
-			if ((asset = getAsset(`${assetName}/index.html`))) {
-				deconstructedResponse.body = serveAsset(asset);
-				deconstructedResponse.headers.set(
-					"Content-Type",
-					getType(asset) || "application/octet-stream"
-				);
-				return deconstructedResponse;
-			} else if ((asset = getAsset(`${assetName.replace(/\/$/, ".html")}`))) {
-				deconstructedResponse.status = 301;
-				deconstructedResponse.headers.set(
-					"Location",
-					`${assetName.slice(0, -1)}${url.search}`
-				);
-				return deconstructedResponse;
-			}
+			metadata = createMetadataObject({
+				redirects,
+				headers,
+				logger: log.warn,
+			});
 		}
+	);
 
-		if (assetName.endsWith("/index")) {
-			deconstructedResponse.status = 301;
-			deconstructedResponse.headers.set(
-				"Location",
-				`${assetName.slice(0, -"index".length)}${url.search}`
-			);
-			return deconstructedResponse;
-		}
+	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;
+				}
 
-		if ((asset = getAsset(assetName))) {
-			if (assetName.endsWith(".html")) {
-				const extensionlessPath = assetName.slice(0, -".html".length);
-				if (getAsset(extensionlessPath) || extensionlessPath === "/") {
-					deconstructedResponse.body = serveAsset(asset);
-					deconstructedResponse.headers.set(
-						"Content-Type",
-						getType(asset) || "application/octet-stream"
-					);
-					return deconstructedResponse;
+				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 {
-					deconstructedResponse.status = 301;
-					deconstructedResponse.headers.set(
-						"Location",
-						`${extensionlessPath}${url.search}`
-					);
-					return deconstructedResponse;
+					rawAcceptEncoding =
+						contentRequest.headers.get("Accept-Encoding") || undefined;
 				}
-			} else {
-				deconstructedResponse.body = serveAsset(asset);
-				deconstructedResponse.headers.set(
-					"Content-Type",
-					getType(asset) || "application/octet-stream"
-				);
-				return deconstructedResponse;
-			}
-		} else if (hasFileExtension(assetName)) {
-			if ((asset = getAsset(assetName + ".html"))) {
-				deconstructedResponse.body = serveAsset(asset);
-				deconstructedResponse.headers.set(
-					"Content-Type",
-					getType(asset) || "application/octet-stream"
-				);
-				return deconstructedResponse;
-			}
-			notFound();
-			return deconstructedResponse;
-		}
 
-		if ((asset = getAsset(`${assetName}.html`))) {
-			deconstructedResponse.body = serveAsset(asset);
-			deconstructedResponse.headers.set(
-				"Content-Type",
-				getType(asset) || "application/octet-stream"
-			);
-			return deconstructedResponse;
-		}
+				const acceptEncoding = parseQualityWeightedList(rawAcceptEncoding);
 
-		if ((asset = getAsset(`${assetName}/index.html`))) {
-			deconstructedResponse.status = 301;
-			deconstructedResponse.headers.set(
-				"Location",
-				`${assetName}/${url.search}`
-			);
-			return deconstructedResponse;
-		} else {
-			notFound();
-			return deconstructedResponse;
-		}
-	};
-
-	const attachHeaders = (
-		request: MiniflareRequest,
-		deconstructedResponse: {
-			status: number;
-			headers: MiniflareHeaders;
-			body?: Buffer;
-		}
-	) => {
-		const headers = deconstructedResponse.headers;
-		const newHeaders = new Headers({});
-		const matches = headersMatcher(request) || [];
-
-		matches.forEach((match) => {
-			Object.entries(match).forEach(([name, value]) => {
-				newHeaders.append(name, `${value}`);
-			});
-		});
+				if (
+					acceptEncoding["identity"] === 0 ||
+					(acceptEncoding["*"] === 0 &&
+						acceptEncoding["identity"] === undefined)
+				) {
+					throw new Error("No acceptable encodings available");
+				}
 
-		const combinedHeaders = {
-			...Object.fromEntries(headers.entries()),
-			...Object.fromEntries(newHeaders.entries()),
-		};
+				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;
 
-		deconstructedResponse.headers = new Headers({});
-		Object.entries(combinedHeaders).forEach(([name, value]) => {
-			if (value) deconstructedResponse.headers.set(name, value);
+				const contentType = getType(filepath) || "application/octet-stream";
+				return { body, contentType };
+			},
 		});
 	};
 
 	return async (input: RequestInfo, init?: RequestInit) => {
-		const request = new Request(input, init);
-		const deconstructedResponse = generateResponse(request);
-		attachHeaders(request, deconstructedResponse);
-
-		const headers = new Headers();
-
-		[...deconstructedResponse.headers.entries()].forEach(([name, value]) => {
-			if (value) headers.set(name, value);
-		});
-
-		return new Response(deconstructedResponse.body, {
-			headers,
-			status: deconstructedResponse.status,
-		});
+		const request = new MiniflareRequest(input, init);
+		return await generateResponse(request as unknown as Request);
 	};
 }
 
-const invalidAssetsFetch: typeof miniflareFetch = () => {
+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

@@ -129,7 +129,8 @@ async function main() {
 		}
 		mf = new Miniflare(config);
 		// Start Miniflare development server
-		await mf.startServer();
+		const mfServer = await mf.startServer();
+		const mfPort = (mfServer.address() as AddressInfo).port;
 		await mf.startScheduler();
 
 		const internalDurableObjectClassNames = Object.values(
@@ -195,6 +196,7 @@ async function main() {
 		process.send &&
 			process.send(
 				JSON.stringify({
+					mfPort: mfPort,
 					ready: true,
 					durableObjectsPort: durableObjectsMfPort,
 				})

package/src/pages/dev.tsx

@@ -451,9 +451,13 @@ async function spawnProxyProcess({
 	command: (string | number)[];
 }): Promise<undefined | number> {
 	if (command.length === 0) {
+		if (port !== undefined) {
+			return port;
+		}
+
 		CLEANUP();
 		throw new FatalError(
-			"Must specify a directory of static assets to serve or a command to run.",
+			"Must specify a directory of static assets to serve or a command to run or a proxy port.",
 			1
 		);
 	}

package/src/pages/hash.tsx

@@ -0,0 +1,13 @@
+import { readFileSync } from "node:fs";
+import { extname } from "node:path";
+import { hash as blake3hash } from "blake3-wasm";
+
+export const hashFile = (filepath: string) => {
+	const contents = readFileSync(filepath);
+	const base64Contents = contents.toString("base64");
+	const extension = extname(filepath).substring(1);
+
+	return blake3hash(base64Contents + extension)
+		.toString("hex")
+		.slice(0, 32);
+};