wrangler 0.0.0-ea7ee45 → 0.0.0-eab9542

package/src/config/validation.ts

@@ -832,6 +832,7 @@ function normalizeAndValidateEnvironment(
 
 	experimental(diagnostics, rawEnv, "unsafe");
 	experimental(diagnostics, rawEnv, "services");
+	experimental(diagnostics, rawEnv, "worker_namespaces");
 
 	const route = normalizeAndValidateRoute(diagnostics, topLevelEnv, rawEnv);
 
@@ -1017,6 +1018,16 @@ function normalizeAndValidateEnvironment(
 			validateBindingArray(envName, validateServiceBinding),
 			[]
 		),
+		worker_namespaces: notInheritable(
+			diagnostics,
+			topLevelEnv,
+			rawConfig,
+			rawEnv,
+			envName,
+			"worker_namespaces",
+			validateBindingArray(envName, validateWorkerNamespaceBinding),
+			[]
+		),
 		unsafe: notInheritable(
 			diagnostics,
 			topLevelEnv,
@@ -1030,6 +1041,14 @@ function normalizeAndValidateEnvironment(
 			}
 		),
 		zone_id: rawEnv.zone_id,
+		no_bundle: inheritable(
+			diagnostics,
+			topLevelEnv,
+			rawEnv,
+			"no_bundle",
+			isBoolean,
+			undefined
+		),
 		minify: inheritable(
 			diagnostics,
 			topLevelEnv,
@@ -1656,6 +1675,7 @@ const validateBindingsHaveUniqueNames = (
 
 	return !hasDuplicates;
 };
+
 const validateServiceBinding: ValidatorFn = (diagnostics, field, value) => {
 	if (typeof value !== "object" || value === null) {
 		diagnostics.errors.push(
@@ -1691,3 +1711,35 @@ const validateServiceBinding: ValidatorFn = (diagnostics, field, value) => {
 	}
 	return isValid;
 };
+
+const validateWorkerNamespaceBinding: ValidatorFn = (
+	diagnostics,
+	field,
+	value
+) => {
+	if (typeof value !== "object" || value === null) {
+		diagnostics.errors.push(
+			`"${field}" binding should be objects, but got ${JSON.stringify(value)}`
+		);
+		return false;
+	}
+	let isValid = true;
+	// Worker namespace bindings must have a binding, and a namespace.
+	if (!isRequiredProperty(value, "binding", "string")) {
+		diagnostics.errors.push(
+			`"${field}" should have a string "binding" field but got ${JSON.stringify(
+				value
+			)}.`
+		);
+		isValid = false;
+	}
+	if (!isRequiredProperty(value, "namespace", "string")) {
+		diagnostics.errors.push(
+			`"${field}" should have a string "namespace" field but got ${JSON.stringify(
+				value
+			)}.`
+		);
+		isValid = false;
+	}
+	return isValid;
+};

package/src/config-cache.ts

@@ -1,44 +1,83 @@
 import { mkdirSync, readFileSync, rmSync, writeFileSync } from "fs";
-import { dirname, join } from "path";
+import * as path from "path";
+import { findUpSync } from "find-up";
+import isInteractive from "./is-interactive";
+import { logger } from "./logger";
 
 let cacheMessageShown = false;
 
-const cacheFolder = "node_modules/.cache/wrangler";
+let __cacheFolder: string | null;
+function getCacheFolder() {
+	if (__cacheFolder || __cacheFolder === null) return __cacheFolder;
 
-const showCacheMessage = () => {
-	if (!cacheMessageShown) {
-		console.log(
-			`Using cached values in '${cacheFolder}'. This is used as a temporary store to improve the developer experience for some commands. It may be purged at any time. It doesn't contain any sensitive information, but it should not be commited into source control.`
-		);
-		cacheMessageShown = true;
+	const closestNodeModulesDirectory = findUpSync("node_modules", {
+		type: "directory",
+	});
+	__cacheFolder = closestNodeModulesDirectory
+		? path.join(closestNodeModulesDirectory, ".cache/wrangler")
+		: null;
+
+	if (!__cacheFolder) {
+		logger.debug("No folder available to cache configuration");
+	}
+	return __cacheFolder;
+}
+
+const arrayFormatter = new Intl.ListFormat("en", {
+	style: "long",
+	type: "conjunction",
+});
+
+function showCacheMessage(fields: string[], folder: string) {
+	if (!cacheMessageShown && isInteractive()) {
+		if (fields.length > 0) {
+			logger.log(
+				`Retrieving cached values for ${arrayFormatter.format(
+					fields
+				)} from ${path.relative(process.cwd(), folder)}`
+			);
+			cacheMessageShown = true;
+		}
 	}
-};
+}
 
-export const getConfigCache = <T>(fileName: string): Partial<T> => {
+export function getConfigCache<T>(fileName: string): Partial<T> {
 	try {
-		const configCacheLocation = join(cacheFolder, fileName);
-		const configCache = JSON.parse(readFileSync(configCacheLocation, "utf-8"));
-		showCacheMessage();
-		return configCache;
-	} catch {
+		const cacheFolder = getCacheFolder();
+		if (cacheFolder) {
+			const configCacheLocation = path.join(cacheFolder, fileName);
+			const configCache = JSON.parse(
+				readFileSync(configCacheLocation, "utf-8")
+			);
+			showCacheMessage(Object.keys(configCache), cacheFolder);
+			return configCache;
+		} else return {};
+	} catch (err) {
 		return {};
 	}
-};
+}
 
-export const saveToConfigCache = <T>(
+export function saveToConfigCache<T>(
 	fileName: string,
 	newValues: Partial<T>
-) => {
-	const configCacheLocation = join(cacheFolder, fileName);
-	const existingValues = getConfigCache(fileName);
-
-	mkdirSync(dirname(configCacheLocation), { recursive: true });
-	writeFileSync(
-		configCacheLocation,
-		JSON.stringify({ ...existingValues, ...newValues }, null, 2)
-	);
-};
-
-export const purgeConfigCaches = () => {
-	rmSync(cacheFolder, { recursive: true, force: true });
-};
+): void {
+	const cacheFolder = getCacheFolder();
+	if (cacheFolder) {
+		logger.debug(`Saving to cache: ${JSON.stringify(newValues)}`);
+		const configCacheLocation = path.join(cacheFolder, fileName);
+		const existingValues = getConfigCache(fileName);
+
+		mkdirSync(path.dirname(configCacheLocation), { recursive: true });
+		writeFileSync(
+			configCacheLocation,
+			JSON.stringify({ ...existingValues, ...newValues }, null, 2)
+		);
+	}
+}
+
+export function purgeConfigCaches() {
+	const cacheFolder = getCacheFolder();
+	if (cacheFolder) {
+		rmSync(cacheFolder, { recursive: true, force: true });
+	}
+}

package/src/create-worker-upload-form.ts

@@ -50,6 +50,7 @@ export interface WorkerMetadata {
 		  }
 		| { type: "r2_bucket"; name: string; bucket_name: string }
 		| { type: "service"; name: string; service: string; environment?: string }
+		| { type: "namespace"; name: string; namespace: string }
 	)[];
 }
 
@@ -116,6 +117,14 @@ export function createWorkerUploadForm(worker: CfWorkerInit): FormData {
 		});
 	});
 
+	bindings.worker_namespaces?.forEach(({ binding, namespace }) => {
+		metadataBindings.push({
+			name: binding,
+			type: "namespace",
+			namespace,
+		});
+	});
+
 	for (const [name, filePath] of Object.entries(bindings.wasm_modules || {})) {
 		metadataBindings.push({
 			name,

package/src/dev/dev.tsx

@@ -24,7 +24,7 @@ import type { CfWorkerInit } from "../worker";
 
 export type DevProps = {
 	name: string | undefined;
-	noBuild: boolean;
+	noBundle: boolean;
 	entry: Entry;
 	port: number;
 	ip: string;
@@ -155,7 +155,7 @@ function DevSession(props: DevSessionProps) {
 		minify: props.minify,
 		nodeCompat: props.nodeCompat,
 		define: props.define,
-		noBuild: props.noBuild,
+		noBundle: props.noBundle,
 	});
 
 	return props.local ? (

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,7 +13,7 @@ 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;
@@ -67,7 +67,7 @@ function useLocalWorker({
 	logLevel,
 }: LocalProps) {
 	// TODO: pass vars via command line
-	const local = useRef<ReturnType<typeof spawn>>();
+	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
@@ -236,43 +236,45 @@ function useLocalWorker({
 				__dirname,
 				"../miniflare-dist/index.mjs"
 			);
-			const optionsArg = JSON.stringify(options, null);
+			const miniflareOptions = JSON.stringify(options, null);
 
 			logger.log("⎔ Starting a local server...");
-			const localServerOptions = [
+			const nodeOptions = [
 				"--experimental-vm-modules", // ensures that Miniflare can run ESM Workers
 				"--no-warnings", // hide annoying Node warnings
-				miniflareCLIPath,
-				optionsArg,
 				// "--log=VERBOSE", // uncomment this to Miniflare to log "everything"!
 			];
 			if (inspect) {
-				localServerOptions.push("--inspect"); // start Miniflare listening for a debugger to attach
+				nodeOptions.push("--inspect"); // start Miniflare listening for a debugger to attach
 			}
-			// spawn isn't technically synchronous here
-			local.current = spawn("node", localServerOptions, {
-				cwd: path.dirname(scriptPath),
+			const child = (local.current = fork(
+				miniflareCLIPath,
+				[miniflareOptions],
+				{
+					cwd: path.dirname(scriptPath),
+					execArgv: nodeOptions,
+				}
+			));
+			child.on("message", (message) => {
+				if (message === "ready") {
+					onReady?.();
+				}
 			});
-			//TODO: instead of being lucky with spawn's timing, have miniflare-cli notify wrangler that it's ready in packages/wrangler/src/miniflare-cli/index.ts, after the mf.startScheduler promise resolves
-			if (onReady) {
-				await new Promise((resolve) => setTimeout(resolve, 200));
-				onReady();
-			}
 
-			local.current.on("close", (code) => {
+			child.on("close", (code) => {
 				if (code) {
 					logger.log(`Miniflare process exited with code ${code}`);
 				}
 			});
 
-			local.current.stdout?.on("data", (data: Buffer) => {
+			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;
-			local.current.stderr?.on("data", (data: Buffer) => {
+			child.stderr?.on("data", (data: Buffer) => {
 				if (!inspectorUrlFound) {
 					stderrData += data.toString();
 					const matches =
@@ -288,20 +290,20 @@ function useLocalWorker({
 				process.stderr.write(data);
 			});
 
-			local.current.on("exit", (code) => {
+			child.on("exit", (code) => {
 				if (code) {
 					logger.error(`Miniflare process exited with code ${code}`);
 				}
 			});
 
-			local.current.on("error", (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();
+				child.kill();
 				local.current = undefined;
 			});
 		}

package/src/dev/remote.tsx

@@ -11,7 +11,12 @@ import useInspector from "../inspect";
 import { logger } from "../logger";
 import { usePreviewServer } from "../proxy";
 import { syncAssets } from "../sites";
-import { ChooseAccount, getAccountChoices, requireApiToken } from "../user";
+import {
+	ChooseAccount,
+	getAccountChoices,
+	requireApiToken,
+	saveAccountToCache,
+} from "../user";
 import type { Route } from "../config/environment";
 import type {
 	CfPreviewToken,
@@ -48,7 +53,7 @@ export function Remote(props: {
 	zone: string | undefined;
 	host: string | undefined;
 	routes: Route[] | undefined;
-	onReady?: () => void;
+	onReady?: (() => void) | undefined;
 }) {
 	const [accountId, setAccountId] = useState(props.accountId);
 	const accountChoicesRef = useRef<Promise<ChooseAccountItem[]>>();
@@ -96,13 +101,20 @@ export function Remote(props: {
 	// This effect handles the async step of fetching the available accounts for the current user.
 	// If only one account is available then it is just used by calling `setAccountId()`.
 	useEffect(() => {
-		if (accountChoicesRef.current !== undefined) {
+		if (
+			accountChoicesRef.current !== undefined ||
+			props.accountId !== undefined
+		) {
 			return;
 		}
 		accountChoicesRef.current = getAccountChoices();
 		accountChoicesRef.current.then(
 			(accounts) => {
 				if (accounts.length === 1) {
+					saveAccountToCache({
+						id: accounts[0].id,
+						name: accounts[0].name,
+					});
 					setAccountId(accounts[0].id);
 				} else {
 					setAccountChoices(accounts);
@@ -119,7 +131,10 @@ export function Remote(props: {
 	return accountId === undefined && accountChoices !== undefined ? (
 		<ChooseAccount
 			accounts={accountChoices}
-			onSelect={(selectedAccountId) => setAccountId(selectedAccountId)}
+			onSelect={(selectedAccount) => {
+				saveAccountToCache(selectedAccount);
+				setAccountId(selectedAccount.id);
+			}}
 			onError={(err) => errorHandler(err)}
 		></ChooseAccount>
 	) : null;
@@ -143,7 +158,7 @@ export function useWorker(props: {
 	zone: string | undefined;
 	host: string | undefined;
 	routes: Route[] | undefined;
-	onReady?: () => void;
+	onReady: (() => void) | undefined;
 }): CfPreviewToken | undefined {
 	const {
 		name,

package/src/dev/use-esbuild.ts

@@ -28,7 +28,7 @@ export function useEsbuild({
 	minify,
 	nodeCompat,
 	define,
-	noBuild,
+	noBundle,
 }: {
 	entry: Entry;
 	destination: string | undefined;
@@ -40,7 +40,7 @@ export function useEsbuild({
 	tsconfig: string | undefined;
 	minify: boolean | undefined;
 	nodeCompat: boolean | undefined;
-	noBuild: boolean;
+	noBundle: boolean;
 }): EsbuildBundle | undefined {
 	const [bundle, setBundle] = useState<EsbuildBundle>();
 	const { exit } = useApp();
@@ -76,7 +76,7 @@ export function useEsbuild({
 				bundleType,
 				modules,
 				stop,
-			}: Awaited<ReturnType<typeof bundleWorker>> = noBuild
+			}: Awaited<ReturnType<typeof bundleWorker>> = noBundle
 				? {
 						modules: [],
 						resolvedEntryPointPath: entry.file,
@@ -99,9 +99,9 @@ export function useEsbuild({
 			// Capture the `stop()` method to use as the `useEffect()` destructor.
 			stopWatching = stop;
 
-			// if "noBuild" is true, then we need to manually watch the entry point and
+			// if "noBundle" is true, then we need to manually watch the entry point and
 			// trigger "builds" when it changes
-			if (noBuild) {
+			if (noBundle) {
 				const watcher = watch(entry.file, {
 					persistent: true,
 				}).on("change", async (_event) => {
@@ -141,7 +141,7 @@ export function useEsbuild({
 		rules,
 		tsconfig,
 		exit,
-		noBuild,
+		noBundle,
 		minify,
 		nodeCompat,
 		define,

package/src/dev.tsx

@@ -3,6 +3,7 @@ import { watch } from "chokidar";
 import getPort from "get-port";
 import { render } from "ink";
 import React from "react";
+import { fetch } from "undici";
 import { findWranglerToml, printBindings, readConfig } from "./config";
 import Dev from "./dev/dev";
 import { getVarsForDev } from "./dev/dev-vars";
@@ -10,6 +11,7 @@ import { getVarsForDev } from "./dev/dev-vars";
 import { getEntry } from "./entry";
 import { logger } from "./logger";
 import { getAssetPaths, getSiteAssetPaths } from "./sites";
+import { getAccountFromCache } from "./user";
 import { getZoneIdFromHost, getZoneForRoute, getHostFromRoute } from "./zones";
 import {
 	printWranglerBanner,
@@ -23,12 +25,15 @@ import {
 
 import type { Config } from "./config";
 import type { Route } from "./config/environment";
+import type { CfWorkerInit } from "./worker";
+import type { RequestInit } from "undici";
 import type { Argv, ArgumentsCamelCase } from "yargs";
 
 interface DevArgs {
 	config?: string;
 	script?: string;
 	name?: string;
+	bundle?: boolean;
 	build?: boolean;
 	format?: string;
 	env?: string;
@@ -74,17 +79,16 @@ export function devOptions(yargs: Argv): Argv<DevArgs> {
 				type: "string",
 				requiresArg: true,
 			})
-			// We want to have a --no-build flag, but yargs requires that
-			// we also have a --build flag (that it adds the --no to by itself)
-			// So we make a --build flag, but hide it, and then add a --no-build flag
+			// We want to have a --no-bundle flag, but yargs requires that
+			// we also have a --bundle flag (that it adds the --no to by itself)
+			// So we make a --bundle flag, but hide it, and then add a --no-bundle flag
 			// that's visible to the user but doesn't "do" anything.
-			.option("build", {
+			.option("bundle", {
 				describe: "Run wrangler's compilation step before publishing",
 				type: "boolean",
-				default: true,
 				hidden: true,
 			})
-			.option("no-build", {
+			.option("no-bundle", {
 				describe: "Skip internal build steps and directly publish script",
 				type: "boolean",
 				default: false,
@@ -368,7 +372,9 @@ export async function startDev(args: ArgumentsCamelCase<DevArgs>) {
 		}
 
 		// eslint-disable-next-line no-inner-declarations
-		async function getBindings(configParam: Config) {
+		async function getBindings(
+			configParam: Config
+		): Promise<CfWorkerInit["bindings"]> {
 			return {
 				kv_namespaces: configParam.kv_namespaces?.map(
 					({ binding, preview_id, id: _id }) => {
@@ -412,6 +418,7 @@ export async function startDev(args: ArgumentsCamelCase<DevArgs>) {
 						};
 					}
 				),
+				worker_namespaces: configParam.worker_namespaces,
 				services: configParam.services,
 				unsafe: configParam.unsafe?.bindings,
 			};
@@ -453,7 +460,7 @@ export async function startDev(args: ArgumentsCamelCase<DevArgs>) {
 			return (
 				<Dev
 					name={getScriptName({ name: args.name, env: args.env }, config)}
-					noBuild={!args.build}
+					noBundle={!(args.bundle ?? !config.no_bundle)}
 					entry={entry}
 					env={args.env}
 					zone={zoneId}
@@ -475,7 +482,7 @@ export async function startDev(args: ArgumentsCamelCase<DevArgs>) {
 					enableLocalPersistence={
 						args["experimental-enable-local-persistence"] || false
 					}
-					accountId={config.account_id}
+					accountId={config.account_id || getAccountFromCache()?.id}
 					assetPaths={assetPaths}
 					port={args.port || config.dev.port || (await getLocalPort())}
 					ip={args.ip || config.dev.ip}
@@ -505,9 +512,14 @@ export async function startDev(args: ArgumentsCamelCase<DevArgs>) {
 			watcher,
 			stop: async () => {
 				devReactElement.unmount();
-				await devReactElement.waitUntilExit();
 				await watcher?.close();
-				process.exit(0);
+			},
+			fetch: async (init?: RequestInit) => {
+				//TODO: we are not guaranteed to be assigned this port, we should fix this ASAP
+				const port = args.port || config.dev.port || (await getLocalPort());
+				const address = args.ip || config.dev.ip || "localhost";
+
+				return await fetch(`http://${address}:${port}/`, init);
 			},
 		};
 	} finally {

package/src/index.tsx

@@ -372,17 +372,16 @@ function createCLIParser(argv: string[]) {
 						type: "string",
 						requiresArg: true,
 					})
-					// We want to have a --no-build flag, but yargs requires that
-					// we also have a --build flag (that it adds the --no to by itself)
-					// So we make a --build flag, but hide it, and then add a --no-build flag
+					// We want to have a --no-bundle flag, but yargs requires that
+					// we also have a --bundle flag (that it adds the --no to by itself)
+					// So we make a --bundle flag, but hide it, and then add a --no-bundle flag
 					// that's visible to the user but doesn't "do" anything.
-					.option("build", {
+					.option("bundle", {
 						describe: "Run wrangler's compilation step before publishing",
 						type: "boolean",
-						default: true,
 						hidden: true,
 					})
-					.option("no-build", {
+					.option("no-bundle", {
 						describe: "Skip internal build steps and directly publish script",
 						type: "boolean",
 						default: false,
@@ -564,7 +563,7 @@ function createCLIParser(argv: string[]) {
 				isWorkersSite: Boolean(args.site || config.site),
 				outDir: args.outdir,
 				dryRun: args.dryRun,
-				noBuild: !args.build,
+				noBundle: !(args.bundle ?? !config.no_bundle),
 			});
 		}
 	);
@@ -917,6 +916,7 @@ function createCLIParser(argv: string[]) {
 											wasm_modules: {},
 											text_blobs: {},
 											data_blobs: {},
+											worker_namespaces: [],
 											unsafe: [],
 										},
 										modules: [],

package/src/is-interactive.ts

@@ -0,0 +1,12 @@
+/**
+ * Test whether the process is "interactive".
+ * Reasons it may not be interactive: it could be running in CI,
+ * or you're piping values from / to another process, etc
+ */
+export default function isInteractive(): boolean {
+	try {
+		return Boolean(process.stdin.isTTY && process.stdout.isTTY);
+	} catch {
+		return false;
+	}
+}

package/src/miniflare-cli/index.ts

@@ -41,6 +41,7 @@ async function main() {
 		// Start Miniflare development server
 		await mf.startServer();
 		await mf.startScheduler();
+		process.send && process.send("ready");
 	} catch (e) {
 		mf.log.error(e as Error);
 		process.exitCode = 1;

package/src/publish.ts

@@ -46,7 +46,7 @@ type Props = {
 	nodeCompat: boolean | undefined;
 	outDir: string | undefined;
 	dryRun: boolean | undefined;
-	noBuild: boolean | undefined;
+	noBundle: boolean | undefined;
 };
 
 type RouteObject = ZoneIdRoute | ZoneNameRoute | CustomDomainRoute;
@@ -341,7 +341,7 @@ See https://developers.cloudflare.com/workers/platform/compatibility-dates for m
 		);
 	}
 	try {
-		if (props.noBuild) {
+		if (props.noBundle) {
 			// if we're not building, let's just copy the entry to the destination directory
 			const destinationDir =
 				typeof destination === "string" ? destination : destination.path;
@@ -356,7 +356,7 @@ See https://developers.cloudflare.com/workers/platform/compatibility-dates for m
 			modules,
 			resolvedEntryPointPath,
 			bundleType,
-		}: Awaited<ReturnType<typeof bundleWorker>> = props.noBuild
+		}: Awaited<ReturnType<typeof bundleWorker>> = props.noBundle
 			? // we can skip the whole bundling step and mock a bundle here
 			  {
 					modules: [],
@@ -426,6 +426,7 @@ See https://developers.cloudflare.com/workers/platform/compatibility-dates for m
 			durable_objects: config.durable_objects,
 			r2_buckets: config.r2_buckets,
 			services: config.services,
+			worker_namespaces: config.worker_namespaces,
 			unsafe: config.unsafe?.bindings,
 		};