wrangler 0.0.0-e7a0cd5b → 0.0.0-e7cf0caa

package/src/dev/remote.tsx

@@ -1,5 +1,7 @@
 import { readFile } from "node:fs/promises";
 import path from "node:path";
+import { Text } from "ink";
+import SelectInput from "ink-select-input";
 import React, { useState, useEffect, useRef } from "react";
 import { useErrorHandler } from "react-error-boundary";
 import { printBundleSize } from "../bundle-reporter";
@@ -10,9 +12,9 @@ import {
 import useInspector from "../inspect";
 import { logger } from "../logger";
 import { startPreviewServer, usePreviewServer } from "../proxy";
+import { helpIfErrorIsSizeOrScriptStartup } from "../publish/publish";
 import { syncAssets } from "../sites";
 import {
-	ChooseAccount,
 	getAccountChoices,
 	requireApiToken,
 	saveAccountToCache,
@@ -302,13 +304,13 @@ export function useWorker(
 			// TODO: Once we get service bindings working in the
 			// edge preview server, we can define remote dev service bindings
 			// and you can uncomment this code.
-			// https://github.com/cloudflare/wrangler2/issues/1182
+			// https://github.com/cloudflare/workers-sdk/issues/1182
 
 			/*
 			if (name) {
 				await registerWorker(name, {
 					mode: "remote",
-					// upstream protocol is always https (https://github.com/cloudflare/wrangler2/issues/583)
+					// upstream protocol is always https (https://github.com/cloudflare/workers-sdk/issues/583)
 					protocol: "https",
 					port: undefined,
 					host: workerPreviewToken.host,
@@ -493,6 +495,7 @@ export async function getRemotePreviewToken(props: RemoteProps) {
 				// code 10049 happens when the preview token expires
 				logger.log("Preview token expired, restart server to fetch a new one");
 			} else {
+				helpIfErrorIsSizeOrScriptStartup(err, props.bundle?.dependencies || {});
 				logger.error("Error on remote worker:", err);
 			}
 		}
@@ -601,3 +604,29 @@ function getWorkerAccountAndContext(props: {
 
 	return { workerAccount, workerContext };
 }
+
+/**
+ * A component that allows the user to select from a list of available accounts.
+ */
+function ChooseAccount(props: {
+	accounts: ChooseAccountItem[];
+	onSelect: (account: { name: string; id: string }) => void;
+	onError: (error: Error) => void;
+}) {
+	return (
+		<>
+			<Text bold>Select an account from below:</Text>
+			<SelectInput
+				items={props.accounts.map((item) => ({
+					key: item.id,
+					label: item.name,
+					value: item,
+				}))}
+				onSelect={(item) => {
+					logger.log(`Using account: "${item.value.name} - ${item.value.id}"`);
+					props.onSelect({ id: item.value.id, name: item.value.name });
+				}}
+			/>
+		</>
+	);
+}

package/src/dev/start-server.ts

@@ -1,6 +1,5 @@
 import { fork } from "node:child_process";
 import { realpathSync } from "node:fs";
-import { writeFile } from "node:fs/promises";
 import * as path from "node:path";
 import * as util from "node:util";
 import onExit from "signal-exit";
@@ -15,29 +14,33 @@ import {
 import { runCustomBuild } from "../entry";
 import { logger } from "../logger";
 import { waitForPortToBeAvailable } from "../proxy";
+import traverseModuleGraph from "../traverse-module-graph";
 import {
 	setupBindings,
-	setupExperimentalLocal,
+	getMiniflare3,
+	buildMiniflare3Logger,
 	setupMiniflareOptions,
 	setupNodeOptions,
+	transformMf2OptionsToMf3Options,
 } from "./local";
 import { startRemoteServer } from "./remote";
 import { validateDevProps } from "./validate-dev-props";
 
 import type { Config } from "../config";
+import type { DurableObjectBindings } from "../config/environment";
 import type { WorkerRegistry } from "../dev-registry";
 import type { Entry } from "../entry";
 import type { DevProps, DirectorySyncResult } from "./dev";
 import type { LocalProps } from "./local";
 import type { EsbuildBundle } from "./use-esbuild";
 import type { Miniflare as Miniflare3Type } from "@miniflare/tre";
-import type { MiniflareOptions } from "miniflare";
 
 import type { ChildProcess } from "node:child_process";
 
 export async function startDevServer(
 	props: DevProps & {
 		local: boolean;
+		disableDevRegistry: boolean;
 	}
 ) {
 	try {
@@ -61,20 +64,29 @@ export async function startDevServer(
 		}
 
 		//start the worker registry
-		startWorkerRegistry().catch((err) => {
-			logger.error("failed to start worker registry", err);
-		});
-		if (props.local) {
-			const boundRegisteredWorkers = await getBoundRegisteredWorkers({
-				services: props.bindings.services,
-				durableObjects: props.bindings.durable_objects,
-			});
+		logger.log("disableDevRegistry: ", props.disableDevRegistry);
+		if (!props.disableDevRegistry) {
+			try {
+				await startWorkerRegistry();
+				if (props.local) {
+					const boundRegisteredWorkers = await getBoundRegisteredWorkers({
+						services: props.bindings.services,
+						durableObjects: props.bindings.durable_objects,
+					});
 
-			if (!util.isDeepStrictEqual(boundRegisteredWorkers, workerDefinitions)) {
-				workerDefinitions = boundRegisteredWorkers || {};
+					if (
+						!util.isDeepStrictEqual(boundRegisteredWorkers, workerDefinitions)
+					) {
+						workerDefinitions = boundRegisteredWorkers || {};
+					}
+				}
+			} catch (err) {
+				logger.error("failed to start worker registry", err);
 			}
 		}
 
+		const betaD1Shims = props.bindings.d1_databases?.map((db) => db.binding);
+
 		//implement a react-free version of useEsbuild
 		const bundle = await runEsbuild({
 			entry: props.entry,
@@ -87,15 +99,19 @@ export async function startDevServer(
 			),
 			tsconfig: props.tsconfig,
 			minify: props.minify,
-			nodeCompat: props.nodeCompat,
+			legacyNodeCompat: props.legacyNodeCompat,
+			nodejsCompat: props.nodejsCompat,
 			define: props.define,
 			noBundle: props.noBundle,
 			assets: props.assetsConfig,
+			betaD1Shims,
 			workerDefinitions,
 			services: props.bindings.services,
 			firstPartyWorkerDevFacade: props.firstPartyWorker,
 			testScheduled: props.testScheduled,
-			experimentalLocalStubCache: props.experimentalLocal,
+			local: props.local,
+			experimentalLocal: props.experimentalLocal,
+			doBindings: props.bindings.durable_objects?.bindings ?? [],
 		});
 
 		if (props.local) {
@@ -107,8 +123,8 @@ export async function startDevServer(
 				compatibilityFlags: props.compatibilityFlags,
 				bindings: props.bindings,
 				assetPaths: props.assetPaths,
-				port: props.port,
-				ip: props.ip,
+				initialPort: props.initialPort,
+				initialIp: props.initialIp,
 				rules: props.rules,
 				inspectorPort: props.inspectorPort,
 				localPersistencePath: props.localPersistencePath,
@@ -117,13 +133,14 @@ export async function startDevServer(
 				queueConsumers: props.queueConsumers,
 				localProtocol: props.localProtocol,
 				localUpstream: props.localUpstream,
-				logPrefix: props.logPrefix,
 				inspect: props.inspect,
 				onReady: props.onReady,
 				enablePagesAssetsServiceBinding: props.enablePagesAssetsServiceBinding,
 				usageModel: props.usageModel,
 				workerDefinitions,
 				experimentalLocal: props.experimentalLocal,
+				accountId: props.accountId,
+				experimentalLocalRemoteKv: props.experimentalLocalRemoteKv,
 			});
 
 			return {
@@ -142,8 +159,8 @@ export async function startDevServer(
 				bindings: props.bindings,
 				assetPaths: props.assetPaths,
 				isWorkersSite: props.isWorkersSite,
-				port: props.port,
-				ip: props.ip,
+				port: props.initialPort,
+				ip: props.initialIp,
 				localProtocol: props.localProtocol,
 				inspectorPort: props.inspectorPort,
 				inspect: props.inspect,
@@ -190,17 +207,21 @@ async function runEsbuild({
 	jsxFragment,
 	rules,
 	assets,
+	betaD1Shims,
 	serveAssetsFromWorker,
 	tsconfig,
 	minify,
-	nodeCompat,
+	legacyNodeCompat,
+	nodejsCompat,
 	define,
 	noBundle,
 	workerDefinitions,
 	services,
 	firstPartyWorkerDevFacade,
 	testScheduled,
-	experimentalLocalStubCache,
+	local,
+	experimentalLocal,
+	doBindings,
 }: {
 	entry: Entry;
 	destination: string | undefined;
@@ -208,17 +229,21 @@ async function runEsbuild({
 	jsxFragment: string | undefined;
 	rules: Config["rules"];
 	assets: Config["assets"];
+	betaD1Shims?: string[];
 	define: Config["define"];
 	services: Config["services"];
 	serveAssetsFromWorker: boolean;
 	tsconfig: string | undefined;
 	minify: boolean | undefined;
-	nodeCompat: boolean | undefined;
+	legacyNodeCompat: boolean | undefined;
+	nodejsCompat: boolean | undefined;
 	noBundle: boolean;
 	workerDefinitions: WorkerRegistry;
 	firstPartyWorkerDevFacade: boolean | undefined;
 	testScheduled?: boolean;
-	experimentalLocalStubCache: boolean | undefined;
+	local: boolean;
+	experimentalLocal: boolean | undefined;
+	doBindings: DurableObjectBindings;
 }): Promise<EsbuildBundle | undefined> {
 	if (!destination) return;
 
@@ -229,14 +254,7 @@ async function runEsbuild({
 		dependencies,
 		sourceMapPath,
 	}: Awaited<ReturnType<typeof bundleWorker>> = noBundle
-		? {
-				modules: [],
-				dependencies: {},
-				resolvedEntryPointPath: entry.file,
-				bundleType: entry.format === "modules" ? "esm" : "commonjs",
-				stop: undefined,
-				sourceMapPath: undefined,
-		  }
+		? await traverseModuleGraph(entry, rules)
 		: await bundleWorker(entry, destination, {
 				serveAssetsFromWorker,
 				jsxFactory,
@@ -244,7 +262,8 @@ async function runEsbuild({
 				rules,
 				tsconfig,
 				minify,
-				nodeCompat,
+				legacyNodeCompat,
+				nodejsCompat,
 				define,
 				checkFetch: true,
 				assets: assets && {
@@ -252,13 +271,15 @@ async function runEsbuild({
 					// disable the cache in dev
 					bypassCache: true,
 				},
+				betaD1Shims,
 				workerDefinitions,
 				services,
 				firstPartyWorkerDevFacade,
 				targetConsumer: "dev", // We are starting a dev server
-				local: false,
 				testScheduled,
-				experimentalLocalStubCache,
+				local,
+				experimentalLocal,
+				doBindings,
 		  });
 
 	return {
@@ -282,21 +303,22 @@ export async function startLocalServer({
 	bindings,
 	workerDefinitions,
 	assetPaths,
-	port,
+	initialPort,
 	inspectorPort,
 	rules,
 	localPersistencePath,
 	liveReload,
-	ip,
+	initialIp,
 	crons,
 	queueConsumers,
 	localProtocol,
 	localUpstream,
 	inspect,
 	onReady,
-	logPrefix,
 	enablePagesAssetsServiceBinding,
 	experimentalLocal,
+	accountId,
+	experimentalLocalRemoteKv,
 }: LocalProps) {
 	let local: ChildProcess | undefined;
 	let experimentalLocalRef: Miniflare3Type | undefined;
@@ -311,14 +333,11 @@ export async function startLocalServer({
 		if (!bundle || !format) return;
 
 		// port for the worker
-
-		if (port !== 0) {
-			await waitForPortToBeAvailable(port, {
-				retryPeriod: 200,
-				timeout: 2000,
-				abortSignal: abortController.signal,
-			});
-		}
+		await waitForPortToBeAvailable(initialPort, {
+			retryPeriod: 200,
+			timeout: 2000,
+			abortSignal: abortController.signal,
+		});
 
 		if (bindings.services && bindings.services.length > 0) {
 			logger.warn(
@@ -326,15 +345,6 @@ export async function startLocalServer({
 			);
 		}
 
-		// 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);
 
 		const upstream =
@@ -357,12 +367,12 @@ export async function startLocalServer({
 			bundle,
 		});
 
-		const { forkOptions, miniflareCLIPath } = setupMiniflareOptions({
+		const { forkOptions, miniflareCLIPath, options } = setupMiniflareOptions({
 			workerName,
-			port,
+			port: initialPort,
 			scriptPath,
 			localProtocol,
-			ip,
+			ip: initialIp,
 			format,
 			rules,
 			compatibilityDate,
@@ -384,27 +394,38 @@ export async function startLocalServer({
 			dataBlobBindings,
 			crons,
 			upstream,
-			logPrefix,
 			workerDefinitions,
 			enablePagesAssetsServiceBinding,
 		});
 
 		if (experimentalLocal) {
-			// TODO: refactor setupMiniflareOptions so we don't need to parse here
-			const mf2Options: MiniflareOptions = JSON.parse(forkOptions[0]);
-			const mf = await setupExperimentalLocal(mf2Options, format, bundle);
+			const log = await buildMiniflare3Logger();
+			const mf3Options = await transformMf2OptionsToMf3Options({
+				miniflare2Options: options,
+				format,
+				bundle,
+				log,
+				kvNamespaces: bindings?.kv_namespaces,
+				r2Buckets: bindings?.r2_buckets,
+				d1Databases: bindings?.d1_databases,
+				authenticatedAccountId: accountId,
+				kvRemote: experimentalLocalRemoteKv,
+				inspectorPort,
+			});
+			const { Miniflare } = await getMiniflare3();
+			const mf = new Miniflare(mf3Options);
 			const runtimeURL = await mf.ready;
 			experimentalLocalRef = mf;
 			removeSignalExitListener = onExit((_code, _signal) => {
 				logger.log("⎔ Shutting down experimental local server.");
-				mf.dispose();
+				void mf.dispose();
 				experimentalLocalRef = undefined;
 			});
 			onReady?.(runtimeURL.hostname, parseInt(runtimeURL.port ?? 8787));
 			return;
 		}
 
-		const nodeOptions = setupNodeOptions({ inspect, ip, inspectorPort });
+		const nodeOptions = setupNodeOptions({ inspect, inspectorPort });
 		logger.log("⎔ Starting a local server...");
 
 		const child = (local = fork(miniflareCLIPath, forkOptions, {
@@ -421,21 +442,21 @@ export async function startLocalServer({
 					await registerWorker(workerName, {
 						protocol: localProtocol,
 						mode: "local",
-						port: message.mfPort,
-						host: ip,
+						port: message.port,
+						host: initialIp,
 						durableObjects: internalDurableObjects.map((binding) => ({
 							name: binding.name,
 							className: binding.class_name,
 						})),
 						...(message.durableObjectsPort
 							? {
-									durableObjectsHost: ip,
+									durableObjectsHost: initialIp,
 									durableObjectsPort: message.durableObjectsPort,
 							  }
 							: {}),
 					});
 				}
-				onReady?.(ip, message.mfPort);
+				onReady?.(initialIp, message.port);
 			}
 		});
 

package/src/dev/use-esbuild.ts

@@ -4,6 +4,7 @@ import { useApp } from "ink";
 import { useState, useEffect } from "react";
 import { bundleWorker, rewriteNodeCompatBuildFailure } from "../bundle";
 import { logBuildFailure, logger } from "../logger";
+import traverseModuleGraph from "../traverse-module-graph";
 import type { Config } from "../config";
 import type { WorkerRegistry } from "../dev-registry";
 import type { Entry } from "../entry";
@@ -30,7 +31,8 @@ export function useEsbuild({
 	serveAssetsFromWorker,
 	tsconfig,
 	minify,
-	nodeCompat,
+	legacyNodeCompat,
+	nodejsCompat,
 	betaD1Shims,
 	define,
 	noBundle,
@@ -41,7 +43,7 @@ export function useEsbuild({
 	local,
 	targetConsumer,
 	testScheduled,
-	experimentalLocalStubCache,
+	experimentalLocal,
 }: {
 	entry: Entry;
 	destination: string | undefined;
@@ -54,7 +56,8 @@ export function useEsbuild({
 	serveAssetsFromWorker: boolean;
 	tsconfig: string | undefined;
 	minify: boolean | undefined;
-	nodeCompat: boolean | undefined;
+	legacyNodeCompat: boolean | undefined;
+	nodejsCompat: boolean | undefined;
 	betaD1Shims?: string[];
 	noBundle: boolean;
 	workerDefinitions: WorkerRegistry;
@@ -63,7 +66,7 @@ export function useEsbuild({
 	local: boolean;
 	targetConsumer: "dev" | "publish";
 	testScheduled: boolean;
-	experimentalLocalStubCache: boolean | undefined;
+	experimentalLocal: boolean | undefined;
 }): EsbuildBundle | undefined {
 	const [bundle, setBundle] = useState<EsbuildBundle>();
 	const { exit } = useApp();
@@ -85,7 +88,7 @@ export function useEsbuild({
 		const watchMode: WatchMode = {
 			async onRebuild(error) {
 				if (error !== null) {
-					if (!nodeCompat) rewriteNodeCompatBuildFailure(error);
+					if (!legacyNodeCompat) rewriteNodeCompatBuildFailure(error);
 					logBuildFailure(error);
 					logger.error("Watch build failed:", error.message);
 				} else {
@@ -105,14 +108,7 @@ export function useEsbuild({
 				stop,
 				sourceMapPath,
 			}: Awaited<ReturnType<typeof bundleWorker>> = noBundle
-				? {
-						modules: [],
-						dependencies: {},
-						resolvedEntryPointPath: entry.file,
-						bundleType: entry.format === "modules" ? "esm" : "commonjs",
-						stop: undefined,
-						sourceMapPath: undefined,
-				  }
+				? await traverseModuleGraph(entry, rules)
 				: await bundleWorker(entry, destination, {
 						serveAssetsFromWorker,
 						jsxFactory,
@@ -121,8 +117,10 @@ export function useEsbuild({
 						watch: watchMode,
 						tsconfig,
 						minify,
-						nodeCompat,
+						legacyNodeCompat,
+						nodejsCompat,
 						betaD1Shims,
+						doBindings: durableObjects.bindings,
 						define,
 						checkFetch: true,
 						assets: assets && {
@@ -136,7 +134,7 @@ export function useEsbuild({
 						local,
 						targetConsumer,
 						testScheduled,
-						experimentalLocalStubCache,
+						experimentalLocal,
 				  });
 
 			// Capture the `stop()` method to use as the `useEffect()` destructor.
@@ -152,7 +150,7 @@ export function useEsbuild({
 				});
 
 				stopWatching = () => {
-					watcher.close();
+					void watcher.close();
 				};
 			}
 			setBundle({
@@ -187,7 +185,8 @@ export function useEsbuild({
 		exit,
 		noBundle,
 		minify,
-		nodeCompat,
+		legacyNodeCompat,
+		nodejsCompat,
 		define,
 		assets,
 		services,
@@ -198,7 +197,7 @@ export function useEsbuild({
 		local,
 		targetConsumer,
 		testScheduled,
-		experimentalLocalStubCache,
+		experimentalLocal,
 	]);
 	return bundle;
 }

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

@@ -28,4 +28,13 @@ export function validateDevProps(props: DevProps) {
 			"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.tsx → dev-registry.ts}

@@ -13,7 +13,7 @@ import type { HttpTerminator } from "http-terminator";
 const DEV_REGISTRY_PORT = "6284";
 const DEV_REGISTRY_HOST = `http://localhost:${DEV_REGISTRY_PORT}`;
 
-let server: Server;
+let server: Server | null;
 let terminator: HttpTerminator;
 
 export type WorkerRegistry = Record<string, WorkerDefinition>;
@@ -102,6 +102,7 @@ export async function startWorkerRegistry() {
  */
 export async function stopWorkerRegistry() {
 	await terminator?.terminate();
+	server = null;
 }
 
 /**