wrangler 2.0.23 → 2.0.26

package/src/pages/build.tsx

@@ -1,32 +1,29 @@
 import { writeFileSync } from "node:fs";
 import { tmpdir } from "node:os";
 import { dirname, join } from "node:path";
+import { FatalError } from "../errors";
 import { logger } from "../logger";
 import * as metrics from "../metrics";
 import { toUrlPath } from "../paths";
 import { isInPagesCI } from "./constants";
+import {
+	EXIT_CODE_FUNCTIONS_NO_ROUTES_ERROR,
+	FunctionsNoRoutesError,
+	getFunctionsNoRoutesWarning,
+} from "./errors";
 import { buildPlugin } from "./functions/buildPlugin";
 import { buildWorker } from "./functions/buildWorker";
 import { generateConfigFromFileTree } from "./functions/filepath-routing";
 import { writeRoutesModule } from "./functions/routes";
+import { convertRoutesToRoutesJSONSpec } from "./functions/routes-transformation";
 import { pagesBetaWarning, RUNNING_BUILDERS } from "./utils";
 import type { Config } from "./functions/routes";
-import type { ArgumentsCamelCase, Argv } from "yargs";
+import type { YargsOptionsToInterface } from "./types";
+import type { Argv } from "yargs";
 
-type PagesBuildArgs = {
-	directory: string;
-	outfile: string;
-	"output-config-path"?: string;
-	minify: boolean;
-	sourcemap: boolean;
-	"fallback-service": string;
-	watch: boolean;
-	plugin: boolean;
-	"build-output-directory"?: string;
-	"node-compat": boolean;
-};
+type PagesBuildArgs = YargsOptionsToInterface<typeof Options>;
 
-export function Options(yargs: Argv): Argv<PagesBuildArgs> {
+export function Options(yargs: Argv) {
 	return yargs
 		.positional("directory", {
 			type: "string",
@@ -43,6 +40,10 @@ export function Options(yargs: Argv): Argv<PagesBuildArgs> {
 				type: "string",
 				description: "The location for the output config file",
 			},
+			"output-routes-path": {
+				type: "string",
+				description: "The location for the output _routes.json file",
+			},
 			minify: {
 				type: "boolean",
 				default: false,
@@ -87,15 +88,16 @@ export function Options(yargs: Argv): Argv<PagesBuildArgs> {
 export const Handler = async ({
 	directory,
 	outfile,
-	"output-config-path": outputConfigPath,
+	outputConfigPath,
+	outputRoutesPath: routesOutputPath,
 	minify,
 	sourcemap,
 	fallbackService,
 	watch,
 	plugin,
-	"build-output-directory": buildOutputDirectory,
-	"node-compat": nodeCompat,
-}: ArgumentsCamelCase<PagesBuildArgs>) => {
+	buildOutputDirectory,
+	nodeCompat,
+}: PagesBuildArgs) => {
 	if (!isInPagesCI) {
 		// Beta message for `wrangler pages <commands>` usage
 		logger.log(pagesBetaWarning);
@@ -108,22 +110,37 @@ export const Handler = async ({
 	}
 
 	buildOutputDirectory ??= dirname(outfile);
-
-	await buildFunctions({
-		outfile,
-		outputConfigPath,
-		functionsDirectory: directory,
-		minify,
-		sourcemap,
-		fallbackService,
-		watch,
-		plugin,
-		buildOutputDirectory,
-		nodeCompat,
-	});
+	try {
+		await buildFunctions({
+			outfile,
+			outputConfigPath,
+			functionsDirectory: directory,
+			minify,
+			sourcemap,
+			fallbackService,
+			watch,
+			plugin,
+			buildOutputDirectory,
+			nodeCompat,
+			routesOutputPath,
+		});
+	} catch (e) {
+		if (e instanceof FunctionsNoRoutesError) {
+			throw new FatalError(
+				getFunctionsNoRoutesWarning(directory),
+				EXIT_CODE_FUNCTIONS_NO_ROUTES_ERROR
+			);
+		} else {
+			throw e;
+		}
+	}
 	await metrics.sendMetricsEvent("build pages functions");
 };
 
+/**
+ * Builds a Functions worker based on the functions directory, with filepath and handler based routing.
+ * @throws FunctionsNoRoutesError when there are no routes found in the functions directory
+ */
 export async function buildFunctions({
 	outfile,
 	outputConfigPath,
@@ -135,19 +152,25 @@ export async function buildFunctions({
 	onEnd,
 	plugin = false,
 	buildOutputDirectory,
+	routesOutputPath,
 	nodeCompat,
-}: {
-	outfile: string;
-	outputConfigPath?: string;
+}: Partial<
+	Pick<
+		PagesBuildArgs,
+		| "outputConfigPath"
+		| "minify"
+		| "sourcemap"
+		| "fallbackService"
+		| "watch"
+		| "plugin"
+		| "buildOutputDirectory"
+		| "nodeCompat"
+	>
+> & {
 	functionsDirectory: string;
-	minify?: boolean;
-	sourcemap?: boolean;
-	fallbackService?: string;
-	watch?: boolean;
 	onEnd?: () => void;
-	plugin?: boolean;
-	buildOutputDirectory?: string;
-	nodeCompat?: boolean;
+	outfile: Required<PagesBuildArgs>["outfile"];
+	routesOutputPath?: PagesBuildArgs["outputRoutesPath"];
 }) {
 	RUNNING_BUILDERS.forEach(
 		(runningBuilder) => runningBuilder.stop && runningBuilder.stop()
@@ -161,6 +184,17 @@ export async function buildFunctions({
 		baseURL,
 	});
 
+	if (!config.routes || config.routes.length === 0) {
+		throw new FunctionsNoRoutesError(
+			`Failed to find any routes while compiling Functions in: ${functionsDirectory}`
+		);
+	}
+
+	if (routesOutputPath) {
+		const routesJSON = convertRoutesToRoutesJSONSpec(config.routes);
+		writeFileSync(routesOutputPath, JSON.stringify(routesJSON, null, 2));
+	}
+
 	if (outputConfigPath) {
 		writeFileSync(
 			outputConfigPath,

package/src/pages/constants.ts

@@ -3,5 +3,10 @@ export const MAX_BUCKET_SIZE = 50 * 1024 * 1024;
 export const MAX_BUCKET_FILE_COUNT = 5000;
 export const BULK_UPLOAD_CONCURRENCY = 3;
 export const MAX_UPLOAD_ATTEMPTS = 5;
+export const MAX_CHECK_MISSING_ATTEMPTS = 5;
 export const SECONDS_TO_WAIT_FOR_PROXY = 5;
 export const isInPagesCI = !!process.env.CF_PAGES;
+/** The max number of rules in _routes.json */
+export const MAX_FUNCTIONS_ROUTES_RULES = 100;
+export const MAX_FUNCTIONS_ROUTES_RULE_LENGTH = 100;
+export const ROUTES_SPEC_VERSION = 1;

package/src/pages/deployments.tsx

@@ -11,14 +11,16 @@ import { requireAuth } from "../user";
 import { PAGES_CONFIG_CACHE_FILENAME } from "./constants";
 import { listProjects } from "./projects";
 import { pagesBetaWarning } from "./utils";
-import type { Deployment, PagesConfigCache } from "./types";
-import type { ArgumentsCamelCase, Argv } from "yargs";
+import type {
+	Deployment,
+	PagesConfigCache,
+	YargsOptionsToInterface,
+} from "./types";
+import type { Argv } from "yargs";
 
-type ListArgs = {
-	"project-name"?: string;
-};
+type ListArgs = YargsOptionsToInterface<typeof ListOptions>;
 
-export function ListOptions(yargs: Argv): Argv<ListArgs> {
+export function ListOptions(yargs: Argv) {
 	return yargs
 		.options({
 			"project-name": {
@@ -30,9 +32,7 @@ export function ListOptions(yargs: Argv): Argv<ListArgs> {
 		.epilogue(pagesBetaWarning);
 }
 
-export async function ListHandler({
-	projectName,
-}: ArgumentsCamelCase<ListArgs>) {
+export async function ListHandler({ projectName }: ListArgs) {
 	const config = getConfigCache<PagesConfigCache>(PAGES_CONFIG_CACHE_FILENAME);
 	const accountId = await requireAuth(config);
 
@@ -102,5 +102,5 @@ export async function ListHandler({
 		patchConsole: false,
 	});
 	unmount();
-	await metrics.sendMetricsEvent("list pages projects deployments");
+	await metrics.sendMetricsEvent("list pages deployments");
 }

package/src/pages/dev.tsx

@@ -1,34 +1,29 @@
 import { execSync, spawn } from "node:child_process";
 import { existsSync } from "node:fs";
-import { tmpdir } from "node:os";
+import { homedir, tmpdir } from "node:os";
 import { join, resolve } from "node:path";
 import { watch } from "chokidar";
+import { build as workerJsBuild } from "esbuild";
 import { unstable_dev } from "../api";
 import { FatalError } from "../errors";
 import { logger } from "../logger";
 import * as metrics from "../metrics";
 import { buildFunctions } from "./build";
 import { SECONDS_TO_WAIT_FOR_PROXY } from "./constants";
+import { FunctionsNoRoutesError, getFunctionsNoRoutesWarning } from "./errors";
 import { CLEANUP, CLEANUP_CALLBACKS, pagesBetaWarning } from "./utils";
-import type { ArgumentsCamelCase, Argv } from "yargs";
-
-type PagesDevArgs = {
-	directory?: string;
-	command?: string;
-	local: boolean;
-	port: number;
-	proxy?: number;
-	"script-path": string;
-	binding?: (string | number)[];
-	kv?: (string | number)[];
-	do?: (string | number)[];
-	"live-reload": boolean;
-	"local-protocol"?: "https" | "http";
-	"experimental-enable-local-persistence": boolean;
-	"node-compat": boolean;
-};
+import type { AdditionalDevProps } from "../dev";
+import type { YargsOptionsToInterface } from "./types";
+import type { Plugin } from "esbuild";
+import type { Argv } from "yargs";
+
+const DURABLE_OBJECTS_BINDING_REGEXP = new RegExp(
+	/^(?<binding>[^=]+)=(?<className>[^@\s]+)(@(?<scriptName>.*)$)?$/
+);
+
+type PagesDevArgs = YargsOptionsToInterface<typeof Options>;
 
-export function Options(yargs: Argv): Argv<PagesDevArgs> {
+export function Options(yargs: Argv) {
 	return yargs
 		.positional("directory", {
 			type: "string",
@@ -46,11 +41,41 @@ export function Options(yargs: Argv): Argv<PagesDevArgs> {
 				default: true,
 				description: "Run on my machine",
 			},
+			"compatibility-date": {
+				describe: "Date to use for compatibility checks",
+				type: "string",
+			},
+			"compatibility-flags": {
+				describe: "Flags to use for compatibility checks",
+				alias: "compatibility-flag",
+				type: "string",
+				array: true,
+			},
+
+			// TODO
+			// For now, all Pages projects are set to 2021-11-02. We're adding compat date soon, and we can then adopt `wrangler dev`'s `default: true`.
+			// However, it looks like it isn't actually connected up properly in `wrangler dev` at the moment, hence commenting this out for now.
+
+			// latest: {
+			// 	describe: "Use the latest version of the worker runtime",
+			// 	type: "boolean",
+			// 	default: false,
+			// },
+
+			ip: {
+				type: "string",
+				default: "0.0.0.0",
+				description: "The IP address to listen on",
+			},
 			port: {
 				type: "number",
 				default: 8788,
 				description: "The port to listen on (serve from)",
 			},
+			"inspector-port": {
+				type: "number",
+				describe: "Port for devtools to connect to",
+			},
 			proxy: {
 				type: "number",
 				description: "The port to proxy (where the static assets are served)",
@@ -68,14 +93,18 @@ export function Options(yargs: Argv): Argv<PagesDevArgs> {
 			},
 			kv: {
 				type: "array",
-				description: "KV namespace to bind",
+				description: "KV namespace to bind (--kv KV_BINDING)",
 				alias: "k",
 			},
 			do: {
 				type: "array",
-				description: "Durable Object to bind (NAME=CLASS)",
+				description: "Durable Object to bind (--do NAME=CLASS)",
 				alias: "o",
 			},
+			r2: {
+				type: "array",
+				description: "R2 bucket to bind (--r2 R2_BINDING)",
+			},
 			"live-reload": {
 				type: "boolean",
 				default: false,
@@ -108,19 +137,24 @@ export function Options(yargs: Argv): Argv<PagesDevArgs> {
 export const Handler = async ({
 	local,
 	directory,
+	"compatibility-date": compatibilityDate = "2021-11-02",
+	"compatibility-flags": compatibilityFlags,
+	ip,
 	port,
+	"inspector-port": inspectorPort,
 	proxy: requestedProxyPort,
 	"script-path": singleWorkerScriptPath,
 	binding: bindings = [],
 	kv: kvs = [],
 	do: durableObjects = [],
+	r2: r2s = [],
 	"live-reload": liveReload,
 	"local-protocol": localProtocol,
 	"experimental-enable-local-persistence": experimentalEnableLocalPersistence,
 	"node-compat": nodeCompat,
 	config: config,
 	_: [_pages, _dev, ...remaining],
-}: ArgumentsCamelCase<PagesDevArgs>) => {
+}: PagesDevArgs) => {
 	// Beta message for `wrangler pages <commands>` usage
 	logger.log(pagesBetaWarning);
 
@@ -133,13 +167,18 @@ export const Handler = async ({
 	}
 
 	const functionsDirectory = "./functions";
-	const usingFunctions = existsSync(functionsDirectory);
+	let usingFunctions = existsSync(functionsDirectory);
 
 	const command = remaining;
 
 	let proxyPort: number | undefined;
 
-	if (directory === undefined) {
+	if (directory !== undefined && command.length > 0) {
+		throw new FatalError(
+			"Specify either a directory OR a proxy command, not both.",
+			1
+		);
+	} else if (directory === undefined) {
 		proxyPort = await spawnProxyProcess({
 			port: requestedProxyPort,
 			command,
@@ -154,8 +193,9 @@ export const Handler = async ({
 		(promiseResolve) => (scriptReadyResolve = promiseResolve)
 	);
 
-	let scriptPath: string;
+	let scriptPath = "";
 
+	// Try to use Functions
 	if (usingFunctions) {
 		const outfile = join(tmpdir(), `./functionsWorker-${Math.random()}.js`);
 		scriptPath = outfile;
@@ -167,36 +207,63 @@ export const Handler = async ({
 		}
 
 		logger.log(`Compiling worker to "${outfile}"...`);
-
+		const onEnd = () => scriptReadyResolve();
 		try {
 			await buildFunctions({
 				outfile,
 				functionsDirectory,
 				sourcemap: true,
 				watch: true,
-				onEnd: () => scriptReadyResolve(),
+				onEnd,
 				buildOutputDirectory: directory,
 				nodeCompat,
 			});
 			await metrics.sendMetricsEvent("build pages functions");
-		} catch {}
 
-		watch([functionsDirectory], {
-			persistent: true,
-			ignoreInitial: true,
-		}).on("all", async () => {
-			await buildFunctions({
-				outfile,
-				functionsDirectory,
-				sourcemap: true,
-				watch: true,
-				onEnd: () => scriptReadyResolve(),
-				buildOutputDirectory: directory,
-				nodeCompat,
+			// If Functions found routes, continue using Functions
+			watch([functionsDirectory], {
+				persistent: true,
+				ignoreInitial: true,
+			}).on("all", async () => {
+				try {
+					await buildFunctions({
+						outfile,
+						functionsDirectory,
+						sourcemap: true,
+						watch: true,
+						onEnd,
+						buildOutputDirectory: directory,
+						nodeCompat,
+					});
+					await metrics.sendMetricsEvent("build pages functions");
+				} catch (e) {
+					if (e instanceof FunctionsNoRoutesError) {
+						logger.warn(
+							getFunctionsNoRoutesWarning(functionsDirectory, "skipping")
+						);
+					} else {
+						throw e;
+					}
+				}
 			});
-			await metrics.sendMetricsEvent("build pages functions");
-		});
-	} else {
+		} catch (e) {
+			// If there are no Functions, then Pages will only serve assets.
+			if (e instanceof FunctionsNoRoutesError) {
+				logger.warn(
+					getFunctionsNoRoutesWarning(functionsDirectory, "skipping")
+				);
+				// Resolve anyway and run without Functions
+				onEnd();
+				// Turn off Functions
+				usingFunctions = false;
+			} else {
+				throw e;
+			}
+		}
+	}
+	// Depending on the result of building Functions, we may not actually be using
+	// Functions even if the directory exists.
+	if (!usingFunctions) {
 		// eslint-disable-next-line @typescript-eslint/no-non-null-assertion
 		scriptReadyResolve!();
 
@@ -208,20 +275,48 @@ export const Handler = async ({
 		if (!existsSync(scriptPath)) {
 			logger.log("No functions. Shimming...");
 			scriptPath = resolve(__dirname, "../templates/pages-shim.ts");
+		} else {
+			const runBuild = async () => {
+				try {
+					await workerJsBuild({
+						entryPoints: [scriptPath],
+						write: false,
+						plugins: [blockWorkerJsImports],
+					});
+				} catch {}
+			};
+			await runBuild();
+			watch([scriptPath], {
+				persistent: true,
+				ignoreInitial: true,
+			}).on("all", async () => {
+				await runBuild();
+			});
 		}
 	}
 
 	await scriptReadyPromise;
 
+	if (scriptPath === "") {
+		// Failed to get a script with or without Functions,
+		// something really bad must have happend.
+		throw new FatalError(
+			"Failed to start wrangler pages dev due to an unknown error",
+			1
+		);
+	}
+
 	const { stop, waitUntilExit } = await unstable_dev(
 		scriptPath,
 		{
+			ip,
 			port,
+			inspectorPort,
 			watch: true,
 			localProtocol,
 			liveReload,
-
-			compatibilityDate: "2021-11-02",
+			compatibilityDate,
+			compatibilityFlags,
 			nodeCompat,
 			vars: Object.fromEntries(
 				bindings
@@ -232,12 +327,29 @@ export const Handler = async ({
 				binding: val.toString(),
 				id: "",
 			})),
-			durableObjects: durableObjects.map((durableObject) => {
-				const [name, class_name] = durableObject.toString().split("=");
-				return {
-					name,
-					class_name,
-				};
+			durableObjects: durableObjects
+				.map((durableObject) => {
+					const { binding, className, scriptName } =
+						DURABLE_OBJECTS_BINDING_REGEXP.exec(durableObject.toString())
+							?.groups || {};
+
+					if (!binding || !className) {
+						logger.warn(
+							"Could not parse Durable Object binding:",
+							durableObject.toString()
+						);
+						return;
+					}
+
+					return {
+						name: binding,
+						class_name: className,
+						script_name: scriptName,
+					};
+				})
+				.filter(Boolean) as AdditionalDevProps["durableObjects"],
+			r2: r2s.map((binding) => {
+				return { binding: binding.toString(), bucket_name: "" };
 			}),
 
 			enablePagesAssetsServiceBinding: {
@@ -314,7 +426,8 @@ function getPort(pid: number) {
 	let command: string, regExp: RegExp;
 
 	if (isWindows()) {
-		command = "\\windows\\system32\\netstat.exe -nao";
+		const drive = homedir().split(":\\")[0];
+		command = drive + ":\\windows\\system32\\netstat.exe -nao";
 		regExp = new RegExp(`TCP\\s+.*:(\\d+)\\s+.*:\\d+\\s+LISTENING\\s+${pid}`);
 	} else {
 		command = "lsof -nPi";
@@ -407,3 +520,15 @@ async function spawnProxyProcess({
 
 	return port;
 }
+
+const blockWorkerJsImports: Plugin = {
+	name: "block-worker-js-imports",
+	setup(build) {
+		build.onResolve({ filter: /.*/g }, (_args) => {
+			logger.error(
+				`_worker.js is importing from another file. This will throw an error if deployed.\nYou should bundle your Worker or remove the import if it is unused.`
+			);
+			return null;
+		});
+	},
+};

package/src/pages/errors.ts

@@ -0,0 +1,22 @@
+/**
+ * Pages error when no routes are found in the functions directory
+ */
+export class FunctionsNoRoutesError extends Error {
+	constructor(message: string) {
+		super(message);
+	}
+}
+/**
+ * Exit code for `pages functions build` when no routes are found.
+ */
+export const EXIT_CODE_FUNCTIONS_NO_ROUTES_ERROR = 156;
+
+/** Warning message for when buildFunctions throws FunctionsNoRoutesError */
+export function getFunctionsNoRoutesWarning(
+	functionsDirectory: string,
+	suffix?: string
+) {
+	return `No routes found when building Functions directory: ${functionsDirectory}${
+		suffix ? " - " + suffix : ""
+	}`;
+}

package/src/pages/functions/buildPlugin.ts

@@ -29,6 +29,10 @@ export function buildPlugin({
 		bundle: true,
 		format: "esm",
 		target: "esnext",
+		loader: {
+			".html": "text",
+			".txt": "text",
+		},
 		outfile,
 		minify,
 		sourcemap,

package/src/pages/functions/buildWorker.ts

@@ -34,6 +34,10 @@ export function buildWorker({
 		bundle: true,
 		format: "esm",
 		target: "esnext",
+		loader: {
+			".html": "text",
+			".txt": "text",
+		},
 		outfile,
 		minify,
 		sourcemap,