wrangler 0.0.0-e7a0cd5b → 0.0.0-e87ad068

package/src/dev.tsx

@@ -1,4 +1,5 @@
 import path from "node:path";
+import chalk from "chalk";
 import { watch } from "chokidar";
 import getPort from "get-port";
 import { render } from "ink";
@@ -13,12 +14,11 @@ import { getEntry } from "./entry";
 import { logger } from "./logger";
 import * as metrics from "./metrics";
 import { getAssetPaths, getSiteAssetPaths } from "./sites";
-import { getAccountFromCache } from "./user";
+import { getAccountFromCache, loginOrRefreshIfRequired } from "./user";
 import { collectKeyValues } from "./utils/collectKeyValues";
 import { identifyD1BindingsAsBeta } from "./worker";
 import { getHostFromRoute, getZoneForRoute, getZoneIdFromHost } from "./zones";
 import {
-	type ConfigPath,
 	DEFAULT_INSPECTOR_PORT,
 	DEFAULT_LOCAL_PORT,
 	getDevCompatibilityDate,
@@ -28,59 +28,16 @@ import {
 	printWranglerBanner,
 } from "./index";
 import type { Config, Environment } from "./config";
-import type { Route } from "./config/environment";
-import type { EnablePagesAssetsServiceBindingOptions } from "./miniflare-cli";
-import type { CfWorkerInit } from "./worker";
-import type { CommonYargsOptions } from "./yargs-types";
-import type { Argv, ArgumentsCamelCase } from "yargs";
-
-interface DevArgs {
-	config?: string;
-	script?: string;
-	name?: string;
-	bundle?: boolean;
-	build?: boolean;
-	format?: string;
-	env?: string;
-	"compatibility-date"?: string;
-	"compatibility-flags"?: string[];
-	latest?: boolean;
-	ip?: string;
-	inspect?: boolean;
-	port?: number;
-	"inspector-port"?: number;
-	routes?: string[];
-	host?: string;
-	"local-protocol"?: "http" | "https";
-	"local-upstream"?: string | undefined;
-	"experimental-public"?: string;
-	public?: string;
-	assets?: string;
-	site?: string;
-	"site-include"?: string[];
-	"site-exclude"?: string[];
-	"upstream-protocol"?: "http" | "https";
-	"jsx-factory"?: string;
-	"jsx-fragment"?: string;
-	tsconfig?: string;
-	local?: boolean;
-	"experimental-local"?: boolean;
-	minify?: boolean;
-	var?: string[];
-	define?: string[];
-	"node-compat"?: boolean;
-	"experimental-enable-local-persistence"?: boolean;
-	persist?: boolean;
-	"persist-to"?: string;
-	"live-reload"?: boolean;
-	onReady?: (ip: string, port: number) => void;
-	logLevel?: "none" | "info" | "error" | "log" | "warn" | "debug";
-	logPrefix?: string;
-	showInteractiveDevSession?: boolean;
-	"test-scheduled"?: boolean;
-}
-
-export function devOptions(yargs: Argv<CommonYargsOptions>): Argv<DevArgs> {
+import type { Route, Rule } from "./config/environment";
+import type { LoggerLevel } from "./logger";
+import type { EnablePagesAssetsServiceBindingOptions } from "./miniflare-cli/types";
+import type { CfWorkerInit, CfModule } from "./worker";
+import type {
+	CommonYargsArgv,
+	StrictYargsOptionsToInterface,
+} from "./yargs-types";
+
+export function devOptions(yargs: CommonYargsArgv) {
 	return (
 		yargs
 			.positional("script", {
@@ -175,6 +132,13 @@ export function devOptions(yargs: Argv<CommonYargsOptions>): Argv<DevArgs> {
 				type: "string",
 				requiresArg: true,
 			})
+			.option("public", {
+				describe: "(Deprecated) Static assets to be served",
+				type: "string",
+				requiresArg: true,
+				deprecated: true,
+				hidden: true,
+			})
 			.option("site", {
 				describe: "Root folder of static assets for Workers Sites",
 				type: "string",
@@ -237,11 +201,25 @@ export function devOptions(yargs: Argv<CommonYargsOptions>): Argv<DevArgs> {
 				type: "boolean",
 				default: false,
 			})
+			.option("experimental-local-remote-kv", {
+				describe:
+					"Read/write KV data from/to real namespaces on the Cloudflare network",
+				type: "boolean",
+				default: false,
+			})
 			.check((argv) => {
 				if (argv.local && argv["experimental-local"]) {
 					throw new Error(
 						"--local and --experimental-local are mutually exclusive. " +
-							"Please select one or the other."
+							"Please enable one or the other."
+					);
+				}
+				if (
+					argv["experimental-local-remote-kv"] &&
+					!argv["experimental-local"]
+				) {
+					throw new Error(
+						"--experimental-local-remote-kv requires --experimental-local to be enabled."
 					);
 				}
 				return true;
@@ -251,7 +229,7 @@ export function devOptions(yargs: Argv<CommonYargsOptions>): Argv<DevArgs> {
 				type: "boolean",
 			})
 			.option("node-compat", {
-				describe: "Enable node.js compatibility",
+				describe: "Enable Node.js compatibility",
 				type: "boolean",
 			})
 			.option("experimental-enable-local-persistence", {
@@ -273,11 +251,20 @@ export function devOptions(yargs: Argv<CommonYargsOptions>): Argv<DevArgs> {
 				requiresArg: true,
 			})
 			.option("live-reload", {
-				// TODO: Add back in once we have remote `--live-reload`
-				hidden: true,
-				// describe: "Auto reload HTML pages when change is detected",
+				describe:
+					"Auto reload HTML pages when change is detected in local mode",
 				type: "boolean",
 			})
+			.check((argv) => {
+				const local = argv["local"] || argv["experimental-local"];
+				if (argv["live-reload"] && !local) {
+					throw new Error(
+						"--live-reload is only supported in local mode. " +
+							"Please enable either --local or --experimental-local."
+					);
+				}
+				return true;
+			})
 			.option("inspect", {
 				describe: "Enable dev tools",
 				type: "boolean",
@@ -297,12 +284,24 @@ export function devOptions(yargs: Argv<CommonYargsOptions>): Argv<DevArgs> {
 			.option("log-level", {
 				choices: ["debug", "info", "log", "warn", "error", "none"] as const,
 				describe: "Specify logging level",
-				default: "log",
+				// Yargs requires this to type log-level properly
+				default: "log" as LoggerLevel,
 			})
 	);
 }
 
-export async function devHandler(args: ArgumentsCamelCase<DevArgs>) {
+type DevArguments = StrictYargsOptionsToInterface<typeof devOptions>;
+
+export async function devHandler(args: DevArguments) {
+	if (!(args.local || args.experimentalLocal)) {
+		const isLoggedIn = await loginOrRefreshIfRequired();
+		if (!isLoggedIn) {
+			throw new Error(
+				"You must be logged in to use wrangler dev in remote mode. Try logging in, or run wrangler dev --local."
+			);
+		}
+	}
+
 	let watcher;
 	try {
 		const devInstance = await startDev(args);
@@ -335,14 +334,22 @@ export type AdditionalDevProps = {
 		preview_bucket_name?: string;
 	}[];
 	d1Databases?: Environment["d1_databases"];
+	processEntrypoint?: boolean;
+	additionalModules?: CfModule[];
+	moduleRoot?: string;
+	rules?: Rule[];
+	constellation?: Environment["constellation"];
 };
 
-type StartDevOptions = ArgumentsCamelCase<DevArgs> &
+type StartDevOptions = DevArguments &
 	// These options can be passed in directly when called with the `wrangler.dev()` API.
 	// They aren't exposed as CLI arguments.
 	AdditionalDevProps & {
 		forceLocal?: boolean;
+		disableDevRegistry?: boolean;
 		enablePagesAssetsServiceBinding?: EnablePagesAssetsServiceBindingOptions;
+		onReady?: (ip: string, port: number) => void;
+		showInteractiveDevSession?: boolean;
 	};
 
 export async function startDev(args: StartDevOptions) {
@@ -354,10 +361,19 @@ export async function startDev(args: StartDevOptions) {
 		}
 		await printWranglerBanner();
 
+		if (args.local && process.platform !== "win32") {
+			logger.info(
+				chalk.magenta(
+					`Want to try out the next version of local mode using the open-source Workers runtime?\nSwitch out --local for ${chalk.bold(
+						"--experimental-local"
+					)} and let us know what you think at https://discord.gg/cloudflaredev !`
+				)
+			);
+		}
+
 		const configPath =
-			(args.config as ConfigPath) ||
-			((args.script &&
-				findWranglerToml(path.dirname(args.script))) as ConfigPath);
+			args.config ||
+			(args.script && findWranglerToml(path.dirname(args.script)));
 		let config = readConfig(configPath, args);
 
 		if (config.configPath) {
@@ -376,7 +392,8 @@ export async function startDev(args: StartDevOptions) {
 
 		const {
 			entry,
-			nodeCompat,
+			legacyNodeCompat,
+			nodejsCompat,
 			upstreamProtocol,
 			zoneId,
 			host,
@@ -385,6 +402,8 @@ export async function startDev(args: StartDevOptions) {
 			getInspectorPort,
 			cliDefines,
 			localPersistencePath,
+			processEntrypoint,
+			additionalModules,
 		} = await validateDevServerSettings(args, config);
 
 		await metrics.sendMetricsEvent(
@@ -398,7 +417,7 @@ export async function startDev(args: StartDevOptions) {
 
 		// eslint-disable-next-line no-inner-declarations
 		async function getDevReactElement(configParam: Config) {
-			const { assetPaths, bindings } = await getBindingsAndAssetPaths(
+			const { assetPaths, bindings } = getBindingsAndAssetPaths(
 				args,
 				configParam
 			);
@@ -412,31 +431,36 @@ export async function startDev(args: StartDevOptions) {
 					zone={zoneId}
 					host={host}
 					routes={routes}
-					rules={getRules(configParam)}
+					processEntrypoint={processEntrypoint}
+					additionalModules={additionalModules}
+					rules={args.rules ?? getRules(configParam)}
 					legacyEnv={isLegacyEnv(configParam)}
 					minify={args.minify ?? configParam.minify}
-					nodeCompat={nodeCompat}
+					legacyNodeCompat={legacyNodeCompat}
+					nodejsCompat={nodejsCompat}
 					build={configParam.build || {}}
 					define={{ ...configParam.define, ...cliDefines }}
 					initialMode={
 						args.local || args.experimentalLocal ? "local" : "remote"
 					}
-					jsxFactory={args["jsx-factory"] || configParam.jsx_factory}
-					jsxFragment={args["jsx-fragment"] || configParam.jsx_fragment}
+					jsxFactory={args.jsxFactory || configParam.jsx_factory}
+					jsxFragment={args.jsxFragment || configParam.jsx_fragment}
 					tsconfig={args.tsconfig ?? configParam.tsconfig}
 					upstreamProtocol={upstreamProtocol}
 					localProtocol={args.localProtocol || configParam.dev.local_protocol}
-					localUpstream={args["local-upstream"] || host}
+					localUpstream={args.localUpstream ?? host}
 					localPersistencePath={localPersistencePath}
 					liveReload={args.liveReload || false}
 					accountId={configParam.account_id || getAccountFromCache()?.id}
 					assetPaths={assetPaths}
 					assetsConfig={configParam.assets}
-					port={args.port || configParam.dev.port || (await getLocalPort())}
-					ip={args.ip || configParam.dev.ip}
+					initialPort={
+						args.port ?? configParam.dev.port ?? (await getLocalPort())
+					}
+					initialIp={args.ip || configParam.dev.ip}
 					inspectorPort={
-						args.inspectorPort ||
-						configParam.dev.inspector_port ||
+						args.inspectorPort ??
+						configParam.dev.inspector_port ??
 						(await getInspectorPort())
 					}
 					isWorkersSite={Boolean(args.site || configParam.site)}
@@ -451,7 +475,6 @@ export async function startDev(args: StartDevOptions) {
 					bindings={bindings}
 					crons={configParam.triggers.crons}
 					queueConsumers={configParam.queues.consumers}
-					logPrefix={args.logPrefix}
 					onReady={args.onReady}
 					inspect={args.inspect ?? true}
 					showInteractiveDevSession={args.showInteractiveDevSession}
@@ -459,17 +482,35 @@ export async function startDev(args: StartDevOptions) {
 					enablePagesAssetsServiceBinding={args.enablePagesAssetsServiceBinding}
 					firstPartyWorker={configParam.first_party_worker}
 					sendMetrics={configParam.send_metrics}
-					testScheduled={args["test-scheduled"]}
+					testScheduled={args.testScheduled}
 					experimentalLocal={args.experimentalLocal}
+					experimentalLocalRemoteKv={args.experimentalLocalRemoteKv}
 				/>
 			);
 		}
 		const devReactElement = render(await getDevReactElement(config));
+
+		// In the bootstrapper script `bin/wrangler.js`, we open an IPC channel, so
+		// IPC messages from this process are propagated through the bootstrapper.
+		// Normally, Node's SIGINT handler would close this for us, but interactive
+		// mode enables raw mode on stdin which disables the built-in handler. The
+		// following line disconnects from the IPC channel when we press `x` or
+		// CTRL-C in interactive mode, ensuring no open handles, and allowing for a
+		// clean exit. Note, if we called `stop()` using the dev API, we don't want
+		// to disconnect here, as the user may still need IPC. We also don't want
+		// to disconnect if this file was imported in Jest (not the case with E2E
+		// tests), as that would stop communication with the test runner.
+		let apiStopped = false;
+		void devReactElement.waitUntilExit().then(() => {
+			if (!apiStopped && typeof jest === "undefined") process.disconnect?.();
+		});
+
 		rerender = devReactElement.rerender;
 		return {
 			devReactElement,
 			watcher,
 			stop: async () => {
+				apiStopped = true;
 				devReactElement.unmount();
 				await watcher?.close();
 			},
@@ -486,14 +527,13 @@ export async function startApiDev(args: StartDevOptions) {
 	await printWranglerBanner();
 
 	const configPath =
-		(args.config as ConfigPath) ||
-		((args.script &&
-			findWranglerToml(path.dirname(args.script))) as ConfigPath);
+		args.config || (args.script && findWranglerToml(path.dirname(args.script)));
 	const config = readConfig(configPath, args);
 
 	const {
 		entry,
-		nodeCompat,
+		legacyNodeCompat,
+		nodejsCompat,
 		upstreamProtocol,
 		zoneId,
 		host,
@@ -502,6 +542,8 @@ export async function startApiDev(args: StartDevOptions) {
 		getInspectorPort,
 		cliDefines,
 		localPersistencePath,
+		processEntrypoint,
+		additionalModules,
 	} = await validateDevServerSettings(args, config);
 
 	await metrics.sendMetricsEvent(
@@ -512,7 +554,7 @@ export async function startApiDev(args: StartDevOptions) {
 
 	// eslint-disable-next-line no-inner-declarations
 	async function getDevServer(configParam: Config) {
-		const { assetPaths, bindings } = await getBindingsAndAssetPaths(
+		const { assetPaths, bindings } = getBindingsAndAssetPaths(
 			args,
 			configParam
 		);
@@ -529,49 +571,46 @@ export async function startApiDev(args: StartDevOptions) {
 			zone: zoneId,
 			host: host,
 			routes: routes,
-			rules: getRules(configParam),
+			processEntrypoint,
+			additionalModules,
+			rules: args.rules ?? getRules(configParam),
 			legacyEnv: isLegacyEnv(configParam),
 			minify: args.minify ?? configParam.minify,
-			nodeCompat: nodeCompat,
+			legacyNodeCompat,
+			nodejsCompat,
 			build: configParam.build || {},
 			define: { ...config.define, ...cliDefines },
 			initialMode: args.local ? "local" : "remote",
-			jsxFactory: args["jsx-factory"] || configParam.jsx_factory,
-			jsxFragment: args["jsx-fragment"] || configParam.jsx_fragment,
+			jsxFactory: args.jsxFactory ?? configParam.jsx_factory,
+			jsxFragment: args.jsxFragment ?? configParam.jsx_fragment,
 			tsconfig: args.tsconfig ?? configParam.tsconfig,
 			upstreamProtocol: upstreamProtocol,
-			localProtocol: args.localProtocol || configParam.dev.local_protocol,
-			localUpstream: args["local-upstream"] || host,
+			localProtocol: args.localProtocol ?? configParam.dev.local_protocol,
+			localUpstream: args.localUpstream ?? host,
 			localPersistencePath,
-			liveReload: args.liveReload || false,
-			accountId: configParam.account_id || getAccountFromCache()?.id,
+			liveReload: args.liveReload ?? false,
+			accountId: configParam.account_id ?? getAccountFromCache()?.id,
 			assetPaths: assetPaths,
 			assetsConfig: configParam.assets,
 			//port can be 0, which means to use a random port
-			port:
-				args.port === 0
-					? args.port
-					: args.port || configParam.dev.port || (await getLocalPort()),
-			ip: args.ip || configParam.dev.ip,
+			initialPort: args.port ?? configParam.dev.port ?? (await getLocalPort()),
+			initialIp: args.ip ?? configParam.dev.ip,
 			inspectorPort:
-				args["inspector-port"] ||
-				configParam.dev.inspector_port ||
+				args.inspectorPort ??
+				configParam.dev.inspector_port ??
 				(await getInspectorPort()),
 			isWorkersSite: Boolean(args.site || configParam.site),
 			compatibilityDate: getDevCompatibilityDate(
 				config,
 				// Only `compatibilityDate` will be set when using `unstable_dev`
-				args["compatibility-date"] ?? args.compatibilityDate
+				args.compatibilityDate
 			),
 			compatibilityFlags:
-				args["compatibility-flags"] ??
-				args.compatibilityFlags ??
-				configParam.compatibility_flags,
+				args.compatibilityFlags ?? configParam.compatibility_flags,
 			usageModel: configParam.usage_model,
 			bindings: bindings,
 			crons: configParam.triggers.crons,
 			queueConsumers: configParam.queues.consumers,
-			logPrefix: args.logPrefix,
 			onReady: args.onReady,
 			inspect: args.inspect ?? true,
 			showInteractiveDevSession: args.showInteractiveDevSession,
@@ -582,6 +621,8 @@ export async function startApiDev(args: StartDevOptions) {
 			sendMetrics: configParam.send_metrics,
 			testScheduled: args.testScheduled,
 			experimentalLocal: args.experimentalLocal,
+			experimentalLocalRemoteKv: args.experimentalLocalRemoteKv,
+			disableDevRegistry: args.disableDevRegistry ?? false,
 		});
 	}
 
@@ -633,7 +674,7 @@ async function getZoneIdHostAndRoutes(args: StartDevOptions, config: Config) {
 		args.local = true;
 	}
 
-	if (!args.local) {
+	if (!args.local && !args.experimentalLocal) {
 		if (host) {
 			zoneId = await getZoneIdFromHost(host);
 		}
@@ -659,7 +700,7 @@ async function validateDevServerSettings(
 	config: Config
 ) {
 	const entry = await getEntry(
-		{ assets: args.assets, script: args.script },
+		{ assets: args.assets, script: args.script, moduleRoot: args.moduleRoot },
 		config,
 		"dev"
 	);
@@ -687,8 +728,7 @@ async function validateDevServerSettings(
 			"Passing --inspect is unnecessary, now you can always connect to devtools."
 		);
 	}
-
-	if (args["experimental-public"]) {
+	if (args.experimentalPublic) {
 		throw new Error(
 			"The --experimental-public field has been renamed to --assets"
 		);
@@ -698,7 +738,7 @@ async function validateDevServerSettings(
 		throw new Error("The --public field has been renamed to --assets");
 	}
 
-	if ((args.assets || config.assets) && (args.site || config.site)) {
+	if ((args.assets ?? config.assets) && (args.site ?? config.site)) {
 		throw new Error("Cannot use Assets and Workers Sites in the same Worker.");
 	}
 
@@ -708,18 +748,27 @@ async function validateDevServerSettings(
 		);
 	}
 	const upstreamProtocol =
-		args["upstream-protocol"] || config.dev.upstream_protocol;
+		args.upstreamProtocol ?? config.dev.upstream_protocol;
 	if (upstreamProtocol === "http") {
 		logger.warn(
 			"Setting upstream-protocol to http is not currently implemented.\n" +
 				"If this is required in your project, please add your use case to the following issue:\n" +
-				"https://github.com/cloudflare/wrangler2/issues/583."
+				"https://github.com/cloudflare/workers-sdk/issues/583."
 		);
 	}
-	const nodeCompat = args.nodeCompat ?? config.node_compat;
-	if (nodeCompat) {
+	const legacyNodeCompat = args.nodeCompat ?? config.node_compat;
+	if (legacyNodeCompat) {
 		logger.warn(
-			"Enabling node.js compatibility mode for built-ins and globals. This is experimental and has serious tradeoffs. Please see https://github.com/ionic-team/rollup-plugin-node-polyfills/ for more details."
+			"Enabling Node.js compatibility mode for built-ins and globals. This is experimental and has serious tradeoffs. Please see https://github.com/ionic-team/rollup-plugin-node-polyfills/ for more details."
+		);
+	}
+
+	const compatibilityFlags =
+		args.compatibilityFlags ?? config.compatibility_flags;
+	const nodejsCompat = compatibilityFlags?.includes("nodejs_compat");
+	if (legacyNodeCompat && nodejsCompat) {
+		throw new Error(
+			"The `nodejs_compat` compatibility flag cannot be used in conjunction with the legacy `--node-compat` flag. If you want to use the Workers runtime Node.js compatibility features, please remove the `--node-compat` argument from your CLI command or `node_compat = true` from your config file."
 		);
 	}
 
@@ -742,7 +791,8 @@ async function validateDevServerSettings(
 	return {
 		entry,
 		upstreamProtocol,
-		nodeCompat,
+		legacyNodeCompat,
+		nodejsCompat,
 		getLocalPort,
 		getInspectorPort,
 		zoneId,
@@ -750,17 +800,16 @@ async function validateDevServerSettings(
 		routes,
 		cliDefines,
 		localPersistencePath,
+		processEntrypoint: !!args.processEntrypoint,
+		additionalModules: args.additionalModules ?? [],
 	};
 }
 
-async function getBindingsAndAssetPaths(
-	args: StartDevOptions,
-	configParam: Config
-) {
+function getBindingsAndAssetPaths(args: StartDevOptions, configParam: Config) {
 	const cliVars = collectKeyValues(args.var);
 
 	// now log all available bindings into the terminal
-	const bindings = await getBindings(configParam, args.env, {
+	const bindings = getBindings(configParam, args.env, args.local ?? false, {
 		kv: args.kv,
 		vars: { ...args.vars, ...cliVars },
 		durableObjects: args.durableObjects,
@@ -787,11 +836,12 @@ async function getBindingsAndAssetPaths(
 	return { assetPaths, bindings };
 }
 
-async function getBindings(
+function getBindings(
 	configParam: Config,
 	env: string | undefined,
+	local: boolean,
 	args: AdditionalDevProps
-): Promise<CfWorkerInit["bindings"]> {
+): CfWorkerInit["bindings"] {
 	const bindings = {
 		kv_namespaces: [
 			...(configParam.kv_namespaces || []).map(
@@ -817,14 +867,15 @@ async function getBindings(
 			),
 			...(args.kv || []),
 		],
+		send_email: configParam.send_email,
 		// Use a copy of combinedVars since we're modifying it later
 		vars: {
 			...getVarsForDev(configParam, env),
 			...args.vars,
 		},
-		metadata_binding: configParam.metadata_binding,
 		wasm_modules: configParam.wasm_modules,
 		text_blobs: configParam.text_blobs,
+		browser: configParam.browser,
 		data_blobs: configParam.data_blobs,
 		durable_objects: {
 			bindings: [
@@ -856,13 +907,39 @@ async function getBindings(
 			...(args.r2 || []),
 		],
 		dispatch_namespaces: configParam.dispatch_namespaces,
+		mtls_certificates: configParam.mtls_certificates,
 		services: configParam.services,
-		unsafe: configParam.unsafe?.bindings,
+		analytics_engine_datasets: configParam.analytics_engine_datasets,
+		unsafe: {
+			bindings: configParam.unsafe.bindings,
+			metadata: configParam.unsafe.metadata,
+		},
 		logfwdr: configParam.logfwdr,
 		d1_databases: identifyD1BindingsAsBeta([
-			...configParam.d1_databases,
+			...(configParam.d1_databases ?? []).map((d1Db) => {
+				//in local dev, bindings don't matter
+				if (local) {
+					return {
+						...d1Db,
+						database_id: "local",
+					};
+				}
+				// if you have a preview_database_id, we'll use it, but we shouldn't force people to use it.
+				if (!d1Db.preview_database_id && !process.env.NO_D1_WARNING) {
+					logger.log(
+						`--------------------\n💡 Recommendation: for development, use a preview D1 database rather than the one you'd use in production.\n💡 Create a new D1 database with "wrangler d1 create <name>" and add its id as preview_database_id to the d1_database "${d1Db.binding}" in your wrangler.toml\n--------------------\n`
+					);
+				}
+				return {
+					...d1Db,
+					database_id: d1Db.preview_database_id
+						? d1Db.preview_database_id
+						: d1Db.database_id,
+				};
+			}),
 			...(args.d1Databases || []),
 		]),
+		constellation: configParam.constellation,
 	};
 
 	return bindings;