wrangler 0.0.0-e928f94 → 0.0.0-e93063e9

package/src/dev/use-esbuild.ts

@@ -0,0 +1,204 @@
+import assert from "node:assert";
+import { watch } from "chokidar";
+import { useApp } from "ink";
+import { useState, useEffect } from "react";
+import { bundleWorker, rewriteNodeCompatBuildFailure } from "../bundle";
+import { logBuildFailure, 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, Metafile } from "esbuild";
+
+export type EsbuildBundle = {
+	id: number;
+	path: string;
+	entry: Entry;
+	type: "esm" | "commonjs";
+	modules: CfModule[];
+	dependencies: Metafile["outputs"][string]["inputs"];
+	sourceMapPath: string | undefined;
+};
+
+export function useEsbuild({
+	entry,
+	destination,
+	jsxFactory,
+	jsxFragment,
+	rules,
+	assets,
+	serveAssetsFromWorker,
+	tsconfig,
+	minify,
+	nodeCompat,
+	betaD1Shims,
+	define,
+	noBundle,
+	workerDefinitions,
+	services,
+	durableObjects,
+	firstPartyWorkerDevFacade,
+	local,
+	targetConsumer,
+	testScheduled,
+	experimentalLocal,
+}: {
+	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;
+	betaD1Shims?: string[];
+	noBundle: boolean;
+	workerDefinitions: WorkerRegistry;
+	durableObjects: Config["durable_objects"];
+	firstPartyWorkerDevFacade: boolean | undefined;
+	local: boolean;
+	targetConsumer: "dev" | "publish";
+	testScheduled: boolean;
+	experimentalLocal: boolean | undefined;
+}): EsbuildBundle | undefined {
+	const [bundle, setBundle] = useState<EsbuildBundle>();
+	const { exit } = useApp();
+	useEffect(() => {
+		let stopWatching: (() => void) | undefined = undefined;
+
+		function updateBundle() {
+			// nothing really changes here, so let's increment the id
+			// to change the return object's identity
+			setBundle((previousBundle) => {
+				assert(
+					previousBundle,
+					"Rebuild triggered with no previous build available"
+				);
+				return { ...previousBundle, id: previousBundle.id + 1 };
+			});
+		}
+
+		const watchMode: WatchMode = {
+			async onRebuild(error) {
+				if (error !== null) {
+					if (!nodeCompat) rewriteNodeCompatBuildFailure(error);
+					logBuildFailure(error);
+					logger.error("Watch build failed:", error.message);
+				} else {
+					updateBundle();
+				}
+			},
+		};
+
+		async function build() {
+			if (!destination) return;
+
+			const {
+				resolvedEntryPointPath,
+				bundleType,
+				modules,
+				dependencies,
+				stop,
+				sourceMapPath,
+			}: Awaited<ReturnType<typeof bundleWorker>> = noBundle
+				? {
+						modules: [],
+						dependencies: {},
+						resolvedEntryPointPath: entry.file,
+						bundleType: entry.format === "modules" ? "esm" : "commonjs",
+						stop: undefined,
+						sourceMapPath: undefined,
+				  }
+				: await bundleWorker(entry, destination, {
+						serveAssetsFromWorker,
+						jsxFactory,
+						jsxFragment,
+						rules,
+						watch: watchMode,
+						tsconfig,
+						minify,
+						nodeCompat,
+						betaD1Shims,
+						define,
+						checkFetch: true,
+						assets: assets && {
+							...assets,
+							// disable the cache in dev
+							bypassCache: true,
+						},
+						workerDefinitions,
+						services,
+						firstPartyWorkerDevFacade,
+						local,
+						targetConsumer,
+						testScheduled,
+						experimentalLocal,
+				  });
+
+			// Capture the `stop()` method to use as the `useEffect()` destructor.
+			stopWatching = stop;
+
+			// if "noBundle" is true, then we need to manually watch the entry point and
+			// trigger "builds" when it changes
+			if (noBundle) {
+				const watcher = watch(entry.file, {
+					persistent: true,
+				}).on("change", async (_event) => {
+					updateBundle();
+				});
+
+				stopWatching = () => {
+					void watcher.close();
+				};
+			}
+			setBundle({
+				id: 0,
+				entry,
+				path: resolvedEntryPointPath,
+				type: bundleType,
+				modules,
+				dependencies,
+				sourceMapPath,
+			});
+		}
+
+		build().catch((err) => {
+			// If esbuild fails on first run, we want to quit the process
+			// since we can't recover from here
+			// related: https://github.com/evanw/esbuild/issues/1037
+			exit(err);
+		});
+
+		return () => {
+			stopWatching?.();
+		};
+	}, [
+		entry,
+		destination,
+		jsxFactory,
+		jsxFragment,
+		serveAssetsFromWorker,
+		rules,
+		tsconfig,
+		exit,
+		noBundle,
+		minify,
+		nodeCompat,
+		define,
+		assets,
+		services,
+		durableObjects,
+		workerDefinitions,
+		firstPartyWorkerDevFacade,
+		betaD1Shims,
+		local,
+		targetConsumer,
+		testScheduled,
+		experimentalLocal,
+	]);
+	return bundle;
+}

package/src/dev/validate-dev-props.ts

@@ -0,0 +1,31 @@
+import type { DevProps } from "./dev";
+
+export function validateDevProps(props: DevProps) {
+	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"
+		);
+	}
+}

package/src/dev-registry.ts

@@ -0,0 +1,201 @@
+import http from "http";
+import net from "net";
+import bodyParser from "body-parser";
+import express from "express";
+import { createHttpTerminator } from "http-terminator";
+import { fetch } from "undici";
+import { logger } from "./logger";
+
+import type { Config } from "./config";
+import type { Server } from "http";
+import type { HttpTerminator } from "http-terminator";
+
+const DEV_REGISTRY_PORT = "6284";
+const DEV_REGISTRY_HOST = `http://localhost:${DEV_REGISTRY_PORT}`;
+
+let server: Server;
+let terminator: HttpTerminator;
+
+export type WorkerRegistry = Record<string, WorkerDefinition>;
+
+type WorkerDefinition = {
+	port: number | undefined;
+	protocol: "http" | "https" | undefined;
+	host: string | undefined;
+	mode: "local" | "remote";
+	headers?: Record<string, string>;
+	durableObjects: { name: string; className: string }[];
+	durableObjectsHost?: string;
+	durableObjectsPort?: number;
+};
+
+/**
+ * A helper function to check whether our service registry is already running
+ */
+async function isPortAvailable() {
+	return new Promise((resolve, reject) => {
+		const netServer = net
+			.createServer()
+			.once("error", (err) => {
+				netServer.close();
+				if ((err as unknown as { code: string }).code === "EADDRINUSE") {
+					resolve(false);
+				} else {
+					reject(err);
+				}
+			})
+			.once("listening", () => {
+				netServer.close();
+				resolve(true);
+			});
+		netServer.listen(DEV_REGISTRY_PORT);
+	});
+}
+
+const jsonBodyParser = bodyParser.json();
+
+/**
+ * Start the service registry. It's a simple server
+ * that exposes endpoints for registering and unregistering
+ * services, as well as getting the state of the registry.
+ */
+export async function startWorkerRegistry() {
+	if ((await isPortAvailable()) && !server) {
+		const app = express();
+
+		let workers: WorkerRegistry = {};
+		app
+			.get("/workers", async (req, res) => {
+				res.json(workers);
+			})
+			.post("/workers/:workerId", jsonBodyParser, async (req, res) => {
+				workers[req.params.workerId] = req.body;
+				res.json(null);
+			})
+			.delete(`/workers/:workerId`, async (req, res) => {
+				delete workers[req.params.workerId];
+				res.json(null);
+			})
+			.delete("/workers", async (req, res) => {
+				workers = {};
+				res.json(null);
+			});
+		server = http.createServer(app);
+		terminator = createHttpTerminator({ server });
+		server.listen(DEV_REGISTRY_PORT);
+
+		/**
+		 * The registry server may have already been started by another wrangler process.
+		 * If wrangler processes are run in parallel, isPortAvailable() can return true
+		 * while another process spins up the server
+		 */
+		server.once("error", (err) => {
+			if ((err as unknown as { code: string }).code !== "EADDRINUSE") {
+				throw err;
+			}
+		});
+	}
+}
+
+/**
+ * Stop the service registry.
+ */
+export async function stopWorkerRegistry() {
+	await terminator?.terminate();
+}
+
+/**
+ * Register a worker in the registry.
+ */
+export async function registerWorker(
+	name: string,
+	definition: WorkerDefinition
+) {
+	try {
+		return await fetch(`${DEV_REGISTRY_HOST}/workers/${name}`, {
+			method: "POST",
+			headers: {
+				"Content-Type": "application/json",
+			},
+			body: JSON.stringify(definition),
+		});
+	} catch (e) {
+		if (
+			!["ECONNRESET", "ECONNREFUSED"].includes(
+				(e as unknown as { cause?: { code?: string } }).cause?.code || "___"
+			)
+		) {
+			logger.error("Failed to register worker in local service registry", e);
+		} else {
+			logger.debug("Failed to register worker in local service registry", e);
+		}
+	}
+}
+
+/**
+ * Unregister a worker from the registry.
+ */
+export async function unregisterWorker(name: string) {
+	try {
+		await fetch(`${DEV_REGISTRY_HOST}/workers/${name}`, {
+			method: "DELETE",
+		});
+	} catch (e) {
+		if (
+			!["ECONNRESET", "ECONNREFUSED"].includes(
+				(e as unknown as { cause?: { code?: string } }).cause?.code || "___"
+			)
+		) {
+			throw e;
+			// logger.error("failed to unregister worker", e);
+		}
+	}
+}
+
+/**
+ * Get the state of the service registry.
+ */
+export async function getRegisteredWorkers(): Promise<
+	WorkerRegistry | undefined
+> {
+	try {
+		const response = await fetch(`${DEV_REGISTRY_HOST}/workers`);
+		return (await response.json()) as WorkerRegistry;
+	} catch (e) {
+		if (
+			!["ECONNRESET", "ECONNREFUSED"].includes(
+				(e as unknown as { cause?: { code?: string } }).cause?.code || "___"
+			)
+		) {
+			throw e;
+		}
+	}
+}
+
+/**
+ * a function that takes your serviceNames and durableObjectNames and returns a
+ * list of the running workers that we're bound to
+ */
+export async function getBoundRegisteredWorkers({
+	services,
+	durableObjects,
+}: {
+	services: Config["services"] | undefined;
+	durableObjects: Config["durable_objects"] | undefined;
+}) {
+	const serviceNames = (services || []).map(
+		(serviceBinding) => serviceBinding.service
+	);
+	const durableObjectServices = (
+		durableObjects || { bindings: [] }
+	).bindings.map((durableObjectBinding) => durableObjectBinding.script_name);
+
+	const workerDefinitions = await getRegisteredWorkers();
+	const filteredWorkers = Object.fromEntries(
+		Object.entries(workerDefinitions || {}).filter(
+			([key, _value]) =>
+				serviceNames.includes(key) || durableObjectServices.includes(key)
+		)
+	);
+	return filteredWorkers;
+}