wrangler 0.0.0-e3e3243 → 0.0.0-e4047cab

package/src/d1/utils.ts

@@ -0,0 +1,48 @@
+import { DEFAULT_MIGRATION_PATH, DEFAULT_MIGRATION_TABLE } from "./constants";
+import { listDatabases } from "./list";
+import type { Config } from "../config";
+import type { Database } from "./types";
+
+export function getDatabaseInfoFromConfig(
+	config: Config,
+	name: string
+): Database | null {
+	for (const d1Database of config.d1_databases) {
+		if (
+			d1Database.database_id &&
+			(name === d1Database.database_name || name === d1Database.binding)
+		) {
+			return {
+				uuid: d1Database.database_id,
+				binding: d1Database.binding,
+				name: d1Database.database_name,
+				migrationsTableName:
+					d1Database.migrations_table || DEFAULT_MIGRATION_TABLE,
+				migrationsFolderPath:
+					d1Database.migrations_dir || DEFAULT_MIGRATION_PATH,
+				internal_env: d1Database.database_internal_env,
+			};
+		}
+	}
+	return null;
+}
+
+export const getDatabaseByNameOrBinding = async (
+	config: Config,
+	accountId: string,
+	name: string
+): Promise<Database> => {
+	const dbFromConfig = getDatabaseInfoFromConfig(config, name);
+	if (dbFromConfig) return dbFromConfig;
+
+	const allDBs = await listDatabases(accountId);
+	const matchingDB = allDBs.find((db) => db.name === name);
+	if (!matchingDB) {
+		throw new Error(`Couldn't find DB with name '${name}'`);
+	}
+	return matchingDB;
+};
+
+export const d1BetaWarning = process.env.NO_D1_WARNING
+	? ""
+	: "🚧 D1 is currently in open alpha and is not recommended for production data and traffic.\nPlease report any bugs to https://github.com/cloudflare/wrangler2/issues/new/choose.\nTo request features, visit https://community.cloudflare.com/c/developers/d1.\nTo give feedback, visit https://discord.gg/cloudflaredev";

package/src/delete.ts

@@ -0,0 +1,108 @@
+import assert from "assert";
+import path from "path";
+import { fetchResult } from "./cfetch";
+import { findWranglerToml, readConfig } from "./config";
+import { confirm } from "./dialogs";
+import { CI } from "./is-ci";
+import isInteractive from "./is-interactive";
+import { deleteKVNamespace, listKVNamespaces } from "./kv/helpers";
+import { logger } from "./logger";
+import * as metrics from "./metrics";
+import { requireAuth } from "./user";
+import { getScriptName, printWranglerBanner } from "./index";
+import type { ConfigPath } from "./index";
+import type {
+	CommonYargsOptions,
+	YargsOptionsToInterface,
+} from "./yargs-types";
+import type { Argv } from "yargs";
+
+export function deleteOptions(yargs: Argv<CommonYargsOptions>) {
+	return yargs
+		.positional("script", {
+			describe: "The path to an entry point for your worker",
+			type: "string",
+			requiresArg: true,
+		})
+		.option("name", {
+			describe: "Name of the worker",
+			type: "string",
+			requiresArg: true,
+		})
+		.option("dry-run", {
+			describe: "Don't actually delete",
+			type: "boolean",
+		})
+		.option("legacy-env", {
+			type: "boolean",
+			describe: "Use legacy environments",
+			hidden: true,
+		});
+}
+
+type DeleteArgs = YargsOptionsToInterface<typeof deleteOptions>;
+
+export async function deleteHandler(args: DeleteArgs) {
+	await printWranglerBanner();
+
+	const configPath =
+		(args.config as ConfigPath) ||
+		(args.script && findWranglerToml(path.dirname(args.script)));
+	const config = readConfig(configPath, args);
+	await metrics.sendMetricsEvent(
+		"delete worker script",
+		{},
+		{ sendMetrics: config.send_metrics }
+	);
+
+	const accountId = args.dryRun ? undefined : await requireAuth(config);
+
+	const scriptName = getScriptName(args, config);
+
+	assert(
+		scriptName,
+		"A worker name must be defined, either via --name, or in wrangler.toml"
+	);
+
+	if (args.dryRun) {
+		logger.log(`--dry-run: exiting now.`);
+		return;
+	}
+
+	assert(accountId, "Missing accountId");
+
+	let confirmed = true;
+	if (isInteractive() || !CI.isCI()) {
+		confirmed = await confirm(
+			`Are you sure you want to delete ${scriptName}? This action cannot be undone.`
+		);
+	}
+
+	if (confirmed) {
+		await fetchResult(
+			`/accounts/${accountId}/workers/services/${scriptName}`,
+			{ method: "DELETE" },
+			new URLSearchParams({ force: "true" })
+		);
+
+		await deleteSiteNamespaceIfExisting(scriptName, accountId);
+
+		logger.log("Successfully deleted", scriptName);
+	}
+}
+
+async function deleteSiteNamespaceIfExisting(
+	scriptName: string,
+	accountId: string
+): Promise<void> {
+	const title = `__${scriptName}-workers_sites_assets`;
+	const previewTitle = `__${scriptName}-workers_sites_assets_preview`;
+	const allNamespaces = await listKVNamespaces(accountId);
+	const namespacesToDelete = allNamespaces.filter(
+		(ns) => ns.title === title || ns.title === previewTitle
+	);
+	for (const ns of namespacesToDelete) {
+		await deleteKVNamespace(accountId, ns.id);
+		logger.log(`🌀 Deleted asset namespace for Workers Site "${ns.title}"`);
+	}
+}

package/src/deployments.ts

@@ -0,0 +1,77 @@
+import { URLSearchParams } from "url";
+import { fetchResult } from "./cfetch";
+import { logger } from "./logger";
+import type { ServiceMetadataRes } from "./init";
+
+export type DeploymentListRes = {
+	latest: {
+		id: string;
+		number: string;
+		metadata: {
+			author_id: string;
+			author_email: string;
+			source: "api" | "dash" | "wrangler" | "terraform" | "other";
+			created_on: string;
+			modified_on: string;
+		};
+		resources: {
+			script: string;
+			bindings: unknown[];
+		};
+	};
+	items: {
+		id: string;
+		number: string;
+		metadata: {
+			author_id: string;
+			author_email: string;
+			source: "api" | "dash" | "wrangler" | "terraform" | "other";
+			created_on: string;
+			modified_on: string;
+		};
+	}[];
+};
+
+export async function deployments(
+	accountId: string,
+	scriptName: string | undefined
+) {
+	const scriptMetadata = await fetchResult<ServiceMetadataRes>(
+		`/accounts/${accountId}/workers/services/${scriptName}`
+	);
+
+	const scriptTag = scriptMetadata.default_environment.script.tag;
+	const params = new URLSearchParams({ order: "asc" });
+	const { items: deploys } = await fetchResult<DeploymentListRes>(
+		`/accounts/${accountId}/workers/deployments/by-script/${scriptTag}`,
+		undefined,
+		params
+	);
+
+	const versionMessages = deploys.map(
+		(versions) =>
+			`\nDeployment ID: ${versions.id}
+Created on: ${versions.metadata.created_on}
+Author: ${versions.metadata.author_email}
+Source: ${sourceStr(versions.metadata.source)}\n`
+	);
+
+	versionMessages[versionMessages.length - 1] += "🟩 Active";
+	logger.log(...versionMessages);
+}
+
+// TODO Include emoji/icon for each source
+function sourceStr(source: string): string {
+	switch (source) {
+		case "api":
+			return "API";
+		case "dash":
+			return "Dashboard";
+		case "wrangler":
+			return "Wrangler";
+		case "terraform":
+			return "Terraform";
+		default:
+			return "Other";
+	}
+}

package/src/deprecated/index.ts

@@ -0,0 +1,438 @@
+import fs from "node:fs";
+import path from "node:path";
+import { DeprecationError } from "../errors";
+import { cloneIntoDirectory, initializeGit } from "../git-client";
+import {
+	CommandLineArgsError,
+	createCLIParser,
+	printWranglerBanner,
+} from "../index";
+import { initHandler } from "../init";
+import { logger } from "../logger";
+import { formatMessage } from "../parse";
+import type {
+	CommonYargsOptions,
+	YargsOptionsToInterface,
+} from "../yargs-types";
+import type { Argv, ArgumentsCamelCase, BuilderCallback } from "yargs";
+
+// https://github.com/cloudflare/wrangler/blob/master/src/cli/mod.rs#L106-L123
+interface GenerateArgs {
+	name?: string;
+	template?: string;
+	type?: string;
+	site?: boolean;
+}
+
+export function generateOptions(yargs: Argv<CommonYargsOptions>) {
+	return yargs
+		.positional("name", {
+			describe: "Name of the Workers project",
+			type: "string",
+		})
+		.positional("template", {
+			type: "string",
+			describe: "The URL of a GitHub template",
+		})
+		.option("type", {
+			alias: "t",
+			type: "string",
+			hidden: true,
+			deprecated: true,
+		})
+		.option("site", {
+			alias: "s",
+			type: "boolean",
+			hidden: true,
+			deprecated: true,
+		});
+}
+
+export async function generateHandler({
+	// somehow, `init` marks name as required but then also runs fine
+	// with the name omitted, and then substitutes it at runtime with ""
+	name = "",
+	template,
+	type,
+	site,
+	...args
+}: ArgumentsCamelCase<GenerateArgs>) {
+	// delegate to `wrangler init` if no template is specified
+	if (template === undefined) {
+		return initHandler({ name, ...args });
+	}
+
+	// print down here cuz `init` prints it own its own
+	await printWranglerBanner();
+
+	if (type) {
+		let message = "The --type option is no longer supported.";
+		if (args.type === "webpack") {
+			message +=
+				"\nIf you wish to use webpack then you will need to create a custom build.";
+			// TODO: Add a link to docs
+		}
+		throw new CommandLineArgsError(message);
+	}
+
+	if (isRemote(name)) {
+		[template, name] = [name, template];
+	}
+
+	const creationDirectory = generateWorkerDirectoryName(name);
+
+	if (site) {
+		const gitDirectory =
+			creationDirectory !== process.cwd()
+				? path.basename(creationDirectory)
+				: "my-site";
+		const message =
+			"The --site option is no longer supported.\n" +
+			"If you wish to create a brand new Worker Sites project then clone the `worker-sites-template` starter repository:\n\n" +
+			"```\n" +
+			`git clone --depth=1 --branch=wrangler2 https://github.com/cloudflare/worker-sites-template ${gitDirectory}\n` +
+			`cd ${gitDirectory}\n` +
+			"```\n\n" +
+			"Find out more about how to create and maintain Sites projects at https://developers.cloudflare.com/workers/platform/sites.\n" +
+			"Have you considered using Cloudflare Pages instead? See https://pages.cloudflare.com/.";
+		throw new CommandLineArgsError(message);
+	}
+
+	logger.log(
+		`Creating a worker in ${path.basename(creationDirectory)} from ${template}`
+	);
+
+	const { remote, subdirectory } = parseTemplatePath(template);
+
+	await cloneIntoDirectory(remote, creationDirectory, subdirectory);
+	await initializeGit(creationDirectory);
+
+	logger.log("✨ Success!");
+}
+
+/**
+ * Creates a path based on the current working directory and a worker name.
+ * Automatically increments a counter when searching for an available directory.
+ *
+ * Running `wrangler generate worker https://some-git-repo` in a directory
+ * with the structure:
+ * ```
+ * - workers
+ * |
+ * | - worker
+ * | | - wrangler.toml
+ * | | ...
+ * |
+ * | - worker-1
+ * | | - wrangler.toml
+ * | | ...
+ * ```
+ *
+ * will result in a new worker called `worker-2` being generated.
+ *
+ * @param workerName the name of the generated worker
+ * @returns an absolute path to the directory to generate the worker into
+ */
+function generateWorkerDirectoryName(workerName: string): string {
+	let workerDirectoryPath = path.resolve(process.cwd(), workerName);
+	let i = 1;
+
+	while (fs.existsSync(workerDirectoryPath)) {
+		workerDirectoryPath = path.resolve(process.cwd(), `${workerName}-${i}`);
+		i++;
+	}
+
+	return workerDirectoryPath;
+}
+
+/**
+ * Checks if an arg is a template, which can be useful if the order
+ * of template & worker name args is switched
+ *
+ * @param arg a template to generate from, or a folder to generate into
+ * @returns true if the given arg was remote (a template)
+ */
+function isRemote(arg: string) {
+	return /^(https?|ftps?|file|git|ssh):\/\//.test(arg) || arg.includes(":");
+}
+
+/**
+ * unreadable regex basically copied from degit. i put some named capture groups in,
+ * but uhh...there's not much to do short of using pomsky or some other tool.
+ *
+ * notably: this only supports `https://` and `git@` urls,
+ * and is missing support for:
+ * - `http`
+ * - `ftp(s)`
+ * - `file`
+ * - `ssh`
+ */
+const TEMPLATE_REGEX =
+	/^(?:(?:https:\/\/)?(?<httpsUrl>[^:/]+\.[^:/]+)\/|git@(?<gitUrl>[^:/]+)[:/]|(?<shorthandUrl>[^/]+):)?(?<user>[^/\s]+)\/(?<repository>[^/\s#]+)(?:(?<subdirectoryPath>(?:\/[^/\s#]+)+))?(?:\/)?(?:#(?<tag>.+))?/;
+
+// there are a few URL formats we support:
+// - `user/repo` -> assume github, use "https://github.com/user/repo.git"
+// - `https://<httpsUrl>
+// - `git@<gitUrl>`
+// - `(bb|bitbucket|gh|github|gl|gitlab):user/repo` -> parse shorthand into https url
+
+/**
+ * There's no URL, so assume a github repo
+ */
+type NoUrl = {
+	httpsUrl: undefined;
+	gitUrl: undefined;
+	shorthandUrl: undefined;
+};
+
+/**
+ * A https url (e.g. https://bitbucket.org/user/repo)
+ */
+type HttpsUrl = Omit<NoUrl, "httpsUrl"> & { httpsUrl: string };
+
+/**
+ * A git url (e.g. git@gitlab.com:user/repo)
+ */
+type GitUrl = Omit<NoUrl, "gitUrl"> & { gitUrl: string };
+
+/**
+ * A shorthand url (e.g. github:user/repo)
+ */
+type ShorthandUrl = Omit<NoUrl, "shorthandUrl"> & { shorthandUrl: string };
+
+/**
+ * Union of all possible URL groups. Exactly one will be present, the rest
+ * will be `undefined`.
+ */
+type TemplateRegexUrlGroup = NoUrl | HttpsUrl | GitUrl | ShorthandUrl;
+
+/**
+ * Possible matches of `TEMPLATE_REGEX` against a passed-in template arg
+ */
+type TemplateRegexGroups = {
+	/** The user the repo is under */
+	user: string;
+
+	/** The repo name */
+	repository: string;
+
+	/** Optional, path to subdirectory containing template. Begins with `/` */
+	subdirectoryPath?: string;
+
+	/** Optional tag (or branch, etc.) to clone */
+	tag?: string;
+} & TemplateRegexUrlGroup;
+
+/**
+ * Parses a regex match on any of the URL groups into a URL base
+ *
+ * @param urlGroup a regex hit for a URL of any sort
+ * @returns the protocol and domain name of the url to clone from
+ */
+function toUrlBase({ httpsUrl, gitUrl, shorthandUrl }: TemplateRegexUrlGroup) {
+	if (httpsUrl !== undefined) {
+		return `https://${httpsUrl}`;
+	}
+
+	if (gitUrl !== undefined) {
+		return `git@${gitUrl}`;
+	}
+
+	if (shorthandUrl !== undefined) {
+		switch (shorthandUrl) {
+			case "github":
+			case "gh":
+				return "https://github.com";
+			case "gitlab":
+			case "gl":
+				return "https://gitlab.com";
+			case "bitbucket":
+			case "bb":
+				return "https://bitbucket.org";
+			default:
+				throw new Error(
+					`Unable to parse shorthand ${shorthandUrl}. Supported options are "bitbucket" ("bb"), "github" ("gh"), and "gitlab" ("gl")`
+				);
+		}
+	}
+
+	return "https://github.com";
+}
+
+/**
+ * Parses a template string (e.g. "user/repo", "github:user/repo/path/to/subdirectory")
+ * into a remote URL to clone from and an optional subdirectory to filter for
+ *
+ * @param templatePath the template string to parse
+ * @returns an object containing the remote url and an optional subdirectory to clone
+ */
+function parseTemplatePath(templatePath: string): {
+	remote: string;
+	subdirectory?: string;
+} {
+	if (!templatePath.includes("/")) {
+		// template is a cloudflare canonical template, it doesn't include a slash in the name
+		return {
+			remote: "https://github.com/cloudflare/templates.git",
+			subdirectory: templatePath,
+		};
+	}
+
+	const groups = TEMPLATE_REGEX.exec(templatePath)?.groups as unknown as
+		| TemplateRegexGroups
+		| undefined;
+
+	if (!groups) {
+		throw new Error(`Unable to parse ${templatePath} as a template`);
+	}
+
+	const { user, repository, subdirectoryPath, tag, ...urlGroups } = groups;
+
+	const urlBase = toUrlBase(urlGroups);
+	const isHttp = urlBase.startsWith("http");
+
+	const remote = `${urlBase}${isHttp ? "/" : ":"}${user}/${repository}.git${
+		tag ? `#${tag}` : ""
+	}`;
+
+	// remove starting /
+	const subdirectory = subdirectoryPath?.slice(1);
+
+	return { remote, subdirectory };
+}
+
+export function buildOptions(yargs: Argv<CommonYargsOptions>) {
+	return yargs;
+}
+type BuildArgs = YargsOptionsToInterface<typeof buildOptions>;
+export async function buildHandler(buildArgs: BuildArgs) {
+	// "[DEPRECATED] 🦀 Build your project (if applicable)",
+
+	const envFlag = buildArgs.env ? ` --env=${buildArgs.env}` : "";
+	logger.log(
+		formatMessage({
+			kind: "warning",
+			text: "Deprecation: `wrangler build` has been deprecated.",
+			notes: [
+				{
+					text: "Please refer to https://developers.cloudflare.com/workers/wrangler/migration/deprecations/#build for more information.",
+				},
+				{
+					text: `Attempting to run \`wrangler publish --dry-run --outdir=dist${envFlag}\` for you instead:`,
+				},
+			],
+		})
+	);
+
+	await createCLIParser([
+		"publish",
+		"--dry-run",
+		"--outdir=dist",
+		...(buildArgs.env ? ["--env", buildArgs.env] : []),
+	]).parse();
+}
+
+export const noOpOptions = () => {};
+export const configHandler = () => {
+	// "🕵️  Authenticate Wrangler with a Cloudflare API Token",
+	throw new DeprecationError(
+		"`wrangler config` has been deprecated, please refer to https://developers.cloudflare.com/workers/wrangler/migration/deprecations/#config for alternatives"
+	);
+};
+
+export function previewOptions(yargs: Argv<CommonYargsOptions>) {
+	return yargs
+		.positional("method", {
+			type: "string",
+			describe: "Type of request to preview your worker",
+		})
+		.positional("body", {
+			type: "string",
+			describe: "Body string to post to your preview worker request.",
+		})
+		.option("watch", {
+			default: true,
+			describe: "Enable live preview",
+			type: "boolean",
+		});
+}
+
+export function previewHandler() {
+	throw new DeprecationError(
+		"The `wrangler preview` command has been deprecated.\n" +
+			"Try using `wrangler dev` to to try out a worker during development.\n"
+	);
+}
+
+export const route: BuilderCallback<unknown, unknown> = (routeYargs: Argv) => {
+	return routeYargs
+		.command(
+			"list",
+			"List the routes associated with a zone",
+			(yargs) => {
+				return yargs
+					.option("zone", {
+						type: "string",
+						requiresArg: true,
+						describe: "Zone id",
+					})
+					.positional("zone", {
+						describe: "Zone id",
+						type: "string",
+					});
+			},
+			() => {
+				// "👯 [DEPRECATED]. Use wrangler.toml to manage routes.
+				const deprecationNotice = "`wrangler route list` has been deprecated.";
+				const futureRoutes =
+					"Refer to wrangler.toml for a list of routes the worker will be deployed to upon publishing.";
+				const presentRoutes =
+					"Refer to the Cloudflare Dashboard to see the routes this worker is currently running on.";
+				throw new DeprecationError(
+					`${deprecationNotice}\n${futureRoutes}\n${presentRoutes}`
+				);
+			}
+		)
+		.command(
+			"delete [id]",
+			"Delete a route associated with a zone",
+			(yargs) => {
+				return yargs
+					.positional("id", {
+						describe: "The hash of the route ID to delete.",
+						type: "string",
+					})
+					.option("zone", {
+						type: "string",
+						requiresArg: true,
+						describe: "zone id",
+					});
+			},
+			() => {
+				// "👯 [DEPRECATED]. Use wrangler.toml to manage routes.
+				const deprecationNotice =
+					"`wrangler route delete` has been deprecated.";
+				const shouldDo =
+					"Remove the unwanted route(s) from wrangler.toml and run `wrangler publish` to remove your worker from those routes.";
+				throw new DeprecationError(`${deprecationNotice}\n${shouldDo}`);
+			}
+		);
+};
+
+export const routeHandler = () => {
+	// "[DEPRECATED]. Use wrangler.toml to manage routes.
+	const deprecationNotice = "`wrangler route` has been deprecated.";
+	const shouldDo =
+		"Please use wrangler.toml and/or `wrangler publish --routes` to modify routes";
+	throw new DeprecationError(`${deprecationNotice}\n${shouldDo}`);
+};
+
+export const subdomainOptions = (yargs: Argv<CommonYargsOptions>) => {
+	return yargs.positional("name", { type: "string" });
+};
+
+export const subdomainHandler = () => {
+	throw new DeprecationError(
+		"`wrangler subdomain` has been deprecated, please refer to https://developers.cloudflare.com/workers/wrangler/migration/deprecations/#subdomain for alternatives"
+	);
+};

package/src/dev/dev-vars.ts

@@ -0,0 +1,39 @@
+import * as path from "node:path";
+import { loadDotEnv } from "../config";
+import { logger } from "../logger";
+import type { Config } from "../config";
+
+/**
+ * Get the Worker `vars` bindings for a `wrangler dev` instance of a Worker.
+ *
+ * The `vars` bindings can be specified in the `wrangler.toml` configuration file.
+ * But "secret" `vars` are usually only provided at the server -
+ * either by creating them in the Dashboard UI, or using the `wrangler secret` command.
+ *
+ * It is useful during development, to provide these types of variable locally.
+ * When running `wrangler dev` we will look for a file called `.dev.vars`, situated
+ * next to the `wrangler.toml` file (or in the current working directory if there is no
+ * `wrangler.toml`). If the `--env <env>` option is set, we'll first look for
+ * `.dev.vars.<env>`.
+ *
+ * Any values in this file, formatted like a `dotenv` file, will add to or override `vars`
+ * bindings provided in the `wrangler.toml`.
+ */
+export function getVarsForDev(
+	config: Config,
+	env: string | undefined
+): Config["vars"] {
+	const configDir = path.resolve(path.dirname(config.configPath ?? "."));
+	const devVarsPath = path.resolve(configDir, ".dev.vars");
+	const loaded = loadDotEnv(devVarsPath, env);
+	if (loaded !== undefined) {
+		const devVarsRelativePath = path.relative(process.cwd(), loaded.path);
+		logger.log(`Using vars defined in ${devVarsRelativePath}`);
+		return {
+			...config.vars,
+			...loaded.parsed,
+		};
+	} else {
+		return config.vars;
+	}
+}