wrangler 0.0.0-e30d1013 → 0.0.0-e311bbbf

package/src/d1/splitter.ts

@@ -0,0 +1,161 @@
+/**
+ * @module
+ * This code is inspired by that of https://www.atdatabases.org/docs/split-sql-query, which is published under MIT license,
+ * and is Copyright (c) 2019 Forbes Lindesay.
+ *
+ * See https://github.com/ForbesLindesay/atdatabases/blob/103c1e7/packages/split-sql-query/src/index.ts
+ * for the original code.
+ */
+
+/**
+ * Is the given `sql` string likely to contain multiple statements.
+ *
+ * If `mayContainMultipleStatements()` returns `false` you can be confident that the sql
+ * does not contain multiple statements. Otherwise you have to check further.
+ */
+export function mayContainMultipleStatements(sql: string): boolean {
+	const trimmed = sql.trimEnd();
+	const semiColonIndex = trimmed.indexOf(";");
+	return semiColonIndex !== -1 && semiColonIndex !== trimmed.length - 1;
+}
+
+/**
+ * Split an SQLQuery into an array of statements
+ */
+export default function splitSqlQuery(sql: string): string[] {
+	if (!mayContainMultipleStatements(sql)) return [sql];
+	const split = splitSqlIntoStatements(sql);
+	if (split.length === 0) {
+		return [sql];
+	} else {
+		return split;
+	}
+}
+
+function splitSqlIntoStatements(sql: string): string[] {
+	const statements: string[] = [];
+	let str = "";
+	const compoundStatementStack: ((s: string) => boolean)[] = [];
+
+	const iterator = sql[Symbol.iterator]();
+	let next = iterator.next();
+	while (!next.done) {
+		const char = next.value;
+
+		if (compoundStatementStack[0]?.(str + char)) {
+			compoundStatementStack.shift();
+		}
+
+		switch (char) {
+			case `'`:
+			case `"`:
+			case "`":
+				str += char + consumeUntilMarker(iterator, char);
+				break;
+			case `$`: {
+				const dollarQuote =
+					"$" + consumeWhile(iterator, isDollarQuoteIdentifier);
+				str += dollarQuote;
+				if (dollarQuote.endsWith("$")) {
+					str += consumeUntilMarker(iterator, dollarQuote);
+				}
+				break;
+			}
+			case `-`:
+				str += char;
+				next = iterator.next();
+				if (!next.done && next.value === "-") {
+					str += next.value + consumeUntilMarker(iterator, "\n");
+					break;
+				} else {
+					continue;
+				}
+			case `/`:
+				str += char;
+				next = iterator.next();
+				if (!next.done && next.value === "*") {
+					str += next.value + consumeUntilMarker(iterator, "*/");
+					break;
+				} else {
+					continue;
+				}
+			case `;`:
+				if (compoundStatementStack.length === 0) {
+					statements.push(str);
+					str = "";
+				} else {
+					str += char;
+				}
+				break;
+			default:
+				str += char;
+				break;
+		}
+
+		if (isCompoundStatementStart(str)) {
+			compoundStatementStack.unshift(isCompoundStatementEnd);
+		}
+
+		next = iterator.next();
+	}
+	statements.push(str);
+
+	return statements
+		.map((statement) => statement.trim())
+		.filter((statement) => statement.length > 0);
+}
+
+/**
+ * Pulls characters from the string iterator while the predicate remains true.
+ */
+function consumeWhile(
+	iterator: Iterator<string>,
+	predicate: (str: string) => boolean
+) {
+	let next = iterator.next();
+	let str = "";
+	while (!next.done) {
+		str += next.value;
+		if (!predicate(str)) {
+			break;
+		}
+		next = iterator.next();
+	}
+	return str;
+}
+
+/**
+ * Pulls characters from the string iterator until the `endMarker` is found.
+ */
+function consumeUntilMarker(iterator: Iterator<string>, endMarker: string) {
+	return consumeWhile(iterator, (str) => !str.endsWith(endMarker));
+}
+
+/**
+ * Returns true if the `str` ends with a dollar-quoted string marker.
+ * See https://www.postgresql.org/docs/current/sql-syntax-lexical.html#SQL-SYNTAX-DOLLAR-QUOTING.
+ */
+function isDollarQuoteIdentifier(str: string) {
+	const lastChar = str.slice(-1);
+	return (
+		// The $ marks the end of the identifier
+		lastChar !== "$" &&
+		// we allow numbers, underscore and letters with diacritical marks
+		(/[0-9_]/i.test(lastChar) ||
+			lastChar.toLowerCase() !== lastChar.toUpperCase())
+	);
+}
+
+/**
+ * Returns true if the `str` ends with a compound statement `BEGIN` marker.
+ */
+function isCompoundStatementStart(str: string) {
+	return /\sBEGIN\s$/.test(str);
+}
+
+/**
+ * Returns true if the `str` ends with a compound statement `END` marker.
+ */
+function isCompoundStatementEnd(str: string) {
+	return /\sEND[;\s]$/.test(str);
+}

package/src/d1/{types.tsx → types.ts}

@@ -1,5 +1,6 @@
 export type Database = {
 	uuid: string;
+	previewDatabaseUuid?: string;
 	name: string;
 	binding: string;
 	internal_env?: string;

package/src/d1/utils.ts

@@ -14,6 +14,7 @@ export function getDatabaseInfoFromConfig(
 		) {
 			return {
 				uuid: d1Database.database_id,
+				previewDatabaseUuid: d1Database.preview_database_id,
 				binding: d1Database.binding,
 				name: d1Database.database_name,
 				migrationsTableName:
@@ -45,4 +46,4 @@ export const getDatabaseByNameOrBinding = async (
 
 export const d1BetaWarning = process.env.NO_D1_WARNING
 	? ""
-	: "🚧 'wrangler d1 <command>' is a beta command. Please report any issues to https://github.com/cloudflare/wrangler2/issues/new/choose";
+	: "--------------------\n🚧 D1 is currently in open alpha and is not recommended for production data and traffic\n🚧 Please report any bugs to https://github.com/cloudflare/workers-sdk/issues/new/choose\n🚧 To request features, visit https://community.cloudflare.com/c/developers/d1\n🚧 To give feedback, visit https://discord.gg/cloudflaredev\n--------------------\n";

package/src/delete.ts

@@ -3,21 +3,17 @@ 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,
+	CommonYargsArgv,
+	StrictYargsOptionsToInterface,
 } from "./yargs-types";
-import type { Argv } from "yargs";
 
-export function deleteOptions(yargs: Argv<CommonYargsOptions>) {
+export function deleteOptions(yargs: CommonYargsArgv) {
 	return yargs
 		.positional("script", {
 			describe: "The path to an entry point for your worker",
@@ -40,14 +36,13 @@ export function deleteOptions(yargs: Argv<CommonYargsOptions>) {
 		});
 }
 
-type DeleteArgs = YargsOptionsToInterface<typeof deleteOptions>;
+type DeleteArgs = StrictYargsOptionsToInterface<typeof deleteOptions>;
 
 export async function deleteHandler(args: DeleteArgs) {
 	await printWranglerBanner();
 
 	const configPath =
-		(args.config as ConfigPath) ||
-		(args.script && findWranglerToml(path.dirname(args.script)));
+		args.config || (args.script && findWranglerToml(path.dirname(args.script)));
 	const config = readConfig(configPath, args);
 	await metrics.sendMetricsEvent(
 		"delete worker script",
@@ -71,12 +66,9 @@ export async function deleteHandler(args: DeleteArgs) {
 
 	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.`
-		);
-	}
+	const confirmed = await confirm(
+		`Are you sure you want to delete ${scriptName}? This action cannot be undone.`
+	);
 
 	if (confirmed) {
 		await fetchResult(

package/src/deployments.ts

@@ -1,77 +1,368 @@
 import { URLSearchParams } from "url";
+import TOML from "@iarna/toml";
+import chalk from "chalk";
+import { FormData } from "undici";
 import { fetchResult } from "./cfetch";
+import { readConfig } from "./config";
+import { confirm, prompt } from "./dialogs";
+import { mapBindings } from "./init";
 import { logger } from "./logger";
+import * as metrics from "./metrics";
+import { requireAuth } from "./user";
+import { getScriptName, printWranglerBanner } from ".";
+
+import type { Config } from "./config";
+import type { WorkerMetadataBinding } from "./create-worker-upload-form";
 import type { ServiceMetadataRes } from "./init";
+import type { CommonYargsOptions } from "./yargs-types";
+import type { ArgumentsCamelCase } from "yargs";
 
-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;
+type DeploymentDetails = {
+	id: string;
+	number: string;
+	annotations: {
+		"workers/triggered_by": string;
+		"workers/rollback_from": string;
+		"workers/message": string;
+	};
+	metadata: {
+		author_id: string;
+		author_email: string;
+		source: "api" | "dash" | "wrangler" | "terraform" | "other";
+		created_on: string;
+		modified_on: string;
+	};
+	resources: {
+		script: {
+			handlers: string[];
 		};
-		resources: {
-			script: string;
-			bindings: unknown[];
+		bindings: WorkerMetadataBinding[];
+		script_runtime: {
+			compatibility_date: string | undefined;
+			compatibility_flags: string[] | undefined;
+			usage_model: string | undefined;
 		};
 	};
-	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 type DeploymentListResult = {
+	latest: DeploymentDetails;
+	items: DeploymentDetails[];
 };
 
 export async function deployments(
 	accountId: string,
-	scriptName: string | undefined
+	scriptName: string | undefined,
+	{ send_metrics: sendMetrics }: { send_metrics?: Config["send_metrics"] } = {}
 ) {
-	const scriptMetadata = await fetchResult<ServiceMetadataRes>(
-		`/accounts/${accountId}/workers/services/${scriptName}`
+	if (!scriptName) {
+		throw new Error(
+			"Required Worker name missing. Please specify the Worker name in wrangler.toml, or pass it as an argument with `--name`"
+		);
+	}
+
+	await metrics.sendMetricsEvent(
+		"view deployments",
+		{ view: scriptName ? "single" : "all" },
+		{
+			sendMetrics,
+		}
 	);
 
-	const scriptTag = scriptMetadata.default_environment.script.tag;
+	const scriptTag = (
+		await fetchResult<ServiceMetadataRes>(
+			`/accounts/${accountId}/workers/services/${scriptName}`
+		)
+	).default_environment.script.tag;
+
 	const params = new URLSearchParams({ order: "asc" });
-	const { items: deploys } = await fetchResult<DeploymentListRes>(
+	const { items: deploys } = await fetchResult<DeploymentListResult>(
 		`/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`
-	);
+	const versionMessages = deploys.map((versions) => {
+		const triggerStr = versions.annotations?.["workers/triggered_by"]
+			? `${formatTrigger(
+					versions.annotations["workers/triggered_by"]
+			  )} from ${formatSource(versions.metadata.source)}`
+			: `${formatSource(versions.metadata.source)}`;
+
+		let version = `
+Deployment ID: ${versions.id}
+Created on:    ${versions.metadata.created_on}
+Author:        ${versions.metadata.author_email}
+Source:        ${triggerStr}`;
+
+		if (versions.annotations?.["workers/rollback_from"]) {
+			version += `\nRollback from: ${versions.annotations["workers/rollback_from"]}`;
+		}
+
+		if (versions.annotations?.["workers/message"]) {
+			version += `\nMessage:       ${versions.annotations["workers/message"]}`;
+		}
+
+		return version + `\n`;
+	});
 
 	versionMessages[versionMessages.length - 1] += "🟩 Active";
 	logger.log(...versionMessages);
 }
 
-// TODO Include emoji/icon for each source
-function sourceStr(source: string): string {
+function formatSource(source: string): string {
 	switch (source) {
 		case "api":
-			return "API";
+			return "API 📡";
 		case "dash":
-			return "Dashboard";
+			return "Dashboard 🖥️";
 		case "wrangler":
-			return "Wrangler";
+			return "Wrangler 🤠";
 		case "terraform":
-			return "Terraform";
+			return "Terraform 🏗️";
 		default:
 			return "Other";
 	}
 }
+function formatTrigger(trigger: string): string {
+	switch (trigger) {
+		case "upload":
+			return "Upload";
+		case "secret":
+			return "Secret Change";
+		case "rollback":
+			return "Rollback";
+		case "promotion":
+			return "Promotion";
+		default:
+			return "Unknown";
+	}
+}
+
+export async function rollbackDeployment(
+	accountId: string,
+	scriptName: string | undefined,
+	{ send_metrics: sendMetrics }: { send_metrics?: Config["send_metrics"] } = {},
+	deploymentId: string | undefined,
+	message: string | undefined
+) {
+	if (deploymentId === undefined) {
+		const scriptTag = (
+			await fetchResult<ServiceMetadataRes>(
+				`/accounts/${accountId}/workers/services/${scriptName}`
+			)
+		).default_environment.script.tag;
+
+		const params = new URLSearchParams({ order: "asc" });
+		const { items: deploys } = await fetchResult<DeploymentListResult>(
+			`/accounts/${accountId}/workers/deployments/by-script/${scriptTag}`,
+			undefined,
+			params
+		);
+
+		if (deploys.length < 2) {
+			throw new Error(
+				"Cannot rollback to previous deployment since there are less than 2 deployemnts"
+			);
+		}
+
+		deploymentId = deploys.at(-2)?.id;
+		if (deploymentId === undefined) {
+			throw new Error("Cannot find previous deployment");
+		}
+	}
+
+	const firstHash = deploymentId.substring(0, deploymentId.indexOf("-"));
+
+	let rollbackMessage = "";
+	if (message !== undefined) {
+		rollbackMessage = message;
+	} else {
+		if (
+			!(await confirm(
+				`This deployment ${chalk.underline(
+					firstHash
+				)} will immediately replace the current deployment and become the active deployment across all your deployed routes and domains. However, your local development environment will not be affected by this rollback. ${chalk.blue.bold(
+					"Note:"
+				)} Rolling back to a previous deployment will not rollback any of the bound resources (Durable Object, R2, KV, etc.).`
+			))
+		) {
+			return;
+		}
+
+		rollbackMessage = await prompt(
+			"Please provide a message for this rollback (120 characters max)",
+			{ defaultValue: "" }
+		);
+	}
+
+	let deployment_id = await rollbackRequest(
+		accountId,
+		scriptName,
+		deploymentId,
+		rollbackMessage
+	);
+
+	await metrics.sendMetricsEvent(
+		"rollback deployments",
+		{ view: scriptName ? "single" : "all" },
+		{
+			sendMetrics,
+		}
+	);
+
+	deploymentId = addHyphens(deploymentId) ?? deploymentId;
+	deployment_id = addHyphens(deployment_id) ?? deployment_id;
+
+	logger.log(`\nSuccessfully rolled back to Deployment ID: ${deploymentId}`);
+	logger.log("Current Deployment ID:", deployment_id);
+}
+
+async function rollbackRequest(
+	accountId: string,
+	scriptName: string | undefined,
+	deploymentId: string,
+	rollbackReason: string
+): Promise<string | null> {
+	const body = new FormData();
+	body.set("message", rollbackReason);
+
+	const { deployment_id } = await fetchResult<{
+		deployment_id: string | null;
+	}>(
+		`/accounts/${accountId}/workers/scripts/${scriptName}?rollback_to=${deploymentId}`,
+		{
+			method: "PUT",
+			body,
+		}
+	);
+
+	return deployment_id;
+}
+
+export async function viewDeployment(
+	accountId: string,
+	scriptName: string | undefined,
+	{ send_metrics: sendMetrics }: { send_metrics?: Config["send_metrics"] } = {},
+	deploymentId: string | undefined
+) {
+	await metrics.sendMetricsEvent(
+		"view deployments",
+		{ view: scriptName ? "single" : "all" },
+		{
+			sendMetrics,
+		}
+	);
+
+	const scriptTag = (
+		await fetchResult<ServiceMetadataRes>(
+			`/accounts/${accountId}/workers/services/${scriptName}`
+		)
+	).default_environment.script.tag;
+
+	if (deploymentId === undefined) {
+		const params = new URLSearchParams({ order: "asc" });
+		const { latest } = await fetchResult<DeploymentListResult>(
+			`/accounts/${accountId}/workers/deployments/by-script/${scriptTag}`,
+			undefined,
+			params
+		);
+
+		deploymentId = latest.id;
+		if (deploymentId === undefined) {
+			throw new Error("Cannot find previous deployment");
+		}
+	}
+
+	const deploymentDetails = await fetchResult<DeploymentListResult["latest"]>(
+		`/accounts/${accountId}/workers/deployments/by-script/${scriptTag}/detail/${deploymentId}`
+	);
+
+	const triggerStr = deploymentDetails.annotations?.["workers/triggered_by"]
+		? `${formatTrigger(
+				deploymentDetails.annotations["workers/triggered_by"]
+		  )} from ${formatSource(deploymentDetails.metadata.source)}`
+		: `${formatSource(deploymentDetails.metadata.source)}`;
+
+	const rollbackStr = deploymentDetails.annotations?.["workers/rollback_from"]
+		? `\nRollback from:       ${deploymentDetails.annotations["workers/rollback_from"]}`
+		: ``;
+
+	const reasonStr = deploymentDetails.annotations?.["workers/message"]
+		? `\nMessage:             ${deploymentDetails.annotations["workers/message"]}`
+		: ``;
+
+	const compatDateStr = deploymentDetails.resources.script_runtime
+		?.compatibility_date
+		? `\nCompatibility Date:  ${deploymentDetails.resources.script_runtime?.compatibility_date}`
+		: ``;
+	const compatFlagsStr = deploymentDetails.resources.script_runtime
+		?.compatibility_flags
+		? `\nCompatibility Flags: ${deploymentDetails.resources.script_runtime?.compatibility_flags}`
+		: ``;
+
+	const bindings = deploymentDetails.resources.bindings;
+
+	const version = `
+Deployment ID:       ${deploymentDetails.id}
+Created on:          ${deploymentDetails.metadata.created_on}
+Author:              ${deploymentDetails.metadata.author_email}
+Source:              ${triggerStr}${rollbackStr}${reasonStr}
+------------------------------------------------------------
+Author ID:           ${deploymentDetails.metadata.author_id}
+Usage Model:         ${deploymentDetails.resources.script_runtime.usage_model}
+Handlers:            ${
+		deploymentDetails.resources.script.handlers
+	}${compatDateStr}${compatFlagsStr}
+--------------------------bindings--------------------------
+${
+	bindings.length > 0
+		? TOML.stringify(mapBindings(bindings) as TOML.JsonMap)
+		: `None`
+}
+`;
+
+	logger.log(version);
+
+	// early return to skip the deployments listings
+	return;
+}
+
+export async function commonDeploymentCMDSetup(
+	yargs: ArgumentsCamelCase<CommonYargsOptions>,
+	deploymentsWarning: string
+) {
+	await printWranglerBanner();
+	const config = readConfig(yargs.config, yargs);
+	const accountId = await requireAuth(config);
+	const scriptName = getScriptName(
+		{ name: yargs.name as string, env: undefined },
+		config
+	);
+
+	logger.log(`${deploymentsWarning}\n`);
+
+	return { accountId, scriptName, config };
+}
+
+export function addHyphens(uuid: string | null): string | null {
+	if (uuid == null) {
+		return uuid;
+	}
+
+	if (uuid.length != 32) {
+		return null;
+	}
+
+	const uuid_parts: string[] = [];
+	uuid_parts.push(uuid.slice(0, 8));
+	uuid_parts.push(uuid.slice(8, 12));
+	uuid_parts.push(uuid.slice(12, 16));
+	uuid_parts.push(uuid.slice(16, 20));
+	uuid_parts.push(uuid.slice(20));
+
+	let hyphenated = "";
+	uuid_parts.forEach((part) => (hyphenated += part + "-"));
+
+	return hyphenated.slice(0, 36);
+}