wrangler 0.0.0-e3e3243 → 0.0.0-e4047cab

package/src/dialogs.tsx

@@ -1,77 +1,168 @@
+import chalk from "chalk";
 import { Box, Text, useInput, render } from "ink";
+import SelectInput from "ink-select-input";
 import TextInput from "ink-text-input";
 import * as React from "react";
 import { useState } from "react";
+
+import { CI } from "./is-ci";
+import isInteractive from "./is-interactive";
+import { logger } from "./logger";
+
 type ConfirmProps = {
-  text: string;
-  onConfirm: (answer: boolean) => void;
+	text: string;
+	onConfirm: (answer: boolean) => void;
 };
 function Confirm(props: ConfirmProps) {
-  useInput((input: string) => {
-    if (input === "y") {
-      props.onConfirm(true);
-    } else if (input === "n") {
-      props.onConfirm(false);
-    } else {
-      console.log("Unrecognised input");
-    }
-  });
-  return (
-    <Box>
-      <Text>{props.text} (y/n) </Text>
-    </Box>
-  );
+	useInput((input: string, key) => {
+		if (input === "y" || key.return === true) {
+			props.onConfirm(true);
+		} else if (input === "n") {
+			props.onConfirm(false);
+		} else {
+			logger.warn("Unrecognised input:", input);
+		}
+	});
+	return (
+		<Box>
+			<Text>
+				{props.text} ({chalk.bold("y")}/n)
+			</Text>
+		</Box>
+	);
 }
 
-export function confirm(text: string): Promise<boolean> {
-  return new Promise((resolve) => {
-    const { unmount } = render(
-      <Confirm
-        text={text}
-        onConfirm={(answer: boolean) => {
-          unmount();
-          resolve(answer);
-        }}
-      />
-    );
-  });
+export function confirm(
+	text: string,
+	beforeConfirm?: JSX.Element
+): Promise<boolean> {
+	return new Promise((resolve) => {
+		const { unmount } = render(
+			<Box flexDirection="column">
+				{beforeConfirm}
+				<Confirm
+					text={text}
+					onConfirm={(answer: boolean) => {
+						unmount();
+						resolve(answer);
+					}}
+				/>
+			</Box>
+		);
+	});
 }
 
 type PromptProps = {
-  text: string;
-  type?: "text" | "password";
-  onSubmit: (text: string) => void;
+	text: string;
+	defaultValue?: string;
+	type?: "text" | "password";
+	onSubmit: (text: string) => void;
 };
 
 function Prompt(props: PromptProps) {
-  const [value, setValue] = useState("");
-
-  return (
-    <Box>
-      <Text>{props.text} </Text>
-      <Box>
-        <TextInput
-          mask={props.type === "password" ? "*" : undefined}
-          value={value}
-          onChange={setValue}
-          onSubmit={props.onSubmit}
-        />
-      </Box>
-    </Box>
-  );
+	const [value, setValue] = useState(props.defaultValue || "");
+
+	return (
+		<Box>
+			<Text>{props.text} </Text>
+			<Box>
+				<TextInput
+					mask={props.type === "password" ? "*" : undefined}
+					value={value}
+					onChange={setValue}
+					onSubmit={props.onSubmit}
+				/>
+			</Box>
+		</Box>
+	);
+}
+
+export async function prompt(
+	text: string,
+	type: "text" | "password" = "text",
+	defaultValue?: string
+): Promise<string> {
+	return new Promise((resolve) => {
+		const { unmount } = render(
+			<Prompt
+				text={text}
+				defaultValue={defaultValue}
+				type={type}
+				onSubmit={(inputText) => {
+					unmount();
+					resolve(inputText);
+				}}
+			/>
+		);
+	});
+}
+
+type SelectOption = {
+	value: string;
+	label: string;
+};
+
+type SelectProps = {
+	text: string;
+	options: SelectOption[];
+	initialIndex: number;
+	onSelect: (value: string) => void;
+};
+
+function Select(props: SelectProps) {
+	return (
+		<Box flexDirection="column">
+			<Text>{props.text}</Text>
+			<SelectInput
+				initialIndex={props.initialIndex}
+				items={props.options}
+				onSelect={async (selected) => {
+					props.onSelect(selected.value);
+				}}
+			/>
+		</Box>
+	);
+}
+
+export function select(
+	text: string,
+	options: SelectOption[],
+	initialIndex: number
+): Promise<string> {
+	return new Promise((resolve) => {
+		const { unmount } = render(
+			<Select
+				text={text}
+				options={options}
+				initialIndex={initialIndex}
+				onSelect={(option: string) => {
+					unmount();
+					resolve(option);
+				}}
+			/>
+		);
+	});
+}
+
+export function logDim(msg: string) {
+	console.log(chalk.gray(msg));
+}
+
+export async function fromDashMessagePrompt(
+	deploySource: "dash" | "wrangler" | "api"
+): Promise<boolean | void> {
+	if (deploySource === "dash") {
+		logger.warn(
+			`You are about to publish a Workers Service that was last published via the Cloudflare Dashboard.\nEdits that have been made via the dashboard will be overridden by your local code and config.`
+		);
+
+		if (!isInteractive() || CI.isCI()) return true;
+
+		return await confirm("Would you like to continue?");
+	}
 }
+export async function tailDOLogPrompt(): Promise<boolean | void> {
+	if (!isInteractive() || CI.isCI()) return true;
 
-export async function prompt(text: string, type: "text" | "password" = "text") {
-  return new Promise((resolve) => {
-    const { unmount } = render(
-      <Prompt
-        text={text}
-        type={type}
-        onSubmit={(inputText) => {
-          unmount();
-          resolve(inputText);
-        }}
-      />
-    );
-  });
+	return await confirm("Would you like to continue?");
 }

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
+) {
+	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/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;
+}