wrangler 0.0.0-e6733a3 → 0.0.0-e6c71262

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

@@ -0,0 +1,211 @@
+import { fetchResult } from "./cfetch";
+import { readConfig } from "./config";
+import { logger } from "./logger";
+import * as metrics from "./metrics";
+import { requireAuth } from "./user";
+import { printWranglerBanner } from ".";
+import type { CommonYargsArgv, CommonYargsOptions } from "./yargs-types";
+import type { CommandModule } from "yargs";
+
+type Namespace = {
+	namespace_id: string;
+	namespace_name: string;
+	created_on: string;
+	created_by: string;
+	modified_on: string;
+	modified_by: string;
+};
+
+// Supporting Workers For Platforms
+// More details at https://blog.cloudflare.com/workers-for-platforms/
+
+/**
+ * Create a dynamic dispatch namespace.
+ */
+async function createWorkerNamespace(accountId: string, name: string) {
+	const namespace = await fetchResult<Namespace>(
+		`/accounts/${accountId}/workers/dispatch/namespaces`,
+		{
+			method: "POST",
+			headers: {
+				"Content-Type": "application/json",
+			},
+			body: JSON.stringify({ name }),
+		}
+	);
+	logger.log(
+		`Created dispatch namespace "${name}" with ID "${namespace.namespace_id}"`
+	);
+}
+
+/**
+ * Delete a dynamic dispatch namespace.
+ */
+async function deleteWorkerNamespace(accountId: string, name: string) {
+	await fetchResult(
+		`/accounts/${accountId}/workers/dispatch/namespaces/${name}`,
+		{ method: "DELETE" }
+	);
+	logger.log(`Deleted dispatch namespace "${name}"`);
+}
+
+/**
+ * List all created dynamic dispatch namespaces for an account
+ */
+async function listWorkerNamespaces(accountId: string) {
+	logger.log(
+		await fetchResult<Namespace>(
+			`/accounts/${accountId}/workers/dispatch/namespaces`,
+			{
+				headers: {
+					"Content-Type": "application/json",
+				},
+			}
+		)
+	);
+}
+
+/**
+ * Get info for a specific dynamic dispatch namespace
+ */
+async function getWorkerNamespaceInfo(accountId: string, name: string) {
+	logger.log(
+		await fetchResult<Namespace>(
+			`/accounts/${accountId}/workers/dispatch/namespaces/${name}`,
+			{
+				headers: {
+					"Content-Type": "application/json",
+				},
+			}
+		)
+	);
+}
+
+/**
+ * Rename a dynamic dispatch namespace
+ */
+async function renameWorkerNamespace(
+	accountId: string,
+	oldName: string,
+	newName: string
+) {
+	void printWranglerBanner();
+
+	await fetchResult(
+		`/accounts/${accountId}/workers/dispatch/namespaces/${oldName}`,
+		{
+			method: "PUT",
+			headers: {
+				"Content-Type": "application/json",
+			},
+			body: JSON.stringify({ name: newName }),
+		}
+	);
+	logger.log(`Renamed dispatch namespace "${oldName}" to "${newName}"`);
+}
+
+export function workerNamespaceCommands(
+	workerNamespaceYargs: CommonYargsArgv,
+	subHelp: CommandModule<CommonYargsOptions, CommonYargsOptions>
+) {
+	return workerNamespaceYargs
+		.command(subHelp)
+		.command(
+			"list",
+			"List all dispatch namespaces",
+			(args) => args,
+			async (args) => {
+				const config = readConfig(args.config, args);
+				const accountId = await requireAuth(config);
+				await listWorkerNamespaces(accountId);
+				await metrics.sendMetricsEvent("list dispatch namespaces", {
+					sendMetrics: config.send_metrics,
+				});
+			}
+		)
+		.command(
+			"get <name>",
+			"Get information about a dispatch namespace",
+			(yargs) => {
+				return yargs.positional("name", {
+					describe: "Name of the dispatch namespace",
+					type: "string",
+					demandOption: true,
+				});
+			},
+			async (args) => {
+				const config = readConfig(args.config, args);
+				const accountId = await requireAuth(config);
+				await getWorkerNamespaceInfo(accountId, args.name);
+				await metrics.sendMetricsEvent("view dispatch namespace", {
+					sendMetrics: config.send_metrics,
+				});
+			}
+		)
+		.command(
+			"create <name>",
+			"Create a dispatch namespace",
+			(yargs) => {
+				return yargs.positional("name", {
+					describe: "Name of the dispatch namespace",
+					type: "string",
+					demandOption: true,
+				});
+			},
+			async (args) => {
+				await printWranglerBanner();
+				const config = readConfig(args.config, args);
+				const accountId = await requireAuth(config);
+				await createWorkerNamespace(accountId, args.name);
+				await metrics.sendMetricsEvent("create dispatch namespace", {
+					sendMetrics: config.send_metrics,
+				});
+			}
+		)
+		.command(
+			"delete <name>",
+			"Delete a dispatch namespace",
+			(yargs) => {
+				return yargs.positional("name", {
+					describe: "Name of the dispatch namespace",
+					type: "string",
+					demandOption: true,
+				});
+			},
+			async (args) => {
+				await printWranglerBanner();
+				const config = readConfig(args.config, args);
+				const accountId = await requireAuth(config);
+				await deleteWorkerNamespace(accountId, args.name);
+				await metrics.sendMetricsEvent("delete dispatch namespace", {
+					sendMetrics: config.send_metrics,
+				});
+			}
+		)
+		.command(
+			"rename <old-name> <new-name>",
+			"Rename a dispatch namespace",
+			(yargs) => {
+				return yargs
+					.positional("old-name", {
+						describe: "Name of the dispatch namespace",
+						type: "string",
+						demandOption: true,
+					})
+					.positional("new-name", {
+						describe: "New name of the dispatch namespace",
+						type: "string",
+						demandOption: true,
+					});
+			},
+			async (args) => {
+				await printWranglerBanner();
+				const config = readConfig(args.config, args);
+				const accountId = await requireAuth(config);
+				await renameWorkerNamespace(accountId, args.oldName, args.newName);
+				await metrics.sendMetricsEvent("rename dispatch namespace", {
+					sendMetrics: config.send_metrics,
+				});
+			}
+		);
+}

package/src/docs/helpers.ts

@@ -0,0 +1,50 @@
+import assert from "node:assert";
+import { fetch } from "undici";
+import { logger } from "../logger";
+
+// The ALGOLIA_APP_ID and ALGOLIA_PUBLIC_KEY are provided at esbuild time as a `define` for production and beta releases.
+// Otherwise it is left undefined, which disables search.
+declare const ALGOLIA_APP_ID: string;
+declare const ALGOLIA_PUBLIC_KEY: string;
+
+export async function runSearch(searchTerm: string) {
+	const id = ALGOLIA_APP_ID;
+	const index = "developers-cloudflare2";
+	const key = ALGOLIA_PUBLIC_KEY;
+	const params = new URLSearchParams({
+		query: searchTerm,
+		hitsPerPage: "1",
+		getRankingInfo: "0",
+	});
+
+	assert(id, "Missing Algolia App ID");
+	assert(key, "Missing Algolia Key");
+
+	const searchResp = await fetch(
+		`https://${id}-dsn.algolia.net/1/indexes/${index}/query`,
+		{
+			method: "POST",
+			body: JSON.stringify({
+				params: params.toString(),
+			}),
+			headers: {
+				"X-Algolia-API-Key": key,
+				"X-Algolia-Application-Id": id,
+			},
+		}
+	);
+	if (!searchResp.ok) {
+		logger.error(`Could not search the docs. Please try again later.`);
+		return;
+	}
+	const searchData = (await searchResp.json()) as { hits: { url: string }[] };
+	logger.debug("searchData: ", searchData);
+	if (searchData.hits[0]) {
+		return searchData.hits[0].url;
+	} else {
+		logger.error(
+			`Could not find docs for: ${searchTerm}. Please try again with another search term.`
+		);
+		return;
+	}
+}

package/src/docs/index.ts

@@ -0,0 +1,54 @@
+import { printWranglerBanner } from "..";
+import { readConfig } from "../config";
+import { logger } from "../logger";
+import * as metrics from "../metrics";
+import openInBrowser from "../open-in-browser";
+import { runSearch } from "./helpers";
+import type {
+	CommonYargsArgv,
+	StrictYargsOptionsToInterface,
+} from "../yargs-types";
+
+export function docsOptions(yargs: CommonYargsArgv) {
+	return yargs
+		.positional("command", {
+			describe: "Enter the wrangler command you want to know more about",
+			type: "string",
+			array: true,
+		})
+		.option("yes", {
+			alias: "y",
+			type: "boolean",
+			description: "Takes you to the docs, even if search fails",
+		});
+}
+
+export async function docsHandler(
+	args: StrictYargsOptionsToInterface<typeof docsOptions>
+) {
+	//if no command is provided, open the docs homepage
+	//or, if a command IS provided, but we can't find anything, open the docs homepage
+	let urlToOpen =
+		args.yes || !args.command || args.command.length === 0
+			? "https://developers.cloudflare.com/workers/wrangler/commands/"
+			: "";
+
+	if (args.command && args.command.length > 0) {
+		const searchTerm = args.command.join(" ");
+		const searchResult = await runSearch(searchTerm);
+
+		urlToOpen = searchResult ?? urlToOpen;
+	}
+
+	if (!urlToOpen) {
+		return;
+	}
+	await printWranglerBanner();
+
+	logger.log(`Opening a link in your default browser: ${urlToOpen}`);
+	await openInBrowser(urlToOpen);
+	const config = readConfig(undefined, args);
+	await metrics.sendMetricsEvent("view docs", {
+		sendMetrics: config.send_metrics,
+	});
+}

package/src/durable.ts

@@ -0,0 +1,102 @@
+import assert from "node:assert";
+import { fetchResult } from "./cfetch";
+import { logger } from "./logger";
+import type { Config } from "./config";
+import type { CfWorkerInit } from "./worker";
+
+/**
+ * For a given Worker + migrations config, figure out which migrations
+ * to upload based on the current migration tag of the deployed Worker.
+ */
+export async function getMigrationsToUpload(
+	scriptName: string,
+	props: {
+		accountId: string | undefined;
+		config: Config;
+		legacyEnv: boolean | undefined;
+		env: string | undefined;
+	}
+): Promise<CfWorkerInit["migrations"]> {
+	const { config, accountId } = props;
+
+	assert(accountId, "Missing accountId");
+	// if config.migrations
+	let migrations;
+	if (config.migrations.length > 0) {
+		// get current migration tag
+		type ScriptData = { id: string; migration_tag?: string };
+		let script: ScriptData | undefined;
+		if (!props.legacyEnv) {
+			try {
+				if (props.env) {
+					const scriptData = await fetchResult<{
+						script: ScriptData;
+					}>(
+						`/accounts/${accountId}/workers/services/${scriptName}/environments/${props.env}`
+					);
+					script = scriptData.script;
+				} else {
+					const scriptData = await fetchResult<{
+						default_environment: {
+							script: ScriptData;
+						};
+					}>(`/accounts/${accountId}/workers/services/${scriptName}`);
+					script = scriptData.default_environment.script;
+				}
+			} catch (err) {
+				if (
+					![
+						10090, // corresponds to workers.api.error.service_not_found, so the script wasn't previously published at all
+						10092, // workers.api.error.environment_not_found, so the script wasn't published to this environment yet
+					].includes((err as { code: number }).code)
+				) {
+					throw err;
+				}
+				// else it's a 404, no script found, and we can proceed
+			}
+		} else {
+			const scripts = await fetchResult<ScriptData[]>(
+				`/accounts/${accountId}/workers/scripts`
+			);
+			script = scripts.find(({ id }) => id === scriptName);
+		}
+
+		if (script?.migration_tag) {
+			// was already published once
+			const scriptMigrationTag = script.migration_tag;
+			const foundIndex = config.migrations.findIndex(
+				(migration) => migration.tag === scriptMigrationTag
+			);
+			if (foundIndex === -1) {
+				logger.warn(
+					`The published script ${scriptName} has a migration tag "${script.migration_tag}, which was not found in wrangler.toml. You may have already deleted it. Applying all available migrations to the script...`
+				);
+				migrations = {
+					old_tag: script.migration_tag,
+					new_tag: config.migrations[config.migrations.length - 1].tag,
+					steps: config.migrations.map(({ tag: _tag, ...rest }) => rest),
+				};
+			} else {
+				if (foundIndex !== config.migrations.length - 1) {
+					// there are new migrations to send up
+					migrations = {
+						old_tag: script.migration_tag,
+						new_tag: config.migrations[config.migrations.length - 1].tag,
+						steps: config.migrations
+							.slice(foundIndex + 1)
+							.map(({ tag: _tag, ...rest }) => rest),
+					};
+				}
+				// else, we're up to date, no migrations to send
+			}
+		} else {
+			// first time publishing durable objects to this script,
+			// so we send all the migrations
+			migrations = {
+				new_tag: config.migrations[config.migrations.length - 1].tag,
+				steps: config.migrations.map(({ tag: _tag, ...rest }) => rest),
+			};
+		}
+	}
+	return migrations;
+}