wrangler 0.0.0-e928f94 → 0.0.0-e93063e9

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,207 @@
+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 { ConfigPath } from ".";
+import type { CommonYargsOptions } from "./yargs-types";
+import type { Argv, 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: Argv<CommonYargsOptions>,
+	subHelp: CommandModule<CommonYargsOptions, CommonYargsOptions>
+) {
+	return workerNamespaceYargs
+		.command(subHelp)
+		.command("list", "List all dispatch namespaces", {}, async (args) => {
+			const config = readConfig(args.config as ConfigPath, 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 as ConfigPath, 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 as ConfigPath, 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 as ConfigPath, 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 as ConfigPath, 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/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/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;
+}