wrangler 2.0.22 → 2.0.25

package/src/pages/upload.tsx

@@ -22,18 +22,16 @@ import {
 	BULK_UPLOAD_CONCURRENCY,
 	MAX_BUCKET_FILE_COUNT,
 	MAX_BUCKET_SIZE,
+	MAX_CHECK_MISSING_ATTEMPTS,
 	MAX_UPLOAD_ATTEMPTS,
 } from "./constants";
 import { pagesBetaWarning } from "./utils";
-import type { UploadPayloadFile } from "./types";
-import type { ArgumentsCamelCase, Argv } from "yargs";
+import type { UploadPayloadFile, YargsOptionsToInterface } from "./types";
+import type { Argv } from "yargs";
 
-type UploadArgs = {
-	directory: string;
-	"output-manifest-path"?: string;
-};
+type UploadArgs = YargsOptionsToInterface<typeof Options>;
 
-export function Options(yargs: Argv): Argv<UploadArgs> {
+export function Options(yargs: Argv) {
 	return yargs
 		.positional("directory", {
 			type: "string",
@@ -52,7 +50,7 @@ export function Options(yargs: Argv): Argv<UploadArgs> {
 export const Handler = async ({
 	directory,
 	outputManifestPath,
-}: ArgumentsCamelCase<UploadArgs>) => {
+}: UploadArgs) => {
 	if (!directory) {
 		throw new FatalError("Must specify a directory.", 1);
 	}
@@ -105,6 +103,7 @@ export const upload = async (
 		"_worker.js",
 		"_redirects",
 		"_headers",
+		"_routes.json",
 		".DS_Store",
 		"node_modules",
 		".git",
@@ -190,19 +189,37 @@ export const upload = async (
 
 	const start = Date.now();
 
-	const missingHashes = await fetchResult<string[]>(
-		`/pages/assets/check-missing`,
-		{
-			method: "POST",
-			headers: {
-				"Content-Type": "application/json",
-				Authorization: `Bearer ${jwt}`,
-			},
-			body: JSON.stringify({
-				hashes: files.map(({ hash }) => hash),
-			}),
+	let attempts = 0;
+	const getMissingHashes = async (): Promise<string[]> => {
+		try {
+			return await fetchResult<string[]>(`/pages/assets/check-missing`, {
+				method: "POST",
+				headers: {
+					"Content-Type": "application/json",
+					Authorization: `Bearer ${jwt}`,
+				},
+				body: JSON.stringify({
+					hashes: files.map(({ hash }) => hash),
+				}),
+			});
+		} catch (e) {
+			if (attempts < MAX_CHECK_MISSING_ATTEMPTS) {
+				// Exponential backoff, 1 second first time, then 2 second, then 4 second etc.
+				await new Promise((resolvePromise) =>
+					setTimeout(resolvePromise, Math.pow(2, attempts++) * 1000)
+				);
+
+				if ((e as { code: number }).code === 8000013) {
+					// Looks like the JWT expired, fetch another one
+					jwt = await fetchJwt();
+				}
+				return getMissingHashes();
+			} else {
+				throw e;
+			}
 		}
-	);
+	};
+	const missingHashes = await getMissingHashes();
 
 	const sortedFiles = files
 		.filter((file) => missingHashes.includes(file.hash))
@@ -256,7 +273,7 @@ export const upload = async (
 		// Don't upload empty buckets (can happen for tiny projects)
 		if (bucket.files.length === 0) continue;
 
-		let attempts = 0;
+		attempts = 0;
 		const doUpload = async (): Promise<void> => {
 			// Populate the payload only when actually uploading (this is limited to 3 concurrent uploads at 50 MiB per bucket meaning we'd only load in a max of ~150 MiB)
 			// This is so we don't run out of memory trying to upload the files.

package/src/publish.ts

@@ -11,6 +11,7 @@ import { createWorkerUploadForm } from "./create-worker-upload-form";
 import { confirm } from "./dialogs";
 import { getMigrationsToUpload } from "./durable";
 import { logger } from "./logger";
+import { getMetricsUsageHeaders } from "./metrics";
 import { ParseError } from "./parse";
 import { syncAssets } from "./sites";
 import { getZoneForRoute } from "./zones";
@@ -51,6 +52,27 @@ type Props = {
 
 type RouteObject = ZoneIdRoute | ZoneNameRoute | CustomDomainRoute;
 
+export type CustomDomain = {
+	id: string;
+	zone_id: string;
+	zone_name: string;
+	hostname: string;
+	service: string;
+	environment: string;
+};
+type UpdatedCustomDomain = CustomDomain & { modified: boolean };
+type ConflictingCustomDomain = CustomDomain & {
+	external_dns_record_id?: string;
+	external_cert_id?: string;
+};
+
+export type CustomDomainChangeset = {
+	added: CustomDomain[];
+	removed: CustomDomain[];
+	updated: UpdatedCustomDomain[];
+	conflicting: ConflictingCustomDomain[];
+};
+
 function sleep(ms: number) {
 	return new Promise((resolve) => setTimeout(resolve, ms));
 }
@@ -79,58 +101,27 @@ function renderRoute(route: Route): string {
 	return result;
 }
 
-// this function takes a string with quotes in it
-// (i.e. `hello "world", if that really is your name`)
-// and peels out the first instance of a substring
-// bounded by quotes (so, in the example above, `world`)
-//
-// this is useful because the /domains api will return
-// which domains conflicted in an error message, bounded
-// by a string, which we can use to provide helpful
-// messages to a user
-function getQuoteBoundedSubstring(content: string) {
-	const matches = content.split('"');
-	return matches[1] ?? "";
-}
-
-function isOriginConflictError(
-	e: unknown
-): e is { code: 100116; message: string; notes: Array<{ text: string }> } {
-	return (
-		typeof e === "object" &&
-		e !== null &&
-		(e as { code: number }).code === 100116
-	);
-}
-
-function isDNSConflictError(
-	e: unknown
-): e is { code: 100117; message: string; notes: Array<{ text: string }> } {
-	return (
-		typeof e === "object" &&
-		e !== null &&
-		(e as { code: number }).code === 100117
-	);
-}
-
-// empty error class to throw and then explicitly catch via `instanceof`
-class CustomDomainOverrideRejected extends Error {}
-
 // publishing to custom domains involves a few more steps than just updating
 // the routing table, and thus the api implementing it is fairly defensive -
 // it will error eagerly on conflicts against existing domains or existing
 // managed DNS records
-//
-// however, you can pass params to override the errors. we start on the
-// defensive path, and if one of these errors occur, we prompt the user
-// for confirmation that they do indeed want to override the conflicts, and
-// then retry the request with the right override added
+
+// however, you can pass params to override the errors. to know if we should
+// override the current state, we generate a "changeset" of required actions
+// to get to the state we want (specified by the list of custom domains). the
+// changeset returns an "updated" collection (existing custom domains
+// connected to other scripts) and a "conflicting" collection (the requested
+// custom domains that have a managed, conflicting DNS record preventing the
+// host's use as a custom domain). with this information, we can prompt to
+// the user what will occur if we create the custom domains requested, and
+// add the override param if they confirm the action
 //
 // if a user does not confirm that they want to override, we skip publishing
 // to these custom domains, but continue on through the rest of the
 // publish stage
-function publishCustomDomains(
+async function publishCustomDomains(
 	workerUrl: string,
+	accountId: string,
 	domains: Array<RouteObject>
 ): Promise<string[]> {
 	const config = {
@@ -146,79 +137,81 @@ function publishCustomDomains(
 		};
 	});
 
+	const fail = () => {
+		return [
+			domains.length > 1
+				? `Publishing to ${domains.length} Custom Domains was skipped, fix conflicts and try again`
+				: `Publishing to Custom Domain "${domains[0].pattern}" was skipped, fix conflict and try again`,
+		];
+	};
+
 	if (!process.stdout.isTTY) {
 		// running in non-interactive mode.
 		// existing origins / dns records are not indicative of errors,
 		// so we aggressively update rather than aggressively fail
 		config.override_existing_origin = true;
 		config.override_existing_dns_record = true;
+	} else {
+		// get a changeset for operations required to achieve a state with the requested domains
+		const changeset = await fetchResult<CustomDomainChangeset>(
+			`${workerUrl}/domains/changeset?replace_state=true`,
+			{
+				method: "POST",
+				body: JSON.stringify(origins),
+				headers: {
+					"Content-Type": "application/json",
+				},
+			}
+		);
+
+		const updatesRequired = changeset.updated.filter(
+			(domain) => domain.modified
+		);
+		if (updatesRequired.length > 0) {
+			// find out which scripts the conflict domains are already attached to
+			// so we can provide that in the confirmation prompt
+			const existing = await Promise.all(
+				updatesRequired.map((domain) =>
+					fetchResult<CustomDomain>(
+						`/accounts/${accountId}/workers/domains/records/${domain.id}`
+					)
+				)
+			);
+			const existingRendered = existing
+				.map(
+					(domain) =>
+						`\t• ${domain.hostname} (used as a domain for "${domain.service}")`
+				)
+				.join("\n");
+			const message = `Custom Domains already exist for these domains:
+${existingRendered}
+Update them to point to this script instead?`;
+			if (!(await confirm(message))) return fail();
+			config.override_existing_origin = true;
+		}
+
+		if (changeset.conflicting.length > 0) {
+			const conflicitingRendered = changeset.conflicting
+				.map((domain) => `\t• ${domain.hostname}`)
+				.join("\n");
+			const message = `You already have DNS records that conflict for these Custom Domains:
+${conflicitingRendered}
+Update them to point to this script instead?`;
+			if (!(await confirm(message))) return fail();
+			config.override_existing_dns_record = true;
+		}
 	}
 
-	// Mixing promise chains with async/await is funky, but it allows us to keep related
-	// logic synchronous-looking (i.e. prompting for confirmation and then re-requesting)
-	// while retaining the flexibility of promise chain fall-throughs. We can group error
-	// handling logic in dedicated catch calls, and all we have to do is re-throw an
-	// error and it will pass down to the next catch call
-	return fetchResult(`${workerUrl}/domains`, {
+	// publish to domains
+	await fetchResult(`${workerUrl}/domains/records`, {
 		method: "PUT",
 		body: JSON.stringify({ ...config, origins }),
 		headers: {
 			"Content-Type": "application/json",
 		},
-	})
-		.catch(async (err) => {
-			if (isOriginConflictError(err)) {
-				const conflictingOrigins = getQuoteBoundedSubstring(err.notes[0].text);
-				const shouldContinue = await confirm(
-					`Custom Domains already exist for these domains: "${conflictingOrigins}"\nUpdate them to point to this script instead?`
-				);
-				if (!shouldContinue) {
-					throw new CustomDomainOverrideRejected();
-				}
-				config.override_existing_origin = true;
-				await fetchResult(`${workerUrl}/domains`, {
-					method: "PUT",
-					body: JSON.stringify({ ...config, origins }),
-					headers: {
-						"Content-Type": "application/json",
-					},
-				});
-			} else {
-				throw err;
-			}
-		})
-		.catch(async (err) => {
-			if (isDNSConflictError(err)) {
-				const conflictingOrigins = getQuoteBoundedSubstring(err.notes[0].text);
-				const shouldContinue = await confirm(
-					`You already have conflicting DNS records for these domains: "${conflictingOrigins}"\nUpdate them to point to this script instead?`
-				);
-				if (!shouldContinue) {
-					throw new CustomDomainOverrideRejected();
-				}
-				config.override_existing_dns_record = true;
-				await fetchResult(`${workerUrl}/domains`, {
-					method: "PUT",
-					body: JSON.stringify({ ...config, origins }),
-					headers: {
-						"Content-Type": "application/json",
-					},
-				});
-			} else {
-				throw err;
-			}
-		})
-		.then(() => domains.map((domain) => renderRoute(domain)))
-		.catch((err) => {
-			if (err instanceof CustomDomainOverrideRejected) {
-				return [
-					domains.length > 1
-						? `Publishing to ${domains.length} Custom Domains was skipped, fix conflicts and try again`
-						: `Publishing to Custom Domain "${domains[0].pattern}" was skipped, fix conflict and try again`,
-				];
-			}
-			throw err;
-		});
+	});
+
+	return domains.map((domain) => renderRoute(domain));
 }
 
 export default async function publish(props: Props): Promise<void> {
@@ -276,6 +269,19 @@ See https://developers.cloudflare.com/workers/platform/compatibility-dates for m
 		);
 	}
 
+	// Warn if user tries minify or node-compat with no-bundle
+	if (props.noBundle && minify) {
+		logger.warn(
+			"`--minify` and `--no-bundle` can't be used together. If you want to minify your Worker and disable Wrangler's bundling, please minify as part of your own bundling process."
+		);
+	}
+
+	if (props.noBundle && nodeCompat) {
+		logger.warn(
+			"`--node-compat` and `--no-bundle` can't be used together. If you want to polyfill Node.js built-ins and disable Wrangler's bundling, please polyfill as part of your own bundling process."
+		);
+	}
+
 	const scriptName = props.name;
 	assert(
 		scriptName,
@@ -378,6 +384,17 @@ See https://developers.cloudflare.com/workers/platform/compatibility-dates for m
 						nodeCompat,
 						define: config.define,
 						checkFetch: false,
+						assets: config.assets && {
+							...config.assets,
+							// enable the cache when publishing
+							bypassCache: false,
+						},
+						services: config.services,
+						// We don't set workerDefinitions here,
+						// because we don't want to apply the dev-time
+						// facades on top of it
+						workerDefinitions: undefined,
+						firstPartyWorkerDevFacade: false,
 					}
 			  );
 
@@ -427,6 +444,7 @@ See https://developers.cloudflare.com/workers/platform/compatibility-dates for m
 			r2_buckets: config.r2_buckets,
 			services: config.services,
 			worker_namespaces: config.worker_namespaces,
+			logfwdr: config.logfwdr,
 			unsafe: config.unsafe?.bindings,
 		};
 
@@ -479,6 +497,7 @@ See https://developers.cloudflare.com/workers/platform/compatibility-dates for m
 				{
 					method: "PUT",
 					body: createWorkerUploadForm(worker),
+					headers: await getMetricsUsageHeaders(config.send_metrics),
 				},
 				new URLSearchParams({
 					include_subdomain_availability: "true",
@@ -490,13 +509,15 @@ See https://developers.cloudflare.com/workers/platform/compatibility-dates for m
 
 			available_on_subdomain = result.available_on_subdomain;
 
-			// Print some useful information returned after publishing
-			// Not all fields will be populated for every worker
-			// These fields are likely to be scraped by tools, so do not rename
-			if (result.id) logger.log("Worker ID: ", result.id);
-			if (result.etag) logger.log("Worker ETag: ", result.etag);
-			if (result.pipeline_hash)
-				logger.log("Worker PipelineHash: ", result.pipeline_hash);
+			if (config.first_party_worker) {
+				// Print some useful information returned after publishing
+				// Not all fields will be populated for every worker
+				// These fields are likely to be scraped by tools, so do not rename
+				if (result.id) logger.log("Worker ID: ", result.id);
+				if (result.etag) logger.log("Worker ETag: ", result.etag);
+				if (result.pipeline_hash)
+					logger.log("Worker PipelineHash: ", result.pipeline_hash);
+			}
 		}
 	} finally {
 		if (typeof destination !== "string") {
@@ -577,7 +598,9 @@ See https://developers.cloudflare.com/workers/platform/compatibility-dates for m
 
 	// Update custom domains for the script
 	if (customDomainsOnly.length > 0) {
-		deployments.push(publishCustomDomains(workerUrl, customDomainsOnly));
+		deployments.push(
+			publishCustomDomains(workerUrl, accountId, customDomainsOnly)
+		);
 	}
 
 	// Configure any schedules for the script.
@@ -601,7 +624,11 @@ See https://developers.cloudflare.com/workers/platform/compatibility-dates for m
 	if (deployments.length > 0) {
 		logger.log("Published", workerName, formatTime(deployMs));
 		for (const target of targets.flat()) {
-			logger.log(" ", target);
+			// Append protocol only on workers.dev domains
+			logger.log(
+				" ",
+				(target.endsWith("workers.dev") ? "https://" : "") + target
+			);
 		}
 	} else {
 		logger.log("No publish targets for", workerName, formatTime(deployMs));

package/src/r2.ts

@@ -1,4 +1,7 @@
+import { Readable } from "node:stream";
 import { fetchResult } from "./cfetch";
+import { fetchR2Objects } from "./cfetch/internal";
+import type { HeadersInit } from "undici";
 
 /**
  * Information about a bucket, returned from `listR2Buckets()`.
@@ -48,3 +51,81 @@ export async function deleteR2Bucket(
 		{ method: "DELETE" }
 	);
 }
+
+export function bucketAndKeyFromObjectPath(objectPath = ""): {
+	bucket: string;
+	key: string;
+} {
+	const match = /^([^/]+)\/(.*)/.exec(objectPath);
+	if (match === null) {
+		throw new Error(
+			`The object path must be in the form of {bucket}/{key} you provided ${objectPath}`
+		);
+	}
+
+	return { bucket: match[1], key: match[2] };
+}
+
+/**
+ * Downloads an object
+ */
+export async function getR2Object(
+	accountId: string,
+	bucketName: string,
+	objectName: string
+): Promise<Readable> {
+	const response = await fetchR2Objects(
+		`/accounts/${accountId}/r2/buckets/${bucketName}/objects/${objectName}`,
+		{ method: "GET" }
+	);
+
+	return Readable.from(response.body);
+}
+
+/**
+ * Uploads an object
+ */
+export async function putR2Object(
+	accountId: string,
+	bucketName: string,
+	objectName: string,
+	object: Readable | Buffer,
+	options: Record<string, unknown>
+): Promise<void> {
+	const headerKeys = [
+		"content-length",
+		"content-type",
+		"content-disposition",
+		"content-encoding",
+		"content-language",
+		"cache-control",
+		"expires",
+	];
+	const headers: HeadersInit = {};
+	for (const key of headerKeys) {
+		const value = options[key] || "";
+		if (value && typeof value === "string") headers[key] = value;
+	}
+
+	await fetchR2Objects(
+		`/accounts/${accountId}/r2/buckets/${bucketName}/objects/${objectName}`,
+		{
+			body: object,
+			headers,
+			method: "PUT",
+		}
+	);
+}
+/**
+ * Delete an Object
+ */
+export async function deleteR2Object(
+	accountId: string,
+	bucketName: string,
+	objectName: string
+): Promise<void> {
+	await fetchR2Objects(
+		`/accounts/${accountId}/r2/buckets/${bucketName}/objects/${objectName}`,
+		{ method: "DELETE" }
+	);
+}

package/src/tail/index.ts

@@ -174,12 +174,12 @@ export type TailEventMessage = {
 	/**
 	 * The event that triggered the worker. In the case of an HTTP request,
 	 * this will be a RequestEvent. If it's a cron trigger, it'll be a
-	 * ScheduledEvent.
+	 * ScheduledEvent. If it's a durable object alarm, it's an AlarmEvent.
 	 *
 	 * Until workers-types exposes individual types for export, we'll have
 	 * to just re-define these types ourselves.
 	 */
-	event: RequestEvent | ScheduledEvent | undefined | null;
+	event: RequestEvent | ScheduledEvent | AlarmEvent | undefined | null;
 };
 
 /**
@@ -297,3 +297,16 @@ export type ScheduledEvent = {
 	 */
 	scheduledTime: number;
 };
+
+/**
+ * A event that was triggered from a durable object alarm
+ */
+export type AlarmEvent = {
+	/**
+	 * The datetime the alarm was scheduled for.
+	 *
+	 * This is sent as an ISO timestamp string (different than ScheduledEvent.scheduledTime),
+	 * you should parse it later on on your own.
+	 */
+	scheduledTime: string;
+};

package/src/tail/printing.ts

@@ -1,6 +1,11 @@
 import { logger } from "../logger";
-import type { RequestEvent, ScheduledEvent, TailEventMessage } from ".";
 import type { Outcome } from "./filters";
+import type {
+	AlarmEvent,
+	RequestEvent,
+	ScheduledEvent,
+	TailEventMessage,
+} from "./index";
 import type WebSocket from "ws";
 
 export function prettyPrintLogs(data: WebSocket.RawData): void {
@@ -14,7 +19,7 @@ export function prettyPrintLogs(data: WebSocket.RawData): void {
 		const outcome = prettifyOutcome(eventMessage.outcome);
 
 		logger.log(`"${cronPattern}" @ ${datetime} - ${outcome}`);
-	} else {
+	} else if (isRequestEvent(eventMessage.event)) {
 		const requestMethod = eventMessage.event?.request.method.toUpperCase();
 		const url = eventMessage.event?.request.url;
 		const outcome = prettifyOutcome(eventMessage.outcome);
@@ -25,6 +30,19 @@ export function prettyPrintLogs(data: WebSocket.RawData): void {
 				? `${requestMethod} ${url} - ${outcome} @ ${datetime}`
 				: `[missing request] - ${outcome} @ ${datetime}`
 		);
+	} else if (isAlarmEvent(eventMessage.event)) {
+		const outcome = prettifyOutcome(eventMessage.outcome);
+		const datetime = new Date(
+			eventMessage.event.scheduledTime
+		).toLocaleString();
+
+		logger.log(`Alarm @ ${datetime} - ${outcome}`);
+	} else {
+		// Unknown event type
+		const outcome = prettifyOutcome(eventMessage.outcome);
+		const datetime = new Date(eventMessage.eventTimestamp).toLocaleString();
+
+		logger.log(`Unknown Event - ${outcome} @ ${datetime}`);
 	}
 
 	if (eventMessage.logs.length > 0) {
@@ -44,12 +62,32 @@ export function jsonPrintLogs(data: WebSocket.RawData): void {
 	console.log(JSON.stringify(JSON.parse(data.toString()), null, 2));
 }
 
+function isRequestEvent(
+	event: TailEventMessage["event"]
+): event is RequestEvent {
+	return Boolean(event && "request" in event);
+}
+
 function isScheduledEvent(
-	event: RequestEvent | ScheduledEvent | undefined | null
+	event: TailEventMessage["event"]
 ): event is ScheduledEvent {
 	return Boolean(event && "cron" in event);
 }
 
+/**
+ * Check to see if an event sent from a worker is an AlarmEvent.
+ *
+ * Because the only property on `AlarmEvent` is "scheduledTime", which it
+ * shares with `ScheduledEvent`, `isAlarmEvent` checks if there's _not_
+ * a "cron" property in `event` to confirm it's an alarm event.
+ *
+ * @param event An event
+ * @returns true if the event is an AlarmEvent
+ */
+function isAlarmEvent(event: TailEventMessage["event"]): event is AlarmEvent {
+	return Boolean(event && "scheduledTime" in event && !("cron" in event));
+}
+
 function prettifyOutcome(outcome: Outcome): string {
 	switch (outcome) {
 		case "ok":

package/src/user/choose-account.tsx

@@ -44,17 +44,26 @@ export async function getAccountChoices(): Promise<ChooseAccountItem[]> {
 	if (accountIdFromEnv) {
 		return [{ id: accountIdFromEnv, name: "" }];
 	} else {
-		const response = await fetchListResult<{
-			account: ChooseAccountItem;
-		}>(`/memberships`);
-		const accounts = response.map((r) => r.account);
-		if (accounts.length === 0) {
-			throw new Error(
-				"Failed to automatically retrieve account IDs for the logged in user.\n" +
-					"In a non-interactive environment, it is mandatory to specify an account ID, either by assigning its value to CLOUDFLARE_ACCOUNT_ID, or as `account_id` in your `wrangler.toml` file."
-			);
-		} else {
-			return accounts;
+		try {
+			const response = await fetchListResult<{
+				account: ChooseAccountItem;
+			}>(`/memberships`);
+			const accounts = response.map((r) => r.account);
+			if (accounts.length === 0) {
+				throw new Error(
+					"Failed to automatically retrieve account IDs for the logged in user.\n" +
+						"In a non-interactive environment, it is mandatory to specify an account ID, either by assigning its value to CLOUDFLARE_ACCOUNT_ID, or as `account_id` in your `wrangler.toml` file."
+				);
+			} else {
+				return accounts;
+			}
+		} catch (err) {
+			if ((err as { code: number }).code === 9109) {
+				throw new Error(
+					`Failed to automatically retrieve account IDs for the logged in user.
+You may have incorrect permissions on your API token. You can skip this account check by adding an \`account_id\` in your \`wrangler.toml\`, or by setting the value of CLOUDFLARE_ACCOUNT_ID"`
+				);
+			} else throw err;
 		}
 	}
 }