wrangler 2.0.23 → 2.0.24

package/src/config/validation.ts

@@ -598,25 +598,68 @@ function normalizeAndValidateAssets(
 	diagnostics: Diagnostics,
 	configPath: string | undefined,
 	rawConfig: RawConfig
-) {
-	if (
-		typeof rawConfig?.assets === "string" ||
-		rawConfig?.assets === undefined
-	) {
-		return rawConfig?.assets;
+): Config["assets"] {
+	// Even though the type doesn't say it,
+	// we allow for a string input in the config,
+	// so let's normalise it
+	if (typeof rawConfig?.assets === "string") {
+		return {
+			bucket: rawConfig.assets,
+			include: [],
+			exclude: [],
+			browser_TTL: undefined,
+			serve_single_page_app: false,
+		};
 	}
 
-	const { bucket, include = [], exclude = [], ...rest } = rawConfig.assets;
+	if (rawConfig?.assets === undefined) {
+		return undefined;
+	}
+
+	if (typeof rawConfig.assets !== "object") {
+		diagnostics.errors.push(
+			`Expected the \`assets\` field to be a string or an object, but got ${typeof rawConfig.assets}.`
+		);
+		return undefined;
+	}
+
+	const {
+		bucket,
+		include = [],
+		exclude = [],
+		browser_TTL,
+		serve_single_page_app,
+		...rest
+	} = rawConfig.assets;
 
 	validateAdditionalProperties(diagnostics, "assets", Object.keys(rest), []);
+
 	validateRequiredProperty(diagnostics, "assets", "bucket", bucket, "string");
 	validateTypedArray(diagnostics, "assets.include", include, "string");
 	validateTypedArray(diagnostics, "assets.exclude", exclude, "string");
 
+	validateOptionalProperty(
+		diagnostics,
+		"assets",
+		"browser_TTL",
+		browser_TTL,
+		"number"
+	);
+
+	validateOptionalProperty(
+		diagnostics,
+		"assets",
+		"serve_single_page_app",
+		serve_single_page_app,
+		"boolean"
+	);
+
 	return {
 		bucket,
 		include,
 		exclude,
+		browser_TTL,
+		serve_single_page_app,
 	};
 }
 
@@ -830,6 +873,13 @@ function normalizeAndValidateEnvironment(
 	isLegacyEnv?: boolean,
 	rawConfig?: RawConfig | undefined
 ): Environment {
+	deprecated(
+		diagnostics,
+		rawEnv,
+		"kv-namespaces",
+		`The "kv-namespaces" field is no longer supported, please rename to "kv_namespaces"`,
+		true
+	);
 	deprecated(
 		diagnostics,
 		rawEnv,
@@ -1045,6 +1095,17 @@ function normalizeAndValidateEnvironment(
 			validateBindingArray(envName, validateWorkerNamespaceBinding),
 			[]
 		),
+		logfwdr: inheritable(
+			diagnostics,
+			topLevelEnv,
+			rawEnv,
+			"logfwdr",
+			validateBindingsProperty(envName, validateCflogfwdrBinding),
+			{
+				schema: undefined,
+				bindings: [],
+			}
+		),
 		unsafe: notInheritable(
 			diagnostics,
 			topLevelEnv,
@@ -1082,6 +1143,14 @@ function normalizeAndValidateEnvironment(
 			isBoolean,
 			undefined
 		),
+		first_party_worker: inheritable(
+			diagnostics,
+			topLevelEnv,
+			rawEnv,
+			"first_party_worker",
+			isBoolean,
+			undefined
+		),
 	};
 
 	return environment;
@@ -1418,6 +1487,30 @@ const validateDurableObjectBinding: ValidatorFn = (
 	return isValid;
 };
 
+const validateCflogfwdrBinding: ValidatorFn = (diagnostics, field, value) => {
+	if (typeof value !== "object" || value === null) {
+		diagnostics.errors.push(
+			`Expected "${field}" to be an object but got ${JSON.stringify(value)}`
+		);
+		return false;
+	}
+
+	let isValid = true;
+	if (!isRequiredProperty(value, "name", "string")) {
+		diagnostics.errors.push(`binding should have a string "name" field.`);
+		isValid = false;
+	}
+
+	if (!isRequiredProperty(value, "destination", "string")) {
+		diagnostics.errors.push(
+			`binding should have a string "destination" field.`
+		);
+		isValid = false;
+	}
+
+	return isValid;
+};
+
 /**
  * Check that the given field is a valid "unsafe" binding object.
  *
@@ -1448,6 +1541,7 @@ const validateUnsafeBinding: ValidatorFn = (diagnostics, field, value) => {
 			"durable_object_namespace",
 			"r2_bucket",
 			"service",
+			"logfwdr",
 		];
 
 		if (safeBindings.includes(value.type)) {

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

@@ -32,6 +32,7 @@ export interface WorkerMetadata {
 	compatibility_flags?: string[];
 	usage_model?: "bundled" | "unbound";
 	migrations?: CfDurableObjectMigrations;
+	capnp_schema?: string;
 	// If you add any new binding types here, also add it to safeBindings
 	// under validateUnsafeBinding in config/validation.ts
 	bindings: (
@@ -51,6 +52,11 @@ export interface WorkerMetadata {
 		| { type: "r2_bucket"; name: string; bucket_name: string }
 		| { type: "service"; name: string; service: string; environment?: string }
 		| { type: "namespace"; name: string; namespace: string }
+		| {
+				type: "logfwdr";
+				name: string;
+				destination: string;
+		  }
 	)[];
 }
 
@@ -125,6 +131,14 @@ export function createWorkerUploadForm(worker: CfWorkerInit): FormData {
 		});
 	});
 
+	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,
@@ -240,6 +254,7 @@ export function createWorkerUploadForm(worker: CfWorkerInit): FormData {
 		...(compatibility_flags && { compatibility_flags }),
 		...(usage_model && { usage_model }),
 		...(migrations && { migrations }),
+		capnp_schema: bindings.logfwdr?.schema,
 	};
 
 	formData.set("metadata", JSON.stringify(metadata));
@@ -259,5 +274,15 @@ export function createWorkerUploadForm(worker: CfWorkerInit): FormData {
 		);
 	}
 
+	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;
 }

package/src/dev/dev.tsx

@@ -1,5 +1,6 @@
 import { spawn } from "node:child_process";
 import * as path from "node:path";
+import * as util from "node:util";
 import { watch } from "chokidar";
 import clipboardy from "clipboardy";
 import commandExists from "command-exists";
@@ -9,6 +10,12 @@ import { withErrorBoundary, useErrorHandler } from "react-error-boundary";
 import onExit from "signal-exit";
 import tmp from "tmp-promise";
 import { fetch } from "undici";
+import {
+	getRegisteredWorkers,
+	startWorkerRegistry,
+	stopWorkerRegistry,
+	unregisterWorker,
+} from "../dev-registry";
 import { runCustomBuild } from "../entry";
 import { openInspector } from "../inspect";
 import { logger } from "../logger";
@@ -16,13 +23,97 @@ import openInBrowser from "../open-in-browser";
 import { Local } from "./local";
 import { Remote } from "./remote";
 import { useEsbuild } from "./use-esbuild";
+import { validateDevProps } from "./validate-dev-props";
 import type { Config } from "../config";
 import type { Route } from "../config/environment";
+import type { WorkerRegistry } from "../dev-registry";
 import type { Entry } from "../entry";
 import type { EnablePagesAssetsServiceBindingOptions } from "../miniflare-cli";
 import type { AssetPaths } from "../sites";
 import type { CfWorkerInit } from "../worker";
 
+/**
+ * This hooks establishes a connection with the dev registry,
+ * and periodically updates itself with details of workers currently
+ * running a dev session on this system.
+ */
+function useDevRegistry(
+	name: string | undefined,
+	services: Config["services"] | undefined,
+	mode: "local" | "remote"
+): WorkerRegistry {
+	const [workers, setWorkers] = useState<WorkerRegistry>({});
+
+	useEffect(() => {
+		// Let's try to start registry
+		// TODO: we should probably call this in a loop
+		// in case the registry dies elsewhere
+		startWorkerRegistry().catch((err) => {
+			logger.error("failed to start worker registry", err);
+		});
+
+		const serviceNames = (services || []).map(
+			(serviceBinding) => serviceBinding.service
+		);
+
+		const interval =
+			// TODO: enable this for remote mode as well
+			// https://github.com/cloudflare/wrangler2/issues/1182
+			mode === "local"
+				? setInterval(() => {
+						getRegisteredWorkers().then(
+							(workerDefinitions: WorkerRegistry | undefined) => {
+								// We only want the workers that we're bound to
+								// so let's filter out the others
+								const filteredWorkers = Object.fromEntries(
+									Object.entries(workerDefinitions || {}).filter(
+										([key, _value]) => serviceNames.includes(key)
+									)
+								);
+								setWorkers((prevWorkers) => {
+									if (!util.isDeepStrictEqual(filteredWorkers, prevWorkers)) {
+										return filteredWorkers;
+									}
+									return prevWorkers;
+								});
+							},
+							(err) => {
+								logger.warn("Failed to get worker definitions", err);
+							}
+						);
+				  }, 300)
+				: undefined;
+
+		return () => {
+			interval && clearInterval(interval);
+			Promise.allSettled([
+				name ? unregisterWorker(name) : Promise.resolve(),
+				stopWorkerRegistry(),
+			]).then(
+				([unregisterResult, stopRegistryResult]) => {
+					if (unregisterResult.status === "rejected") {
+						logger.error(
+							"Failed to unregister worker",
+							unregisterResult.reason
+						);
+					}
+					if (stopRegistryResult.status === "rejected") {
+						logger.error(
+							"Failed to stop worker registry",
+							stopRegistryResult.reason
+						);
+					}
+				},
+				(err) => {
+					logger.error("Failed to clear dev registry effect", err);
+				}
+			);
+		};
+	}, [name, services, mode]);
+
+	return workers;
+}
+
 export type DevProps = {
 	name: string | undefined;
 	noBundle: boolean;
@@ -46,6 +137,7 @@ export type DevProps = {
 	crons: Config["triggers"]["crons"];
 	isWorkersSite: boolean;
 	assetPaths: AssetPaths | undefined;
+	assetsConfig: Config["assets"];
 	compatibilityDate: string;
 	compatibilityFlags: string[] | undefined;
 	usageModel: "bundled" | "unbound" | undefined;
@@ -64,36 +156,12 @@ export type DevProps = {
 	showInteractiveDevSession: boolean | undefined;
 	forceLocal: boolean | undefined;
 	enablePagesAssetsServiceBinding?: EnablePagesAssetsServiceBindingOptions;
+	firstPartyWorker: boolean | undefined;
+	sendMetrics: boolean | undefined;
 };
 
 export function DevImplementation(props: DevProps): JSX.Element {
-	if (
-		!props.isWorkersSite &&
-		props.assetPaths &&
-		props.entry.format === "service-worker"
-	) {
-		throw new Error(
-			"You cannot use the service-worker format with an `assets` directory yet. For information on how to migrate to the module-worker format, see: https://developers.cloudflare.com/workers/learning/migrating-to-module-workers/"
-		);
-	}
-
-	if (props.bindings.wasm_modules && props.entry.format === "modules") {
-		throw new Error(
-			"You cannot configure [wasm_modules] with an ES module worker. Instead, import the .wasm module directly in your code"
-		);
-	}
-
-	if (props.bindings.text_blobs && props.entry.format === "modules") {
-		throw new Error(
-			"You cannot configure [text_blobs] with an ES module worker. Instead, import the file directly in your code, and optionally configure `[rules]` in your wrangler.toml"
-		);
-	}
-
-	if (props.bindings.data_blobs && props.entry.format === "modules") {
-		throw new Error(
-			"You cannot configure [data_blobs] with an ES module worker. Instead, import the file directly in your code, and optionally configure `[rules]` in your wrangler.toml"
-		);
-	}
+	validateDevProps(props);
 
 	// only load the UI if we're running in a supported environment
 	const { isRawModeSupported } = useStdin();
@@ -157,6 +225,12 @@ function DevSession(props: DevSessionProps) {
 
 	const directory = useTmpDir();
 
+	const workerDefinitions = useDevRegistry(
+		props.name,
+		props.bindings.services,
+		props.local ? "local" : "remote"
+	);
+
 	const bundle = useEsbuild({
 		entry: props.entry,
 		destination: directory,
@@ -171,6 +245,10 @@ function DevSession(props: DevSessionProps) {
 		nodeCompat: props.nodeCompat,
 		define: props.define,
 		noBundle: props.noBundle,
+		assets: props.assetsConfig,
+		workerDefinitions,
+		services: props.bindings.services,
+		firstPartyWorkerDevFacade: props.firstPartyWorker,
 	});
 
 	return props.local ? (
@@ -182,7 +260,6 @@ function DevSession(props: DevSessionProps) {
 			compatibilityFlags={props.compatibilityFlags}
 			bindings={props.bindings}
 			assetPaths={props.assetPaths}
-			isWorkersSite={props.isWorkersSite}
 			port={props.port}
 			ip={props.ip}
 			rules={props.rules}
@@ -223,6 +300,8 @@ function DevSession(props: DevSessionProps) {
 			host={props.host}
 			routes={props.routes}
 			onReady={props.onReady}
+			sourceMapPath={bundle?.sourceMapPath}
+			sendMetrics={props.sendMetrics}
 		/>
 	);
 }

package/src/dev/local.tsx

@@ -4,6 +4,7 @@ import { writeFile } from "node:fs/promises";
 import path from "node:path";
 import { useState, useEffect, useRef } from "react";
 import onExit from "signal-exit";
+import { registerWorker } from "../dev-registry";
 import useInspector from "../inspect";
 import { logger } from "../logger";
 import { DEFAULT_MODULE_RULES } from "../module-collection";
@@ -23,7 +24,6 @@ interface LocalProps {
 	compatibilityFlags: string[] | undefined;
 	bindings: CfWorkerInit["bindings"];
 	assetPaths: AssetPaths | undefined;
-	isWorkersSite: boolean;
 	port: number;
 	ip: string;
 	rules: Config["rules"];
@@ -58,7 +58,6 @@ function useLocalWorker({
 	compatibilityFlags,
 	bindings,
 	assetPaths,
-	isWorkersSite,
 	port,
 	inspectorPort,
 	rules,
@@ -88,6 +87,15 @@ function useLocalWorker({
 		  // so that it's persisted in the temp dir across a dev session
 		  // even when we change source and reload
 		  null;
+
+	useEffect(() => {
+		if (bindings.services && bindings.services.length > 0) {
+			logger.warn(
+				"⎔ Support for service bindings in local mode is experimental and may change."
+			);
+		}
+	}, [bindings.services]);
+
 	useEffect(() => {
 		const abortController = new AbortController();
 		async function startLocalWorker() {
@@ -100,12 +108,6 @@ function useLocalWorker({
 				abortSignal: abortController.signal,
 			});
 
-			if (bindings.services && bindings.services.length > 0) {
-				throw new Error(
-					"⎔ Service bindings are not yet supported in local mode."
-				);
-			}
-
 			// In local mode, we want to copy all referenced modules into
 			// the output bundle directory before starting up
 			for (const module of bundle.modules) {
@@ -273,8 +275,17 @@ function useLocalWorker({
 				stdio: "pipe",
 			}));
 
-			child.on("message", (message) => {
+			child.on("message", async (message) => {
 				if (message === "ready") {
+					// Let's register our presence in the dev registry
+					if (workerName) {
+						await registerWorker(workerName, {
+							protocol: localProtocol,
+							mode: "local",
+							port,
+							host: ip,
+						});
+					}
 					onReady?.();
 				}
 			});
@@ -357,7 +368,6 @@ function useLocalWorker({
 		localPersistencePath,
 		liveReload,
 		assetPaths,
-		isWorkersSite,
 		rules,
 		bindings.wasm_modules,
 		bindings.text_blobs,

package/src/dev/remote.tsx

@@ -55,6 +55,8 @@ export function Remote(props: {
 	host: string | undefined;
 	routes: Route[] | undefined;
 	onReady?: (() => void) | undefined;
+	sourceMapPath: string | undefined;
+	sendMetrics: boolean | undefined;
 }) {
 	const [accountId, setAccountId] = useState(props.accountId);
 	const accountChoicesRef = useRef<Promise<ChooseAccountItem[]>>();
@@ -78,6 +80,7 @@ export function Remote(props: {
 		host: props.host,
 		routes: props.routes,
 		onReady: props.onReady,
+		sendMetrics: props.sendMetrics,
 	});
 
 	usePreviewServer({
@@ -97,6 +100,7 @@ export function Remote(props: {
 				: undefined,
 		port: props.inspectorPort,
 		logToTerminal: true,
+		sourceMapPath: props.sourceMapPath,
 	});
 
 	const errorHandler = useErrorHandler();
@@ -161,6 +165,7 @@ export function useWorker(props: {
 	host: string | undefined;
 	routes: Route[] | undefined;
 	onReady: (() => void) | undefined;
+	sendMetrics: boolean | undefined;
 }): CfPreviewToken | undefined {
 	const {
 		name,
@@ -202,6 +207,7 @@ export function useWorker(props: {
 				zone: props.zone,
 				host: props.host,
 				routes: props.routes,
+				sendMetrics: props.sendMetrics,
 			};
 
 			setSession(
@@ -230,6 +236,7 @@ export function useWorker(props: {
 		props.legacyEnv,
 		props.routes,
 		props.zone,
+		props.sendMetrics,
 	]);
 
 	// This effect uses the session to upload the worker and create a preview
@@ -320,17 +327,40 @@ export function useWorker(props: {
 				zone: props.zone,
 				host: props.host,
 				routes: props.routes,
+				sendMetrics: props.sendMetrics,
 			};
 
-			setToken(
-				await createWorkerPreview(
-					init,
-					workerAccount,
-					workerCtx,
-					session,
-					abortController.signal
-				)
+			const workerPreviewToken = await createWorkerPreview(
+				init,
+				workerAccount,
+				workerCtx,
+				session,
+				abortController.signal
 			);
+
+			setToken(workerPreviewToken);
+
+			// TODO: Once we get service bindings working in the
+			// edge preview server, we can define remote dev service bindings
+			// and you can uncomment this code.
+			// https://github.com/cloudflare/wrangler2/issues/1182
+
+			/*
+			if (name) {
+				await registerWorker(name, {
+					mode: "remote",
+					// upstream protocol is always https (https://github.com/cloudflare/wrangler2/issues/583)
+					protocol: "https",
+					port: undefined,
+					host: workerPreviewToken.host,
+					headers: {
+						"cf-workers-preview-token": workerPreviewToken.value,
+						host: workerPreviewToken.host,
+					},
+				});
+			}
+			*/
+
 			onReady?.();
 		}
 		start().catch((err) => {
@@ -377,6 +407,7 @@ export function useWorker(props: {
 		props.routes,
 		session,
 		onReady,
+		props.sendMetrics,
 	]);
 	return token;
 }

package/src/dev/use-esbuild.ts

@@ -5,6 +5,7 @@ import { useState, useEffect } from "react";
 import { bundleWorker } from "../bundle";
 import { logger } from "../logger";
 import type { Config } from "../config";
+import type { WorkerRegistry } from "../dev-registry";
 import type { Entry } from "../entry";
 import type { CfModule } from "../worker";
 import type { WatchMode } from "esbuild";
@@ -15,6 +16,7 @@ export type EsbuildBundle = {
 	entry: Entry;
 	type: "esm" | "commonjs";
 	modules: CfModule[];
+	sourceMapPath: string | undefined;
 };
 
 export function useEsbuild({
@@ -23,24 +25,32 @@ export function useEsbuild({
 	jsxFactory,
 	jsxFragment,
 	rules,
+	assets,
 	serveAssetsFromWorker,
 	tsconfig,
 	minify,
 	nodeCompat,
 	define,
 	noBundle,
+	workerDefinitions,
+	services,
+	firstPartyWorkerDevFacade,
 }: {
 	entry: Entry;
 	destination: string | undefined;
 	jsxFactory: string | undefined;
 	jsxFragment: string | undefined;
 	rules: Config["rules"];
+	assets: Config["assets"];
 	define: Config["define"];
+	services: Config["services"];
 	serveAssetsFromWorker: boolean;
 	tsconfig: string | undefined;
 	minify: boolean | undefined;
 	nodeCompat: boolean | undefined;
 	noBundle: boolean;
+	workerDefinitions: WorkerRegistry;
+	firstPartyWorkerDevFacade: boolean | undefined;
 }): EsbuildBundle | undefined {
 	const [bundle, setBundle] = useState<EsbuildBundle>();
 	const { exit } = useApp();
@@ -76,12 +86,14 @@ export function useEsbuild({
 				bundleType,
 				modules,
 				stop,
+				sourceMapPath,
 			}: Awaited<ReturnType<typeof bundleWorker>> = noBundle
 				? {
 						modules: [],
 						resolvedEntryPointPath: entry.file,
 						bundleType: entry.format === "modules" ? "esm" : "commonjs",
 						stop: undefined,
+						sourceMapPath: undefined,
 				  }
 				: await bundleWorker(entry, destination, {
 						serveAssetsFromWorker,
@@ -94,6 +106,14 @@ export function useEsbuild({
 						nodeCompat,
 						define,
 						checkFetch: true,
+						assets: assets && {
+							...assets,
+							// disable the cache in dev
+							bypassCache: true,
+						},
+						workerDefinitions,
+						services,
+						firstPartyWorkerDevFacade,
 				  });
 
 			// Capture the `stop()` method to use as the `useEffect()` destructor.
@@ -119,6 +139,7 @@ export function useEsbuild({
 				path: resolvedEntryPointPath,
 				type: bundleType,
 				modules,
+				sourceMapPath,
 			});
 		}
 
@@ -145,6 +166,10 @@ export function useEsbuild({
 		minify,
 		nodeCompat,
 		define,
+		assets,
+		services,
+		workerDefinitions,
+		firstPartyWorkerDevFacade,
 	]);
 	return bundle;
 }