wrangler 0.0.0-e7a0cd5b → 0.0.0-e87ad068

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,
@@ -105,6 +107,8 @@ export function Remote(props: RemoteProps) {
 		logToTerminal: true,
 		sourceMapPath: props.sourceMapPath,
 		host: previewToken?.host,
+		name: props.name,
+		sourceMapMetadata: props.bundle?.sourceMapMetadata,
 	});
 
 	const errorHandler = useErrorHandler();
@@ -302,13 +306,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 +497,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);
 			}
 		}
@@ -571,6 +576,8 @@ async function createRemoteWorkerInit(props: {
 		usage_model: props.usageModel,
 		keepVars: true,
 		logpush: false,
+		placement: undefined, // no placement in dev
+		tail_consumers: undefined, // no tail consumers in dev - TODO revist?
 	};
 
 	return init;
@@ -601,3 +608,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,11 +1,10 @@
 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";
 import tmp from "tmp-promise";
-import { bundleWorker } from "../bundle";
+import { bundleWorker, dedupeModulesByName } from "../bundle";
 import {
 	getBoundRegisteredWorkers,
 	registerWorker,
@@ -15,29 +14,34 @@ 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 { CfModule } from "../worker";
 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,25 +65,36 @@ 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,
 			destination: directory.name,
 			jsxFactory: props.jsxFactory,
+			processEntrypoint: props.processEntrypoint,
+			additionalModules: props.additionalModules,
 			rules: props.rules,
 			jsxFragment: props.jsxFragment,
 			serveAssetsFromWorker: Boolean(
@@ -87,15 +102,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 +126,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 +136,15 @@ 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,
+				sourceMapPath: bundle?.sourceMapPath,
 			});
 
 			return {
@@ -142,8 +163,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,
@@ -188,87 +209,111 @@ async function runEsbuild({
 	destination,
 	jsxFactory,
 	jsxFragment,
+	processEntrypoint,
+	additionalModules,
 	rules,
 	assets,
+	betaD1Shims,
 	serveAssetsFromWorker,
 	tsconfig,
 	minify,
-	nodeCompat,
+	legacyNodeCompat,
+	nodejsCompat,
 	define,
 	noBundle,
 	workerDefinitions,
 	services,
 	firstPartyWorkerDevFacade,
 	testScheduled,
-	experimentalLocalStubCache,
+	local,
+	experimentalLocal,
+	doBindings,
 }: {
 	entry: Entry;
 	destination: string | undefined;
 	jsxFactory: string | undefined;
 	jsxFragment: string | undefined;
+	processEntrypoint: boolean;
+	additionalModules: CfModule[];
 	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;
 
-	const {
-		resolvedEntryPointPath,
-		bundleType,
-		modules,
-		dependencies,
-		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,
-				tsconfig,
-				minify,
-				nodeCompat,
-				define,
-				checkFetch: true,
-				assets: assets && {
-					...assets,
-					// disable the cache in dev
-					bypassCache: true,
-				},
-				workerDefinitions,
-				services,
-				firstPartyWorkerDevFacade,
-				targetConsumer: "dev", // We are starting a dev server
-				local: false,
-				testScheduled,
-				experimentalLocalStubCache,
-		  });
+	let traverseModuleGraphResult:
+		| Awaited<ReturnType<typeof bundleWorker>>
+		| undefined;
+	let bundleResult: Awaited<ReturnType<typeof bundleWorker>> | undefined;
+	if (noBundle) {
+		traverseModuleGraphResult = await traverseModuleGraph(entry, rules);
+	}
+
+	if (processEntrypoint || !noBundle) {
+		bundleResult = await bundleWorker(entry, destination, {
+			bundle: !noBundle,
+			disableModuleCollection: noBundle,
+			serveAssetsFromWorker,
+			jsxFactory,
+			jsxFragment,
+			rules,
+			tsconfig,
+			minify,
+			legacyNodeCompat,
+			nodejsCompat,
+			define,
+			checkFetch: true,
+			assets: assets && {
+				...assets,
+				// disable the cache in dev
+				bypassCache: true,
+			},
+			betaD1Shims,
+			workerDefinitions,
+			services,
+			firstPartyWorkerDevFacade,
+			targetConsumer: "dev", // We are starting a dev server
+			testScheduled,
+			local,
+			experimentalLocal,
+			doBindings,
+			additionalModules: dedupeModulesByName([
+				...(traverseModuleGraphResult?.modules ?? []),
+				...additionalModules,
+			]),
+		});
+	}
 
 	return {
 		id: 0,
 		entry,
-		path: resolvedEntryPointPath,
-		type: bundleType,
-		modules,
-		dependencies,
-		sourceMapPath,
+		path: bundleResult?.resolvedEntryPointPath ?? entry.file,
+		type:
+			bundleResult?.bundleType ??
+			(entry.format === "modules" ? "esm" : "commonjs"),
+		modules: bundleResult
+			? bundleResult.modules
+			: dedupeModulesByName([
+					...(traverseModuleGraphResult?.modules ?? []),
+					...additionalModules,
+			  ]),
+		dependencies: bundleResult?.dependencies ?? {},
+		sourceMapPath: bundleResult?.sourceMapPath,
+		sourceMapMetadata: bundleResult?.sourceMapMetadata,
 	};
 }
 
@@ -282,21 +327,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 +357,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 +369,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 +391,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 +418,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 +466,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);
 			}
 		});