wrangler 0.0.0-e6733a3 → 0.0.0-e6c71262

package/src/create-worker-preview.ts

@@ -0,0 +1,293 @@
+import { URL } from "node:url";
+import { fetch } from "undici";
+import { fetchResult } from "./cfetch";
+import { createWorkerUploadForm } from "./create-worker-upload-form";
+import { logger } from "./logger";
+import { parseJSON } from "./parse";
+import { getAccessToken } from "./user/access";
+import type { CfAccount, CfWorkerContext, CfWorkerInit } from "./worker";
+import type { HeadersInit } from "undici";
+
+/**
+ * A Preview Session on the edge
+ */
+export interface CfPreviewSession {
+	/**
+	 * A randomly generated id for this session
+	 */
+	id: string;
+	/**
+	 * A value to use when creating a worker preview under a session
+	 */
+	value: string;
+	/**
+	 * The host where the session is available.
+	 */
+	host: string;
+	/**
+	 * A websocket url to a DevTools inspector.
+	 *
+	 * Workers does not have a fully-featured implementation
+	 * of the Chrome DevTools protocol, but supports the following:
+	 *  * `console.log()` output.
+	 *  * `Error` stack traces.
+	 *  * `fetch()` events.
+	 *
+	 * There is no support for breakpoints, but we want to implement
+	 * this eventually.
+	 *
+	 * @link https://chromedevtools.github.io/devtools-protocol/
+	 */
+	inspectorUrl: URL;
+	/**
+	 * A url to prewarm the preview session.
+	 *
+	 * @example
+	 * fetch(prewarmUrl, { method: 'POST' })
+	 */
+	prewarmUrl: URL;
+}
+
+/**
+ * A preview mode.
+ *
+ * * If true, then using a `workers.dev` subdomain.
+ * * Otherwise, a list of routes under a single zone.
+ */
+type CfPreviewMode = { workers_dev: boolean } | { routes: string[] };
+
+/**
+ * A preview token.
+ */
+export interface CfPreviewToken {
+	/**
+	 * The header value required to trigger a preview.
+	 *
+	 * @example
+	 * const headers = { 'cf-workers-preview-token': value }
+	 * const response = await fetch('https://' + host, { headers })
+	 */
+	value: string;
+	/**
+	 * The host where the preview is available.
+	 */
+	host: string;
+	/**
+	 * A websocket url to a DevTools inspector.
+	 *
+	 * Workers does not have a fully-featured implementation
+	 * of the Chrome DevTools protocol, but supports the following:
+	 *  * `console.log()` output.
+	 *  * `Error` stack traces.
+	 *  * `fetch()` events.
+	 *
+	 * There is no support for breakpoints, but we want to implement
+	 * this eventually.
+	 *
+	 * @link https://chromedevtools.github.io/devtools-protocol/
+	 */
+	inspectorUrl: URL;
+	/**
+	 * A url to prewarm the preview session.
+	 *
+	 * @example
+	 * fetch(prewarmUrl, { method: 'POST',
+	 * 	 headers: {
+	 *     "cf-workers-preview-token": (preview)token.value,
+	 *   }
+	 * })
+	 */
+	prewarmUrl: URL;
+}
+
+// Credit: https://stackoverflow.com/a/2117523
+function randomId(): string {
+	return "xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx".replace(/[xy]/g, function (c) {
+		const r = (Math.random() * 16) | 0,
+			v = c == "x" ? r : (r & 0x3) | 0x8;
+		return v.toString(16);
+	});
+}
+
+// URLs are often relative to the zone. Sometimes the base zone
+// will be grey-clouded, and so the host must be swapped out for
+// the worker route host, which is more likely to be orange-clouded
+function switchHost(originalUrl: string, host?: string): URL {
+	const url = new URL(originalUrl);
+	url.hostname = host ?? url.hostname;
+	return url;
+}
+/**
+ * Generates a preview session token.
+ */
+export async function createPreviewSession(
+	account: CfAccount,
+	ctx: CfWorkerContext,
+	abortSignal: AbortSignal
+): Promise<CfPreviewSession> {
+	const { accountId } = account;
+	const initUrl = ctx.zone
+		? `/zones/${ctx.zone}/workers/edge-preview`
+		: `/accounts/${accountId}/workers/subdomain/edge-preview`;
+
+	const { exchange_url } = await fetchResult<{ exchange_url: string }>(
+		initUrl,
+		undefined,
+		undefined,
+		abortSignal
+	);
+
+	const switchedExchangeUrl = switchHost(exchange_url, ctx.host).toString();
+
+	logger.debug(`-- START EXCHANGE API REQUEST: GET ${switchedExchangeUrl}`);
+	logger.debug("-- END EXCHANGE API REQUEST");
+	const exchangeResponse = await fetch(switchedExchangeUrl, {
+		signal: abortSignal,
+	});
+	const bodyText = await exchangeResponse.text();
+	logger.debug(
+		"-- START EXCHANGE API RESPONSE:",
+		exchangeResponse.statusText,
+		exchangeResponse.status
+	);
+	logger.debug("HEADERS:", JSON.stringify(exchangeResponse.headers, null, 2));
+	logger.debug("RESPONSE:", bodyText);
+	logger.debug("-- END EXCHANGE API RESPONSE");
+
+	const { inspector_websocket, prewarm, token } = parseJSON<{
+		inspector_websocket: string;
+		token: string;
+		prewarm: string;
+	}>(bodyText);
+	const inspector = new URL(inspector_websocket);
+	inspector.searchParams.append("cf_workers_preview_token", token);
+
+	return {
+		id: randomId(),
+		value: token,
+		host: ctx.host ?? inspector.host,
+		inspectorUrl: switchHost(inspector.href, ctx.host),
+		prewarmUrl: switchHost(prewarm, ctx.host),
+	};
+}
+
+/**
+ * Creates a preview token.
+ */
+async function createPreviewToken(
+	account: CfAccount,
+	worker: CfWorkerInit,
+	ctx: CfWorkerContext,
+	session: CfPreviewSession,
+	abortSignal: AbortSignal
+): Promise<CfPreviewToken> {
+	const { value, host, inspectorUrl, prewarmUrl } = session;
+	const { accountId } = account;
+	const scriptId = worker.name || (ctx.zone ? session.id : host.split(".")[0]);
+	const url =
+		ctx.env && !ctx.legacyEnv
+			? `/accounts/${accountId}/workers/services/${scriptId}/environments/${ctx.env}/edge-preview`
+			: `/accounts/${accountId}/workers/scripts/${scriptId}/edge-preview`;
+
+	const mode: CfPreviewMode = ctx.zone
+		? {
+				routes: ctx.routes
+					? // extract all the route patterns
+					  ctx.routes.map((route) => {
+							if (typeof route === "string") {
+								return route;
+							}
+							if (route.custom_domain) {
+								return `${route.pattern}/*`;
+							}
+							return route.pattern;
+					  })
+					: // if there aren't any patterns, then just match on all routes
+					  ["*/*"],
+		  }
+		: { workers_dev: true };
+
+	const formData = createWorkerUploadForm(worker);
+	formData.set("wrangler-session-config", JSON.stringify(mode));
+
+	const { preview_token } = await fetchResult<{ preview_token: string }>(
+		url,
+		{
+			method: "POST",
+			body: formData,
+			headers: {
+				"cf-preview-upload-config-token": value,
+			},
+		},
+		undefined,
+		abortSignal
+	);
+
+	return {
+		value: preview_token,
+		host:
+			ctx.host ??
+			(worker.name
+				? `${
+						worker.name
+						// TODO: this should also probably have the env prefix
+						// but it doesn't appear to work yet, instead giving us the
+						// "There is nothing here yet" screen
+						// ctx.env && !ctx.legacyEnv
+						//   ? `${ctx.env}.${worker.name}`
+						//   : worker.name
+				  }.${host.split(".").slice(1).join(".")}`
+				: host),
+
+		inspectorUrl,
+		prewarmUrl,
+	};
+}
+
+/**
+ * A stub to create a Cloudflare Worker preview.
+ *
+ * @example
+ * const {value, host} = await createWorker(init, acct);
+ */
+export async function createWorkerPreview(
+	init: CfWorkerInit,
+	account: CfAccount,
+	ctx: CfWorkerContext,
+	session: CfPreviewSession,
+	abortSignal: AbortSignal
+): Promise<CfPreviewToken> {
+	const token = await createPreviewToken(
+		account,
+		init,
+		ctx,
+		session,
+		abortSignal
+	);
+	const accessToken = await getAccessToken(token.prewarmUrl.hostname);
+
+	const headers: HeadersInit = { "cf-workers-preview-token": token.value };
+	if (accessToken) {
+		headers.cookie = `CF_Authorization=${accessToken}`;
+	}
+
+	// fire and forget the prewarm call
+	fetch(token.prewarmUrl.href, {
+		method: "POST",
+		signal: abortSignal,
+		headers,
+	}).then(
+		(response) => {
+			if (!response.ok) {
+				logger.warn("worker failed to prewarm: ", response.statusText);
+			}
+		},
+		(err) => {
+			if ((err as { code: string }).code !== "ABORT_ERR") {
+				logger.warn("worker failed to prewarm: ", err);
+			}
+		}
+	);
+
+	return token;
+}

package/src/create-worker-upload-form.ts

@@ -0,0 +1,380 @@
+import { readFileSync } from "node:fs";
+import { FormData, File } from "undici";
+import type {
+	CfWorkerInit,
+	CfModuleType,
+	CfDurableObjectMigrations,
+	CfPlacement,
+} from "./worker.js";
+
+export function toMimeType(type: CfModuleType): string {
+	switch (type) {
+		case "esm":
+			return "application/javascript+module";
+		case "commonjs":
+			return "application/javascript";
+		case "compiled-wasm":
+			return "application/wasm";
+		case "buffer":
+			return "application/octet-stream";
+		case "text":
+			return "text/plain";
+		default:
+			throw new TypeError("Unsupported module: " + type);
+	}
+}
+
+export type WorkerMetadataBinding =
+	// If you add any new binding types here, also add it to safeBindings
+	// under validateUnsafeBinding in config/validation.ts
+	| { type: "plain_text"; name: string; text: string }
+	| { type: "json"; name: string; json: unknown }
+	| { type: "wasm_module"; name: string; part: string }
+	| { type: "text_blob"; name: string; part: string }
+	| { type: "browser"; name: string }
+	| { type: "data_blob"; name: string; part: string }
+	| { type: "kv_namespace"; name: string; namespace_id: string }
+	| {
+			type: "send_email";
+			name: string;
+			destination_address?: string;
+			allowed_destination_addresses?: string[];
+	  }
+	| {
+			type: "durable_object_namespace";
+			name: string;
+			class_name: string;
+			script_name?: string;
+			environment?: string;
+	  }
+	| { type: "queue"; name: string; queue_name: string }
+	| { type: "r2_bucket"; name: string; bucket_name: string }
+	| { type: "d1"; name: string; id: string; internalEnv?: string }
+	| { type: "constellation"; name: string; project: string }
+	| { type: "service"; name: string; service: string; environment?: string }
+	| { type: "analytics_engine"; name: string; dataset?: string }
+	| { type: "dispatch_namespace"; name: string; namespace: string }
+	| { type: "mtls_certificate"; name: string; certificate_id: string }
+	| {
+			type: "logfwdr";
+			name: string;
+			destination: string;
+	  };
+
+export interface WorkerMetadata {
+	/** The name of the entry point module. Only exists when the worker is in the ES module format */
+	main_module?: string;
+	/** The name of the entry point module. Only exists when the worker is in the service-worker format */
+	body_part?: string;
+	compatibility_date?: string;
+	compatibility_flags?: string[];
+	usage_model?: "bundled" | "unbound";
+	migrations?: CfDurableObjectMigrations;
+	capnp_schema?: string;
+	bindings: WorkerMetadataBinding[];
+	keep_bindings?: WorkerMetadataBinding["type"][];
+	logpush?: boolean;
+	placement?: CfPlacement;
+	// Allow unsafe.metadata to add arbitary properties at runtime
+	[key: string]: unknown;
+}
+
+/**
+ * Creates a `FormData` upload from a `CfWorkerInit`.
+ */
+export function createWorkerUploadForm(worker: CfWorkerInit): FormData {
+	const formData = new FormData();
+	const {
+		main,
+		bindings,
+		migrations,
+		usage_model,
+		compatibility_date,
+		compatibility_flags,
+		keepVars,
+		logpush,
+		placement,
+	} = worker;
+
+	let { modules } = worker;
+
+	const metadataBindings: WorkerMetadata["bindings"] = [];
+
+	Object.entries(bindings.vars || {})?.forEach(([key, value]) => {
+		if (typeof value === "string") {
+			metadataBindings.push({ name: key, type: "plain_text", text: value });
+		} else {
+			metadataBindings.push({ name: key, type: "json", json: value });
+		}
+	});
+
+	bindings.kv_namespaces?.forEach(({ id, binding }) => {
+		metadataBindings.push({
+			name: binding,
+			type: "kv_namespace",
+			namespace_id: id,
+		});
+	});
+
+	bindings.send_email?.forEach(
+		({ name, destination_address, allowed_destination_addresses }) => {
+			metadataBindings.push({
+				name: name,
+				type: "send_email",
+				destination_address,
+				allowed_destination_addresses,
+			});
+		}
+	);
+
+	bindings.durable_objects?.bindings.forEach(
+		({ name, class_name, script_name, environment }) => {
+			metadataBindings.push({
+				name,
+				type: "durable_object_namespace",
+				class_name: class_name,
+				...(script_name && { script_name }),
+				...(environment && { environment }),
+			});
+		}
+	);
+
+	bindings.queues?.forEach(({ binding, queue_name }) => {
+		metadataBindings.push({
+			type: "queue",
+			name: binding,
+			queue_name,
+		});
+	});
+
+	bindings.r2_buckets?.forEach(({ binding, bucket_name }) => {
+		metadataBindings.push({
+			name: binding,
+			type: "r2_bucket",
+			bucket_name,
+		});
+	});
+
+	bindings.d1_databases?.forEach(
+		({ binding, database_id, database_internal_env }) => {
+			metadataBindings.push({
+				name: binding,
+				type: "d1",
+				id: database_id,
+				internalEnv: database_internal_env,
+			});
+		}
+	);
+
+	bindings.constellation?.forEach(({ binding, project_id }) => {
+		metadataBindings.push({
+			name: binding,
+			type: "constellation",
+			project: project_id,
+		});
+	});
+
+	bindings.services?.forEach(({ binding, service, environment }) => {
+		metadataBindings.push({
+			name: binding,
+			type: "service",
+			service,
+			...(environment && { environment }),
+		});
+	});
+
+	bindings.analytics_engine_datasets?.forEach(({ binding, dataset }) => {
+		metadataBindings.push({
+			name: binding,
+			type: "analytics_engine",
+			dataset,
+		});
+	});
+
+	bindings.dispatch_namespaces?.forEach(({ binding, namespace }) => {
+		metadataBindings.push({
+			name: binding,
+			type: "dispatch_namespace",
+			namespace,
+		});
+	});
+
+	bindings.mtls_certificates?.forEach(({ binding, certificate_id }) => {
+		metadataBindings.push({
+			name: binding,
+			type: "mtls_certificate",
+			certificate_id,
+		});
+	});
+
+	bindings.logfwdr?.bindings.forEach(({ name, destination }) => {
+		metadataBindings.push({
+			name: name,
+			type: "logfwdr",
+			destination,
+		});
+	});
+
+	for (const [name, filePath] of Object.entries(bindings.wasm_modules || {})) {
+		metadataBindings.push({
+			name,
+			type: "wasm_module",
+			part: name,
+		});
+
+		formData.set(
+			name,
+			new File([readFileSync(filePath)], filePath, {
+				type: "application/wasm",
+			})
+		);
+	}
+
+	if (bindings.browser !== undefined) {
+		metadataBindings.push({
+			name: bindings.browser.binding,
+			type: "browser",
+		});
+	}
+
+	for (const [name, filePath] of Object.entries(bindings.text_blobs || {})) {
+		metadataBindings.push({
+			name,
+			type: "text_blob",
+			part: name,
+		});
+
+		if (name !== "__STATIC_CONTENT_MANIFEST") {
+			formData.set(
+				name,
+				new File([readFileSync(filePath)], filePath, {
+					type: "text/plain",
+				})
+			);
+		}
+	}
+
+	for (const [name, filePath] of Object.entries(bindings.data_blobs || {})) {
+		metadataBindings.push({
+			name,
+			type: "data_blob",
+			part: name,
+		});
+
+		formData.set(
+			name,
+			new File([readFileSync(filePath)], filePath, {
+				type: "application/octet-stream",
+			})
+		);
+	}
+
+	if (main.type === "commonjs") {
+		// This is a service-worker format worker.
+		for (const module of Object.values([...(modules || [])])) {
+			if (module.name === "__STATIC_CONTENT_MANIFEST") {
+				// Add the manifest to the form data.
+				formData.set(
+					module.name,
+					new File([module.content], module.name, {
+						type: "text/plain",
+					})
+				);
+				// And then remove it from the modules collection
+				modules = modules?.filter((m) => m !== module);
+			} else if (
+				module.type === "compiled-wasm" ||
+				module.type === "text" ||
+				module.type === "buffer"
+			) {
+				// Convert all wasm/text/data modules into `wasm_module`/`text_blob`/`data_blob` bindings.
+				// The "name" of the module is a file path. We use it
+				// to instead be a "part" of the body, and a reference
+				// that we can use inside our source. This identifier has to be a valid
+				// JS identifier, so we replace all non alphanumeric characters
+				// with an underscore.
+				const name = module.name.replace(/[^a-zA-Z0-9_$]/g, "_");
+				metadataBindings.push({
+					name,
+					type:
+						module.type === "compiled-wasm"
+							? "wasm_module"
+							: module.type === "text"
+							? "text_blob"
+							: "data_blob",
+					part: name,
+				});
+
+				// Add the module to the form data.
+				formData.set(
+					name,
+					new File([module.content], module.name, {
+						type:
+							module.type === "compiled-wasm"
+								? "application/wasm"
+								: module.type === "text"
+								? "text/plain"
+								: "application/octet-stream",
+					})
+				);
+				// And then remove it from the modules collection
+				modules = modules?.filter((m) => m !== module);
+			}
+		}
+	}
+
+	if (bindings.unsafe?.bindings) {
+		// @ts-expect-error unsafe bindings don't need to match a specific type here
+		metadataBindings.push(...bindings.unsafe.bindings);
+	}
+
+	const metadata: WorkerMetadata = {
+		...(main.type !== "commonjs"
+			? { main_module: main.name }
+			: { body_part: main.name }),
+		bindings: metadataBindings,
+		...(compatibility_date && { compatibility_date }),
+		...(compatibility_flags && { compatibility_flags }),
+		...(usage_model && { usage_model }),
+		...(migrations && { migrations }),
+		capnp_schema: bindings.logfwdr?.schema,
+		...(keepVars && { keep_bindings: ["plain_text", "json"] }),
+		...(logpush !== undefined && { logpush }),
+		...(placement && { placement }),
+	};
+
+	if (bindings.unsafe?.metadata !== undefined) {
+		for (const key of Object.keys(bindings.unsafe.metadata)) {
+			metadata[key] = bindings.unsafe.metadata[key];
+		}
+	}
+
+	formData.set("metadata", JSON.stringify(metadata));
+
+	if (main.type === "commonjs" && modules && modules.length > 0) {
+		throw new TypeError(
+			"More than one module can only be specified when type = 'esm'"
+		);
+	}
+
+	for (const module of [main].concat(modules || [])) {
+		formData.set(
+			module.name,
+			new File([module.content], module.name, {
+				type: toMimeType(module.type ?? main.type ?? "esm"),
+			})
+		);
+	}
+
+	if (bindings.logfwdr && bindings.logfwdr.schema) {
+		const filePath = bindings.logfwdr.schema;
+		formData.set(
+			filePath,
+			new File([readFileSync(filePath)], filePath, {
+				type: "application/octet-stream",
+			})
+		);
+	}
+
+	return formData;
+}