wrangler 2.0.25 → 2.0.28

package/src/generate.ts

@@ -88,7 +88,7 @@ export async function generateHandler({
 		`Creating a worker in ${path.basename(creationDirectory)} from ${template}`
 	);
 
-	await createCloudflare(creationDirectory, template, {
+	await createCloudflare(path.basename(creationDirectory), template, {
 		init: true, // initialize a git repository
 		debug: logger.loggerLevel === "debug",
 		force: false, // do not overwrite an existing directory

package/src/index.tsx

@@ -15,6 +15,7 @@ import { findWranglerToml, readConfig } from "./config";
 import { createWorkerUploadForm } from "./create-worker-upload-form";
 import { devHandler, devOptions } from "./dev";
 import { confirm, prompt } from "./dialogs";
+import { workerNamespaceCommands } from "./dispatch-namespace";
 import { getEntry } from "./entry";
 import { DeprecationError } from "./errors";
 import { generateHandler, generateOptions } from "./generate";
@@ -73,7 +74,7 @@ import {
 } from "./user";
 import { whoami } from "./whoami";
 
-import { workerNamespaceCommands } from "./worker-namespace";
+import { getWorkerForZone } from "./zones";
 import type { Config } from "./config";
 import type { KeyValue } from "./kv";
 import type { TailCLIFilters } from "./tail";
@@ -469,6 +470,19 @@ function createCLIParser(argv: string[]) {
 						requiresArg: true,
 						array: true,
 					})
+					.option("var", {
+						describe:
+							"A key-value pair to be injected into the script as a variable",
+						type: "string",
+						requiresArg: true,
+						array: true,
+					})
+					.option("define", {
+						describe: "A key-value pair to be substituted in the script",
+						type: "string",
+						requiresArg: true,
+						array: true,
+					})
 					.option("triggers", {
 						describe: "cron schedules to attach",
 						alias: ["schedule", "schedules"],
@@ -562,6 +576,20 @@ function createCLIParser(argv: string[]) {
 				);
 			}
 
+			const cliVars =
+				args.var?.reduce<Record<string, string>>((collectVars, v) => {
+					const [key, ...value] = v.split(":");
+					collectVars[key] = value.join("");
+					return collectVars;
+				}, {}) || {};
+
+			const cliDefines =
+				args.define?.reduce<Record<string, string>>((collectDefines, d) => {
+					const [key, ...value] = d.split(":");
+					collectDefines[key] = value.join("");
+					return collectDefines;
+				}, {}) || {};
+
 			const accountId = args.dryRun ? undefined : await requireAuth(config);
 
 			const assetPaths =
@@ -585,6 +613,8 @@ function createCLIParser(argv: string[]) {
 					? new Date().toISOString().substring(0, 10)
 					: args["compatibility-date"],
 				compatibilityFlags: args["compatibility-flags"],
+				vars: cliVars,
+				defines: cliDefines,
 				triggers: args.triggers,
 				jsxFactory: args["jsx-factory"],
 				jsxFragment: args["jsx-fragment"],
@@ -604,12 +634,12 @@ function createCLIParser(argv: string[]) {
 
 	// tail
 	wrangler.command(
-		"tail [name]",
+		"tail [worker]",
 		"🦚 Starts a log tailing session for a published Worker.",
 		(yargs) => {
 			return yargs
-				.positional("name", {
-					describe: "Name of the worker",
+				.positional("worker", {
+					describe: "Name or route of the worker to tail",
 					type: "string",
 				})
 				.option("format", {
@@ -677,7 +707,22 @@ function createCLIParser(argv: string[]) {
 				sendMetrics: config.send_metrics,
 			});
 
-			const scriptName = getLegacyScriptName(args, config);
+			let scriptName;
+
+			// Worker names can't contain "." (and most routes should), so use that as a discriminator
+			if (args.worker?.includes(".")) {
+				scriptName = await getWorkerForZone(args.worker);
+				if (args.format === "pretty") {
+					logger.log(
+						`Connecting to worker ${scriptName} at route ${args.worker}`
+					);
+				}
+			} else {
+				scriptName = getLegacyScriptName(
+					{ name: args.worker, ...args },
+					config
+				);
+			}
 
 			if (!scriptName) {
 				throw new Error(
@@ -966,7 +1011,7 @@ function createCLIParser(argv: string[]) {
 											wasm_modules: {},
 											text_blobs: {},
 											data_blobs: {},
-											worker_namespaces: [],
+											dispatch_namespaces: [],
 											logfwdr: { schema: undefined, bindings: [] },
 											unsafe: [],
 										},
@@ -975,6 +1020,7 @@ function createCLIParser(argv: string[]) {
 										compatibility_date: undefined,
 										compatibility_flags: undefined,
 										usage_model: undefined,
+										keep_bindings: false, // this doesn't matter since it's a new script anyway
 									}),
 								}
 							);
@@ -2022,8 +2068,8 @@ function createCLIParser(argv: string[]) {
 	});
 
 	wrangler.command(
-		"worker-namespace",
-		"📦 Interact with a worker namespace",
+		"dispatch-namespace",
+		"📦 Interact with a dispatch namespace",
 		(workerNamespaceYargs) => {
 			return workerNamespaceCommands(workerNamespaceYargs, subHelp);
 		}

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/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/metrics/send-event.ts

@@ -40,11 +40,11 @@ export type EventNames =
 	| "unrevoke pubsub broker credentials"
 	| "list pubsub broker revoked credentials"
 	| "list pubsub broker public-keys"
-	| "list worker namespaces"
-	| "view worker namespace"
-	| "create worker namespace"
-	| "delete worker namespace"
-	| "rename worker namespace"
+	| "list dispatch namespaces"
+	| "view dispatch namespace"
+	| "create dispatch namespace"
+	| "delete dispatch namespace"
+	| "rename dispatch namespace"
 	| "create pages project"
 	| "list pages projects"
 	| "create pages deployment"

package/src/miniflare-cli/assets.ts

@@ -466,6 +466,14 @@ async function generateAssetsFetch(
 				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;
 		}

package/src/miniflare-cli/index.ts

@@ -76,10 +76,13 @@ async function main() {
 				namespace.get = (id) => {
 					const stub = new DurableObjectStub(factory, id);
 					stub.fetch = (...reqArgs) => {
-						const url = `http://${host}${port ? `:${port}` : ""}`;
+						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,
-							new MiniflareRequest(...reqArgs)
+							url.toString(),
+							requestFromArgs
 						);
 						request.headers.set("x-miniflare-durable-object-name", name);
 						request.headers.set("x-miniflare-durable-object-id", id.toString());

package/src/pages/build.tsx

@@ -1,10 +1,16 @@
 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";
@@ -104,23 +110,37 @@ export const Handler = async ({
 	}
 
 	buildOutputDirectory ??= dirname(outfile);
-
-	await buildFunctions({
-		outfile,
-		outputConfigPath,
-		functionsDirectory: directory,
-		minify,
-		sourcemap,
-		fallbackService,
-		watch,
-		plugin,
-		buildOutputDirectory,
-		nodeCompat,
-		routesOutputPath,
-	});
+	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,
@@ -164,7 +184,13 @@ export async function buildFunctions({
 		baseURL,
 	});
 
-	if (config.routes && routesOutputPath) {
+	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));
 	}

package/src/pages/constants.ts

@@ -8,4 +8,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;