wrangler 0.0.0-e2f9bb2 → 0.0.0-e30d1013

package/src/dev/use-esbuild.ts

@@ -1,118 +1,204 @@
 import assert from "node:assert";
+import { watch } from "chokidar";
 import { useApp } from "ink";
 import { useState, useEffect } from "react";
-import { bundleWorker } from "../bundle";
-import { logger } from "../logger";
+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 } from "esbuild";
+import type { WatchMode, Metafile } from "esbuild";
 
 export type EsbuildBundle = {
-  id: number;
-  path: string;
-  entry: Entry;
-  type: "esm" | "commonjs";
-  modules: CfModule[];
-  serveAssetsFromWorker: boolean;
+	id: number;
+	path: string;
+	entry: Entry;
+	type: "esm" | "commonjs";
+	modules: CfModule[];
+	dependencies: Metafile["outputs"][string]["inputs"];
+	sourceMapPath: string | undefined;
 };
 
 export function useEsbuild({
-  entry,
-  destination,
-  staticRoot,
-  jsxFactory,
-  jsxFragment,
-  rules,
-  serveAssetsFromWorker,
-  tsconfig,
-  minify,
-  nodeCompat,
+	entry,
+	destination,
+	jsxFactory,
+	jsxFragment,
+	rules,
+	assets,
+	serveAssetsFromWorker,
+	tsconfig,
+	minify,
+	nodeCompat,
+	betaD1Shims,
+	define,
+	noBundle,
+	workerDefinitions,
+	services,
+	durableObjects,
+	firstPartyWorkerDevFacade,
+	local,
+	targetConsumer,
+	testScheduled,
+	experimentalLocalStubCache,
 }: {
-  entry: Entry;
-  destination: string | undefined;
-  staticRoot: string | undefined;
-  jsxFactory: string | undefined;
-  jsxFragment: string | undefined;
-  rules: Config["rules"];
-  serveAssetsFromWorker: boolean;
-  tsconfig: string | undefined;
-  minify: boolean | undefined;
-  nodeCompat: boolean | undefined;
+	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;
+	experimentalLocalStubCache: boolean | undefined;
 }): EsbuildBundle | undefined {
-  const [bundle, setBundle] = useState<EsbuildBundle>();
-  const { exit } = useApp();
-  useEffect(() => {
-    let stopWatching: (() => void) | undefined = undefined;
+	const [bundle, setBundle] = useState<EsbuildBundle>();
+	const { exit } = useApp();
+	useEffect(() => {
+		let stopWatching: (() => void) | undefined = undefined;
 
-    const watchMode: WatchMode = {
-      async onRebuild(error) {
-        if (error) logger.error("Watch build failed:", error);
-        else {
-          // 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 };
-          });
-        }
-      },
-    };
+		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 };
+			});
+		}
 
-    async function build() {
-      if (!destination) return;
+		const watchMode: WatchMode = {
+			async onRebuild(error) {
+				if (error !== null) {
+					if (!nodeCompat) rewriteNodeCompatBuildFailure(error);
+					logBuildFailure(error);
+					logger.error("Watch build failed:", error.message);
+				} else {
+					updateBundle();
+				}
+			},
+		};
 
-      const { resolvedEntryPointPath, bundleType, modules, stop } =
-        await bundleWorker(entry, destination, {
-          // In dev, we serve assets from the local proxy before we send the request to the worker.
-          serveAssetsFromWorker: false,
-          jsxFactory,
-          jsxFragment,
-          rules,
-          watch: watchMode,
-          tsconfig,
-          minify,
-          nodeCompat,
-        });
+		async function build() {
+			if (!destination) return;
 
-      // Capture the `stop()` method to use as the `useEffect()` destructor.
-      stopWatching = stop;
+			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,
+						experimentalLocalStubCache,
+				  });
 
-      setBundle({
-        id: 0,
-        entry,
-        path: resolvedEntryPointPath,
-        type: bundleType,
-        modules,
-        serveAssetsFromWorker,
-      });
-    }
+			// Capture the `stop()` method to use as the `useEffect()` destructor.
+			stopWatching = stop;
 
-    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);
-    });
+			// 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();
+				});
 
-    return () => {
-      stopWatching?.();
-    };
-  }, [
-    entry,
-    destination,
-    staticRoot,
-    jsxFactory,
-    jsxFragment,
-    serveAssetsFromWorker,
-    rules,
-    tsconfig,
-    exit,
-    minify,
-    nodeCompat,
-  ]);
-  return bundle;
+				stopWatching = () => {
+					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,
+		experimentalLocalStubCache,
+	]);
+	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.tsx

@@ -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;
+}