wrangler 2.6.1 → 2.7.0

package/src/dev/use-esbuild.ts

@@ -152,7 +152,7 @@ export function useEsbuild({
 				});
 
 				stopWatching = () => {
-					watcher.close();
+					void watcher.close();
 				};
 			}
 			setBundle({

package/src/dev.tsx

@@ -30,7 +30,7 @@ import {
 } from "./index";
 import type { Config, Environment } from "./config";
 import type { Route } from "./config/environment";
-import type { EnablePagesAssetsServiceBindingOptions } from "./miniflare-cli";
+import type { EnablePagesAssetsServiceBindingOptions } from "./miniflare-cli/types";
 import type { CfWorkerInit } from "./worker";
 import type { CommonYargsOptions } from "./yargs-types";
 import type { Argv, ArgumentsCamelCase } from "yargs";
@@ -328,7 +328,7 @@ export function devOptions(yargs: Argv<CommonYargsOptions>): Argv<DevArgs> {
 }
 
 export async function devHandler(args: ArgumentsCamelCase<DevArgs>) {
-	if (!args.local) {
+	if (!(args.local || args.experimentalLocal)) {
 		const isLoggedIn = await loginOrRefreshIfRequired();
 		if (!isLoggedIn) {
 			throw new Error(
@@ -376,6 +376,7 @@ type StartDevOptions = ArgumentsCamelCase<DevArgs> &
 	// They aren't exposed as CLI arguments.
 	AdditionalDevProps & {
 		forceLocal?: boolean;
+		disableDevRegistry?: boolean;
 		enablePagesAssetsServiceBinding?: EnablePagesAssetsServiceBindingOptions;
 	};
 
@@ -442,7 +443,7 @@ export async function startDev(args: StartDevOptions) {
 
 		// eslint-disable-next-line no-inner-declarations
 		async function getDevReactElement(configParam: Config) {
-			const { assetPaths, bindings } = await getBindingsAndAssetPaths(
+			const { assetPaths, bindings } = getBindingsAndAssetPaths(
 				args,
 				configParam
 			);
@@ -512,11 +513,28 @@ export async function startDev(args: StartDevOptions) {
 			);
 		}
 		const devReactElement = render(await getDevReactElement(config));
+
+		// In the bootstrapper script `bin/wrangler.js`, we open an IPC channel, so
+		// IPC messages from this process are propagated through the bootstrapper.
+		// Normally, Node's SIGINT handler would close this for us, but interactive
+		// mode enables raw mode on stdin which disables the built-in handler. The
+		// following line disconnects from the IPC channel when we press `x` or
+		// CTRL-C in interactive mode, ensuring no open handles, and allowing for a
+		// clean exit. Note, if we called `stop()` using the dev API, we don't want
+		// to disconnect here, as the user may still need IPC. We also don't want
+		// to disconnect if this file was imported in Jest (not the case with E2E
+		// tests), as that would stop communication with the test runner.
+		let apiStopped = false;
+		void devReactElement.waitUntilExit().then(() => {
+			if (!apiStopped && typeof jest === "undefined") process.disconnect?.();
+		});
+
 		rerender = devReactElement.rerender;
 		return {
 			devReactElement,
 			watcher,
 			stop: async () => {
+				apiStopped = true;
 				devReactElement.unmount();
 				await watcher?.close();
 			},
@@ -559,7 +577,7 @@ export async function startApiDev(args: StartDevOptions) {
 
 	// eslint-disable-next-line no-inner-declarations
 	async function getDevServer(configParam: Config) {
-		const { assetPaths, bindings } = await getBindingsAndAssetPaths(
+		const { assetPaths, bindings } = getBindingsAndAssetPaths(
 			args,
 			configParam
 		);
@@ -627,6 +645,7 @@ export async function startApiDev(args: StartDevOptions) {
 			testScheduled: args.testScheduled,
 			experimentalLocal: args.experimentalLocal,
 			experimentalLocalRemoteKv: args.experimentalLocalRemoteKv,
+			disableDevRegistry: args.disableDevRegistry ?? false,
 		});
 	}
 
@@ -798,14 +817,11 @@ async function validateDevServerSettings(
 	};
 }
 
-async function getBindingsAndAssetPaths(
-	args: StartDevOptions,
-	configParam: Config
-) {
+function getBindingsAndAssetPaths(args: StartDevOptions, configParam: Config) {
 	const cliVars = collectKeyValues(args.var);
 
 	// now log all available bindings into the terminal
-	const bindings = await getBindings(configParam, args.env, {
+	const bindings = getBindings(configParam, args.env, args.local ?? false, {
 		kv: args.kv,
 		vars: { ...args.vars, ...cliVars },
 		durableObjects: args.durableObjects,
@@ -832,11 +848,12 @@ async function getBindingsAndAssetPaths(
 	return { assetPaths, bindings };
 }
 
-async function getBindings(
+function getBindings(
 	configParam: Config,
 	env: string | undefined,
+	local: boolean,
 	args: AdditionalDevProps
-): Promise<CfWorkerInit["bindings"]> {
+): CfWorkerInit["bindings"] {
 	const bindings = {
 		kv_namespaces: [
 			...(configParam.kv_namespaces || []).map(
@@ -906,6 +923,13 @@ async function getBindings(
 		logfwdr: configParam.logfwdr,
 		d1_databases: identifyD1BindingsAsBeta([
 			...(configParam.d1_databases ?? []).map((d1Db) => {
+				//in local dev, bindings don't matter
+				if (local) {
+					return {
+						...d1Db,
+						database_id: "local",
+					};
+				}
 				if (!d1Db.preview_database_id) {
 					throw new Error(
 						`In development, you should use a separate D1 database than the one you'd use in production. Please create a new D1 database with "wrangler d1 create <name>" and add its id as preview_database_id to the d1_database "${d1Db.binding}" in your wrangler.toml`

package/src/dialogs.ts

@@ -0,0 +1,136 @@
+import chalk from "chalk";
+import prompts from "prompts";
+import { CI } from "./is-ci";
+import isInteractive from "./is-interactive";
+import { logger } from "./logger";
+
+// TODO: Use this function across the codebase.
+function isNonInteractiveOrCI(): boolean {
+	return !isInteractive() || CI.isCI();
+}
+
+export class NoDefaultValueProvided extends Error {
+	constructor() {
+		// This is user-facing, so make the message something understandable
+		// It _should_ always be caught and replaced with a more descriptive error
+		// but this is fine as a fallback.
+		super("This command cannot be run in a non-interactive context");
+		Object.setPrototypeOf(this, new.target.prototype);
+	}
+}
+
+interface ConfirmOptions {
+	defaultValue?: boolean;
+}
+
+export async function confirm(
+	text: string,
+	{ defaultValue = true }: ConfirmOptions = {}
+): Promise<boolean> {
+	if (isNonInteractiveOrCI()) {
+		logger.log(`? ${text}`);
+		logger.log(
+			`🤖 ${chalk.dim(
+				"Using default value in non-interactive context:"
+			)} ${chalk.white.bold(defaultValue ? "yes" : "no")}`
+		);
+		return defaultValue;
+	}
+	const { value } = await prompts({
+		type: "confirm",
+		name: "value",
+		message: text,
+		initial: defaultValue,
+		onState: (state) => {
+			if (state.aborted) {
+				process.nextTick(() => {
+					process.exit(1);
+				});
+			}
+		},
+	});
+	return value;
+}
+
+interface PromptOptions {
+	defaultValue?: string;
+	isSecret?: boolean;
+}
+
+export async function prompt(
+	text: string,
+	options: PromptOptions = {}
+): Promise<string> {
+	if (isNonInteractiveOrCI()) {
+		if (options?.defaultValue === undefined) {
+			throw new NoDefaultValueProvided();
+		}
+		logger.log(`? ${text}`);
+		logger.log(
+			`🤖 ${chalk.dim(
+				"Using default value in non-interactive context:"
+			)} ${chalk.white.bold(options.defaultValue)}`
+		);
+		return options.defaultValue;
+	}
+	const { value } = await prompts({
+		type: "text",
+		name: "value",
+		message: text,
+		initial: options?.defaultValue,
+		style: options?.isSecret ? "password" : "default",
+		onState: (state) => {
+			if (state.aborted) {
+				process.nextTick(() => {
+					process.exit(1);
+				});
+			}
+		},
+	});
+	return value;
+}
+
+interface SelectOptions<Values> {
+	choices: SelectOption<Values>[];
+	defaultOption?: number;
+}
+
+interface SelectOption<Values> {
+	title: string;
+	description?: string;
+	value: Values;
+}
+
+export async function select<Values extends string>(
+	text: string,
+	options: SelectOptions<Values>
+): Promise<Values> {
+	if (isNonInteractiveOrCI()) {
+		if (options?.defaultOption === undefined) {
+			throw new NoDefaultValueProvided();
+		}
+		logger.log(`? ${text}`);
+		logger.log(
+			`🤖 ${chalk.dim(
+				"Using default value in non-interactive context:"
+			)} ${chalk.white.bold(options.choices[options.defaultOption].title)}`
+		);
+		return options.choices[options.defaultOption].value;
+	}
+
+	const { value } = await prompts({
+		type: "select",
+		name: "value",
+		message: text,
+		choices: options.choices,
+		initial: options.defaultOption,
+		onState: (state) => {
+			if (state.aborted) {
+				process.nextTick(() => {
+					process.exit(1);
+				});
+			}
+		},
+	});
+	return value;
+}

package/src/dispatch-namespace.ts

@@ -90,7 +90,7 @@ async function renameWorkerNamespace(
 	oldName: string,
 	newName: string
 ) {
-	printWranglerBanner();
+	void printWranglerBanner();
 
 	await fetchResult(
 		`/accounts/${accountId}/workers/dispatch/namespaces/${oldName}`,

package/src/docs/index.ts

@@ -0,0 +1,97 @@
+import { printWranglerBanner } from "..";
+import { readConfig } from "../config";
+import { logger } from "../logger";
+import * as metrics from "../metrics";
+import openInBrowser from "../open-in-browser";
+
+import type {
+	CommonYargsOptions,
+	YargsOptionsToInterface,
+} from "../yargs-types";
+import type { ArgumentsCamelCase, Argv } from "yargs";
+
+const argToUrlHash = {
+	docs: "docs",
+	init: "init",
+	generate: "generate",
+	dev: "dev",
+	publish: "publish",
+	delete: "delete",
+	"kv:namespace": "kvnamespace",
+	"kv:key": "kvkey",
+	"kv:bulk": "kvbulk",
+	"r2 bucket": "r2-bucket",
+	"r2 object": "r2-object",
+	secret: "secret",
+	"secret:bulk": "secretbulk",
+	tail: "tail",
+	pages: "pages",
+	login: "login",
+	logout: "logout",
+	whoami: "whoami",
+	types: "types",
+	deployments: "deployments",
+};
+
+export function docsOptions(yargs: Argv<CommonYargsOptions>) {
+	return yargs.positional("command", {
+		describe: "Enter the wrangler command you want to know more about",
+		type: "string",
+		// requiresArg: true,
+		choices: [
+			"docs",
+			"init",
+			"generate",
+			"dev",
+			"publish",
+			"delete",
+			"tail",
+			"secret",
+			"secret:bulk",
+			"kv:namespace",
+			"kv:key",
+			"kv:bulk",
+			"pages",
+			// "queues", //TODO: Undocumented
+			"r2 object",
+			"r2 bucket",
+			// "dispatch-namespace", // TODO: Undocumented - Workers for Platforms
+			// "d1", //TODO: Undocumented
+			// "pubsub", //TODO: Undocumented
+			"login",
+			"logout",
+			"whoami",
+			"types",
+			"deployments",
+			"api",
+		],
+	});
+}
+
+type DocsArgs = YargsOptionsToInterface<typeof docsOptions>;
+
+function isValidParam(k: string): k is keyof typeof argToUrlHash {
+	return k in argToUrlHash;
+}
+
+export async function docsHandler(args: ArgumentsCamelCase<DocsArgs>) {
+	let urlToOpen =
+		"https://developers.cloudflare.com/workers/wrangler/commands/";
+
+	if (args.command === "api") {
+		//if api, take them to the API docs
+		urlToOpen = "https://developers.cloudflare.com/workers/wrangler/api/";
+	} else if (args.command && isValidParam(args.command)) {
+		//otherwise, they get the wrangler commands page
+		urlToOpen += `#${argToUrlHash[args.command]}`;
+	}
+
+	await printWranglerBanner();
+
+	logger.log(`Opening a link in your default browser: ${urlToOpen}`);
+	await openInBrowser(urlToOpen);
+	const config = readConfig(undefined, {});
+	await metrics.sendMetricsEvent("view docs", {
+		sendMetrics: config.send_metrics,
+	});
+}

package/src/environment-variables/factory.ts

@@ -0,0 +1,88 @@
+import { logger } from "../logger";
+
+type VariableNames =
+	| "CLOUDFLARE_ACCOUNT_ID"
+	| "CLOUDFLARE_API_TOKEN"
+	| "CLOUDFLARE_API_KEY"
+	| "CLOUDFLARE_EMAIL"
+	| "WRANGLER_SEND_METRICS"
+	| "CLOUDFLARE_API_BASE_URL"
+	| "WRANGLER_LOG"
+	| "WRANGLER_API_ENVIRONMENT"
+	| "WRANGLER_CLIENT_ID"
+	| "WRANGLER_AUTH_DOMAIN"
+	| "WRANGLER_AUTH_URL"
+	| "WRANGLER_TOKEN_URL"
+	| "WRANGLER_REVOKE_URL"
+	| "WRANGLER_CF_AUTHORIZATION_TOKEN";
+
+type DeprecatedNames =
+	| "CF_ACCOUNT_ID"
+	| "CF_API_TOKEN"
+	| "CF_API_KEY"
+	| "CF_EMAIL"
+	| "CF_API_BASE_URL";
+
+/**
+ * Create a function used to access an environment variable.
+ *
+ * This is not memoized to allow us to change the value at runtime, such as in testing.
+ * A warning is shown if the client is using a deprecated version - but only once.
+ */
+export function getEnvironmentVariableFactory({
+	variableName,
+	deprecatedName,
+}: {
+	variableName: VariableNames;
+	deprecatedName?: DeprecatedNames;
+}): () => string | undefined;
+
+/**
+ * Create a function used to access an environment variable, with a default value.
+ *
+ * This is not memoized to allow us to change the value at runtime, such as in testing.
+ * A warning is shown if the client is using a deprecated version - but only once.
+ */
+export function getEnvironmentVariableFactory({
+	variableName,
+	deprecatedName,
+	defaultValue,
+}: {
+	variableName: VariableNames;
+	deprecatedName?: DeprecatedNames;
+	defaultValue: () => string;
+}): () => string;
+
+/**
+ * Create a function used to access an environment variable.
+ *
+ * This is not memoized to allow us to change the value at runtime, such as in testing.
+ * A warning is shown if the client is using a deprecated version - but only once.
+ */
+export function getEnvironmentVariableFactory({
+	variableName,
+	deprecatedName,
+	defaultValue,
+}: {
+	variableName: VariableNames;
+	deprecatedName?: DeprecatedNames;
+	defaultValue?: () => string;
+}): () => string | undefined {
+	let hasWarned = false;
+	return () => {
+		if (process.env[variableName]) {
+			return process.env[variableName];
+		} else if (deprecatedName && process.env[deprecatedName]) {
+			if (!hasWarned) {
+				// Only show the warning once.
+				hasWarned = true;
+				logger.warn(
+					`Using "${deprecatedName}" environment variable. This is deprecated. Please use "${variableName}", instead.`
+				);
+			}
+			return process.env[deprecatedName];
+		} else {
+			return defaultValue?.();
+		}
+	};
+}

package/src/environment-variables/misc-variables.ts

@@ -0,0 +1,30 @@
+import { getEnvironmentVariableFactory } from "./factory";
+
+/**
+ * `WRANGLER_SEND_METRICS` can override whether we attempt to send metrics information to Sparrow.
+ */
+export const getWranglerSendMetricsFromEnv = getEnvironmentVariableFactory({
+	variableName: "WRANGLER_SEND_METRICS",
+});
+
+/**
+ * Set `WRANGLER_API_ENVIRONMENT` environment variable to "staging" to tell Wrangler to hit the staging APIs rather than production.
+ */
+export const getCloudflareApiEnvironmentFromEnv = getEnvironmentVariableFactory(
+	{
+		variableName: "WRANGLER_API_ENVIRONMENT",
+		defaultValue: () => "production",
+	}
+);
+
+/**
+ * `CLOUDFLARE_API_BASE_URL` specifies the URL to the Cloudflare API.
+ */
+export const getCloudflareApiBaseUrl = getEnvironmentVariableFactory({
+	variableName: "CLOUDFLARE_API_BASE_URL",
+	deprecatedName: "CF_API_BASE_URL",
+	defaultValue: () =>
+		getCloudflareApiEnvironmentFromEnv() === "staging"
+			? "https://api.staging.cloudflare.com/client/v4"
+			: "https://api.cloudflare.com/client/v4",
+});