wrangler 0.0.0-e33bea9b → 0.0.0-e351afcf

package/src/deployments.ts

@@ -1,9 +1,21 @@
 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";
 
 type DeploymentDetails = {
 	id: string;
@@ -11,6 +23,7 @@ type DeploymentDetails = {
 	annotations: {
 		"workers/triggered_by": string;
 		"workers/rollback_from": string;
+		"workers/message": string;
 	};
 	metadata: {
 		author_id: string;
@@ -20,8 +33,15 @@ type DeploymentDetails = {
 		modified_on: string;
 	};
 	resources: {
-		script: string;
-		bindings: unknown[];
+		script: {
+			handlers: string[];
+		};
+		bindings: WorkerMetadataBinding[];
+		script_runtime: {
+			compatibility_date: string | undefined;
+			compatibility_flags: string[] | undefined;
+			usage_model: string | undefined;
+		};
 	};
 };
 
@@ -49,11 +69,12 @@ export async function deployments(
 		}
 	);
 
-	const scriptMetadata = await fetchResult<ServiceMetadataRes>(
-		`/accounts/${accountId}/workers/services/${scriptName}`
-	);
+	const scriptTag = (
+		await fetchResult<ServiceMetadataRes>(
+			`/accounts/${accountId}/workers/services/${scriptName}`
+		)
+	).default_environment.script.tag;
 
-	const scriptTag = scriptMetadata.default_environment.script.tag;
 	const params = new URLSearchParams({ order: "asc" });
 	const { items: deploys } = await fetchResult<DeploymentListResult>(
 		`/accounts/${accountId}/workers/deployments/by-script/${scriptTag}`,
@@ -72,12 +93,16 @@ export async function deployments(
 Deployment ID: ${versions.id}
 Created on:    ${versions.metadata.created_on}
 Author:        ${versions.metadata.author_email}
-Trigger:       ${triggerStr}`;
+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`;
 	});
 
@@ -99,7 +124,6 @@ function formatSource(source: string): string {
 			return "Other";
 	}
 }
-
 function formatTrigger(trigger: string): string {
 	switch (trigger) {
 		case "upload":
@@ -114,3 +138,231 @@ function formatTrigger(trigger: string): string {
 			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);
+}

package/src/dev/dev.tsx

@@ -116,6 +116,7 @@ export type DevProps = {
 	initialPort: number;
 	initialIp: string;
 	inspectorPort: number;
+	processEntrypoint: boolean;
 	rules: Config["rules"];
 	accountId: string | undefined;
 	initialMode: "local" | "remote";
@@ -271,6 +272,7 @@ function DevSession(props: DevSessionProps) {
 		entry: props.entry,
 		destination: directory,
 		jsxFactory: props.jsxFactory,
+		processEntrypoint: props.processEntrypoint,
 		rules: props.rules,
 		jsxFragment: props.jsxFragment,
 		serveAssetsFromWorker: Boolean(

package/src/dev/local.tsx

@@ -695,6 +695,7 @@ export function setupMiniflareOptions({
 					durableObjectsPersist: true,
 					kvPersist: true,
 					r2Persist: true,
+					d1Persist: true,
 			  }),
 
 		liveReload,
@@ -792,6 +793,18 @@ export async function buildMiniflare3Logger(): Promise<Miniflare3LogType> {
 	return logLevel === LogLevel.NONE ? new NoOpLog() : new Log(logLevel);
 }
 
+function transformMf2PersistToMf3(persist?: boolean | string) {
+	// Wrangler reuses Miniflare 3 instances between reloads but not Miniflare 2
+	// ones. We previously set `*Persist` options to `true` by default to
+	// persist data between reloads in the temporary script directory (Miniflare
+	// 2's working directory). However, with Miniflare 3, the working directory
+	// is the current working directory, so we want to set these to `false`
+	// and use Miniflare 3's native in-memory persistence.
+	//
+	// See https://github.com/cloudflare/workers-sdk/issues/2995.
+	return persist === true ? false : persist;
+}
+
 export async function transformMf2OptionsToMf3Options({
 	miniflare2Options,
 	format,
@@ -819,8 +832,9 @@ export async function transformMf2OptionsToMf3Options({
 		};
 	}
 
-	const options: Miniflare3Options = {
+	let options: Partial<Miniflare3Options> = {
 		...miniflare2Options,
+
 		// Miniflare 3 distinguishes between binding name and namespace/bucket IDs.
 		kvNamespaces: Object.fromEntries(
 			kvNamespaces?.map(({ binding, id }) => [binding, id]) ?? []
@@ -834,8 +848,17 @@ export async function transformMf2OptionsToMf3Options({
 				preview_database_id ?? database_id,
 			]) ?? []
 		),
+
+		cachePersist: transformMf2PersistToMf3(miniflare2Options.cachePersist),
+		durableObjectsPersist: transformMf2PersistToMf3(
+			miniflare2Options.durableObjectsPersist
+		),
+		kvPersist: transformMf2PersistToMf3(miniflare2Options.kvPersist),
+		r2Persist: transformMf2PersistToMf3(miniflare2Options.r2Persist),
+		d1Persist: transformMf2PersistToMf3(miniflare2Options.d1Persist),
+
 		inspectorPort,
-		verbose: true,
+		verbose: logger.loggerLevel === "debug",
 		cloudflareFetch,
 		log,
 	};
@@ -873,22 +896,27 @@ export async function transformMf2OptionsToMf3Options({
 		const root = path.dirname(bundle.path);
 
 		assert.strictEqual(bundle.type, "esm");
-		// Required for source mapped paths to resolve correctly
-		options.modulesRoot = root;
-		options.modules = [
-			// Entrypoint
-			{
-				type: "ESModule",
-				path: bundle.path,
-				contents: await readFile(bundle.path, "utf-8"),
-			},
-			// Misc (WebAssembly, etc, ...)
-			...bundle.modules.map((module) => ({
-				type: ModuleTypeToRuleType[module.type ?? "esm"],
-				path: path.resolve(root, module.name),
-				contents: module.content,
-			})),
-		];
+		options = {
+			// Creating a new options object ensures types check (Miniflare's
+			// options type requires source code to be specified)
+			...options,
+			// Required for source mapped paths to resolve correctly
+			modulesRoot: root,
+			modules: [
+				// Entrypoint
+				{
+					type: "ESModule",
+					path: bundle.path,
+					contents: await readFile(bundle.path, "utf-8"),
+				},
+				// Misc (WebAssembly, etc, ...)
+				...bundle.modules.map((module) => ({
+					type: ModuleTypeToRuleType[module.type ?? "esm"],
+					path: path.resolve(root, module.name),
+					contents: module.content,
+				})),
+			],
+		};
 	}
 
 	if (kvRemote) {
@@ -906,7 +934,7 @@ export async function transformMf2OptionsToMf3Options({
 		options.kvPersist = `remote:?cache=${encodeURIComponent(kvRemoteCache)}`;
 	}
 
-	return options;
+	return options as Miniflare3Options;
 }
 
 // Caching of the `npx-import`ed `@miniflare/tre` package
@@ -916,5 +944,5 @@ export async function getMiniflare3(): Promise<
 	// eslint-disable-next-line @typescript-eslint/consistent-type-imports
 	typeof import("@miniflare/tre")
 > {
-	return (miniflare3Module ??= await npxImport("@miniflare/tre@3.0.0-next.12"));
+	return (miniflare3Module ??= await npxImport("@miniflare/tre@3.0.0-next.13"));
 }

package/src/dev/start-server.ts

@@ -14,6 +14,7 @@ import {
 import { runCustomBuild } from "../entry";
 import { logger } from "../logger";
 import { waitForPortToBeAvailable } from "../proxy";
+import traverseModuleGraph from "../traverse-module-graph";
 import {
 	setupBindings,
 	getMiniflare3,
@@ -91,6 +92,7 @@ export async function startDevServer(
 			entry: props.entry,
 			destination: directory.name,
 			jsxFactory: props.jsxFactory,
+			processEntrypoint: props.processEntrypoint,
 			rules: props.rules,
 			jsxFragment: props.jsxFragment,
 			serveAssetsFromWorker: Boolean(
@@ -204,6 +206,7 @@ async function runEsbuild({
 	destination,
 	jsxFactory,
 	jsxFragment,
+	processEntrypoint,
 	rules,
 	assets,
 	betaD1Shims,
@@ -226,6 +229,7 @@ async function runEsbuild({
 	destination: string | undefined;
 	jsxFactory: string | undefined;
 	jsxFragment: string | undefined;
+	processEntrypoint: boolean;
 	rules: Config["rules"];
 	assets: Config["assets"];
 	betaD1Shims?: string[];
@@ -246,56 +250,55 @@ async function runEsbuild({
 }): Promise<EsbuildBundle | undefined> {
 	if (!destination) return;
 
-	const {
-		resolvedEntryPointPath,
-		bundleType,
-		modules,
-		dependencies,
-		sourceMapPath,
-	}: Awaited<ReturnType<typeof bundleWorker>> = noBundle
-		? {
-				modules: [],
-				dependencies: {},
-				resolvedEntryPointPath: entry.file,
-				bundleType: entry.format === "modules" ? "esm" : "commonjs",
-				stop: undefined,
-				sourceMapPath: undefined,
-		  }
-		: await bundleWorker(entry, destination, {
-				serveAssetsFromWorker,
-				jsxFactory,
-				jsxFragment,
-				rules,
-				tsconfig,
-				minify,
-				legacyNodeCompat,
-				nodejsCompat,
-				define,
-				checkFetch: true,
-				assets: assets && {
-					...assets,
-					// disable the cache in dev
-					bypassCache: true,
-				},
-				betaD1Shims,
-				workerDefinitions,
-				services,
-				firstPartyWorkerDevFacade,
-				targetConsumer: "dev", // We are starting a dev server
-				testScheduled,
-				local,
-				experimentalLocal,
-				doBindings,
-		  });
+	let traverseModuleGraphResult:
+		| Awaited<ReturnType<typeof bundleWorker>>
+		| undefined;
+	let bundleResult: Awaited<ReturnType<typeof bundleWorker>> | undefined;
+	if (noBundle) {
+		traverseModuleGraphResult = await traverseModuleGraph(entry, rules);
+	}
+
+	if (processEntrypoint || !noBundle) {
+		bundleResult = await bundleWorker(entry, destination, {
+			bundle: !noBundle,
+			disableModuleCollection: noBundle,
+			serveAssetsFromWorker,
+			jsxFactory,
+			jsxFragment,
+			rules,
+			tsconfig,
+			minify,
+			legacyNodeCompat,
+			nodejsCompat,
+			define,
+			checkFetch: true,
+			assets: assets && {
+				...assets,
+				// disable the cache in dev
+				bypassCache: true,
+			},
+			betaD1Shims,
+			workerDefinitions,
+			services,
+			firstPartyWorkerDevFacade,
+			targetConsumer: "dev", // We are starting a dev server
+			testScheduled,
+			local,
+			experimentalLocal,
+			doBindings,
+		});
+	}
 
 	return {
 		id: 0,
 		entry,
-		path: resolvedEntryPointPath,
-		type: bundleType,
-		modules,
-		dependencies,
-		sourceMapPath,
+		path: bundleResult?.resolvedEntryPointPath ?? entry.file,
+		type:
+			bundleResult?.bundleType ??
+			(entry.format === "modules" ? "esm" : "commonjs"),
+		modules: traverseModuleGraphResult?.modules ?? bundleResult?.modules ?? [],
+		dependencies: bundleResult?.dependencies ?? {},
+		sourceMapPath: bundleResult?.sourceMapPath,
 	};
 }