wrangler 0.0.0-e33bea9b → 0.0.0-e3990bbf

package/src/dev/use-esbuild.ts

@@ -1,209 +0,0 @@
-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,
-	legacyNodeCompat,
-	nodejsCompat,
-	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;
-	legacyNodeCompat: boolean | undefined;
-	nodejsCompat: 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 (!legacyNodeCompat) 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,
-						legacyNodeCompat,
-						nodejsCompat,
-						betaD1Shims,
-						doBindings: durableObjects.bindings,
-						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,
-		legacyNodeCompat,
-		nodejsCompat,
-		define,
-		assets,
-		services,
-		durableObjects,
-		workerDefinitions,
-		firstPartyWorkerDevFacade,
-		betaD1Shims,
-		local,
-		targetConsumer,
-		testScheduled,
-		experimentalLocal,
-	]);
-	return bundle;
-}

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

@@ -1,40 +0,0 @@
-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"
-		);
-	}
-
-	if (
-		props.compatibilityFlags?.includes("nodejs_compat") &&
-		props.legacyNodeCompat
-	) {
-		throw new Error(
-			"You cannot use the `nodejs_compat` compatibility flag in conjunction with the legacy `--node-compat` flag. If you want to use the new runtime Node.js compatibility features, please remove the `--node-compat` argument from your CLI command or your config file."
-		);
-	}
-}

package/src/dev-registry.ts

@@ -1,201 +0,0 @@
-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;
-}