wrangler 0.0.0-e09abbc → 0.0.0-e0abf917

package/src/dev/local.tsx

@@ -1,373 +0,0 @@
-import { fork } from "node:child_process";
-import { realpathSync } from "node:fs";
-import { writeFile } from "node:fs/promises";
-import path from "node:path";
-import { useState, useEffect, useRef } from "react";
-import onExit from "signal-exit";
-import useInspector from "../inspect";
-import { logger } from "../logger";
-import { DEFAULT_MODULE_RULES } from "../module-collection";
-import { waitForPortToBeAvailable } from "../proxy";
-import type { Config } from "../config";
-import type { EnablePagesAssetsServiceBindingOptions } from "../miniflare-cli";
-import type { AssetPaths } from "../sites";
-import type { CfWorkerInit, CfScriptFormat } from "../worker";
-import type { EsbuildBundle } from "./use-esbuild";
-import type { MiniflareOptions } from "miniflare";
-import type { ChildProcess } from "node:child_process";
-interface LocalProps {
-	name: string | undefined;
-	bundle: EsbuildBundle | undefined;
-	format: CfScriptFormat | undefined;
-	compatibilityDate: string;
-	compatibilityFlags: string[] | undefined;
-	bindings: CfWorkerInit["bindings"];
-	assetPaths: AssetPaths | undefined;
-	isWorkersSite: boolean;
-	port: number;
-	ip: string;
-	rules: Config["rules"];
-	inspectorPort: number;
-	enableLocalPersistence: boolean;
-	liveReload: boolean;
-	crons: Config["triggers"]["crons"];
-	localProtocol: "http" | "https";
-	localUpstream: string | undefined;
-	inspect: boolean;
-	onReady: (() => void) | undefined;
-	logLevel: "none" | "error" | "log" | "warn" | "debug" | undefined;
-	logPrefix?: string;
-	enablePagesAssetsServiceBinding?: EnablePagesAssetsServiceBindingOptions;
-}
-
-export function Local(props: LocalProps) {
-	const { inspectorUrl } = useLocalWorker(props);
-	useInspector({
-		inspectorUrl,
-		port: props.inspectorPort,
-		logToTerminal: false,
-	});
-	return null;
-}
-
-function useLocalWorker({
-	name: workerName,
-	bundle,
-	format,
-	compatibilityDate,
-	compatibilityFlags,
-	bindings,
-	assetPaths,
-	isWorkersSite,
-	port,
-	rules,
-	enableLocalPersistence,
-	liveReload,
-	ip,
-	crons,
-	localProtocol,
-	localUpstream,
-	inspect,
-	onReady,
-	logLevel,
-	logPrefix,
-	enablePagesAssetsServiceBinding,
-}: LocalProps) {
-	// TODO: pass vars via command line
-	const local = useRef<ChildProcess>();
-	const removeSignalExitListener = useRef<() => void>();
-	const [inspectorUrl, setInspectorUrl] = useState<string | undefined>();
-	// if we're using local persistence for data, we should use the cwd
-	// as an explicit path, or else it'll use the temp dir
-	// which disappears when dev ends
-	const localPersistencePath = enableLocalPersistence
-		? // Maybe we could make the path configurable as well?
-		  path.join(process.cwd(), "wrangler-local-state")
-		: // We otherwise choose null, but choose true later
-		  // so that it's persisted in the temp dir across a dev session
-		  // even when we change source and reload
-		  null;
-	useEffect(() => {
-		const abortController = new AbortController();
-		async function startLocalWorker() {
-			if (!bundle || !format) return;
-
-			// port for the worker
-			await waitForPortToBeAvailable(port, {
-				retryPeriod: 200,
-				timeout: 2000,
-				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) {
-				await writeFile(
-					path.join(path.dirname(bundle.path), module.name),
-					module.content
-				);
-			}
-
-			const scriptPath = realpathSync(bundle.path);
-
-			// the wasm_modules/text_blobs/data_blobs bindings are
-			// relative to process.cwd(), but the actual worker bundle
-			// is in the temp output directory; so we rewrite the paths to be absolute,
-			// letting miniflare resolve them correctly
-
-			// wasm
-			const wasmBindings: Record<string, string> = {};
-			for (const [name, filePath] of Object.entries(
-				bindings.wasm_modules || {}
-			)) {
-				wasmBindings[name] = path.join(process.cwd(), filePath);
-			}
-
-			// text
-			const textBlobBindings: Record<string, string> = {};
-			for (const [name, filePath] of Object.entries(
-				bindings.text_blobs || {}
-			)) {
-				textBlobBindings[name] = path.join(process.cwd(), filePath);
-			}
-
-			// data
-			const dataBlobBindings: Record<string, string> = {};
-			for (const [name, filePath] of Object.entries(
-				bindings.data_blobs || {}
-			)) {
-				dataBlobBindings[name] = path.join(process.cwd(), filePath);
-			}
-
-			if (format === "service-worker") {
-				for (const { type, name } of bundle.modules) {
-					if (type === "compiled-wasm") {
-						// In service-worker format, .wasm modules are referenced by global identifiers,
-						// so we convert it here.
-						// This identifier has to be a valid JS identifier, so we replace all non alphanumeric
-						// characters with an underscore.
-						const identifier = name.replace(/[^a-zA-Z0-9_$]/g, "_");
-						wasmBindings[identifier] = name;
-					} else if (type === "text") {
-						// In service-worker format, text modules are referenced by global identifiers,
-						// so we convert it here.
-						// This identifier has to be a valid JS identifier, so we replace all non alphanumeric
-						// characters with an underscore.
-						const identifier = name.replace(/[^a-zA-Z0-9_$]/g, "_");
-						textBlobBindings[identifier] = name;
-					} else if (type === "buffer") {
-						// In service-worker format, data blobs are referenced by global identifiers,
-						// so we convert it here.
-						// This identifier has to be a valid JS identifier, so we replace all non alphanumeric
-						// characters with an underscore.
-						const identifier = name.replace(/[^a-zA-Z0-9_$]/g, "_");
-						dataBlobBindings[identifier] = name;
-					}
-				}
-			}
-
-			const upstream =
-				typeof localUpstream === "string"
-					? `${localProtocol}://${localUpstream}`
-					: undefined;
-
-			const options: MiniflareOptions = {
-				name: workerName,
-				port,
-				scriptPath,
-				https: localProtocol === "https",
-				host: ip,
-				modules: format === "modules",
-				modulesRules: (rules || [])
-					.concat(DEFAULT_MODULE_RULES)
-					.map(({ type, globs: include, fallthrough }) => ({
-						type,
-						include,
-						fallthrough,
-					})),
-				compatibilityDate,
-				compatibilityFlags,
-				kvNamespaces: bindings.kv_namespaces?.map((kv) => kv.binding),
-				r2Buckets: bindings.r2_buckets?.map((r2) => r2.binding),
-				durableObjects: Object.fromEntries(
-					(bindings.durable_objects?.bindings ?? []).map<[string, string]>(
-						(value) => [value.name, value.class_name]
-					)
-				),
-				...(localPersistencePath
-					? {
-							cachePersist: path.join(localPersistencePath, "cache"),
-							durableObjectsPersist: path.join(localPersistencePath, "do"),
-							kvPersist: path.join(localPersistencePath, "kv"),
-							r2Persist: path.join(localPersistencePath, "r2"),
-					  }
-					: {
-							// We mark these as true, so that they'll
-							// persist in the temp directory.
-							// This means they'll persist across a dev session,
-							// even if we change source and reload,
-							// and be deleted when the dev session ends
-							cachePersist: true,
-							durableObjectsPersist: true,
-							kvPersist: true,
-							r2Persist: true,
-					  }),
-
-				liveReload,
-				sitePath: assetPaths?.assetDirectory
-					? path.join(assetPaths.baseDirectory, assetPaths.assetDirectory)
-					: undefined,
-				siteInclude: assetPaths?.includePatterns.length
-					? assetPaths?.includePatterns
-					: undefined,
-				siteExclude: assetPaths?.excludePatterns.length
-					? assetPaths.excludePatterns
-					: undefined,
-				bindings: bindings.vars,
-				wasmBindings,
-				textBlobBindings,
-				dataBlobBindings,
-				sourceMap: true,
-				logUnhandledRejections: true,
-				crons,
-				upstream,
-				disableLogs: logLevel === "none",
-				logOptions: logPrefix ? { prefix: logPrefix } : undefined,
-			};
-
-			// The path to the Miniflare CLI assumes that this file is being run from
-			// `wrangler-dist` and that the CLI is found in `miniflare-dist`.
-			// If either of those paths change this line needs updating.
-			const miniflareCLIPath = path.resolve(
-				__dirname,
-				"../miniflare-dist/index.mjs"
-			);
-			const miniflareOptions = JSON.stringify(options, null);
-
-			logger.log("⎔ Starting a local server...");
-			const nodeOptions = [
-				"--experimental-vm-modules", // ensures that Miniflare can run ESM Workers
-				"--no-warnings", // hide annoying Node warnings
-				// "--log=VERBOSE", // uncomment this to Miniflare to log "everything"!
-			];
-			if (inspect) {
-				nodeOptions.push("--inspect"); // start Miniflare listening for a debugger to attach
-			}
-
-			const forkOptions = [miniflareOptions];
-
-			if (enablePagesAssetsServiceBinding) {
-				forkOptions.push(JSON.stringify(enablePagesAssetsServiceBinding));
-			}
-
-			const child = (local.current = fork(miniflareCLIPath, forkOptions, {
-				cwd: path.dirname(scriptPath),
-				execArgv: nodeOptions,
-				stdio: "pipe",
-			}));
-
-			child.on("message", (message) => {
-				if (message === "ready") {
-					onReady?.();
-				}
-			});
-
-			child.on("close", (code) => {
-				if (code) {
-					logger.log(`Miniflare process exited with code ${code}`);
-				}
-			});
-
-			child.stdout?.on("data", (data: Buffer) => {
-				process.stdout.write(data);
-			});
-
-			// parse the node inspector url (which may be received in chunks) from stderr
-			let stderrData = "";
-			let inspectorUrlFound = false;
-			child.stderr?.on("data", (data: Buffer) => {
-				if (!inspectorUrlFound) {
-					stderrData += data.toString();
-					const matches =
-						/Debugger listening on (ws:\/\/127\.0\.0\.1:\d+\/[A-Za-z0-9-]+)[\r|\n]/.exec(
-							stderrData
-						);
-					if (matches) {
-						inspectorUrlFound = true;
-						setInspectorUrl(matches[1]);
-					}
-				}
-
-				process.stderr.write(data);
-			});
-
-			child.on("exit", (code) => {
-				if (code) {
-					logger.error(`Miniflare process exited with code ${code}`);
-				}
-			});
-
-			child.on("error", (error: Error) => {
-				logger.error(`Miniflare process failed to spawn`);
-				logger.error(error);
-			});
-
-			removeSignalExitListener.current = onExit((_code, _signal) => {
-				logger.log("⎔ Shutting down local server.");
-				child.kill();
-				local.current = undefined;
-			});
-		}
-
-		startLocalWorker().catch((err) => {
-			logger.error("local worker:", err);
-		});
-
-		return () => {
-			abortController.abort();
-			if (local.current) {
-				logger.log("⎔ Shutting down local server.");
-				local.current?.kill();
-				local.current = undefined;
-				removeSignalExitListener.current && removeSignalExitListener.current();
-				removeSignalExitListener.current = undefined;
-			}
-		};
-	}, [
-		bundle,
-		workerName,
-		format,
-		port,
-		ip,
-		bindings.durable_objects?.bindings,
-		bindings.kv_namespaces,
-		bindings.r2_buckets,
-		bindings.vars,
-		bindings.services,
-		compatibilityDate,
-		compatibilityFlags,
-		localPersistencePath,
-		liveReload,
-		assetPaths,
-		isWorkersSite,
-		rules,
-		bindings.wasm_modules,
-		bindings.text_blobs,
-		bindings.data_blobs,
-		crons,
-		localProtocol,
-		localUpstream,
-		inspect,
-		logLevel,
-		logPrefix,
-		onReady,
-		enablePagesAssetsServiceBinding,
-	]);
-	return { inspectorUrl };
-}