wrangler 0.0.0-e178d6fb → 0.0.0-e1c2f5b9

package/src/{publish.ts → publish/publish.ts}

@@ -2,28 +2,39 @@ import assert from "node:assert";
 import { mkdirSync, readFileSync, writeFileSync } from "node:fs";
 import path from "node:path";
 import { URLSearchParams } from "node:url";
+import chalk from "chalk";
 import tmp from "tmp-promise";
-import { bundleWorker } from "./bundle";
-import { printBundleSize } from "./bundle-reporter";
-import { fetchListResult, fetchResult } from "./cfetch";
-import { printBindings } from "./config";
-import { createWorkerUploadForm } from "./create-worker-upload-form";
-import { confirm } from "./dialogs";
-import { getMigrationsToUpload } from "./durable";
-import { logger } from "./logger";
-import { ParseError } from "./parse";
-import { syncAssets } from "./sites";
-import { getZoneForRoute } from "./zones";
-import type { Config } from "./config";
+import { bundleWorker } from "../bundle";
+import {
+	printBundleSize,
+	printOffendingDependencies,
+} from "../bundle-reporter";
+import { fetchListResult, fetchResult } from "../cfetch";
+import { printBindings } from "../config";
+import { createWorkerUploadForm } from "../create-worker-upload-form";
+import { confirm, fromDashMessagePrompt } from "../dialogs";
+import { getMigrationsToUpload } from "../durable";
+import { logger } from "../logger";
+import { getMetricsUsageHeaders } from "../metrics";
+import { ParseError } from "../parse";
+import { getQueue, putConsumer } from "../queues/client";
+import { getWorkersDevSubdomain } from "../routes";
+import { syncAssets } from "../sites";
+import { identifyD1BindingsAsBeta } from "../worker";
+import { getZoneForRoute } from "../zones";
+import type { FetchError } from "../cfetch";
+import type { Config } from "../config";
 import type {
 	Route,
 	ZoneIdRoute,
 	ZoneNameRoute,
 	CustomDomainRoute,
-} from "./config/environment";
-import type { Entry } from "./entry";
-import type { AssetPaths } from "./sites";
-import type { CfWorkerInit } from "./worker";
+} from "../config/environment";
+import type { DeploymentListRes } from "../deployments";
+import type { Entry } from "../entry";
+import type { PutConsumerBody } from "../queues/client";
+import type { AssetPaths } from "../sites";
+import type { CfWorkerInit } from "../worker";
 
 type Props = {
 	config: Config;
@@ -35,6 +46,8 @@ type Props = {
 	compatibilityDate: string | undefined;
 	compatibilityFlags: string[] | undefined;
 	assetPaths: AssetPaths | undefined;
+	vars: Record<string, string> | undefined;
+	defines: Record<string, string> | undefined;
 	triggers: string[] | undefined;
 	routes: string[] | undefined;
 	legacyEnv: boolean | undefined;
@@ -47,14 +60,64 @@ type Props = {
 	outDir: string | undefined;
 	dryRun: boolean | undefined;
 	noBundle: boolean | undefined;
+	keepVars: boolean | undefined;
+	logpush: boolean | undefined;
 };
 
 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));
 }
 
+const scriptStartupErrorRegex = /startup/i;
+
+function errIsScriptSizeOrStartupErr(err: unknown) {
+	if (!err) return false;
+
+	// 10027 = workers.api.error.script_too_large
+	if ((err as { code: number }).code === 10027) {
+		return true;
+	}
+
+	// 10021 = validation error
+	// no explicit error code for more granular errors than "invalid script"
+	// but the error will contain a string error message directly from the
+	// validator.
+	// the error always SHOULD look like "Script startup exceeded CPU limit."
+	// (or the less likely "Script startup exceeded memory limits.")
+	if (
+		(err as { code: number }).code === 10021 &&
+		err instanceof ParseError &&
+		scriptStartupErrorRegex.test(err.notes[0]?.text)
+	) {
+		return true;
+	}
+
+	return false;
+}
+
 function renderRoute(route: Route): string {
 	let result = "";
 	if (typeof route === "string") {
@@ -79,58 +142,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,88 +178,117 @@ 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> {
 	// TODO: warn if git/hg has uncommitted changes
-	const { config, accountId } = props;
+	const { config, accountId, name } = props;
+	if (accountId && name) {
+		try {
+			const serviceMetaData = await fetchResult(
+				`/accounts/${accountId}/workers/services/${name}`
+			);
+			const { default_environment } = serviceMetaData as {
+				default_environment: {
+					script: { last_deployed_from: "dash" | "wrangler" | "api" };
+				};
+			};
+
+			if (
+				(await fromDashMessagePrompt(
+					default_environment.script.last_deployed_from
+				)) === false
+			)
+				return;
+		} catch (e) {
+			// code: 10090, message: workers.api.error.service_not_found
+			// is thrown from the above fetchResult on the first publish of a Worker
+			if ((e as { code?: number }).code !== 10090) {
+				logger.error(e);
+			}
+		}
+	}
 
 	if (!(props.compatibilityDate || config.compatibility_date)) {
 		const compatibilityDateStr = `${new Date().getFullYear()}-${(
-			new Date().getMonth() + ""
+			new Date().getMonth() +
+			1 +
+			""
 		).padStart(2, "0")}-${(new Date().getDate() + "").padStart(2, "0")}`;
 
 		throw new Error(`A compatibility_date is required when publishing. Add the following to your wrangler.toml file:.
@@ -266,6 +327,7 @@ See https://developers.cloudflare.com/workers/platform/compatibility-dates for m
 
 	const jsxFactory = props.jsxFactory || config.jsx_factory;
 	const jsxFragment = props.jsxFragment || config.jsx_fragment;
+	const keepVars = props.keepVars ?? config.keep_vars;
 
 	const minify = props.minify ?? config.minify;
 
@@ -322,7 +384,8 @@ See https://developers.cloudflare.com/workers/platform/compatibility-dates for m
 		? `/accounts/${accountId}/workers/services/${scriptName}/environments/${envName}`
 		: `/accounts/${accountId}/workers/scripts/${scriptName}`;
 
-	let available_on_subdomain; // we'll set this later
+	let available_on_subdomain: boolean | undefined = undefined; // we'll set this later
+	let scriptTag: string | null = null;
 
 	const { format } = props.entry;
 
@@ -365,14 +428,29 @@ See https://developers.cloudflare.com/workers/platform/compatibility-dates for m
 			);
 		}
 
+		// If we are using d1 bindings, and are not bundling the worker
+		// we should error here as the d1 shim won't be added
+		const betaD1Shims = identifyD1BindingsAsBeta(config.d1_databases);
+		if (
+			Array.isArray(betaD1Shims) &&
+			betaD1Shims.length > 0 &&
+			props.noBundle
+		) {
+			throw new Error(
+				"While in beta, you cannot use D1 bindings without bundling your worker. Please remove `no_bundle` from your wrangler.toml file or remove the `--no-bundle` flag to access D1 bindings."
+			);
+		}
+
 		const {
 			modules,
+			dependencies,
 			resolvedEntryPointPath,
 			bundleType,
 		}: Awaited<ReturnType<typeof bundleWorker>> = props.noBundle
 			? // we can skip the whole bundling step and mock a bundle here
 			  {
 					modules: [],
+					dependencies: {},
 					resolvedEntryPointPath: props.entry.file,
 					bundleType: props.entry.format === "modules" ? "esm" : "commonjs",
 					stop: undefined,
@@ -383,14 +461,33 @@ See https://developers.cloudflare.com/workers/platform/compatibility-dates for m
 					{
 						serveAssetsFromWorker:
 							!props.isWorkersSite && Boolean(props.assetPaths),
+						betaD1Shims: identifyD1BindingsAsBeta(config.d1_databases)?.map(
+							(db) => db.binding
+						),
 						jsxFactory,
 						jsxFragment,
 						rules: props.rules,
 						tsconfig: props.tsconfig ?? config.tsconfig,
 						minify,
 						nodeCompat,
-						define: config.define,
+						define: { ...config.define, ...props.defines },
 						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,
+						// We want to know if the build is for development or publishing
+						// This could potentially cause issues as we no longer have identical behaviour between dev and publish?
+						targetConsumer: "publish",
+						local: false,
+						experimentalLocal: false,
 					}
 			  );
 
@@ -426,7 +523,7 @@ See https://developers.cloudflare.com/workers/platform/compatibility-dates for m
 					? { binding: "__STATIC_CONTENT", id: assets.namespace }
 					: []
 			),
-			vars: config.vars,
+			vars: { ...config.vars, ...props.vars },
 			wasm_modules: config.wasm_modules,
 			text_blobs: {
 				...config.text_blobs,
@@ -437,9 +534,15 @@ See https://developers.cloudflare.com/workers/platform/compatibility-dates for m
 			},
 			data_blobs: config.data_blobs,
 			durable_objects: config.durable_objects,
+			queues: config.queues.producers?.map((producer) => {
+				return { binding: producer.binding, queue_name: producer.queue };
+			}),
 			r2_buckets: config.r2_buckets,
+			d1_databases: identifyD1BindingsAsBeta(config.d1_databases),
 			services: config.services,
-			worker_namespaces: config.worker_namespaces,
+			analytics_engine_datasets: config.analytics_engine_datasets,
+			dispatch_namespaces: config.dispatch_namespaces,
+			logfwdr: config.logfwdr,
 			unsafe: config.unsafe?.bindings,
 		};
 
@@ -465,51 +568,83 @@ See https://developers.cloudflare.com/workers/platform/compatibility-dates for m
 			compatibility_flags:
 				props.compatibilityFlags ?? config.compatibility_flags,
 			usage_model: config.usage_model,
+			keepVars,
+			logpush: props.logpush !== undefined ? props.logpush : config.logpush,
 		};
 
-		void printBundleSize(
+		// As this is not deterministic for testing, we detect if in a jest environment and run asynchronously
+		// We do not care about the timing outside of testing
+		const bundleSizePromise = printBundleSize(
 			{ name: path.basename(resolvedEntryPointPath), content: content },
 			modules
 		);
+		if (process.env.JEST_WORKER_ID !== undefined) await bundleSizePromise;
+		else void bundleSizePromise;
 
 		const withoutStaticAssets = {
 			...bindings,
 			kv_namespaces: config.kv_namespaces,
 			text_blobs: config.text_blobs,
 		};
-		printBindings(withoutStaticAssets);
+
+		// mask anything that was overridden in cli args
+		// so that we don't log potential secrets into the terminal
+		const maskedVars = { ...withoutStaticAssets.vars };
+		for (const key of Object.keys(maskedVars)) {
+			if (maskedVars[key] !== config.vars[key]) {
+				// This means it was overridden in cli args
+				// so let's mask it
+				maskedVars[key] = "(hidden)";
+			}
+		}
+
+		printBindings({ ...withoutStaticAssets, vars: maskedVars });
+
+		await ensureQueuesExist(config);
 
 		if (!props.dryRun) {
 			// Upload the script so it has time to propagate.
 			// We can also now tell whether available_on_subdomain is set
-			const result = await fetchResult<{
-				available_on_subdomain: boolean;
-				id: string | null;
-				etag: string | null;
-				pipeline_hash: string | null;
-			}>(
-				workerUrl,
-				{
-					method: "PUT",
-					body: createWorkerUploadForm(worker),
-				},
-				new URLSearchParams({
-					include_subdomain_availability: "true",
-					// pass excludeScript so the whole body of the
-					// script doesn't get included in the response
-					excludeScript: "true",
-				})
-			);
-
-			available_on_subdomain = result.available_on_subdomain;
+			try {
+				const result = await fetchResult<{
+					available_on_subdomain: boolean;
+					id: string | null;
+					etag: string | null;
+					pipeline_hash: string | null;
+					tag: string | null;
+				}>(
+					workerUrl,
+					{
+						method: "PUT",
+						body: createWorkerUploadForm(worker),
+						headers: await getMetricsUsageHeaders(config.send_metrics),
+					},
+					new URLSearchParams({
+						include_subdomain_availability: "true",
+						// pass excludeScript so the whole body of the
+						// script doesn't get included in the response
+						excludeScript: "true",
+					})
+				);
 
-			// 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);
+				available_on_subdomain = result.available_on_subdomain;
+				scriptTag = result.tag;
+
+				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);
+				}
+			} catch (err) {
+				if (errIsScriptSizeOrStartupErr(err)) {
+					printOffendingDependencies(dependencies);
+				}
+				throw err;
+			}
 		}
 	} finally {
 		if (typeof destination !== "string") {
@@ -530,7 +665,7 @@ See https://developers.cloudflare.com/workers/platform/compatibility-dates for m
 
 	if (deployToWorkersDev) {
 		// Deploy to a subdomain of `workers.dev`
-		const userSubdomain = await getSubdomain(accountId);
+		const userSubdomain = await getWorkersDevSubdomain(accountId);
 		const scriptURL =
 			props.legacyEnv || !props.env
 				? `${scriptName}.${userSubdomain}.workers.dev`
@@ -568,6 +703,61 @@ See https://developers.cloudflare.com/workers/platform/compatibility-dates for m
 					"Content-Type": "application/json",
 				},
 			});
+		} else if (routes.length !== 0) {
+			// if you get to this point it's because
+			// you're trying to deploy a worker to a custom
+			// domain that's already bound to another worker.
+			// so this thing is about finding workers that have
+			// bindings to the routes you're trying to deploy to.
+			//
+			// the logic is kinda similar (read: duplicated) from publishRoutesFallback,
+			// except here we know we have a good API token or whatever so we don't need
+			// to bother with all the error handling tomfoolery.
+			const routesWithOtherBindings: Record<string, string[]> = {};
+			for (const route of routes) {
+				const zone = await getZoneForRoute(route);
+				if (!zone) {
+					continue;
+				}
+
+				const routePattern = typeof route === "string" ? route : route.pattern;
+				const routesInZone = await fetchListResult<{
+					pattern: string;
+					script: string;
+				}>(`/zones/${zone.id}/workers/routes`);
+
+				routesInZone.forEach(({ script, pattern }) => {
+					if (pattern === routePattern && script !== scriptName) {
+						if (!(script in routesWithOtherBindings)) {
+							routesWithOtherBindings[script] = [];
+						}
+
+						routesWithOtherBindings[script].push(pattern);
+					}
+				});
+			}
+
+			if (Object.keys(routesWithOtherBindings).length > 0) {
+				let errorMessage =
+					"Can't publish a worker to routes that are assigned to another worker.\n";
+
+				for (const worker in routesWithOtherBindings) {
+					const assignedRoutes = routesWithOtherBindings[worker];
+					errorMessage += `"${worker}" is already assigned to routes:\n${assignedRoutes.map(
+						(r) => `  - ${chalk.underline(r)}\n`
+					)}`;
+				}
+
+				const resolution =
+					"Unassign other workers from the routes you want to publish to, and then try again.";
+				const dashLink = `Visit ${chalk.blue(
+					chalk.underline(
+						`https://dash.cloudflare.com/${accountId}/workers/overview`
+					)
+				)} to unassign a worker from a route.`;
+
+				throw new Error(`${errorMessage}\n${resolution}\n${dashLink}`);
+			}
 		}
 	}
 
@@ -590,7 +780,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.
@@ -608,48 +800,45 @@ See https://developers.cloudflare.com/workers/platform/compatibility-dates for m
 		);
 	}
 
+	if (config.queues.consumers && config.queues.consumers.length) {
+		deployments.push(...updateQueueConsumers(config));
+	}
+
 	const targets = await Promise.all(deployments);
 	const deployMs = Date.now() - start - uploadMs;
 
 	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));
 	}
-}
-
-function formatTime(duration: number) {
-	return `(${(duration / 1000).toFixed(2)} sec)`;
-}
 
-async function getSubdomain(accountId: string): Promise<string> {
 	try {
-		const { subdomain } = await fetchResult(
-			`/accounts/${accountId}/workers/subdomain`
+		const deploymentsList = await fetchResult<DeploymentListRes>(
+			`/accounts/${accountId}/workers/deployments/by-script/${scriptTag}`
 		);
-		return subdomain;
+
+		logger.log("Current Deployment ID:", deploymentsList.latest.id);
 	} catch (e) {
-		const error = e as { code?: number };
-		if (typeof error === "object" && !!error && error.code === 10007) {
-			// 10007 error code: not found
-			// https://api.cloudflare.com/#worker-subdomain-get-subdomain
-
-			const errorMessage =
-				"Error: You need to register a workers.dev subdomain before publishing to workers.dev";
-			const solutionMessage =
-				"You can either publish your worker to one or more routes by specifying them in wrangler.toml, or register a workers.dev subdomain here:";
-			const onboardingLink = `https://dash.cloudflare.com/${accountId}/workers/onboarding`;
-
-			throw new Error(`${errorMessage}\n${solutionMessage}\n${onboardingLink}`);
+		if ((e as { code: number }).code === 10023) {
+			// TODO: remove this try/catch once deployments is completely rolled out
 		} else {
 			throw e;
 		}
 	}
 }
 
+function formatTime(duration: number) {
+	return `(${(duration / 1000).toFixed(2)} sec)`;
+}
+
 /**
  * Associate the newly deployed Worker with the given routes.
  */
@@ -762,16 +951,19 @@ async function publishRoutesFallback(
 			}
 		}
 
-		const { pattern } = await fetchResult(`/zones/${zoneId}/workers/routes`, {
-			method: "POST",
-			body: JSON.stringify({
-				pattern: routePattern,
-				script: scriptName,
-			}),
-			headers: {
-				"Content-Type": "application/json",
-			},
-		});
+		const { pattern } = await fetchResult<{ pattern: string }>(
+			`/zones/${zoneId}/workers/routes`,
+			{
+				method: "POST",
+				body: JSON.stringify({
+					pattern: routePattern,
+					script: scriptName,
+				}),
+				headers: {
+					"Content-Type": "application/json",
+				},
+			}
+		);
 
 		deployedRoutes.push(pattern);
 	}
@@ -791,3 +983,54 @@ async function publishRoutesFallback(
 function isAuthenticationError(e: unknown): e is ParseError {
 	return e instanceof ParseError && (e as { code?: number }).code === 10000;
 }
+
+async function ensureQueuesExist(config: Config) {
+	const producers = (config.queues.producers || []).map(
+		(producer) => producer.queue
+	);
+	const consumers = (config.queues.consumers || []).map(
+		(consumer) => consumer.queue
+	);
+
+	const queueNames = producers.concat(consumers);
+	for (const queue of queueNames) {
+		try {
+			await getQueue(config, queue);
+		} catch (err) {
+			const queueErr = err as FetchError;
+			if (queueErr.code === 11000) {
+				// queue_not_found
+				throw new Error(
+					`Queue "${queue}" does not exist. To create it, run: wrangler queues create ${queue}`
+				);
+			}
+			throw err;
+		}
+	}
+}
+
+function updateQueueConsumers(config: Config): Promise<string[]>[] {
+	const consumers = config.queues.consumers || [];
+	return consumers.map((consumer) => {
+		const body: PutConsumerBody = {
+			dead_letter_queue: consumer.dead_letter_queue,
+			settings: {
+				batch_size: consumer.max_batch_size,
+				max_retries: consumer.max_retries,
+				max_wait_time_ms: consumer.max_batch_timeout
+					? 1000 * consumer.max_batch_timeout
+					: undefined,
+			},
+		};
+
+		if (config.name === undefined) {
+			// TODO: how can we reliably get the current script name?
+			throw new Error("Script name is required to update queue consumers");
+		}
+		const scriptName = config.name;
+		const envName = undefined; // TODO: script environment for wrangler publish?
+		return putConsumer(config, consumer.queue, scriptName, envName, body).then(
+			() => [`Consumer for ${consumer.queue}`]
+		);
+	});
+}