wrangler 2.0.23 → 2.0.26

package/src/dev.tsx

@@ -127,9 +127,9 @@ export function devOptions(yargs: Argv): Argv<DevArgs> {
 				default: true,
 			})
 			.option("ip", {
-				describe: "IP address to listen on, defaults to `localhost`",
+				describe: "IP address to listen on",
 				type: "string",
-				requiresArg: true,
+				default: "0.0.0.0",
 			})
 			.option("port", {
 				describe: "Port to listen on",
@@ -260,9 +260,7 @@ export async function devHandler(args: ArgumentsCamelCase<DevArgs>) {
 	}
 }
 
-type StartDevOptions = ArgumentsCamelCase<DevArgs> & {
-	// These options can be passed in directly when called with the `wrangler.dev()` API.
-	// They aren't exposed as CLI arguments.
+export type AdditionalDevProps = {
 	vars?: {
 		[key: string]: unknown;
 	};
@@ -277,9 +275,19 @@ type StartDevOptions = ArgumentsCamelCase<DevArgs> & {
 		script_name?: string | undefined;
 		environment?: string | undefined;
 	}[];
-	forceLocal?: boolean;
-	enablePagesAssetsServiceBinding?: EnablePagesAssetsServiceBindingOptions;
+	r2?: {
+		binding: string;
+		bucket_name: string;
+		preview_bucket_name?: string;
+	}[];
 };
+type StartDevOptions = ArgumentsCamelCase<DevArgs> &
+	// These options can be passed in directly when called with the `wrangler.dev()` API.
+	// They aren't exposed as CLI arguments.
+	AdditionalDevProps & {
+		forceLocal?: boolean;
+		enablePagesAssetsServiceBinding?: EnablePagesAssetsServiceBindingOptions;
+	};
 
 export async function startDev(args: StartDevOptions) {
 	let watcher: ReturnType<typeof watch> | undefined;
@@ -296,11 +304,6 @@ export async function startDev(args: StartDevOptions) {
 			((args.script &&
 				findWranglerToml(path.dirname(args.script))) as ConfigPath);
 		let config = readConfig(configPath, args);
-		await metrics.sendMetricsEvent(
-			"run dev",
-			{ local: args.local },
-			{ sendMetrics: config.send_metrics, offline: args.local }
-		);
 
 		if (config.configPath) {
 			watcher = watch(config.configPath, {
@@ -322,6 +325,15 @@ export async function startDev(args: StartDevOptions) {
 			"dev"
 		);
 
+		await metrics.sendMetricsEvent(
+			"run dev",
+			{
+				local: args.local,
+				usesTypeScript: /\.tsx?$/.test(entry.file),
+			},
+			{ sendMetrics: config.send_metrics, offline: args.local }
+		);
+
 		if (config.services && config.services.length > 0) {
 			logger.warn(
 				`This worker is bound to live services: ${config.services
@@ -412,77 +424,19 @@ export async function startDev(args: StartDevOptions) {
 			);
 		}
 
-		// eslint-disable-next-line no-inner-declarations
-		async function getBindings(
-			configParam: Config
-		): Promise<CfWorkerInit["bindings"]> {
-			return {
-				kv_namespaces: [
-					...(configParam.kv_namespaces || []).map(
-						({ binding, preview_id, id: _id }) => {
-							// In `dev`, we make folks use a separate kv namespace called
-							// `preview_id` instead of `id` so that they don't
-							// break production data. So here we check that a `preview_id`
-							// has actually been configured.
-							// This whole block of code will be obsoleted in the future
-							// when we have copy-on-write for previews on edge workers.
-							if (!preview_id) {
-								// TODO: This error has to be a _lot_ better, ideally just asking
-								// to create a preview namespace for the user automatically
-								throw new Error(
-									`In development, you should use a separate kv namespace than the one you'd use in production. Please create a new kv namespace with "wrangler kv:namespace create <name> --preview" and add its id as preview_id to the kv_namespace "${binding}" in your wrangler.toml`
-								); // Ugh, I really don't like this message very much
-							}
-							return {
-								binding,
-								id: preview_id,
-							};
-						}
-					),
-					...(args.kv || []),
-				],
-				// Use a copy of combinedVars since we're modifying it later
-				vars: {
-					...getVarsForDev(configParam),
-					...args.vars,
-				},
-				wasm_modules: configParam.wasm_modules,
-				text_blobs: configParam.text_blobs,
-				data_blobs: configParam.data_blobs,
-				durable_objects: {
-					bindings: [
-						...(configParam.durable_objects || { bindings: [] }).bindings,
-						...(args.durableObjects || []),
-					],
-				},
-				r2_buckets: configParam.r2_buckets?.map(
-					({ binding, preview_bucket_name, bucket_name: _bucket_name }) => {
-						// same idea as kv namespace preview id,
-						// same copy-on-write TODO
-						if (!preview_bucket_name) {
-							throw new Error(
-								`In development, you should use a separate r2 bucket than the one you'd use in production. Please create a new r2 bucket with "wrangler r2 bucket create <name>" and add its name as preview_bucket_name to the r2_buckets "${binding}" in your wrangler.toml`
-							);
-						}
-						return {
-							binding,
-							bucket_name: preview_bucket_name,
-						};
-					}
-				),
-				worker_namespaces: configParam.worker_namespaces,
-				services: configParam.services,
-				unsafe: configParam.unsafe?.bindings,
-			};
-		}
-
 		const getLocalPort = memoizeGetPort(DEFAULT_LOCAL_PORT);
 		const getInspectorPort = memoizeGetPort(DEFAULT_INSPECTOR_PORT);
 
 		// 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);
+			const bindings = await getBindings(configParam, {
+				kv: args.kv,
+				vars: args.vars,
+				durableObjects: args.durableObjects,
+				r2: args.r2,
+			});
+
 			// mask anything that was overridden in .dev.vars
 			// so that we don't log potential secrets into the terminal
 			const maskedVars = { ...bindings.vars };
@@ -537,20 +491,21 @@ export async function startDev(args: StartDevOptions) {
 					liveReload={args.liveReload || false}
 					accountId={config.account_id || getAccountFromCache()?.id}
 					assetPaths={assetPaths}
+					assetsConfig={config.assets}
 					port={args.port || config.dev.port || (await getLocalPort())}
 					ip={args.ip || config.dev.ip}
 					inspectorPort={
-						args["inspector-port"] ||
+						args.inspectorPort ||
 						config.dev.inspector_port ||
 						(await getInspectorPort())
 					}
 					isWorkersSite={Boolean(args.site || config.site)}
 					compatibilityDate={getDevCompatibilityDate(
 						config,
-						args["compatibility-date"]
+						args.compatibilityDate
 					)}
 					compatibilityFlags={
-						args["compatibility-flags"] || config.compatibility_flags
+						args.compatibilityFlags || config.compatibility_flags
 					}
 					usageModel={config.usage_model}
 					bindings={bindings}
@@ -562,6 +517,8 @@ export async function startDev(args: StartDevOptions) {
 					showInteractiveDevSession={args.showInteractiveDevSession}
 					forceLocal={args.forceLocal}
 					enablePagesAssetsServiceBinding={args.enablePagesAssetsServiceBinding}
+					firstPartyWorker={config.first_party_worker}
+					sendMetrics={config.send_metrics}
 				/>
 			);
 		}
@@ -596,3 +553,73 @@ function memoizeGetPort(defaultPort: number) {
 		return portValue || (portValue = await getPort({ port: defaultPort }));
 	};
 }
+
+async function getBindings(
+	configParam: Config,
+	args: AdditionalDevProps
+): Promise<CfWorkerInit["bindings"]> {
+	const bindings = {
+		kv_namespaces: [
+			...(configParam.kv_namespaces || []).map(
+				({ binding, preview_id, id: _id }) => {
+					// In `dev`, we make folks use a separate kv namespace called
+					// `preview_id` instead of `id` so that they don't
+					// break production data. So here we check that a `preview_id`
+					// has actually been configured.
+					// This whole block of code will be obsoleted in the future
+					// when we have copy-on-write for previews on edge workers.
+					if (!preview_id) {
+						// TODO: This error has to be a _lot_ better, ideally just asking
+						// to create a preview namespace for the user automatically
+						throw new Error(
+							`In development, you should use a separate kv namespace than the one you'd use in production. Please create a new kv namespace with "wrangler kv:namespace create <name> --preview" and add its id as preview_id to the kv_namespace "${binding}" in your wrangler.toml`
+						); // Ugh, I really don't like this message very much
+					}
+					return {
+						binding,
+						id: preview_id,
+					};
+				}
+			),
+			...(args.kv || []),
+		],
+		// Use a copy of combinedVars since we're modifying it later
+		vars: {
+			...getVarsForDev(configParam),
+			...args.vars,
+		},
+		wasm_modules: configParam.wasm_modules,
+		text_blobs: configParam.text_blobs,
+		data_blobs: configParam.data_blobs,
+		durable_objects: {
+			bindings: [
+				...(configParam.durable_objects || { bindings: [] }).bindings,
+				...(args.durableObjects || []),
+			],
+		},
+		r2_buckets: [
+			...(configParam.r2_buckets?.map(
+				({ binding, preview_bucket_name, bucket_name: _bucket_name }) => {
+					// same idea as kv namespace preview id,
+					// same copy-on-write TODO
+					if (!preview_bucket_name) {
+						throw new Error(
+							`In development, you should use a separate r2 bucket than the one you'd use in production. Please create a new r2 bucket with "wrangler r2 bucket create <name>" and add its name as preview_bucket_name to the r2_buckets "${binding}" in your wrangler.toml`
+						);
+					}
+					return {
+						binding,
+						bucket_name: preview_bucket_name,
+					};
+				}
+			) || []),
+			...(args.r2 || []),
+		],
+		worker_namespaces: configParam.worker_namespaces,
+		services: configParam.services,
+		unsafe: configParam.unsafe?.bindings,
+		logfwdr: configParam.logfwdr,
+	};
+
+	return bindings;
+}

package/src/generate.ts

@@ -1,33 +1,131 @@
-import { DeprecationError } from "./errors";
+import fs from "node:fs";
+import path from "node:path";
+import { setup as createCloudflare } from "create-cloudflare";
+import { initHandler } from "./init";
+import { logger } from "./logger";
+import { CommandLineArgsError, printWranglerBanner } from ".";
 import type { Argv, ArgumentsCamelCase } from "yargs";
 
+// https://github.com/cloudflare/wrangler/blob/master/src/cli/mod.rs#L106-L123
 interface GenerateArgs {
-	name: string;
-	template: string;
+	name?: string;
+	template?: string;
+	type?: string;
+	site?: boolean;
 }
 
 export function generateOptions(yargs: Argv) {
 	return yargs
 		.positional("name", {
 			describe: "Name of the Workers project",
-			default: "worker",
+			type: "string",
 		})
 		.positional("template", {
+			type: "string",
 			describe: "The URL of a GitHub template",
-			default: "https://github.com/cloudflare/worker-template",
+		})
+		.option("type", {
+			alias: "t",
+			type: "string",
+			hidden: true,
+			deprecated: true,
+		})
+		.option("site", {
+			alias: "s",
+			type: "boolean",
+			hidden: true,
+			deprecated: true,
 		});
 }
 
-export function generateHandler(
-	generateArgs: ArgumentsCamelCase<GenerateArgs>
-) {
-	// "👯 [DEPRECATED]. Scaffold a Cloudflare Workers project from a public GitHub repository.",
-	throw new DeprecationError(
-		"`wrangler generate` has been deprecated.\n" +
-			"Try running `wrangler init` to generate a basic Worker, or cloning the template repository instead:\n\n" +
+export async function generateHandler({
+	// somehow, `init` marks name as required but then also runs fine
+	// with the name omitted, and then substitutes it at runtime with ""
+	name = "",
+	template,
+	type,
+	site,
+	...args
+}: ArgumentsCamelCase<GenerateArgs>) {
+	// delegate to `wrangler init` if no template is specified
+	if (template === undefined) {
+		return initHandler({ name, ...args });
+	}
+
+	// print down here cuz `init` prints it own its own
+	printWranglerBanner();
+
+	if (type) {
+		let message = "The --type option is no longer supported.";
+		if (args.type === "webpack") {
+			message +=
+				"\nIf you wish to use webpack then you will need to create a custom build.";
+			// TODO: Add a link to docs
+		}
+		throw new CommandLineArgsError(message);
+	}
+
+	const creationDirectory = generateWorkerDirectoryName(name);
+
+	if (site) {
+		const gitDirectory =
+			creationDirectory !== process.cwd()
+				? path.basename(creationDirectory)
+				: "my-site";
+		const message =
+			"The --site option is no longer supported.\n" +
+			"If you wish to create a brand new Worker Sites project then clone the `worker-sites-template` starter repository:\n\n" +
 			"```\n" +
-			`git clone ${generateArgs.template}\n` +
+			`git clone --depth=1 --branch=wrangler2 https://github.com/cloudflare/worker-sites-template ${gitDirectory}\n` +
+			`cd ${gitDirectory}\n` +
 			"```\n\n" +
-			"Please refer to https://developers.cloudflare.com/workers/wrangler/deprecations/#generate for more information."
+			"Find out more about how to create and maintain Sites projects at https://developers.cloudflare.com/workers/platform/sites.\n" +
+			"Have you considered using Cloudflare Pages instead? See https://pages.cloudflare.com/.";
+		throw new CommandLineArgsError(message);
+	}
+
+	logger.log(
+		`Creating a worker in ${path.basename(creationDirectory)} from ${template}`
 	);
+
+	await createCloudflare(creationDirectory, template, {
+		init: true, // initialize a git repository
+		debug: logger.loggerLevel === "debug",
+		force: false, // do not overwrite an existing directory
+	});
+}
+
+/**
+ * Creates a path based on the current working directory and a worker name.
+ * Automatically increments a counter when searching for an available directory.
+ *
+ * Running `wrangler generate worker https://some-git-repo` in a directory
+ * with the structure:
+ * ```
+ * - workers
+ * |
+ * | - worker
+ * | | - wrangler.toml
+ * | | ...
+ * |
+ * | - worker-1
+ * | | - wrangler.toml
+ * | | ...
+ * ```
+ *
+ * will result in a new worker called `worker-2` being generated.
+ *
+ * @param workerName the name of the generated worker
+ * @returns an absolute path to the directory to generate the worker into
+ */
+function generateWorkerDirectoryName(workerName: string): string {
+	let workerDirectoryPath = path.resolve(process.cwd(), workerName);
+	let i = 1;
+
+	while (fs.existsSync(workerDirectoryPath)) {
+		workerDirectoryPath = path.resolve(process.cwd(), `${workerName}-${i}`);
+		i++;
+	}
+
+	return workerDirectoryPath;
 }

package/src/index.tsx

@@ -1,4 +1,6 @@
+import * as fs from "node:fs";
 import path from "node:path";
+import * as stream from "node:stream";
 import { StringDecoder } from "node:string_decoder";
 import { setTimeout } from "node:timers/promises";
 import TOML from "@iarna/toml";
@@ -45,7 +47,15 @@ import {
 import { previewHandler, previewOptions } from "./preview";
 import publish from "./publish";
 import { pubSubCommands } from "./pubsub/pubsub-commands";
-import { createR2Bucket, deleteR2Bucket, listR2Buckets } from "./r2";
+import {
+	bucketAndKeyFromObjectPath,
+	createR2Bucket,
+	deleteR2Bucket,
+	deleteR2Object,
+	getR2Object,
+	listR2Buckets,
+	putR2Object,
+} from "./r2";
 import { getAssetPaths, getSiteAssetPaths } from "./sites";
 import {
 	createTail,
@@ -67,6 +77,7 @@ import { workerNamespaceCommands } from "./worker-namespace";
 import type { Config } from "./config";
 import type { KeyValue } from "./kv";
 import type { TailCLIFilters } from "./tail";
+import type { Readable } from "node:stream";
 import type { RawData } from "ws";
 import type { CommandModule } from "yargs";
 import type Yargs from "yargs";
@@ -513,10 +524,16 @@ function createCLIParser(argv: string[]) {
 				(args.config as ConfigPath) ||
 				(args.script && findWranglerToml(path.dirname(args.script)));
 			const config = readConfig(configPath, args);
-			await metrics.sendMetricsEvent("deploy worker script", {
-				sendMetrics: config.send_metrics,
-			});
 			const entry = await getEntry(args, config, "publish");
+			await metrics.sendMetricsEvent(
+				"deploy worker script",
+				{
+					usesTypeScript: /\.tsx?$/.test(entry.file),
+				},
+				{
+					sendMetrics: config.send_metrics,
+				}
+			);
 
 			if (args.public) {
 				throw new Error("The --public field has been renamed to --assets");
@@ -950,6 +967,7 @@ function createCLIParser(argv: string[]) {
 											text_blobs: {},
 											data_blobs: {},
 											worker_namespaces: [],
+											logfwdr: { schema: undefined, bindings: [] },
 											unsafe: [],
 										},
 										modules: [],
@@ -1714,6 +1732,7 @@ function createCLIParser(argv: string[]) {
 								);
 							}
 						}
+
 						if (errors.length > 0) {
 							throw new Error(
 								`Unexpected JSON input from "${filename}".\n` +
@@ -1746,6 +1765,195 @@ function createCLIParser(argv: string[]) {
 	wrangler.command("r2", "📦 Interact with an R2 store", (r2Yargs) => {
 		return r2Yargs
 			.command(subHelp)
+			.command("object", "Manage R2 objects", (r2ObjectYargs) => {
+				return r2ObjectYargs
+					.command(
+						"get <objectPath>",
+						"Fetch an object from an R2 bucket",
+						(Objectyargs) => {
+							return Objectyargs.positional("objectPath", {
+								describe:
+									"The source object path in the form of {bucket}/{key}",
+								type: "string",
+							})
+								.option("file", {
+									describe: "The destination file to create",
+									alias: "f",
+									conflicts: "pipe",
+									requiresArg: true,
+									type: "string",
+								})
+								.option("pipe", {
+									describe:
+										"Enables the file to be piped to a destination, rather than specified with the --file option",
+									alias: "p",
+									conflicts: "file",
+									type: "boolean",
+								});
+						},
+						async (objectGetYargs) => {
+							const config = readConfig(
+								objectGetYargs.config as ConfigPath,
+								objectGetYargs
+							);
+							const accountId = await requireAuth(config);
+							const { objectPath, pipe } = objectGetYargs;
+							const { bucket, key } = bucketAndKeyFromObjectPath(objectPath);
+
+							let file = objectGetYargs.file;
+							if (!file && !pipe) {
+								file = key;
+							}
+							if (!pipe) {
+								await printWranglerBanner();
+								logger.log(`Downloading "${key}" from "${bucket}".`);
+							}
+							const input = await getR2Object(accountId, bucket, key);
+							const output = file ? fs.createWriteStream(file) : process.stdout;
+							await new Promise<void>((resolve, reject) => {
+								stream.pipeline(input, output, (err: unknown) => {
+									err ? reject(err) : resolve();
+								});
+							});
+							if (!pipe) logger.log("Download complete.");
+						}
+					)
+					.command(
+						"put <objectPath>",
+						"Create an object in an R2 bucket",
+						(Objectyargs) => {
+							return Objectyargs.positional("objectPath", {
+								describe:
+									"The destination object path in the form of {bucket}/{key}",
+								type: "string",
+							})
+								.option("file", {
+									describe: "The path of the file to upload",
+									alias: "f",
+									conflicts: "pipe",
+									requiresArg: true,
+									type: "string",
+								})
+								.option("pipe", {
+									describe:
+										"Enables the file to be piped in, rather than specified with the --file option",
+									alias: "p",
+									conflicts: "file",
+									type: "boolean",
+								})
+								.option("content-type", {
+									describe:
+										"A standard MIME type describing the format of the object data",
+									alias: "ct",
+									requiresArg: true,
+									type: "string",
+								})
+								.option("content-disposition", {
+									describe:
+										"Specifies presentational information for the object",
+									alias: "cd",
+									requiresArg: true,
+									type: "string",
+								})
+								.option("content-encoding", {
+									describe:
+										"Specifies what content encodings have been applied to the object and thus what decoding mechanisms must be applied to obtain the media-type referenced by the Content-Type header field",
+									alias: "ce",
+									requiresArg: true,
+									type: "string",
+								})
+								.option("content-language", {
+									describe: "The language the content is in",
+									alias: "cl",
+									requiresArg: true,
+									type: "string",
+								})
+								.option("cache-control", {
+									describe:
+										"Specifies caching behavior along the request/reply chain",
+									alias: "cc",
+									requiresArg: true,
+									type: "string",
+								})
+								.option("expires", {
+									describe:
+										"The date and time at which the object is no longer cacheable",
+									alias: "e",
+									requiresArg: true,
+									type: "string",
+								});
+						},
+						async (objectPutYargs) => {
+							await printWranglerBanner();
+
+							const config = readConfig(
+								objectPutYargs.config as ConfigPath,
+								objectPutYargs
+							);
+							const accountId = await requireAuth(config);
+							const { objectPath, file, pipe, ...options } = objectPutYargs;
+							const { bucket, key } = bucketAndKeyFromObjectPath(objectPath);
+							if (!file && !pipe) {
+								throw new CommandLineArgsError(
+									"Either the --file or --pipe options are required."
+								);
+							}
+							let object: Readable | Buffer;
+							let objectSize: number;
+							if (file) {
+								object = fs.createReadStream(file);
+								const stats = fs.statSync(file);
+								objectSize = stats.size;
+							} else {
+								object = await new Promise<Buffer>((resolve, reject) => {
+									const stdin = process.stdin;
+									const chunks = Array<Buffer>();
+									stdin.on("data", (chunk) => chunks.push(chunk));
+									stdin.on("end", () => resolve(Buffer.concat(chunks)));
+									stdin.on("error", (err) =>
+										reject(
+											new CommandLineArgsError(
+												`Could not pipe. Reason: "${err.message}"`
+											)
+										)
+									);
+								});
+								objectSize = object.byteLength;
+							}
+
+							logger.log(`Creating object "${key}" in bucket "${bucket}".`);
+							await putR2Object(accountId, bucket, key, object, {
+								...options,
+								"content-length": `${objectSize}`,
+							});
+							logger.log("Upload complete.");
+						}
+					)
+					.command(
+						"delete <objectPath>",
+						"Delete an object in an R2 bucket",
+						(objectDeleteYargs) => {
+							return objectDeleteYargs.positional("objectPath", {
+								describe:
+									"The destination object path in the form of {bucket}/{key}",
+								type: "string",
+							});
+						},
+						async (args) => {
+							const { objectPath } = args;
+							await printWranglerBanner();
+
+							const config = readConfig(args.config as ConfigPath, args);
+							const accountId = await requireAuth(config);
+							const { bucket, key } = bucketAndKeyFromObjectPath(objectPath);
+							logger.log(`Deleting object "${key}" from bucket "${bucket}".`);
+
+							await deleteR2Object(accountId, bucket, key);
+							logger.log("Delete complete.");
+						}
+					);
+			})
+
 			.command("bucket", "Manage R2 buckets", (r2BucketYargs) => {
 				r2BucketYargs.command(
 					"create <name>",