wrangler 2.0.24 → 2.0.27

package/src/init.ts

@@ -5,12 +5,16 @@ import TOML from "@iarna/toml";
 import { findUp } from "find-up";
 import { version as wranglerVersion } from "../package.json";
 
+import { fetchDashboardScript } from "./cfetch/internal";
+import { readConfig } from "./config";
 import { confirm, select } from "./dialogs";
 import { initializeGit, isGitInstalled, isInsideGitRepo } from "./git-client";
 import { logger } from "./logger";
 import { getPackageManager } from "./package-manager";
 import { parsePackageJSON, parseTOML, readFileSync } from "./parse";
+import { requireAuth } from "./user";
 import { CommandLineArgsError, printWranglerBanner } from "./index";
+import type { ConfigPath } from "./index";
 
 import type { Argv, ArgumentsCamelCase } from "yargs";
 
@@ -36,6 +40,12 @@ export async function initOptions(yargs: Argv) {
 			describe: 'Answer "yes" to any prompts for new projects',
 			type: "boolean",
 			alias: "y",
+		})
+		.option("from-dash", {
+			describe: "Download script from the dashboard for local development",
+			type: "string",
+			requiresArg: true,
+			hidden: true,
 		});
 }
 
@@ -61,7 +71,11 @@ export async function initHandler(args: ArgumentsCamelCase<InitArgs>) {
 	const devDepsToInstall: string[] = [];
 	const instructions: string[] = [];
 	let shouldRunPackageManagerInstall = false;
-	const creationDirectory = path.resolve(process.cwd(), args.name ?? "");
+	const fromDashScriptName = args["from-dash"] as string;
+	const creationDirectory = path.resolve(
+		process.cwd(),
+		(args.name ? args.name : fromDashScriptName) ?? ""
+	);
 
 	if (args.site) {
 		const gitDirectory =
@@ -90,6 +104,7 @@ export async function initHandler(args: ArgumentsCamelCase<InitArgs>) {
 
 	// TODO: ask which directory to make the worker in (defaults to args.name)
 	// TODO: if args.name isn't provided, ask what to name the worker
+	// Note: `--from-dash` will be a fallback creationDir/Worker name if none is provided.
 
 	const wranglerTomlDestination = path.join(
 		creationDirectory,
@@ -98,12 +113,15 @@ export async function initHandler(args: ArgumentsCamelCase<InitArgs>) {
 	let justCreatedWranglerToml = false;
 
 	if (fs.existsSync(wranglerTomlDestination)) {
+		let shouldContinue = false;
 		logger.warn(
 			`${path.relative(process.cwd(), wranglerTomlDestination)} already exists!`
 		);
-		const shouldContinue = await confirm(
-			"Do you want to continue initializing this project?"
-		);
+		if (!fromDashScriptName) {
+			shouldContinue = await confirm(
+				"Do you want to continue initializing this project?"
+			);
+		}
 		if (!shouldContinue) {
 			return;
 		}
@@ -438,27 +456,23 @@ export async function initHandler(args: ArgumentsCamelCase<InitArgs>) {
 				process.cwd(),
 				path.join(creationDirectory, "./src/index.ts")
 			);
-
-			const newWorkerType = yesFlag
-				? "fetch"
-				: await getNewWorkerType(newWorkerFilename);
-
-			if (newWorkerType !== "none") {
-				const template = getNewWorkerTemplate("ts", newWorkerType);
-
+			if (fromDashScriptName) {
+				const config = readConfig(args.config as ConfigPath, args);
+				const accountId = await requireAuth(config);
 				await mkdir(path.join(creationDirectory, "./src"), {
 					recursive: true,
 				});
-				await writeFile(
-					path.join(creationDirectory, "./src/index.ts"),
-					readFileSync(path.join(__dirname, `../templates/${template}`))
+
+				const dashScript = await fetchDashboardScript(
+					`/accounts/${accountId}/workers/scripts/${fromDashScriptName}`,
+					{
+						method: "GET",
+					}
 				);
 
-				logger.log(
-					`✨ Created ${path.relative(
-						process.cwd(),
-						path.join(creationDirectory, "./src/index.ts")
-					)}`
+				await writeFile(
+					path.join(creationDirectory, "./src/index.ts"),
+					dashScript
 				);
 
 				await writePackageJsonScriptsAndUpdateWranglerToml(
@@ -466,8 +480,39 @@ export async function initHandler(args: ArgumentsCamelCase<InitArgs>) {
 					justCreatedWranglerToml,
 					pathToPackageJson,
 					"src/index.ts",
-					getNewWorkerToml(newWorkerType)
+					{}
 				);
+			} else {
+				const newWorkerType = yesFlag
+					? "fetch"
+					: await getNewWorkerType(newWorkerFilename);
+
+				if (newWorkerType !== "none") {
+					const template = getNewWorkerTemplate("ts", newWorkerType);
+
+					await mkdir(path.join(creationDirectory, "./src"), {
+						recursive: true,
+					});
+					await writeFile(
+						path.join(creationDirectory, "./src/index.ts"),
+						readFileSync(path.join(__dirname, `../templates/${template}`))
+					);
+
+					logger.log(
+						`✨ Created ${path.relative(
+							process.cwd(),
+							path.join(creationDirectory, "./src/index.ts")
+						)}`
+					);
+
+					await writePackageJsonScriptsAndUpdateWranglerToml(
+						shouldWritePackageJsonScripts,
+						justCreatedWranglerToml,
+						pathToPackageJson,
+						"src/index.ts",
+						getNewWorkerToml(newWorkerType)
+					);
+				}
 			}
 		}
 	} else {
@@ -477,35 +522,63 @@ export async function initHandler(args: ArgumentsCamelCase<InitArgs>) {
 				path.join(creationDirectory, "./src/index.js")
 			);
 
-			const newWorkerType = yesFlag
-				? "fetch"
-				: await getNewWorkerType(newWorkerFilename);
-
-			if (newWorkerType !== "none") {
-				const template = getNewWorkerTemplate("js", newWorkerType);
-
+			if (fromDashScriptName) {
+				const config = readConfig(args.config as ConfigPath, args);
+				const accountId = await requireAuth(config);
 				await mkdir(path.join(creationDirectory, "./src"), {
 					recursive: true,
 				});
-				await writeFile(
-					path.join(creationDirectory, "./src/index.js"),
-					readFileSync(path.join(__dirname, `../templates/${template}`))
+
+				const dashScript = await fetchDashboardScript(
+					`/accounts/${accountId}/workers/scripts/${fromDashScriptName}`,
+					{
+						method: "GET",
+					}
 				);
 
-				logger.log(
-					`✨ Created ${path.relative(
-						process.cwd(),
-						path.join(creationDirectory, "./src/index.js")
-					)}`
+				await writeFile(
+					path.join(creationDirectory, "./src/index.js"),
+					dashScript
 				);
 
 				await writePackageJsonScriptsAndUpdateWranglerToml(
 					shouldWritePackageJsonScripts,
 					justCreatedWranglerToml,
 					pathToPackageJson,
-					"src/index.js",
-					getNewWorkerToml(newWorkerType)
+					"src/index.ts",
+					{}
 				);
+			} else {
+				const newWorkerType = yesFlag
+					? "fetch"
+					: await getNewWorkerType(newWorkerFilename);
+
+				if (newWorkerType !== "none") {
+					const template = getNewWorkerTemplate("js", newWorkerType);
+
+					await mkdir(path.join(creationDirectory, "./src"), {
+						recursive: true,
+					});
+					await writeFile(
+						path.join(creationDirectory, "./src/index.js"),
+						readFileSync(path.join(__dirname, `../templates/${template}`))
+					);
+
+					logger.log(
+						`✨ Created ${path.relative(
+							process.cwd(),
+							path.join(creationDirectory, "./src/index.js")
+						)}`
+					);
+
+					await writePackageJsonScriptsAndUpdateWranglerToml(
+						shouldWritePackageJsonScripts,
+						justCreatedWranglerToml,
+						pathToPackageJson,
+						"src/index.js",
+						getNewWorkerToml(newWorkerType)
+					);
+				}
 			}
 		}
 	}

package/src/inspect.ts

@@ -320,10 +320,7 @@ export default function useInspector(props: InspectorProps) {
 														const convertedFnName =
 															pos.name || functionName || "";
 														exceptionLines.push(
-															`    at ${convertedFnName} (${pos.source?.replace(
-																`${mapContent.sourceRoot}/`,
-																""
-															)}:${pos.line}:${pos.column})`
+															`    at ${convertedFnName} (${pos.source}:${pos.line}:${pos.column})`
 														);
 													}
 												}

package/src/metrics/metrics-config.ts

@@ -6,10 +6,10 @@ import { fetchResult } from "../cfetch";
 import { getConfigCache, saveToConfigCache } from "../config-cache";
 import { confirm } from "../dialogs";
 import { getEnvironmentVariableFactory } from "../environment-variables";
+import { CI } from "../is-ci";
 import isInteractive from "../is-interactive";
 import { logger } from "../logger";
 import { getAPIToken } from "../user";
-import { CI } from "./is-ci";
 
 /**
  * The date that the metrics being gathered was last updated in a way that would require

package/src/miniflare-cli/assets.ts

@@ -335,6 +335,11 @@ async function generateAssetsFetch(
 
 	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;
@@ -377,7 +382,7 @@ async function generateAssetsFetch(
 		}
 
 		const notFound = () => {
-			let cwd = url.pathname;
+			let cwd = assetName;
 			while (cwd) {
 				cwd = cwd.slice(0, cwd.lastIndexOf("/"));
 
@@ -407,38 +412,36 @@ async function generateAssetsFetch(
 
 		let asset;
 
-		if (url.pathname.endsWith("/")) {
-			if ((asset = getAsset(`${url.pathname}/index.html`))) {
+		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(`${url.pathname.replace(/\/$/, ".html")}`))
-			) {
+			} else if ((asset = getAsset(`${assetName.replace(/\/$/, ".html")}`))) {
 				deconstructedResponse.status = 301;
 				deconstructedResponse.headers.set(
 					"Location",
-					`${url.pathname.slice(0, -1)}${url.search}`
+					`${assetName.slice(0, -1)}${url.search}`
 				);
 				return deconstructedResponse;
 			}
 		}
 
-		if (url.pathname.endsWith("/index")) {
+		if (assetName.endsWith("/index")) {
 			deconstructedResponse.status = 301;
 			deconstructedResponse.headers.set(
 				"Location",
-				`${url.pathname.slice(0, -"index".length)}${url.search}`
+				`${assetName.slice(0, -"index".length)}${url.search}`
 			);
 			return deconstructedResponse;
 		}
 
-		if ((asset = getAsset(url.pathname))) {
-			if (url.pathname.endsWith(".html")) {
-				const extensionlessPath = url.pathname.slice(0, -".html".length);
+		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(
@@ -462,12 +465,20 @@ async function generateAssetsFetch(
 				);
 				return deconstructedResponse;
 			}
-		} else if (hasFileExtension(url.pathname)) {
+		} 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(`${url.pathname}.html`))) {
+		if ((asset = getAsset(`${assetName}.html`))) {
 			deconstructedResponse.body = serveAsset(asset);
 			deconstructedResponse.headers.set(
 				"Content-Type",
@@ -476,11 +487,11 @@ async function generateAssetsFetch(
 			return deconstructedResponse;
 		}
 
-		if ((asset = getAsset(`${url.pathname}/index.html`))) {
+		if ((asset = getAsset(`${assetName}/index.html`))) {
 			deconstructedResponse.status = 301;
 			deconstructedResponse.headers.set(
 				"Location",
-				`${url.pathname}/${url.search}`
+				`${assetName}/${url.search}`
 			);
 			return deconstructedResponse;
 		} else {

package/src/miniflare-cli/index.ts

@@ -1,10 +1,23 @@
-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;
@@ -44,7 +57,48 @@ async function main() {
 		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]) {
@@ -73,12 +127,80 @@ async function main() {
 		// Start Miniflare development server
 		await mf.startServer();
 		await mf.startScheduler();
-		process.send && process.send("ready");
+
+		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();
 	}
 }
 

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,