wrangler 2.0.23 → 2.0.26

package/src/config/environment.ts

@@ -217,6 +217,11 @@ interface EnvironmentInheritable {
 		namespace: string;
 	}[];
 
+	/**
+	 *	Designates this worker as an internal-only "first-party" worker.
+	 */
+	first_party_worker: boolean | undefined;
+
 	/**
 	 * TODO: remove this as it has been deprecated.
 	 *
@@ -224,6 +229,24 @@ interface EnvironmentInheritable {
 	 * So we need to include it in this type so it is available.
 	 */
 	zone_id?: string;
+
+	/**
+	 * Specify a compiled capnp schema to use
+	 * Then add a binding per field in the top level message that you will send to logfwdr
+	 *
+	 * @default `{schema:undefined,bindings:[]}`
+	 * @inheritable
+	 */
+	logfwdr: {
+		/** capnp schema filename */
+		schema: string | undefined;
+		bindings: {
+			/** The binding name used to refer to logfwdr */
+			name: string;
+			/** The destination for this logged message */
+			destination: string;
+		}[];
+	};
 }
 
 /**
@@ -329,14 +352,16 @@ interface EnvironmentNonInheritable {
 	 * @default `[]`
 	 * @nonInheritable
 	 */
-	services: {
-		/** The binding name used to refer to the bound service. */
-		binding: string;
-		/** The name of the service. */
-		service: string;
-		/** The environment of the service (e.g. production, staging, etc). */
-		environment?: string;
-	}[];
+	services:
+		| {
+				/** The binding name used to refer to the bound service. */
+				binding: string;
+				/** The name of the service. */
+				service: string;
+				/** The environment of the service (e.g. production, staging, etc). */
+				environment?: string;
+		  }[]
+		| undefined;
 
 	/**
 	 * "Unsafe" tables for features that aren't directly supported by wrangler.
@@ -375,6 +400,13 @@ interface EnvironmentDeprecated {
 	 */
 	zone_id?: string;
 
+	/**
+	 * Legacy way of defining KVNamespaces that is no longer supported.
+	 *
+	 * @deprecated DO NOT USE. This was a legacy bug from wrangler 1, that we do not want to support.
+	 */
+	"kv-namespaces"?: string;
+
 	/**
 	 * A list of services that your worker should be bound to.
 	 *

package/src/config/index.ts

@@ -85,6 +85,7 @@ export function printBindings(bindings: CfWorkerInit["bindings"]) {
 		durable_objects,
 		kv_namespaces,
 		r2_buckets,
+		logfwdr,
 		services,
 		text_blobs,
 		unsafe,
@@ -149,6 +150,18 @@ export function printBindings(bindings: CfWorkerInit["bindings"]) {
 		});
 	}
 
+	if (logfwdr !== undefined && logfwdr.bindings.length > 0) {
+		output.push({
+			type: "logfwdr",
+			entries: logfwdr.bindings.map((binding) => {
+				return {
+					key: binding.name,
+					value: binding.destination,
+				};
+			}),
+		});
+	}
+
 	if (services !== undefined && services.length > 0) {
 		output.push({
 			type: "Services",

package/src/config/validation.ts

@@ -357,7 +357,7 @@ function normalizeAndValidateDev(
 	rawDev: RawDevConfig
 ): DevConfig {
 	const {
-		ip = "localhost",
+		ip = "0.0.0.0",
 		port,
 		inspector_port,
 		local_protocol = "http",
@@ -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,103 @@ 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,
+	durableObjects: Config["durable_objects"] | 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 durableObjectServices = (
+			durableObjects || { bindings: [] }
+		).bindings.map((durableObjectBinding) => durableObjectBinding.script_name);
+
+		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) ||
+											durableObjectServices.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, durableObjects, mode]);
+
+	return workers;
+}
+
 export type DevProps = {
 	name: string | undefined;
 	noBundle: boolean;
@@ -46,6 +143,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 +162,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 +231,13 @@ function DevSession(props: DevSessionProps) {
 
 	const directory = useTmpDir();
 
+	const workerDefinitions = useDevRegistry(
+		props.name,
+		props.bindings.services,
+		props.bindings.durable_objects,
+		props.local ? "local" : "remote"
+	);
+
 	const bundle = useEsbuild({
 		entry: props.entry,
 		destination: directory,
@@ -171,6 +252,11 @@ function DevSession(props: DevSessionProps) {
 		nodeCompat: props.nodeCompat,
 		define: props.define,
 		noBundle: props.noBundle,
+		assets: props.assetsConfig,
+		workerDefinitions,
+		services: props.bindings.services,
+		durableObjects: props.bindings.durable_objects || { bindings: [] },
+		firstPartyWorkerDevFacade: props.firstPartyWorker,
 	});
 
 	return props.local ? (
@@ -180,9 +266,10 @@ function DevSession(props: DevSessionProps) {
 			format={props.entry.format}
 			compatibilityDate={props.compatibilityDate}
 			compatibilityFlags={props.compatibilityFlags}
+			usageModel={props.usageModel}
 			bindings={props.bindings}
+			workerDefinitions={workerDefinitions}
 			assetPaths={props.assetPaths}
-			isWorkersSite={props.isWorkersSite}
 			port={props.port}
 			ip={props.ip}
 			rules={props.rules}
@@ -223,6 +310,8 @@ function DevSession(props: DevSessionProps) {
 			host={props.host}
 			routes={props.routes}
 			onReady={props.onReady}
+			sourceMapPath={bundle?.sourceMapPath}
+			sendMetrics={props.sendMetrics}
 		/>
 	);
 }
@@ -404,6 +493,10 @@ function useHotkeys(props: {
 					break;
 				// open browser
 				case "b": {
+					if (ip === "0.0.0.0") {
+						await openInBrowser(`${localProtocol}://127.0.0.1:${port}`);
+						return;
+					}
 					await openInBrowser(`${localProtocol}://${ip}:${port}`);
 					break;
 				}