Implement updates to provisioning

Author: penalosa

packages/wrangler/src/api/startDevWorker/utils.ts

@@ -2,6 +2,7 @@ import assert from "node:assert";
 import { readFile } from "node:fs/promises";
 import { assertNever } from "../../utils/assert-never";
 import type { ConfigBindingOptions } from "../../config";
+import type { WorkerMetadataBinding } from "../../deployment-bundle/create-worker-upload-form";
 import type { CfWorkerInit } from "../../deployment-bundle/worker";
 import type {
 	Binding,
@@ -308,8 +309,22 @@ export function convertCfWorkerInitBindingsToBindings(
 	return output;
 }
 
+/**
+ * Convert either StartDevWorkerOptions["bindings"] or WorkerMetadataBinding[] to CfWorkerInit["bindings"]
+ * This function is by design temporary, but has lived longer than originally expected.
+ * For some context, CfWorkerInit is the in-memory representation of a Worker that Wrangler uses,
+ * WorkerMetadataBinding is the representation of bindings that comes from the API, and StartDevWorkerOptions
+ * is the "new" in-memory representation of a Worker that's used in Wrangler's dev flow. Over
+ * time, all uses of CfWorkerInit should transition to StartDevWorkerOptions, but that's a pretty big refactor.
+ * As such, in the meantime we have conversion functions so that different code paths can deal with the format they
+ * expect and were written for.
+ *
+ * WARNING: Using this with WorkerMetadataBinding[] will lose information about certain
+ * binding types (i.e. WASM modules, text blobs, and data blobs). These binding types are deprecated
+ * but may still be used by some Workers in the wild.
+ */
 export async function convertBindingsToCfWorkerInitBindings(
-	inputBindings: StartDevWorkerOptions["bindings"]
+	inputBindings: StartDevWorkerOptions["bindings"] | WorkerMetadataBinding[]
 ): Promise<{
 	bindings: CfWorkerInit["bindings"];
 	fetchers: Record<string, ServiceFetch>;
@@ -349,23 +364,35 @@ export async function convertBindingsToCfWorkerInitBindings(
 
 	const fetchers: Record<string, ServiceFetch> = {};
 
-	for (const [name, binding] of Object.entries(inputBindings ?? {})) {
+	const iterator: [string, WorkerMetadataBinding | Binding][] = Array.isArray(
+		inputBindings
+	)
+		? inputBindings.map((b) => [b.name, b])
+		: Object.entries(inputBindings ?? {});
+
+	for (const [name, binding] of iterator) {
 		if (binding.type === "plain_text") {
 			bindings.vars ??= {};
-			bindings.vars[name] = binding.value;
+			bindings.vars[name] = "value" in binding ? binding.value : binding.text;
 		} else if (binding.type === "json") {
 			bindings.vars ??= {};
-			bindings.vars[name] = binding.value;
+			bindings.vars[name] = "value" in binding ? binding.value : binding.json;
 		} else if (binding.type === "kv_namespace") {
 			bindings.kv_namespaces ??= [];
 			bindings.kv_namespaces.push({ ...binding, binding: name });
 		} else if (binding.type === "send_email") {
 			bindings.send_email ??= [];
 			bindings.send_email.push({ ...binding, name: name });
 		} else if (binding.type === "wasm_module") {
+			if (!("source" in binding)) {
+				continue;
+			}
 			bindings.wasm_modules ??= {};
 			bindings.wasm_modules[name] = await getBinaryFileContents(binding.source);
 		} else if (binding.type === "text_blob") {
+			if (!("source" in binding)) {
+				continue;
+			}
 			bindings.text_blobs ??= {};
 
 			if (typeof binding.source.path === "string") {
@@ -377,6 +404,9 @@ export async function convertBindingsToCfWorkerInitBindings(
 				);
 			}
 		} else if (binding.type === "data_blob") {
+			if (!("source" in binding)) {
+				continue;
+			}
 			bindings.data_blobs ??= {};
 			bindings.data_blobs[name] = await getBinaryFileContents(binding.source);
 		} else if (binding.type === "browser") {
@@ -415,7 +445,14 @@ export async function convertBindingsToCfWorkerInitBindings(
 			bindings.analytics_engine_datasets.push({ ...binding, binding: name });
 		} else if (binding.type === "dispatch_namespace") {
 			bindings.dispatch_namespaces ??= [];
-			bindings.dispatch_namespaces.push({ ...binding, binding: name });
+			bindings.dispatch_namespaces.push({
+				...binding,
+				binding: name,
+				outbound:
+					binding.outbound && "worker" in binding.outbound
+						? undefined
+						: binding.outbound,
+			});
 		} else if (binding.type === "mtls_certificate") {
 			bindings.mtls_certificates ??= [];
 			bindings.mtls_certificates.push({ ...binding, binding: name });

packages/wrangler/src/deploy/deploy.ts

@@ -855,7 +855,7 @@ See https://developers.cloudflare.com/workers/platform/compatibility-dates for m
 				}
 			}
 
-			workerBundle = createWorkerUploadForm(worker);
+			workerBundle = createWorkerUploadForm(worker, { dryRun: true });
 			printBindings(
 				{ ...withoutStaticAssets, vars: maskedVars },
 				config.tail_consumers,

packages/wrangler/src/deployment-bundle/bindings.ts

@@ -1,18 +1,21 @@
 import assert from "node:assert";
 import { fetchResult } from "../cfetch";
+import { experimental_patchConfig } from "../cli";
+import { PatchConfigError } from "../config/patch-config";
 import { createD1Database } from "../d1/create";
 import { listDatabases } from "../d1/list";
 import { getDatabaseInfoFromIdOrName } from "../d1/utils";
 import { prompt, select } from "../dialogs";
 import { UserError } from "../errors";
+import { isNonInteractiveOrCI } from "../is-interactive";
 import { createKVNamespace, listKVNamespaces } from "../kv/helpers";
 import { logger } from "../logger";
 import * as metrics from "../metrics";
 import { APIError } from "../parse";
 import { createR2Bucket, getR2Bucket, listR2Buckets } from "../r2/helpers";
 import { isLegacyEnv } from "../utils/isLegacyEnv";
 import { printBindings } from "../utils/print-bindings";
-import type { Config } from "../config";
+import type { Config, RawConfig } from "../config";
 import type { ComplianceConfig } from "../environment-variables/misc-variables";
 import type { WorkerMetadataBinding } from "./create-worker-upload-form";
 import type {
@@ -164,6 +167,13 @@ class R2Handler extends ProvisionResourceHandler<"r2_bucket", CfR2Bucket> {
 	get name(): string | undefined {
 		return this.binding.bucket_name as string;
 	}
+
+	override inherit(): void {
+		if (!this.binding.bucket_name) {
+			this.binding.bucket_name = INHERIT_SYMBOL;
+		}
+	}
+
 	async create(name: string) {
 		await createR2Bucket(
 			this.complianceConfig,
@@ -186,7 +196,10 @@ class R2Handler extends ProvisionResourceHandler<"r2_bucket", CfR2Bucket> {
 			(existing) =>
 				existing.type === this.type &&
 				existing.name === this.binding.binding &&
-				existing.jurisdiction === this.binding.jurisdiction
+				existing.jurisdiction === this.binding.jurisdiction &&
+				(this.binding.bucket_name
+					? this.binding.bucket_name === existing.bucket_name
+					: true)
 		);
 	}
 	async isConnectedToExistingResource(): Promise<boolean> {
@@ -426,6 +439,7 @@ async function collectPendingResources(
 		(a, b) => HANDLERS[a.resourceType].sort - HANDLERS[b.resourceType].sort
 	);
 }
+
 export async function provisionBindings(
 	bindings: CfWorkerInit["bindings"],
 	accountId: string,
@@ -441,6 +455,11 @@ export async function provisionBindings(
 	);
 
 	if (pendingResources.length > 0) {
+		if (!config.configPath) {
+			throw new UserError(
+				"Provisioning resources is not supported without a config file"
+			);
+		}
 		if (!isLegacyEnv(config)) {
 			throw new UserError(
 				"Provisioning resources is not supported with a service environment"
@@ -471,6 +490,45 @@ export async function provisionBindings(
 			);
 		}
 
+		const patch: RawConfig = {};
+
+		for (const resource of pendingResources) {
+			patch[resource.resourceType] = config[resource.resourceType].map(
+				(binding) => {
+					if (binding.binding === resource.binding) {
+						// Using an early return here would be nicer but makes TS blow up
+						binding = resource.handler.binding;
+					}
+
+					return Object.fromEntries(
+						Object.entries(binding).filter(
+							// Make sure all the values are JSON serialisable.
+							// Otherwise we end up with "undefined" in the config
+							([_, value]) => typeof value === "string"
+						)
+					) as typeof binding;
+				}
+			);
+		}
+
+		// If the user is performing an interactive deploy, write the provisioned IDs back to the config file.
+		// This is not necessary, as future deploys can use inherited resources, but it can help with
+		// portability of the config file, and adds robustness to bindings being renamed.
+		if (!isNonInteractiveOrCI()) {
+			try {
+				await experimental_patchConfig(config.configPath, patch, false);
+				logger.log(
+					"Your Worker was deployed with provisioned resources. We've written the IDs of these resources to your config file, which you can choose to save or discard—either way future deploys will continue to work."
+				);
+			} catch (e) {
+				if (e instanceof PatchConfigError) {
+					// no-op — if the user is using TOML config we can't update it.
+				} else {
+					throw e;
+				}
+			}
+		}
+
 		const resourceCount = pendingResources.reduce(
 			(acc, resource) => {
 				acc[resource.resourceType] ??= 0;

packages/wrangler/src/deployment-bundle/create-worker-upload-form.ts

@@ -219,7 +219,10 @@ export type WorkerMetadata = WorkerMetadataPut | WorkerMetadataVersionsPost;
 /**
  * Creates a `FormData` upload from a `CfWorkerInit`.
  */
-export function createWorkerUploadForm(worker: CfWorkerInit): FormData {
+export function createWorkerUploadForm(
+	worker: CfWorkerInit,
+	options?: { dryRun: true }
+): FormData {
 	const formData = new FormData();
 	const {
 		main,
@@ -279,6 +282,14 @@ export function createWorkerUploadForm(worker: CfWorkerInit): FormData {
 	});
 
 	bindings.kv_namespaces?.forEach(({ id, binding, raw }) => {
+		// If we're doing a dry run there's no way to know whether or not a KV namespace
+		// is inheritable or requires provisioning (since that would require hitting the API).
+		// As such, _assume_ any undefined IDs are inheritable when doing a dry run.
+		// When this Worker is actually deployed, some may be provisioned at the point of deploy
+		if (options?.dryRun && id === undefined) {
+			id = INHERIT_SYMBOL;
+		}
+
 		if (id === undefined) {
 			throw new UserError(`${binding} bindings must have an "id" field`);
 		}
@@ -357,6 +368,9 @@ export function createWorkerUploadForm(worker: CfWorkerInit): FormData {
 
 	bindings.r2_buckets?.forEach(
 		({ binding, bucket_name, jurisdiction, raw }) => {
+			if (options?.dryRun && bucket_name === undefined) {
+				bucket_name = INHERIT_SYMBOL;
+			}
 			if (bucket_name === undefined) {
 				throw new UserError(
 					`${binding} bindings must have a "bucket_name" field`
@@ -382,6 +396,9 @@ export function createWorkerUploadForm(worker: CfWorkerInit): FormData {
 
 	bindings.d1_databases?.forEach(
 		({ binding, database_id, database_internal_env, raw }) => {
+			if (options?.dryRun && database_id === undefined) {
+				database_id = INHERIT_SYMBOL;
+			}
 			if (database_id === undefined) {
 				throw new UserError(
 					`${binding} bindings must have a "database_id" field`