wrangler 2.0.27 → 2.0.28

package/src/__tests__/worker-namespace.test.ts

@@ -4,7 +4,7 @@ import { mockConsoleMethods } from "./helpers/mock-console";
 import { runInTempDir } from "./helpers/run-in-tmp";
 import { runWrangler } from "./helpers/run-wrangler";
 
-describe("worker-namespace", () => {
+describe("dispatch-namespace", () => {
 	runInTempDir();
 	const std = mockConsoleMethods();
 	mockAccountId();
@@ -14,8 +14,8 @@ describe("worker-namespace", () => {
 		unsetAllMocks();
 	});
 
-	it("should should display a list of available subcommands, for worker-namespace with no subcommand", async () => {
-		await runWrangler("worker-namespace");
+	it("should should display a list of available subcommands, for dispatch-namespace with no subcommand", async () => {
+		await runWrangler("dispatch-namespace");
 
 		// wait a tick for the help menu to be printed
 		await new Promise((resolve) => setImmediate(resolve));
@@ -24,16 +24,16 @@ describe("worker-namespace", () => {
 		Object {
 		  "debug": "",
 		  "err": "",
-		  "out": "wrangler worker-namespace
+		  "out": "wrangler dispatch-namespace
 
-		📦 Interact with a worker namespace
+		📦 Interact with a dispatch namespace
 
 		Commands:
-		  wrangler worker-namespace list                          List all Worker namespaces
-		  wrangler worker-namespace get <name>                    Get information about a Worker namespace
-		  wrangler worker-namespace create <name>                 Create a Worker namespace
-		  wrangler worker-namespace delete <name>                 Delete a Worker namespace
-		  wrangler worker-namespace rename <old-name> <new-name>  Rename a Worker namespace
+		  wrangler dispatch-namespace list                          List all dispatch namespaces
+		  wrangler dispatch-namespace get <name>                    Get information about a dispatch namespace
+		  wrangler dispatch-namespace create <name>                 Create a dispatch namespace
+		  wrangler dispatch-namespace delete <name>                 Delete a dispatch namespace
+		  wrangler dispatch-namespace rename <old-name> <new-name>  Rename a dispatch namespace
 
 		Flags:
 		  -c, --config   Path to .toml configuration file  [string]
@@ -73,19 +73,19 @@ describe("worker-namespace", () => {
 
 		it("should display help for create", async () => {
 			await expect(
-				runWrangler("worker-namespace create")
+				runWrangler("dispatch-namespace create")
 			).rejects.toThrowErrorMatchingInlineSnapshot(
 				`"Not enough non-option arguments: got 0, need at least 1"`
 			);
 
 			expect(std.out).toMatchInlineSnapshot(`
 			"
-			wrangler worker-namespace create <name>
+			wrangler dispatch-namespace create <name>
 
-			Create a Worker namespace
+			Create a dispatch namespace
 
 			Positionals:
-			  name  Name of the Worker namespace  [string] [required]
+			  name  Name of the dispatch namespace  [string] [required]
 
 			Flags:
 			  -c, --config   Path to .toml configuration file  [string]
@@ -97,11 +97,11 @@ describe("worker-namespace", () => {
 		it("should attempt to create the given namespace", async () => {
 			const namespaceName = "my-namespace";
 			const requests = mockCreateRequest(namespaceName);
-			await runWrangler(`worker-namespace create ${namespaceName}`);
+			await runWrangler(`dispatch-namespace create ${namespaceName}`);
 			expect(requests.count).toEqual(1);
 
 			expect(std.out).toMatchInlineSnapshot(
-				`"Created Worker namespace \\"my-namespace\\" with ID \\"some-namespace-id\\""`
+				`"Created dispatch namespace \\"my-namespace\\" with ID \\"some-namespace-id\\""`
 			);
 		});
 	});
@@ -125,19 +125,19 @@ describe("worker-namespace", () => {
 
 		it("should display help for delete", async () => {
 			await expect(
-				runWrangler("worker-namespace create")
+				runWrangler("dispatch-namespace create")
 			).rejects.toThrowErrorMatchingInlineSnapshot(
 				`"Not enough non-option arguments: got 0, need at least 1"`
 			);
 
 			expect(std.out).toMatchInlineSnapshot(`
 			"
-			wrangler worker-namespace create <name>
+			wrangler dispatch-namespace create <name>
 
-			Create a Worker namespace
+			Create a dispatch namespace
 
 			Positionals:
-			  name  Name of the Worker namespace  [string] [required]
+			  name  Name of the dispatch namespace  [string] [required]
 
 			Flags:
 			  -c, --config   Path to .toml configuration file  [string]
@@ -149,11 +149,11 @@ describe("worker-namespace", () => {
 		it("should try to delete the given namespace", async () => {
 			const namespaceName = "my-namespace";
 			const requests = mockDeleteRequest(namespaceName);
-			await runWrangler(`worker-namespace delete ${namespaceName}`);
+			await runWrangler(`dispatch-namespace delete ${namespaceName}`);
 			expect(requests.count).toBe(1);
 
 			expect(std.out).toMatchInlineSnapshot(
-				`"Deleted Worker namespace \\"my-namespace\\""`
+				`"Deleted dispatch namespace \\"my-namespace\\""`
 			);
 		});
 	});
@@ -183,19 +183,19 @@ describe("worker-namespace", () => {
 
 		it("should display help for get", async () => {
 			await expect(
-				runWrangler("worker-namespace get")
+				runWrangler("dispatch-namespace get")
 			).rejects.toThrowErrorMatchingInlineSnapshot(
 				`"Not enough non-option arguments: got 0, need at least 1"`
 			);
 
 			expect(std.out).toMatchInlineSnapshot(`
 			        "
-			        wrangler worker-namespace get <name>
+			        wrangler dispatch-namespace get <name>
 
-			        Get information about a Worker namespace
+			        Get information about a dispatch namespace
 
 			        Positionals:
-			          name  Name of the Worker namespace  [string] [required]
+			          name  Name of the dispatch namespace  [string] [required]
 
 			        Flags:
 			          -c, --config   Path to .toml configuration file  [string]
@@ -207,7 +207,7 @@ describe("worker-namespace", () => {
 		it("should attempt to get info for the given namespace", async () => {
 			const namespaceName = "my-namespace";
 			const requests = mockInfoRequest(namespaceName);
-			await runWrangler(`worker-namespace get ${namespaceName}`);
+			await runWrangler(`dispatch-namespace get ${namespaceName}`);
 			expect(requests.count).toBe(1);
 
 			expect(std.out).toMatchInlineSnapshot(`
@@ -248,7 +248,7 @@ describe("worker-namespace", () => {
 
 		it("should list all namespaces", async () => {
 			const requests = mockListRequest();
-			await runWrangler("worker-namespace list");
+			await runWrangler("dispatch-namespace list");
 			expect(requests.count).toBe(1);
 			expect(std.out).toMatchInlineSnapshot(`
 			"[
@@ -291,20 +291,20 @@ describe("worker-namespace", () => {
 
 		it("should display help for rename", async () => {
 			await expect(
-				runWrangler("worker-namespace rename")
+				runWrangler("dispatch-namespace rename")
 			).rejects.toThrowErrorMatchingInlineSnapshot(
 				`"Not enough non-option arguments: got 0, need at least 2"`
 			);
 
 			expect(std.out).toMatchInlineSnapshot(`
 			"
-			wrangler worker-namespace rename <old-name> <new-name>
+			wrangler dispatch-namespace rename <old-name> <new-name>
 
-			Rename a Worker namespace
+			Rename a dispatch namespace
 
 			Positionals:
-			  old-name  Name of the Worker namespace  [string] [required]
-			  new-name  New name of the Worker namespace  [string] [required]
+			  old-name  Name of the dispatch namespace  [string] [required]
+			  new-name  New name of the dispatch namespace  [string] [required]
 
 			Flags:
 			  -c, --config   Path to .toml configuration file  [string]
@@ -317,10 +317,12 @@ describe("worker-namespace", () => {
 			const namespaceName = "my-namespace";
 			const newName = "new-namespace";
 			const requests = mockRenameRequest(namespaceName);
-			await runWrangler(`worker-namespace rename ${namespaceName} ${newName}`);
+			await runWrangler(
+				`dispatch-namespace rename ${namespaceName} ${newName}`
+			);
 			expect(requests.count).toBe(1);
 			expect(std.out).toMatchInlineSnapshot(
-				`"Renamed Worker namespace \\"my-namespace\\" to \\"new-namespace\\""`
+				`"Renamed dispatch namespace \\"my-namespace\\" to \\"new-namespace\\""`
 			);
 		});
 	});

package/src/bundle.ts

@@ -380,7 +380,7 @@ async function applyMultiWorkerDevFacade(
 	services: Config["services"],
 	workerDefinitions: WorkerRegistry
 ) {
-	const targetPath = path.join(tmpDirPath, "serve-static-assets.entry.js");
+	const targetPath = path.join(tmpDirPath, "multiworker-dev-facade.entry.js");
 	const serviceMap = Object.fromEntries(
 		(services || []).map((serviceBinding) => [
 			serviceBinding.binding,

package/src/cfetch/internal.ts

@@ -1,5 +1,6 @@
 import assert from "node:assert";
-import { fetch, Headers } from "undici";
+import Busboy from "busboy";
+import { fetch, File, FormData, Headers } from "undici";
 import { version as wranglerVersion } from "../../package.json";
 import { getEnvironmentVariableFactory } from "../environment-variables";
 import { logger } from "../logger";
@@ -226,12 +227,72 @@ export async function fetchDashboardScript(
 		?.startsWith("multipart");
 
 	if (usesModules) {
-		const file = await response.text();
+		// Response from edge contains generic "name = worker.js" for dashboard created scripts
+		const form = await formData(response);
+		const entries = Array.from(form.entries());
+		if (entries.length > 1)
+			throw new RangeError("Expected only one entry in multipart response");
+		const [_, file] = entries[0];
+
+		if (file instanceof File) {
+			return await file.text();
+		}
+
+		return file ?? "";
 
 		// Follow up on issue in Undici about multipart/form-data support & replace the workaround: https://github.com/nodejs/undici/issues/974
 		// This should be using a builtin formData() parser pattern.
-		return file.split("\n").slice(4, -4).join("\n");
 	} else {
 		return response.text();
 	}
 }
+
+async function formData({ headers, body }: Response): Promise<FormData> {
+	// undici doesn't include a multipart/form-data parser yet, so we parse
+	// form data with busboy instead
+	const contentType = headers.get("Content-Type") ?? "";
+	if (!/multipart\/form-data/.test(contentType))
+		throw Error("Need Content-Type for multipart/form-data");
+
+	const responseFormData = new FormData();
+
+	let busboy: Busboy.Busboy;
+
+	const parsedHeaders = Object.fromEntries(
+		Array.from(headers).map(([header, value]) => [header.toLowerCase(), value])
+	);
+	try {
+		busboy = Busboy({ headers: parsedHeaders });
+	} catch (err) {
+		// Error due to headers:
+		throw Object.assign(new TypeError(), { cause: err });
+	}
+
+	busboy.on("field", (name, value) => {
+		responseFormData.append(name, value);
+	});
+	busboy.on("file", (name, value, info) => {
+		const { filename, encoding, mimeType } = info;
+		const base64 = encoding.toLowerCase() === "base64";
+		const chunks: Buffer[] = [];
+		value.on("data", (chunk) => {
+			if (base64) chunk = Buffer.from(chunk.toString(), "base64");
+			chunks.push(chunk);
+		});
+		value.on("end", () => {
+			const file = new File(chunks, filename, { type: mimeType });
+			responseFormData.append(name, file);
+		});
+	});
+
+	const busboyResolve = new Promise((resolve, reject) => {
+		busboy.on("finish", resolve);
+		busboy.on("error", (err) => reject(err));
+	});
+
+	if (body !== null) for await (const chunk of body) busboy.write(chunk);
+	busboy.end();
+	await busboyResolve;
+
+	return responseFormData;
+}

package/src/config/environment.ts

@@ -210,7 +210,7 @@ interface EnvironmentInheritable {
 	 * @default `[]`
 	 * @nonInheritable
 	 */
-	worker_namespaces: {
+	dispatch_namespaces: {
 		/** The binding name used to refer to the bound service. */
 		binding: string;
 		/** The namespace to bind to. */

package/src/config/index.ts

@@ -91,7 +91,7 @@ export function printBindings(bindings: CfWorkerInit["bindings"]) {
 		unsafe,
 		vars,
 		wasm_modules,
-		worker_namespaces,
+		dispatch_namespaces,
 	} = bindings;
 
 	if (data_blobs !== undefined && Object.keys(data_blobs).length > 0) {
@@ -219,10 +219,10 @@ export function printBindings(bindings: CfWorkerInit["bindings"]) {
 		});
 	}
 
-	if (worker_namespaces !== undefined && worker_namespaces.length > 0) {
+	if (dispatch_namespaces !== undefined && dispatch_namespaces.length > 0) {
 		output.push({
-			type: "Worker Namespaces",
-			entries: worker_namespaces.map(({ binding, namespace }) => {
+			type: "dispatch namespaces",
+			entries: dispatch_namespaces.map(({ binding, namespace }) => {
 				return {
 					key: binding,
 					value: namespace,

package/src/config/validation.ts

@@ -899,7 +899,7 @@ function normalizeAndValidateEnvironment(
 
 	experimental(diagnostics, rawEnv, "unsafe");
 	experimental(diagnostics, rawEnv, "services");
-	experimental(diagnostics, rawEnv, "worker_namespaces");
+	experimental(diagnostics, rawEnv, "dispatch_namespaces");
 
 	const route = normalizeAndValidateRoute(diagnostics, topLevelEnv, rawEnv);
 
@@ -1085,13 +1085,13 @@ function normalizeAndValidateEnvironment(
 			validateBindingArray(envName, validateServiceBinding),
 			[]
 		),
-		worker_namespaces: notInheritable(
+		dispatch_namespaces: notInheritable(
 			diagnostics,
 			topLevelEnv,
 			rawConfig,
 			rawEnv,
 			envName,
-			"worker_namespaces",
+			"dispatch_namespaces",
 			validateBindingArray(envName, validateWorkerNamespaceBinding),
 			[]
 		),

package/src/create-worker-upload-form.ts

@@ -23,6 +23,31 @@ export function toMimeType(type: CfModuleType): string {
 	}
 }
 
+type WorkerMetadataBinding =
+	// If you add any new binding types here, also add it to safeBindings
+	// under validateUnsafeBinding in config/validation.ts
+	| { type: "plain_text"; name: string; text: string }
+	| { type: "json"; name: string; json: unknown }
+	| { type: "wasm_module"; name: string; part: string }
+	| { type: "text_blob"; name: string; part: string }
+	| { type: "data_blob"; name: string; part: string }
+	| { type: "kv_namespace"; name: string; namespace_id: string }
+	| {
+			type: "durable_object_namespace";
+			name: string;
+			class_name: string;
+			script_name?: string;
+			environment?: string;
+	  }
+	| { type: "r2_bucket"; name: string; bucket_name: string }
+	| { type: "service"; name: string; service: string; environment?: string }
+	| { type: "namespace"; name: string; namespace: string }
+	| {
+			type: "logfwdr";
+			name: string;
+			destination: string;
+	  };
+
 export interface WorkerMetadata {
 	/** The name of the entry point module. Only exists when the worker is in the ES module format */
 	main_module?: string;
@@ -33,31 +58,8 @@ export interface WorkerMetadata {
 	usage_model?: "bundled" | "unbound";
 	migrations?: CfDurableObjectMigrations;
 	capnp_schema?: string;
-	// If you add any new binding types here, also add it to safeBindings
-	// under validateUnsafeBinding in config/validation.ts
-	bindings: (
-		| { type: "plain_text"; name: string; text: string }
-		| { type: "json"; name: string; json: unknown }
-		| { type: "wasm_module"; name: string; part: string }
-		| { type: "text_blob"; name: string; part: string }
-		| { type: "data_blob"; name: string; part: string }
-		| { type: "kv_namespace"; name: string; namespace_id: string }
-		| {
-				type: "durable_object_namespace";
-				name: string;
-				class_name: string;
-				script_name?: string;
-				environment?: string;
-		  }
-		| { type: "r2_bucket"; name: string; bucket_name: string }
-		| { type: "service"; name: string; service: string; environment?: string }
-		| { type: "namespace"; name: string; namespace: string }
-		| {
-				type: "logfwdr";
-				name: string;
-				destination: string;
-		  }
-	)[];
+	bindings: WorkerMetadataBinding[];
+	keep_bindings: WorkerMetadataBinding["type"][];
 }
 
 /**
@@ -123,7 +125,7 @@ export function createWorkerUploadForm(worker: CfWorkerInit): FormData {
 		});
 	});
 
-	bindings.worker_namespaces?.forEach(({ binding, namespace }) => {
+	bindings.dispatch_namespaces?.forEach(({ binding, namespace }) => {
 		metadataBindings.push({
 			name: binding,
 			type: "namespace",
@@ -255,6 +257,7 @@ export function createWorkerUploadForm(worker: CfWorkerInit): FormData {
 		...(usage_model && { usage_model }),
 		...(migrations && { migrations }),
 		capnp_schema: bindings.logfwdr?.schema,
+		keep_bindings: ["plain_text", "json"],
 	};
 
 	formData.set("metadata", JSON.stringify(metadata));

package/src/dev/remote.tsx

@@ -182,7 +182,7 @@ export function useWorker(props: {
 	} = props;
 	const [session, setSession] = useState<CfPreviewSession | undefined>();
 	const [token, setToken] = useState<CfPreviewToken | undefined>();
-
+	const [restartCounter, setRestartCounter] = useState<number>(0);
 	// This is the most reliable way to detect whether
 	// something's "happened" in our system; We make a ref and
 	// mark it once we log our initial message. Refs are vars!
@@ -237,6 +237,7 @@ export function useWorker(props: {
 		props.routes,
 		props.zone,
 		props.sendMetrics,
+		restartCounter,
 	]);
 
 	// This effect uses the session to upload the worker and create a preview
@@ -314,6 +315,7 @@ export function useWorker(props: {
 				compatibility_date: compatibilityDate,
 				compatibility_flags: compatibilityFlags,
 				usage_model: usageModel,
+				keep_bindings: true,
 			};
 
 			const workerAccount: CfAccount = {
@@ -379,6 +381,13 @@ export function useWorker(props: {
 					logger.error(
 						`${errorMessage}\n${solutionMessage}\n${onboardingLink}`
 					);
+				} else if (err.code === 10049) {
+					logger.log("Preview token expired, fetching a new one");
+					// code 10049 happens when the preview token expires
+					// since we want a new preview token when this happens,
+					// lets increment the counter, and trigger a rerun of
+					// the useEffect above
+					setRestartCounter((prevCount) => prevCount + 1);
 				} else {
 					logger.error("Error on remote worker:", err);
 				}

package/src/dev.tsx

@@ -63,6 +63,8 @@ interface DevArgs {
 	tsconfig?: string;
 	local?: boolean;
 	minify?: boolean;
+	var?: string[];
+	define?: string[];
 	"node-compat"?: boolean;
 	"experimental-enable-local-persistence"?: boolean;
 	"live-reload"?: boolean;
@@ -129,7 +131,6 @@ export function devOptions(yargs: Argv): Argv<DevArgs> {
 			.option("ip", {
 				describe: "IP address to listen on",
 				type: "string",
-				default: "0.0.0.0",
 			})
 			.option("port", {
 				describe: "Port to listen on",
@@ -196,6 +197,19 @@ export function devOptions(yargs: Argv): Argv<DevArgs> {
 				describe: "Protocol to forward requests to host on, defaults to https.",
 				choices: ["http", "https"] as const,
 			})
+			.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("jsx-factory", {
 				describe: "The function that is called for each JSX element",
 				type: "string",
@@ -427,22 +441,36 @@ export async function startDev(args: StartDevOptions) {
 		const getLocalPort = memoizeGetPort(DEFAULT_LOCAL_PORT);
 		const getInspectorPort = memoizeGetPort(DEFAULT_INSPECTOR_PORT);
 
+		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;
+			}, {}) || {};
+
 		// eslint-disable-next-line no-inner-declarations
 		async function getDevReactElement(configParam: Config) {
 			// now log all available bindings into the terminal
 			const bindings = await getBindings(configParam, {
 				kv: args.kv,
-				vars: args.vars,
+				vars: { ...args.vars, ...cliVars },
 				durableObjects: args.durableObjects,
 				r2: args.r2,
 			});
 
-			// mask anything that was overridden in .dev.vars
+			// mask anything that was overridden in .dev.vars or cli args
 			// so that we don't log potential secrets into the terminal
 			const maskedVars = { ...bindings.vars };
 			for (const key of Object.keys(maskedVars)) {
 				if (maskedVars[key] !== configParam.vars[key]) {
-					// This means it was overridden in .dev.vars
+					// This means it was overridden in .dev.vars or cli args
 					// so let's mask it
 					maskedVars[key] = "(hidden)";
 				}
@@ -477,7 +505,7 @@ export async function startDev(args: StartDevOptions) {
 					minify={args.minify ?? config.minify}
 					nodeCompat={nodeCompat}
 					build={config.build || {}}
-					define={config.define}
+					define={{ ...config.define, ...cliDefines }}
 					initialMode={args.local ? "local" : "remote"}
 					jsxFactory={args["jsx-factory"] || config.jsx_factory}
 					jsxFragment={args["jsx-fragment"] || config.jsx_fragment}
@@ -615,7 +643,7 @@ async function getBindings(
 			) || []),
 			...(args.r2 || []),
 		],
-		worker_namespaces: configParam.worker_namespaces,
+		dispatch_namespaces: configParam.dispatch_namespaces,
 		services: configParam.services,
 		unsafe: configParam.unsafe?.bindings,
 		logfwdr: configParam.logfwdr,