wrangler 2.0.24 → 2.0.27

package/src/pages/functions/routes-transformation.ts

@@ -0,0 +1,122 @@
+import { join as pathJoin } from "node:path";
+import { toUrlPath } from "../../paths";
+import { MAX_FUNCTIONS_ROUTES_RULES, ROUTES_SPEC_VERSION } from "../constants";
+import { consolidateRoutes } from "./routes-consolidation";
+import type { RouteConfig } from "./routes";
+
+/** Interface for _routes.json */
+interface RoutesJSONSpec {
+	version: typeof ROUTES_SPEC_VERSION;
+	include: string[];
+	exclude: string[];
+}
+
+type RoutesJSONRouteInput = Pick<RouteConfig, "routePath" | "middleware">[];
+
+export function convertRoutesToGlobPatterns(
+	routes: RoutesJSONRouteInput
+): string[] {
+	const convertedRoutes = routes.map(({ routePath, middleware }) => {
+		const globbedRoutePath: string = routePath.replace(/:\w+\*?.*/, "*");
+
+		// Middleware mountings need to end in glob so that they can handle their
+		// own sub-path routes
+		if (
+			typeof middleware === "string" ||
+			(Array.isArray(middleware) && middleware.length > 0)
+		) {
+			if (!globbedRoutePath.endsWith("*")) {
+				return toUrlPath(pathJoin(globbedRoutePath, "*"));
+			}
+		}
+
+		return toUrlPath(globbedRoutePath);
+	});
+
+	return Array.from(new Set(convertedRoutes));
+}
+
+/**
+ * Converts Functions routes like /foo/:bar to a Routing object that's used
+ * to determine if a request should run in the Functions user-worker.
+ * Also consolidates redundant routes such as [/foo/bar, /foo/:bar] -> /foo/*
+ *
+ * @returns RoutesJSONSpec to be written to _routes.json
+ */
+export function convertRoutesToRoutesJSONSpec(
+	routes: RoutesJSONRouteInput
+): RoutesJSONSpec {
+	// The initial routes coming in are sorted most-specific to least-specific.
+	// The order doesn't have any affect on the output of this function, but
+	// it should speed up route consolidation with less-specific routes being first.
+	const reversedRoutes = [...routes].reverse();
+	const include = convertRoutesToGlobPatterns(reversedRoutes);
+	return optimizeRoutesJSONSpec({
+		version: ROUTES_SPEC_VERSION,
+		include,
+		exclude: [],
+	});
+}
+
+/**
+ * Optimizes and returns a new Routes JSON Spec instance performing
+ * de-duping, consolidation, truncation, and sorting
+ */
+export function optimizeRoutesJSONSpec(spec: RoutesJSONSpec): RoutesJSONSpec {
+	const optimizedSpec = { ...spec };
+
+	let consolidatedRoutes = consolidateRoutes(optimizedSpec.include);
+	if (consolidatedRoutes.length > MAX_FUNCTIONS_ROUTES_RULES) {
+		consolidatedRoutes = ["/*"];
+	}
+	// Sort so that least-specific routes are first
+	consolidatedRoutes.sort((a, b) => compareRoutes(b, a));
+
+	optimizedSpec.include = consolidatedRoutes;
+
+	return optimizedSpec;
+}
+
+/**
+ * Simplified routes comparison (copied from the one in filepath-routing.)
+ * This version will sort most-specific to least-specific, but the input is simplified
+ * routes like /foo/*, /foo, etc
+ */
+export function compareRoutes(routeA: string, routeB: string) {
+	function parseRoutePath(routePath: string): string[] {
+		return routePath.slice(1).split("/").filter(Boolean);
+	}
+
+	const segmentsA = parseRoutePath(routeA);
+	const segmentsB = parseRoutePath(routeB);
+
+	// sort routes with fewer segments after those with more segments
+	if (segmentsA.length !== segmentsB.length) {
+		return segmentsB.length - segmentsA.length;
+	}
+
+	for (let i = 0; i < segmentsA.length; i++) {
+		const isWildcardA = segmentsA[i].includes("*");
+		const isWildcardB = segmentsB[i].includes("*");
+
+		// sort wildcard segments after non-wildcard segments
+		if (isWildcardA && !isWildcardB) return 1;
+		if (!isWildcardA && isWildcardB) return -1;
+	}
+
+	// all else equal, just sort the paths lexicographically
+	return routeA.localeCompare(routeB);
+}
+
+export function isRoutesJSONSpec(data: unknown): data is RoutesJSONSpec {
+	return (
+		(typeof data === "object" &&
+			data &&
+			"version" in data &&
+			typeof (data as RoutesJSONSpec).version === "number" &&
+			(data as RoutesJSONSpec).version === ROUTES_SPEC_VERSION &&
+			Array.isArray((data as RoutesJSONSpec).include) &&
+			Array.isArray((data as RoutesJSONSpec).exclude)) ||
+		false
+	);
+}

package/src/pages/functions.tsx

@@ -0,0 +1,96 @@
+import { existsSync, lstatSync, readFileSync, writeFileSync } from "node:fs";
+import path from "node:path";
+import { FatalError } from "../errors";
+import { logger } from "../logger";
+import { isInPagesCI, ROUTES_SPEC_VERSION } from "./constants";
+import {
+	isRoutesJSONSpec,
+	optimizeRoutesJSONSpec,
+} from "./functions/routes-transformation";
+import { pagesBetaWarning } from "./utils";
+import type { YargsOptionsToInterface } from "./types";
+import type { Argv } from "yargs";
+
+type OptimizeRoutesArgs = YargsOptionsToInterface<typeof OptimizeRoutesOptions>;
+
+export function OptimizeRoutesOptions(yargs: Argv) {
+	return yargs
+		.options({
+			"routes-path": {
+				type: "string",
+				demandOption: true,
+				description: "The location of the _routes.json file",
+			},
+		})
+		.options({
+			"output-routes-path": {
+				type: "string",
+				demandOption: true,
+				description: "The location of the optimized output routes file",
+			},
+		});
+}
+
+export async function OptimizeRoutesHandler({
+	routesPath,
+	outputRoutesPath,
+}: OptimizeRoutesArgs) {
+	if (!isInPagesCI) {
+		// Beta message for `wrangler pages <commands>` usage
+		logger.log(pagesBetaWarning);
+	}
+
+	let routesFileContents: string;
+	const routesOutputDirectory = path.dirname(outputRoutesPath);
+
+	if (!existsSync(routesPath)) {
+		throw new FatalError(
+			`Oops! File ${routesPath} does not exist. Please make sure --routes-path is a valid file path (for example "/public/_routes.json").`,
+			1
+		);
+	}
+
+	if (
+		!existsSync(routesOutputDirectory) ||
+		!lstatSync(routesOutputDirectory).isDirectory()
+	) {
+		throw new FatalError(
+			`Oops! Folder ${routesOutputDirectory} does not exist. Please make sure --output-routes-path is a valid file path (for example "/public/_routes.json").`,
+			1
+		);
+	}
+
+	try {
+		routesFileContents = readFileSync(routesPath, "utf-8");
+	} catch (err) {
+		throw new FatalError(`Error while reading ${routesPath} file: ${err}`);
+	}
+
+	const routes = JSON.parse(routesFileContents);
+
+	if (!isRoutesJSONSpec(routes)) {
+		throw new FatalError(
+			`
+      Invalid _routes.json file found at: ${routesPath}. Please make sure the JSON object has the following format:
+      {
+        version: ${ROUTES_SPEC_VERSION};
+        include: string[];
+        exclude: string[];
+      }
+      `,
+			1
+		);
+	}
+
+	const optimizedRoutes = optimizeRoutesJSONSpec(routes);
+	const optimizedRoutesContents = JSON.stringify(optimizedRoutes);
+
+	try {
+		writeFileSync(outputRoutesPath, optimizedRoutesContents);
+	} catch (err) {
+		throw new FatalError(
+			`Error writing to ${outputRoutesPath} file: ${err}`,
+			1
+		);
+	}
+}

package/src/pages/index.tsx

@@ -3,6 +3,7 @@
 import * as Build from "./build";
 import * as Deployments from "./deployments";
 import * as Dev from "./dev";
+import * as Functions from "./functions";
 import * as Projects from "./projects";
 import * as Publish from "./publish";
 import * as Upload from "./upload";
@@ -19,66 +20,75 @@ process.on("SIGTERM", () => {
 });
 
 export const pages: BuilderCallback<unknown, unknown> = (yargs) => {
-	return yargs
-		.command(
-			"dev [directory] [-- command..]",
-			"🧑‍💻 Develop your full-stack Pages application locally",
-			Dev.Options,
-			Dev.Handler
-		)
-		.command("functions", false, (yargs) =>
-			// we hide this command from help output because
-			// it's not meant to be used directly right now
-			{
-				return yargs.command(
-					"build [directory]",
-					"Compile a folder of Cloudflare Pages Functions into a single Worker",
-					Build.Options,
-					Build.Handler
-				);
-			}
-		)
-		.command("project", "⚡️ Interact with your Pages projects", (yargs) =>
-			yargs
-				.command(
-					"list",
-					"List your Cloudflare Pages projects",
-					Projects.ListOptions,
-					Projects.ListHandler
-				)
-				.command(
-					"create [project-name]",
-					"Create a new Cloudflare Pages project",
-					Projects.CreateOptions,
-					Projects.CreateHandler
-				)
-				.command("upload [directory]", false, Upload.Options, Upload.Handler)
-				.epilogue(pagesBetaWarning)
-		)
-		.command(
-			"deployment",
-			"🚀 Interact with the deployments of a project",
-			(yargs) =>
+	return (
+		yargs
+			.command(
+				"dev [directory] [-- command..]",
+				"🧑‍💻 Develop your full-stack Pages application locally",
+				Dev.Options,
+				Dev.Handler
+			)
+			/**
+			 * `wrangler pages functions` is meant for internal use only for now,
+			 * so let's hide this command from the help output
+			 */
+			.command("functions", false, (yargs) =>
+				yargs
+					.command(
+						"build [directory]",
+						"Compile a folder of Cloudflare Pages Functions into a single Worker",
+						Build.Options,
+						Build.Handler
+					)
+					.command(
+						"optimize-routes [routesPath] [outputRoutesPath]",
+						"Consolidate and optimize the route paths declared in _routes.json",
+						Functions.OptimizeRoutesOptions,
+						Functions.OptimizeRoutesHandler
+					)
+			)
+			.command("project", "⚡️ Interact with your Pages projects", (yargs) =>
 				yargs
 					.command(
 						"list",
-						"List deployments in your Cloudflare Pages project",
-						Deployments.ListOptions,
-						Deployments.ListHandler
+						"List your Cloudflare Pages projects",
+						Projects.ListOptions,
+						Projects.ListHandler
 					)
 					.command(
-						"create [directory]",
-						"🆙 Publish a directory of static assets as a Pages deployment",
-						Publish.Options,
-						Publish.Handler
+						"create [project-name]",
+						"Create a new Cloudflare Pages project",
+						Projects.CreateOptions,
+						Projects.CreateHandler
 					)
+					.command("upload [directory]", false, Upload.Options, Upload.Handler)
 					.epilogue(pagesBetaWarning)
-		)
-		.command(
-			"publish [directory]",
-			"🆙 Publish a directory of static assets as a Pages deployment",
-			Publish.Options,
-			Publish.Handler
-		)
-		.epilogue(pagesBetaWarning);
+			)
+			.command(
+				"deployment",
+				"🚀 Interact with the deployments of a project",
+				(yargs) =>
+					yargs
+						.command(
+							"list",
+							"List deployments in your Cloudflare Pages project",
+							Deployments.ListOptions,
+							Deployments.ListHandler
+						)
+						.command(
+							"create [directory]",
+							"🆙 Publish a directory of static assets as a Pages deployment",
+							Publish.Options,
+							Publish.Handler
+						)
+						.epilogue(pagesBetaWarning)
+			)
+			.command(
+				"publish [directory]",
+				"🆙 Publish a directory of static assets as a Pages deployment",
+				Publish.Options,
+				Publish.Handler
+			)
+			.epilogue(pagesBetaWarning)
+	);
 };

package/src/pages/projects.tsx

@@ -124,12 +124,18 @@ export async function CreateHandler({
 			isGitDir = false;
 		}
 
+		if (isGitDir) {
+			try {
+				productionBranch = execSync(`git rev-parse --abbrev-ref HEAD`)
+					.toString()
+					.trim();
+			} catch (err) {}
+		}
+
 		productionBranch = await prompt(
 			"Enter the production branch name:",
 			"text",
-			isGitDir
-				? execSync(`git rev-parse --abbrev-ref HEAD`).toString().trim()
-				: "production"
+			productionBranch ?? "production"
 		);
 	}
 

package/src/pages/publish.tsx

@@ -16,22 +16,25 @@ import * as metrics from "../metrics";
 import { requireAuth } from "../user";
 import { buildFunctions } from "./build";
 import { PAGES_CONFIG_CACHE_FILENAME } from "./constants";
+import { FunctionsNoRoutesError, getFunctionsNoRoutesWarning } from "./errors";
+import {
+	isRoutesJSONSpec,
+	optimizeRoutesJSONSpec,
+} from "./functions/routes-transformation";
 import { listProjects } from "./projects";
 import { upload } from "./upload";
 import { pagesBetaWarning } from "./utils";
-import type { Deployment, PagesConfigCache, Project } from "./types";
-import type { ArgumentsCamelCase, Argv } from "yargs";
-
-type PublishArgs = {
-	directory: string;
-	"project-name"?: string;
-	branch?: string;
-	"commit-hash"?: string;
-	"commit-message"?: string;
-	"commit-dirty"?: boolean;
-};
+import type {
+	Deployment,
+	PagesConfigCache,
+	Project,
+	YargsOptionsToInterface,
+} from "./types";
+import type { Argv } from "yargs";
+
+type PublishArgs = YargsOptionsToInterface<typeof Options>;
 
-export function Options(yargs: Argv): Argv<PublishArgs> {
+export function Options(yargs: Argv) {
 	return yargs
 		.positional("directory", {
 			type: "string",
@@ -77,7 +80,7 @@ export const Handler = async ({
 	commitMessage,
 	commitDirty,
 	config: wranglerConfig,
-}: ArgumentsCamelCase<PublishArgs>) => {
+}: PublishArgs) => {
 	if (wranglerConfig) {
 		throw new FatalError("Pages does not support wrangler.toml", 1);
 	}
@@ -251,19 +254,27 @@ export const Handler = async ({
 
 	let builtFunctions: string | undefined = undefined;
 	const functionsDirectory = join(cwd(), "functions");
+	const routesOutputPath = join(tmpdir(), `_routes-${Math.random()}.json`);
 	if (existsSync(functionsDirectory)) {
 		const outfile = join(tmpdir(), `./functionsWorker-${Math.random()}.js`);
-
-		await new Promise((resolve) =>
-			buildFunctions({
+		try {
+			await buildFunctions({
 				outfile,
 				functionsDirectory,
-				onEnd: () => resolve(null),
+				onEnd: () => {},
 				buildOutputDirectory: dirname(outfile),
-			})
-		);
-
-		builtFunctions = readFileSync(outfile, "utf-8");
+				routesOutputPath,
+			});
+			builtFunctions = readFileSync(outfile, "utf-8");
+		} catch (e) {
+			if (e instanceof FunctionsNoRoutesError) {
+				logger.warn(
+					getFunctionsNoRoutesWarning(functionsDirectory, "skipping")
+				);
+			} else {
+				throw e;
+			}
+		}
 	}
 
 	const manifest = await upload({ directory, accountId, projectName });
@@ -290,6 +301,7 @@ export const Handler = async ({
 
 	let _headers: string | undefined,
 		_redirects: string | undefined,
+		_routes: string | undefined,
 		_workerJS: string | undefined;
 
 	try {
@@ -306,18 +318,59 @@ export const Handler = async ({
 
 	if (_headers) {
 		formData.append("_headers", new File([_headers], "_headers"));
+		logger.log(`✨ Uploading _headers`);
 	}
 
 	if (_redirects) {
 		formData.append("_redirects", new File([_redirects], "_redirects"));
+		logger.log(`✨ Uploading _redirects`);
 	}
 
 	if (builtFunctions) {
 		formData.append("_worker.js", new File([builtFunctions], "_worker.js"));
+		logger.log(`✨ Uploading Functions`);
+		try {
+			_routes = readFileSync(routesOutputPath, "utf-8");
+			if (_routes) {
+				formData.append("_routes.json", new File([_routes], "_routes.json"));
+			}
+		} catch {}
 	} else if (_workerJS) {
+		// Advanced Mode
+		// https://developers.cloudflare.com/pages/platform/functions/#advanced-mode
 		formData.append("_worker.js", new File([_workerJS], "_worker.js"));
-	}
+		logger.log(`✨ Uploading _worker.js`);
+
+		try {
+			// In advanced mode, developers can specify a custom _routes.json
+			// file. In which case, we need to run it through optimization
+			// to potentially reduce the overall worker pipeline size
+			const routesPath = join(directory, "_routes.json");
+			const advancedModeRoutesString = readFileSync(routesPath, "utf-8");
+			const advancedModeRoutes = JSON.parse(advancedModeRoutesString);
+
+			if (!isRoutesJSONSpec(advancedModeRoutes)) {
+				throw new FatalError(
+					"Invalid _routes.json file found at:" + routesPath,
+					1
+				);
+			}
+
+			_routes = JSON.stringify(optimizeRoutesJSONSpec(advancedModeRoutes));
+			formData.append("_routes.json", new File([_routes], "_routes.json"));
+			logger.log(`✨ Uploading _routes.json`);
 
+			logger.warn(
+				`🚨 _routes.json is an experimental feature and is subject to change. Don't use unless you really must!`
+			);
+		} catch (e) {
+			// Ignore file not existing errors for _routes.json but forward the potential
+			// FatalError from an invalid spec
+			if (e instanceof FatalError) {
+				throw e;
+			}
+		}
+	}
 	const deploymentResponse = await fetchResult<Deployment>(
 		`/accounts/${accountId}/pages/projects/${projectName}/deployments`,
 		{

package/src/pages/types.ts

@@ -1,3 +1,12 @@
+import type { ArgumentsCamelCase, Argv } from "yargs";
+
+/**
+ * Given some Yargs Options function factory, extract the interface
+ * that corresponds to the yargs arguments
+ */
+export type YargsOptionsToInterface<T extends (yargs: Argv) => Argv> =
+	T extends (yargs: Argv) => Argv<infer P> ? ArgumentsCamelCase<P> : never;
+
 export type Project = {
 	name: string;
 	subdomain: string;

package/src/pages/upload.tsx

@@ -26,15 +26,12 @@ import {
 	MAX_UPLOAD_ATTEMPTS,
 } from "./constants";
 import { pagesBetaWarning } from "./utils";
-import type { UploadPayloadFile } from "./types";
-import type { ArgumentsCamelCase, Argv } from "yargs";
+import type { UploadPayloadFile, YargsOptionsToInterface } from "./types";
+import type { Argv } from "yargs";
 
-type UploadArgs = {
-	directory: string;
-	"output-manifest-path"?: string;
-};
+type UploadArgs = YargsOptionsToInterface<typeof Options>;
 
-export function Options(yargs: Argv): Argv<UploadArgs> {
+export function Options(yargs: Argv) {
 	return yargs
 		.positional("directory", {
 			type: "string",
@@ -53,7 +50,7 @@ export function Options(yargs: Argv): Argv<UploadArgs> {
 export const Handler = async ({
 	directory,
 	outputManifestPath,
-}: ArgumentsCamelCase<UploadArgs>) => {
+}: UploadArgs) => {
 	if (!directory) {
 		throw new FatalError("Must specify a directory.", 1);
 	}
@@ -106,6 +103,7 @@ export const upload = async (
 		"_worker.js",
 		"_redirects",
 		"_headers",
+		"_routes.json",
 		".DS_Store",
 		"node_modules",
 		".git",

package/src/proxy.ts

@@ -177,6 +177,7 @@ export function usePreviewServer({
 		const cleanupListeners: (() => void)[] = [];
 
 		// create a ClientHttp2Session
+		logger.debug("PREVIEW URL:", `https://${previewToken.host}`);
 		const remote = connect(`https://${previewToken.host}`);
 		cleanupListeners.push(() => remote.destroy());
 
@@ -221,6 +222,15 @@ export function usePreviewServer({
 				}
 			}
 			const request = message.pipe(remote.request(headers));
+			logger.debug(
+				"WORKER REQUEST",
+				new Date().toLocaleTimeString(),
+				method,
+				url
+			);
+			logger.debug("HEADERS", JSON.stringify(headers, null, 2));
+			logger.debug("PREVIEW TOKEN", previewToken);
+
 			request.on("response", (responseHeaders) => {
 				const status = responseHeaders[":status"] ?? 500;
 

package/src/r2.ts

@@ -33,10 +33,10 @@ export async function createR2Bucket(
 	accountId: string,
 	bucketName: string
 ): Promise<void> {
-	return await fetchResult<void>(
-		`/accounts/${accountId}/r2/buckets/${bucketName}`,
-		{ method: "PUT" }
-	);
+	return await fetchResult<void>(`/accounts/${accountId}/r2/buckets`, {
+		method: "POST",
+		body: JSON.stringify({ name: bucketName }),
+	});
 }
 
 /**
@@ -116,3 +116,16 @@ export async function putR2Object(
 		}
 	);
 }
+/**
+ * Delete an Object
+ */
+export async function deleteR2Object(
+	accountId: string,
+	bucketName: string,
+	objectName: string
+): Promise<void> {
+	await fetchR2Objects(
+		`/accounts/${accountId}/r2/buckets/${bucketName}/objects/${objectName}`,
+		{ method: "DELETE" }
+	);
+}

package/src/tail/filters.ts

@@ -58,13 +58,14 @@ type OutcomeFilter = {
 
 /**
  * There are five possible outcomes we can get, three of which
- * (exception, exceededCpu, and unknown) are considered errors
+ * (exception, exceededCpu, exceededMemory, and unknown) are considered errors
  */
 export type Outcome =
 	| "ok"
 	| "canceled"
 	| "exception"
 	| "exceededCpu"
+	| "exceededMemory"
 	| "unknown";
 
 /**
@@ -210,6 +211,7 @@ function parseOutcome(
 			case "error":
 				outcomes.add("exception");
 				outcomes.add("exceededCpu");
+				outcomes.add("exceededMemory");
 				outcomes.add("unknown");
 				break;