wrangler 0.0.0-e978986 → 0.0.0-e9e9872

package/src/dev/local.tsx

@@ -1,4 +1,4 @@
-import { spawn } from "node:child_process";
+import { fork } from "node:child_process";
 import { realpathSync } from "node:fs";
 import { writeFile } from "node:fs/promises";
 import path from "node:path";
@@ -13,306 +13,342 @@ 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;
-  public: string | undefined;
-  port: number;
-  ip: string;
-  rules: Config["rules"];
-  inspectorPort: number;
-  enableLocalPersistence: boolean;
-  crons: Config["triggers"]["crons"];
+	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;
+	crons: Config["triggers"]["crons"];
+	localProtocol: "http" | "https";
+	localUpstream: string | undefined;
+	inspect: boolean | undefined;
+	onReady: (() => void) | undefined;
+	logLevel: "none" | "error" | "log" | "warn" | "debug" | undefined;
 }
 
 export function Local(props: LocalProps) {
-  const { inspectorUrl } = useLocalWorker(props);
-  useInspector({
-    inspectorUrl,
-    port: props.inspectorPort,
-    logToTerminal: false,
-  });
-  return null;
+	const { inspectorUrl } = useLocalWorker(props);
+	useInspector({
+		inspectorUrl,
+		port: props.inspectorPort,
+		logToTerminal: false,
+	});
+	return null;
 }
 
 function useLocalWorker({
-  name: workerName,
-  bundle,
-  format,
-  compatibilityDate,
-  compatibilityFlags,
-  bindings,
-  assetPaths,
-  public: publicDirectory,
-  port,
-  rules,
-  enableLocalPersistence,
-  ip,
-  crons,
+	name: workerName,
+	bundle,
+	format,
+	compatibilityDate,
+	compatibilityFlags,
+	bindings,
+	assetPaths,
+	isWorkersSite,
+	port,
+	rules,
+	enableLocalPersistence,
+	ip,
+	crons,
+	localProtocol,
+	localUpstream,
+	inspect,
+	onReady,
+	logLevel,
 }: LocalProps) {
-  // TODO: pass vars via command line
-  const local = useRef<ReturnType<typeof spawn>>();
-  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;
+	// 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."
+				);
+			}
 
-      // port for the worker
-      await waitForPortToBeAvailable(port, {
-        retryPeriod: 200,
-        timeout: 2000,
-        abortSignal: abortController.signal,
-      });
+			// 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
+				);
+			}
 
-      if (publicDirectory) {
-        throw new Error(
-          '⎔ A "public" folder is not yet supported in local mode.'
-        );
-      }
-      if (bindings.services && bindings.services.length > 0) {
-        throw new Error(
-          "⎔ Service bindings are not yet supported in local mode."
-        );
-      }
+			const scriptPath = realpathSync(bundle.path);
 
-      // 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
-        );
-      }
+			// 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
 
-      const scriptPath = realpathSync(bundle.path);
+			// wasm
+			const wasmBindings: Record<string, string> = {};
+			for (const [name, filePath] of Object.entries(
+				bindings.wasm_modules || {}
+			)) {
+				wasmBindings[name] = path.join(process.cwd(), filePath);
+			}
 
-      // 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
+			// text
+			const textBlobBindings: Record<string, string> = {};
+			for (const [name, filePath] of Object.entries(
+				bindings.text_blobs || {}
+			)) {
+				textBlobBindings[name] = path.join(process.cwd(), filePath);
+			}
 
-      // wasm
-      const wasmBindings: Record<string, string> = {};
-      for (const [name, filePath] of Object.entries(
-        bindings.wasm_modules || {}
-      )) {
-        wasmBindings[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);
+			}
 
-      // text
-      const textBlobBindings: Record<string, string> = {};
-      for (const [name, filePath] of Object.entries(
-        bindings.text_blobs || {}
-      )) {
-        textBlobBindings[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;
+					}
+				}
+			}
 
-      // data
-      const dataBlobBindings: Record<string, string> = {};
-      for (const [name, filePath] of Object.entries(
-        bindings.data_blobs || {}
-      )) {
-        dataBlobBindings[name] = path.join(process.cwd(), filePath);
-      }
+			const upstream =
+				typeof localUpstream === "string"
+					? `${localProtocol}://${localUpstream}`
+					: undefined;
 
-      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 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
+					? {
+							kvPersist: path.join(localPersistencePath, "kv"),
+							durableObjectsPersist: path.join(localPersistencePath, "do"),
+							cachePersist: path.join(localPersistencePath, "cache"),
+					  }
+					: {
+							// 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
+							durableObjectsPersist: true,
+							cachePersist: true,
+							kvPersist: true,
+					  }),
 
-      const options: MiniflareOptions = {
-        name: workerName,
-        port,
-        scriptPath,
-        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),
-        durableObjects: Object.fromEntries(
-          (bindings.durable_objects?.bindings ?? []).map<[string, string]>(
-            (value) => [value.name, value.class_name]
-          )
-        ),
-        ...(localPersistencePath
-          ? {
-              kvPersist: path.join(localPersistencePath, "kv"),
-              durableObjectsPersist: path.join(localPersistencePath, "do"),
-              cachePersist: path.join(localPersistencePath, "cache"),
-            }
-          : {
-              // 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
-              durableObjectsPersist: true,
-              cachePersist: true,
-              kvPersist: true,
-            }),
+				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",
+			};
 
-        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,
-      };
+			// 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);
 
-      // 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 optionsArg = 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 child = (local.current = fork(
+				miniflareCLIPath,
+				[miniflareOptions],
+				{
+					cwd: path.dirname(scriptPath),
+					execArgv: nodeOptions,
+				}
+			));
+			child.on("message", (message) => {
+				if (message === "ready") {
+					onReady?.();
+				}
+			});
 
-      logger.log("⎔ Starting a local server...");
-      local.current = spawn(
-        "node",
-        [
-          "--experimental-vm-modules", // ensures that Miniflare can run ESM Workers
-          "--no-warnings", // hide annoying Node warnings
-          "--inspect", // start Miniflare listening for a debugger to attach
-          miniflareCLIPath,
-          optionsArg,
-          // "--log=VERBOSE", // uncomment this to Miniflare to log "everything"!
-        ],
-        {
-          cwd: path.dirname(scriptPath),
-        }
-      );
+			child.on("close", (code) => {
+				if (code) {
+					logger.log(`Miniflare process exited with code ${code}`);
+				}
+			});
 
-      local.current.on("close", (code) => {
-        if (code) {
-          logger.log(`Miniflare process exited with code ${code}`);
-        }
-      });
+			child.stdout?.on("data", (data: Buffer) => {
+				process.stdout.write(data);
+			});
 
-      local.current.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]);
+					}
+				}
 
-      local.current.stderr?.on("data", (data: Buffer) => {
-        const matches =
-          /Debugger listening on (ws:\/\/127\.0\.0\.1:\d+\/[A-Za-z0-9-]+)/.exec(
-            data.toString()
-          );
-        if (matches) {
-          setInspectorUrl(matches[1]);
-        }
-      });
+				process.stderr.write(data);
+			});
 
-      local.current.on("exit", (code) => {
-        if (code) {
-          logger.error(`Miniflare process exited with code ${code}`);
-        }
-      });
+			child.on("exit", (code) => {
+				if (code) {
+					logger.error(`Miniflare process exited with code ${code}`);
+				}
+			});
 
-      local.current.on("error", (error: Error) => {
-        logger.error(`Miniflare process failed to spawn`);
-        logger.error(error);
-      });
+			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.");
-        local.current?.kill();
-        local.current = undefined;
-      });
-    }
+			removeSignalExitListener.current = onExit((_code, _signal) => {
+				logger.log("⎔ Shutting down local server.");
+				child.kill();
+				local.current = undefined;
+			});
+		}
 
-    startLocalWorker().catch((err) => {
-      logger.error("local worker:", err);
-    });
+		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.vars,
-    bindings.services,
-    compatibilityDate,
-    compatibilityFlags,
-    localPersistencePath,
-    assetPaths,
-    publicDirectory,
-    rules,
-    bindings.wasm_modules,
-    bindings.text_blobs,
-    bindings.data_blobs,
-    crons,
-  ]);
-  return { inspectorUrl };
+		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,
+		assetPaths,
+		isWorkersSite,
+		rules,
+		bindings.wasm_modules,
+		bindings.text_blobs,
+		bindings.data_blobs,
+		crons,
+		localProtocol,
+		localUpstream,
+		inspect,
+		logLevel,
+		onReady,
+	]);
+	return { inspectorUrl };
 }