wrangler 0.0.0-ece06ea → 0.0.0-ecfbb0c

package/src/dialogs.tsx

@@ -1,85 +1,135 @@
-import * as React from "react";
-import { useState } from "react";
+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 { logger } from "./logger";
 type ConfirmProps = {
-  text: string;
-  onConfirm: (answer: boolean) => void | Promise<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);
-        }}
-      />
-    );
-  });
+	return new Promise((resolve) => {
+		const { unmount } = render(
+			<Confirm
+				text={text}
+				onConfirm={(answer: boolean) => {
+					unmount();
+					resolve(answer);
+				}}
+			/>
+		);
+	});
 }
 
 type PromptProps = {
-  text: string;
-  type?: "text" | "password";
-  onSubmit: (text: string) => void;
+	text: string;
+	defaultValue?: string;
+	type?: "text" | "password";
+	onSubmit: (text: string) => void;
 };
 
-export function Prompt(props: PromptProps) {
-  const [value, setValue] = useState("");
+function Prompt(props: PromptProps) {
+	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>
-  );
+	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") {
-  return new Promise((resolve) => {
-    const { unmount } = render(
-      <Prompt
-        text={text}
-        type={type}
-        onSubmit={(text) => {
-          unmount();
-          resolve(text);
-        }}
-      />
-    );
-  });
+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);
+				}}
+			/>
+		);
+	});
 }
 
-// this one feels a little non "standard"
-// export async function select(
-//   title: string,
-//   choices: { label: string; value: string }[]
-// ): Promise<{ label: string; value: string }>{
+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);
+				}}
+			/>
+		);
+	});
+}

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;
+}

package/src/entry.ts

@@ -0,0 +1,328 @@
+import assert from "node:assert";
+import { existsSync, statSync } from "node:fs";
+import path from "node:path";
+import * as esbuild from "esbuild";
+import { execaCommand } from "execa";
+import { logger } from "./logger";
+import type { Config } from "./config";
+import type { CfScriptFormat } from "./worker";
+import type { Metafile } from "esbuild";
+
+/**
+ * An entry point for the Worker.
+ *
+ * It consists not just of a `file`, but also of a `directory` that is used to resolve relative paths.
+ */
+export type Entry = { file: string; directory: string; format: CfScriptFormat };
+
+/**
+ * Compute the entry-point for the Worker.
+ */
+export async function getEntry(
+	args: {
+		script?: string;
+		format?: CfScriptFormat | undefined;
+		assets?: string | undefined;
+	},
+	config: Config,
+	command: "dev" | "publish"
+): Promise<Entry> {
+	let file: string;
+	let directory = process.cwd();
+	if (args.script) {
+		// If the script name comes from the command line it is relative to the current working directory.
+		file = path.resolve(args.script);
+	} else if (config.main === undefined) {
+		if (config.site?.["entry-point"]) {
+			directory = path.resolve(path.dirname(config.configPath ?? "."));
+			file = path.extname(config.site?.["entry-point"])
+				? path.resolve(config.site?.["entry-point"])
+				: // site.entry-point could be a directory
+				  path.resolve(config.site?.["entry-point"], "index.js");
+		} else if (args.assets) {
+			file = path.resolve(__dirname, "../templates/no-op-worker.js");
+		} else {
+			throw new Error(
+				`Missing entry-point: The entry-point should be specified via the command line (e.g. \`wrangler ${command} path/to/script\`) or the \`main\` config field.`
+			);
+		}
+	} else {
+		directory = path.resolve(path.dirname(config.configPath ?? "."));
+		file = path.resolve(directory, config.main);
+	}
+
+	const relativeFile = path.relative(directory, file) || ".";
+	await runCustomBuild(file, relativeFile, config.build);
+
+	if (fileExists(file) === false) {
+		throw new Error(
+			getMissingEntryPointMessage(
+				`The entry-point file at "${relativeFile}" was not found.`,
+				file,
+				relativeFile
+			)
+		);
+	}
+	const format = await guessWorkerFormat(
+		file,
+		directory,
+		args.format ?? config.build?.upload?.format,
+		config.tsconfig
+	);
+
+	const { localBindings, remoteBindings } =
+		partitionDurableObjectBindings(config);
+
+	if (command === "dev" && remoteBindings.length > 0) {
+		logger.warn(
+			"WARNING: You have Durable Object bindings that are not defined locally in the worker being developed.\n" +
+				"Be aware that changes to the data stored in these Durable Objects will be permanent and affect the live instances.\n" +
+				"Remote Durable Objects that are affected:\n" +
+				remoteBindings.map((b) => `- ${JSON.stringify(b)}`).join("\n")
+		);
+	}
+
+	if (format === "service-worker" && localBindings.length > 0) {
+		const errorMessage =
+			"You seem to be trying to use Durable Objects in a Worker written as a service-worker.";
+		const addScriptName =
+			"You can use Durable Objects defined in other Workers by specifying a `script_name` in your wrangler.toml, where `script_name` is the name of the Worker that implements that Durable Object. For example:";
+		const addScriptNameExamples = generateAddScriptNameExamples(localBindings);
+		const migrateText =
+			"Alternatively, migrate your worker to ES Module syntax to implement a Durable Object in this Worker:";
+		const migrateUrl =
+			"https://developers.cloudflare.com/workers/learning/migrating-to-module-workers/";
+		throw new Error(
+			`${errorMessage}\n${addScriptName}\n${addScriptNameExamples}\n${migrateText}\n${migrateUrl}`
+		);
+	}
+
+	return { file, directory, format };
+}
+
+export async function runCustomBuild(
+	expectedEntryAbsolute: string,
+	expectedEntryRelative: string,
+	build: Config["build"]
+) {
+	if (build?.command) {
+		// TODO: add a deprecation message here?
+		logger.log("Running custom build:", build.command);
+		await execaCommand(build.command, {
+			shell: true,
+			// we keep these two as "inherit" so that
+			// logs are still visible.
+			stdout: "inherit",
+			stderr: "inherit",
+			...(build.cwd && { cwd: build.cwd }),
+		});
+
+		if (fileExists(expectedEntryAbsolute) === false) {
+			throw new Error(
+				getMissingEntryPointMessage(
+					`The expected output file at "${expectedEntryRelative}" was not found after running custom build: ${build.command}.\n` +
+						"The `main` property in wrangler.toml should point to the file generated by the custom build.",
+					expectedEntryAbsolute,
+					expectedEntryRelative
+				)
+			);
+		}
+	}
+}
+
+/**
+ * A function to "guess" the type of worker.
+ * We do this by running a lightweight build of the actual script,
+ * and looking at the metafile generated by esbuild. If it has a default
+ * export (or really, any exports), that means it's a "modules" worker.
+ * Else, it's a "service-worker" worker. This seems hacky, but works remarkably
+ * well in practice.
+ */
+export default async function guessWorkerFormat(
+	entryFile: string,
+	entryWorkingDirectory: string,
+	hint: CfScriptFormat | undefined,
+	tsconfig?: string | undefined
+): Promise<CfScriptFormat> {
+	const result = await esbuild.build({
+		entryPoints: [entryFile],
+		absWorkingDir: entryWorkingDirectory,
+		metafile: true,
+		bundle: false,
+		format: "esm",
+		target: "es2020",
+		write: false,
+		loader: {
+			".js": "jsx",
+			".mjs": "jsx",
+			".cjs": "jsx",
+		},
+		...(tsconfig && { tsconfig }),
+	});
+	// result.metafile is defined because of the `metafile: true` option above.
+	// eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+	const metafile = result.metafile!;
+	const entryPoints = Object.entries(metafile.outputs).filter(
+		([_path, output]) => output.entryPoint !== undefined
+	);
+	assert(
+		entryPoints.length > 0,
+		`Cannot find entry-point "${entryFile}" in generated bundle.` +
+			listEntryPoints(entryPoints)
+	);
+	assert(
+		entryPoints.length < 2,
+		"More than one entry-point found for generated bundle." +
+			listEntryPoints(entryPoints)
+	);
+
+	let guessedWorkerFormat: CfScriptFormat;
+	const scriptExports = entryPoints[0][1].exports;
+	if (scriptExports.length > 0) {
+		if (scriptExports.includes("default")) {
+			guessedWorkerFormat = "modules";
+		} else {
+			logger.warn(
+				`The entrypoint ${path.relative(
+					process.cwd(),
+					entryFile
+				)} has exports like an ES Module, but hasn't defined a default export like a module worker normally would. Building the worker using "service-worker" format...`
+			);
+			guessedWorkerFormat = "service-worker";
+		}
+	} else {
+		guessedWorkerFormat = "service-worker";
+	}
+
+	if (hint) {
+		if (hint !== guessedWorkerFormat) {
+			if (hint === "service-worker") {
+				throw new Error(
+					"You configured this worker to be a 'service-worker', but the file you are trying to build appears to have a `default` export like a module worker. Please pass `--format modules`, or simply remove the configuration."
+				);
+			} else {
+				throw new Error(
+					"You configured this worker to be 'modules', but the file you are trying to build doesn't export a handler. Please pass `--format service-worker`, or simply remove the configuration."
+				);
+			}
+		}
+	}
+	return guessedWorkerFormat;
+}
+
+function listEntryPoints(
+	outputs: [string, ValueOf<Metafile["outputs"]>][]
+): string {
+	return outputs.map(([_input, output]) => output.entryPoint).join("\n");
+}
+
+type ValueOf<T> = T[keyof T];
+
+/**
+ * Returns true if the given `filePath` exists as-is,
+ * or if some version of it (by appending a common extension) exists.
+ */
+export function fileExists(filePath: string): boolean {
+	if (path.extname(filePath) !== "") {
+		return existsSync(filePath);
+	}
+	const base = path.join(path.dirname(filePath), path.basename(filePath));
+	for (const ext of [".ts", ".tsx", ".js", ".jsx"]) {
+		if (existsSync(base + ext)) {
+			return true;
+		}
+	}
+	return false;
+}
+
+type DurableObjectBindings = Config["durable_objects"]["bindings"];
+
+/**
+ * Groups the durable object bindings into two lists:
+ * those that are defined locally and those that refer to a durable object defined in another script.
+ */
+function partitionDurableObjectBindings(config: Config): {
+	localBindings: DurableObjectBindings;
+	remoteBindings: DurableObjectBindings;
+} {
+	const localBindings: DurableObjectBindings = [];
+	const remoteBindings: DurableObjectBindings = [];
+	for (const binding of config.durable_objects.bindings) {
+		if (binding.script_name === undefined) {
+			localBindings.push(binding);
+		} else {
+			remoteBindings.push(binding);
+		}
+	}
+	return { localBindings, remoteBindings };
+}
+
+/**
+ * Generates some help text based on the Durable Object bindings in a given
+ * config indicating how the user can add a `script_name` field to bind an
+ * externally defined Durable Object.
+ */
+function generateAddScriptNameExamples(
+	localBindings: DurableObjectBindings
+): string {
+	function exampleScriptName(binding_name: string): string {
+		return `${binding_name.toLowerCase().replaceAll("_", "-")}-worker`;
+	}
+
+	return localBindings
+		.map(({ name, class_name }) => {
+			const script_name = exampleScriptName(name);
+			const currentBinding = `{ name = ${name}, class_name = ${class_name} }`;
+			const fixedBinding = `{ name = ${name}, class_name = ${class_name}, script_name = ${script_name} }`;
+
+			return `${currentBinding} ==> ${fixedBinding}`;
+		})
+		.join("\n");
+}
+
+/**
+ * Generate an appropriate message for when the entry-point is missing.
+ *
+ * To be more helpful to developers, we check whether there is a suitable file
+ * nearby to the expected file path.
+ */
+function getMissingEntryPointMessage(
+	message: string,
+	absoluteEntryPointPath: string,
+	relativeEntryPointPath: string
+): string {
+	if (
+		existsSync(absoluteEntryPointPath) &&
+		statSync(absoluteEntryPointPath).isDirectory()
+	) {
+		// The expected entry-point is a directory, so offer further guidance.
+		message += `\nThe provided entry-point path, "${relativeEntryPointPath}", points to a directory, rather than a file.\n`;
+
+		// Perhaps we can even guess what the correct path should be...
+		const possiblePaths: string[] = [];
+		for (const basenamePath of [
+			"worker",
+			"dist/worker",
+			"index",
+			"dist/index",
+		]) {
+			for (const extension of [".ts", ".tsx", ".js", ".jsx"]) {
+				const filePath = basenamePath + extension;
+				if (fileExists(path.resolve(absoluteEntryPointPath, filePath))) {
+					possiblePaths.push(path.join(relativeEntryPointPath, filePath));
+				}
+			}
+		}
+
+		if (possiblePaths.length > 0) {
+			message +=
+				`\nDid you mean to set the main field to${
+					possiblePaths.length > 1 ? " one of" : ""
+				}:\n` +
+				"```\n" +
+				possiblePaths.map((filePath) => `main = "./${filePath}"\n`).join("") +
+				"```";
+		}
+	}
+	return message;
+}

package/src/environment-variables.ts

@@ -0,0 +1,35 @@
+import { logger } from "./logger";
+
+/**
+ * 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: string;
+	deprecatedName?: string;
+	defaultValue?: string;
+}) {
+	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/errors.ts

@@ -0,0 +1,11 @@
+export class DeprecationError extends Error {
+	constructor(message: string) {
+		super(`Deprecation:\n${message}`);
+	}
+}
+
+export class FatalError extends Error {
+	constructor(message?: string, readonly code?: number) {
+		super(message);
+	}
+}