wrangler 2.1.4 → 2.1.6

package/src/dev/start-server.ts

@@ -2,10 +2,16 @@ 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 { registerWorker } from "../dev-registry";
+import {
+	getBoundRegisteredWorkers,
+	registerWorker,
+	startWorkerRegistry,
+	stopWorkerRegistry,
+} from "../dev-registry";
 import { runCustomBuild } from "../entry";
 import { logger } from "../logger";
 import { waitForPortToBeAvailable } from "../proxy";
@@ -17,6 +23,7 @@ import {
 import { validateDevProps } from "./validate-dev-props";
 
 import type { Config } from "../config";
+import type { WorkerRegistry } from "../dev-registry";
 import type { Entry } from "../entry";
 import type { DevProps, DirectorySyncResult } from "./dev";
 import type { LocalProps } from "./local";
@@ -30,6 +37,7 @@ export async function startDevServer(
 	}
 ) {
 	try {
+		let workerDefinitions: WorkerRegistry = {};
 		validateDevProps(props);
 
 		if (props.build.command) {
@@ -48,6 +56,21 @@ export async function startDevServer(
 			throw new Error("Failed to create temporary directory.");
 		}
 
+		//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,
+			});
+
+			if (!util.isDeepStrictEqual(boundRegisteredWorkers, workerDefinitions)) {
+				workerDefinitions = boundRegisteredWorkers || {};
+			}
+		}
+
 		//implement a react-free version of useEsbuild
 		const bundle = await runEsbuild({
 			entry: props.entry,
@@ -64,7 +87,10 @@ export async function startDevServer(
 			define: props.define,
 			noBundle: props.noBundle,
 			assets: props.assetsConfig,
+			workerDefinitions,
 			services: props.bindings.services,
+			firstPartyWorkerDevFacade: props.firstPartyWorker,
+			testScheduled: props.testScheduled,
 		});
 
 		//run local now
@@ -90,13 +116,14 @@ export async function startDevServer(
 			inspect: props.inspect,
 			onReady: props.onReady,
 			enablePagesAssetsServiceBinding: props.enablePagesAssetsServiceBinding,
-			usageModel: undefined,
-			workerDefinitions: undefined,
+			usageModel: props.usageModel,
+			workerDefinitions,
 		});
 
 		return {
 			stop: async () => {
 				stop();
+				await stopWorkerRegistry();
 			},
 			inspectorUrl,
 		};
@@ -129,6 +156,10 @@ async function runEsbuild({
 	nodeCompat,
 	define,
 	noBundle,
+	workerDefinitions,
+	services,
+	firstPartyWorkerDevFacade,
+	testScheduled,
 }: {
 	entry: Entry;
 	destination: string | undefined;
@@ -143,6 +174,9 @@ async function runEsbuild({
 	minify: boolean | undefined;
 	nodeCompat: boolean | undefined;
 	noBundle: boolean;
+	workerDefinitions: WorkerRegistry;
+	firstPartyWorkerDevFacade: boolean | undefined;
+	testScheduled?: boolean;
 }): Promise<EsbuildBundle | undefined> {
 	if (!destination) return;
 
@@ -174,10 +208,11 @@ async function runEsbuild({
 					// disable the cache in dev
 					bypassCache: true,
 				},
-				services: undefined,
-				workerDefinitions: undefined,
-				firstPartyWorkerDevFacade: undefined,
+				workerDefinitions,
+				services,
+				firstPartyWorkerDevFacade,
 				targetConsumer: "dev", // We are starting a dev server
+				testScheduled,
 		  });
 
 	return {
@@ -237,8 +272,8 @@ export async function startLocalServer({
 		}
 
 		if (bindings.services && bindings.services.length > 0) {
-			throw new Error(
-				"⎔ Service bindings are not yet supported in local mode."
+			logger.warn(
+				"⎔ Support for service bindings in local mode is experimental and may change."
 			);
 		}
 

package/src/dev/use-esbuild.ts

@@ -37,6 +37,7 @@ export function useEsbuild({
 	durableObjects,
 	firstPartyWorkerDevFacade,
 	targetConsumer,
+	testScheduled,
 }: {
 	entry: Entry;
 	destination: string | undefined;
@@ -55,6 +56,7 @@ export function useEsbuild({
 	durableObjects: Config["durable_objects"];
 	firstPartyWorkerDevFacade: boolean | undefined;
 	targetConsumer: "dev" | "publish";
+	testScheduled: boolean;
 }): EsbuildBundle | undefined {
 	const [bundle, setBundle] = useState<EsbuildBundle>();
 	const { exit } = useApp();
@@ -119,6 +121,7 @@ export function useEsbuild({
 						services,
 						firstPartyWorkerDevFacade,
 						targetConsumer,
+						testScheduled,
 				  });
 
 			// Capture the `stop()` method to use as the `useEffect()` destructor.
@@ -177,6 +180,7 @@ export function useEsbuild({
 		workerDefinitions,
 		firstPartyWorkerDevFacade,
 		targetConsumer,
+		testScheduled,
 	]);
 	return bundle;
 }

package/src/dev-registry.tsx

@@ -5,6 +5,8 @@ import express from "express";
 import { createHttpTerminator } from "http-terminator";
 import { fetch } from "undici";
 import { logger } from "./logger";
+
+import type { Config } from "./config";
 import type { Server } from "http";
 import type { HttpTerminator } from "http-terminator";
 
@@ -158,3 +160,31 @@ export async function getRegisteredWorkers(): Promise<
 		}
 	}
 }
+
+/**
+ * a function that takes your serviceNames and durableObjectNames and returns a
+ * list of the running workers that we're bound to
+ */
+export async function getBoundRegisteredWorkers({
+	services,
+	durableObjects,
+}: {
+	services: Config["services"] | undefined;
+	durableObjects: Config["durable_objects"] | undefined;
+}) {
+	const serviceNames = (services || []).map(
+		(serviceBinding) => serviceBinding.service
+	);
+	const durableObjectServices = (
+		durableObjects || { bindings: [] }
+	).bindings.map((durableObjectBinding) => durableObjectBinding.script_name);
+
+	const workerDefinitions = await getRegisteredWorkers();
+	const filteredWorkers = Object.fromEntries(
+		Object.entries(workerDefinitions || {}).filter(
+			([key, _value]) =>
+				serviceNames.includes(key) || durableObjectServices.includes(key)
+		)
+	);
+	return filteredWorkers;
+}

package/src/dev.tsx

@@ -72,6 +72,7 @@ interface DevArgs {
 	logLevel?: "none" | "error" | "log" | "warn" | "debug";
 	logPrefix?: string;
 	showInteractiveDevSession?: boolean;
+	"test-scheduled"?: boolean;
 }
 
 export function devOptions(yargs: Argv): Argv<DevArgs> {
@@ -273,6 +274,17 @@ export function devOptions(yargs: Argv): Argv<DevArgs> {
 				describe: "Use legacy environments",
 				hidden: true,
 			})
+			.option("test-scheduled", {
+				describe: "Test scheduled events by visiting /__scheduled in browser",
+				type: "boolean",
+				default: false,
+			})
+			.option("log-level", {
+				// "none" will currently default to "error" for Wrangler Logger
+				choices: ["debug", "info", "log", "warn", "error", "none"] as const,
+				describe: "Specify logging level",
+				default: "log",
+			})
 	);
 }
 
@@ -309,6 +321,7 @@ export type AdditionalDevProps = {
 		preview_bucket_name?: string;
 	}[];
 };
+
 type StartDevOptions = ArgumentsCamelCase<DevArgs> &
 	// These options can be passed in directly when called with the `wrangler.dev()` API.
 	// They aren't exposed as CLI arguments.
@@ -430,6 +443,7 @@ export async function startDev(args: StartDevOptions) {
 					enablePagesAssetsServiceBinding={args.enablePagesAssetsServiceBinding}
 					firstPartyWorker={configParam.first_party_worker}
 					sendMetrics={configParam.send_metrics}
+					testScheduled={args["test-scheduled"]}
 				/>
 			);
 		}
@@ -541,8 +555,9 @@ export async function startApiDev(args: StartDevOptions) {
 			forceLocal: args.forceLocal,
 			enablePagesAssetsServiceBinding: args.enablePagesAssetsServiceBinding,
 			local: true,
-			firstPartyWorker: undefined,
-			sendMetrics: undefined,
+			firstPartyWorker: configParam.first_party_worker,
+			sendMetrics: configParam.send_metrics,
+			testScheduled: args.testScheduled,
 		});
 	}
 
@@ -699,7 +714,10 @@ async function validateDevServerSettings(
 		: args.persist
 		? // If just flagged on, treat it as relative to wrangler.toml,
 		  // if one can be found, otherwise cwd()
-		  path.resolve(config.configPath || process.cwd(), ".wrangler/state")
+		  path.resolve(
+				config.configPath ? path.dirname(config.configPath) : process.cwd(),
+				".wrangler/state"
+		  )
 		: null;
 
 	const cliDefines =

package/src/index.tsx

@@ -527,6 +527,12 @@ function createCLIParser(argv: string[]) {
 						describe: "Don't actually publish",
 						type: "boolean",
 					})
+					.option("keep-vars", {
+						describe:
+							"Stop wrangler from deleting vars that are not present in the wrangler.toml\nBy default Wrangler will remove all vars and replace them with those found in the wrangler.toml configuration.\nIf your development approach is to modify vars after deployment via the dashboard you may wish to set this flag.",
+						default: false,
+						type: "boolean",
+					})
 					.option("legacy-env", {
 						type: "boolean",
 						describe: "Use legacy environments",
@@ -631,6 +637,7 @@ function createCLIParser(argv: string[]) {
 				outDir: args.outdir,
 				dryRun: args.dryRun,
 				noBundle: !(args.bundle ?? !config.no_bundle),
+				keepVars: args.keepVars,
 			});
 		}
 	);
@@ -1021,7 +1028,7 @@ function createCLIParser(argv: string[]) {
 										compatibility_date: undefined,
 										compatibility_flags: undefined,
 										usage_model: undefined,
-										keep_bindings: false, // this doesn't matter since it's a new script anyway
+										keepVars: false, // this doesn't matter since it's a new script anyway
 									}),
 								}
 							);

package/src/init.ts

@@ -941,7 +941,9 @@ async function getWorkerConfig(
 			: { route: routeOrRoutes[0] };
 
 	return {
-		compatibility_date: serviceEnvMetadata.script.compatibility_date,
+		compatibility_date:
+			serviceEnvMetadata.script.compatibility_date ??
+			new Date().toISOString().substring(0, 10),
 		...routeOrRoutesToConfig,
 		usage_model: serviceEnvMetadata.script.usage_model,
 		migrations: [

package/src/inspect.ts

@@ -610,36 +610,36 @@ function logConsoleMessage(evt: Protocol.Runtime.ConsoleAPICalledEvent): void {
 							break;
 						case "weakmap":
 						case "map":
-							args.push(
-								"{\n" +
-									// Maps always have entries
-									// eslint-disable-next-line @typescript-eslint/no-non-null-assertion
-									ro.preview
-										.entries!.map(({ key, value }) => {
-											return `  ${key?.description ?? "<unknown>"} => ${
-												value.description
-											}`;
-										})
-										.join(",\n") +
-									(ro.preview.overflow ? "\n  ..." : "") +
-									"\n}"
-							);
+							ro.preview.entries === undefined
+								? args.push("{}")
+								: args.push(
+										"{\n" +
+											ro.preview.entries
+												.map(({ key, value }) => {
+													return `  ${key?.description ?? "<unknown>"} => ${
+														value.description
+													}`;
+												})
+												.join(",\n") +
+											(ro.preview.overflow ? "\n  ..." : "") +
+											"\n}"
+								  );
 
 							break;
 						case "weakset":
 						case "set":
-							args.push(
-								"{ " +
-									// Sets always have entries
-									// eslint-disable-next-line @typescript-eslint/no-non-null-assertion
-									ro.preview
-										.entries!.map(({ value }) => {
-											return `${value.description}`;
-										})
-										.join(", ") +
-									(ro.preview.overflow ? ", ..." : "") +
-									" }"
-							);
+							ro.preview.entries === undefined
+								? args.push("{}")
+								: args.push(
+										"{ " +
+											ro.preview.entries
+												.map(({ value }) => {
+													return `${value.description}`;
+												})
+												.join(", ") +
+											(ro.preview.overflow ? ", ..." : "") +
+											" }"
+								  );
 							break;
 						case "regexp":
 							break;

package/src/miniflare-cli/assets.ts

@@ -189,7 +189,14 @@ async function generateAssetsFetch(
 				}
 				const body = readFileSync(filepath) as unknown as ReadableStream;
 
-				const contentType = getType(filepath) || "application/octet-stream";
+				let contentType = getType(filepath) || "application/octet-stream";
+				if (
+					contentType.startsWith("text/") &&
+					!contentType.includes("charset")
+				) {
+					contentType = `${contentType}; charset=utf-8`;
+				}
+
 				return { body, contentType };
 			},
 		});

package/src/pages/constants.ts

@@ -8,8 +8,9 @@ export const MAX_UPLOAD_ATTEMPTS = 5;
 export const MAX_CHECK_MISSING_ATTEMPTS = 5;
 export const SECONDS_TO_WAIT_FOR_PROXY = 5;
 export const isInPagesCI = !!process.env.CF_PAGES;
-/** The max number of rules in _routes.json */
+/** Max number of rules in _routes.json */
 export const MAX_FUNCTIONS_ROUTES_RULES = 100;
+/** Max char length of each rule in _routes.json */
 export const MAX_FUNCTIONS_ROUTES_RULE_LENGTH = 100;
 export const ROUTES_SPEC_VERSION = 1;
 export const ROUTES_SPEC_DESCRIPTION = `Generated by wrangler@${wranglerVersion}`;

package/src/pages/dev.tsx

@@ -1,21 +1,23 @@
 import { execSync, spawn } from "node:child_process";
-import { existsSync } from "node:fs";
+import { existsSync, readFileSync } from "node:fs";
 import { homedir, tmpdir } from "node:os";
 import { join, resolve } from "node:path";
 import { watch } from "chokidar";
-import { build as workerJsBuild } from "esbuild";
+import * as esbuild from "esbuild";
 import { unstable_dev } from "../api";
+import { esbuildAliasExternalPlugin } from "../bundle";
 import { FatalError } from "../errors";
 import { logger } from "../logger";
 import * as metrics from "../metrics";
 import { getBasePath } from "../paths";
 import { buildFunctions } from "./build";
-import { SECONDS_TO_WAIT_FOR_PROXY } from "./constants";
+import { ROUTES_SPEC_VERSION, SECONDS_TO_WAIT_FOR_PROXY } from "./constants";
 import { FunctionsNoRoutesError, getFunctionsNoRoutesWarning } from "./errors";
+import { validateRoutes } from "./functions/routes-validation";
 import { CLEANUP, CLEANUP_CALLBACKS, pagesBetaWarning } from "./utils";
 import type { AdditionalDevProps } from "../dev";
+import type { RoutesJSONSpec } from "./functions/routes-transformation";
 import type { YargsOptionsToInterface } from "./types";
-import type { Plugin } from "esbuild";
 import type { Argv } from "yargs";
 
 const DURABLE_OBJECTS_BINDING_REGEXP = new RegExp(
@@ -144,6 +146,13 @@ export function Options(yargs: Argv) {
 				type: "string",
 				hidden: true,
 			},
+
+			"log-level": {
+				// "none" will currently default to "error" for Wrangler Logger
+				choices: ["debug", "info", "log", "warn", "error", "none"] as const,
+				describe: "Specify logging level",
+				default: "log",
+			},
 		})
 		.epilogue(pagesBetaWarning);
 }
@@ -170,10 +179,21 @@ export const Handler = async ({
 	"node-compat": nodeCompat,
 	config: config,
 	_: [_pages, _dev, ...remaining],
+	logLevel,
 }: PagesDevArgs) => {
 	// Beta message for `wrangler pages <commands>` usage
 	logger.log(pagesBetaWarning);
 
+	type LogLevelArg = "debug" | "info" | "log" | "warn" | "error" | "none";
+	if (logLevel) {
+		// we don't define a "none" logLevel, so "error" will do for now.
+		// The YargsOptionsToInterface doesn't handle the passing in of Unions from choices in Yargs
+		logger.loggerLevel =
+			(logLevel as LogLevelArg) === "none"
+				? "error"
+				: (logLevel as Exclude<"none", LogLevelArg>);
+	}
+
 	if (!local) {
 		throw new FatalError("Only local mode is supported at the moment.", 1);
 	}
@@ -184,6 +204,7 @@ export const Handler = async ({
 
 	const functionsDirectory = "./functions";
 	let usingFunctions = existsSync(functionsDirectory);
+	let usingWorkerScript = false;
 
 	const command = remaining;
 
@@ -285,6 +306,7 @@ export const Handler = async ({
 			}
 		}
 	}
+
 	// Depending on the result of building Functions, we may not actually be using
 	// Functions even if the directory exists.
 	if (!usingFunctions) {
@@ -295,14 +317,15 @@ export const Handler = async ({
 			directory !== undefined
 				? join(directory, singleWorkerScriptPath)
 				: singleWorkerScriptPath;
+		usingWorkerScript = existsSync(scriptPath);
 
-		if (!existsSync(scriptPath)) {
+		if (!usingWorkerScript) {
 			logger.log("No functions. Shimming...");
 			scriptPath = resolve(getBasePath(), "templates/pages-shim.ts");
 		} else {
 			const runBuild = async () => {
 				try {
-					await workerJsBuild({
+					await esbuild.build({
 						entryPoints: [scriptPath],
 						write: false,
 						plugins: [blockWorkerJsImports],
@@ -330,8 +353,108 @@ export const Handler = async ({
 		);
 	}
 
+	let entrypoint = scriptPath;
+
+	// custom _routes.json apply only to Functions or Advanced Mode Pages projects
+	if (directory && (usingFunctions || usingWorkerScript)) {
+		const routesJSONPath = join(directory, "_routes.json");
+
+		if (existsSync(routesJSONPath)) {
+			let routesJSONContents: string;
+			const runBuild = async (
+				entrypointFile: string,
+				outfile: string,
+				routes: string
+			) => {
+				await esbuild.build({
+					entryPoints: [
+						resolve(getBasePath(), "templates/pages-dev-pipeline.ts"),
+					],
+					bundle: true,
+					sourcemap: true,
+					format: "esm",
+					plugins: [
+						esbuildAliasExternalPlugin({
+							__ENTRY_POINT__: entrypointFile,
+						}),
+					],
+					outfile,
+					define: {
+						__ROUTES__: routes,
+					},
+				});
+			};
+
+			try {
+				// always run the routes validation first. If _routes.json is invalid we
+				// want to throw accordingly and exit.
+				routesJSONContents = readFileSync(routesJSONPath, "utf-8");
+				validateRoutes(JSON.parse(routesJSONContents), directory);
+
+				entrypoint = join(
+					tmpdir(),
+					`${Math.random().toString(36).slice(2)}.js`
+				);
+				await runBuild(scriptPath, entrypoint, routesJSONContents);
+			} catch (err) {
+				if (err instanceof FatalError) {
+					throw err;
+				} else {
+					throw new FatalError(
+						`Could not validate _routes.json at ${directory}: ${err}`,
+						1
+					);
+				}
+			}
+
+			watch([routesJSONPath], {
+				persistent: true,
+				ignoreInitial: true,
+			}).on("all", async () => {
+				try {
+					/**
+					 * Watch for _routes.json file changes and validate file each time.
+					 * If file is valid proceed to running the build.
+					 */
+					routesJSONContents = readFileSync(routesJSONPath, "utf-8");
+					validateRoutes(JSON.parse(routesJSONContents), directory as string);
+					await runBuild(scriptPath, entrypoint, routesJSONContents);
+				} catch (err) {
+					/**
+					 * If _routes.json is invalid, don't exit but instead fallback to a sensible default
+					 * and continue to serve the assets. At the same time make sure we warn users that we
+					 * we detected an invalid file and that we'll be using a default.
+					 * This basically equivalates to serving a Functions or _worker.js project as is,
+					 * without applying any additional routing rules on top.
+					 */
+					const error =
+						err instanceof FatalError
+							? err
+							: `Could not validate _routes.json at ${directory}: ${err}`;
+					const defaultRoutesJSONSpec: RoutesJSONSpec = {
+						version: ROUTES_SPEC_VERSION,
+						include: ["/*"],
+						exclude: [],
+					};
+
+					logger.error(error);
+					logger.warn(
+						`Falling back to the following _routes.json default: ${JSON.stringify(
+							defaultRoutesJSONSpec,
+							null,
+							2
+						)}`
+					);
+
+					routesJSONContents = JSON.stringify(defaultRoutesJSONSpec);
+					await runBuild(scriptPath, entrypoint, routesJSONContents);
+				}
+			});
+		}
+	}
+
 	const { stop, waitUntilExit } = await unstable_dev(
-		scriptPath,
+		entrypoint,
 		{
 			ip,
 			port,
@@ -385,7 +508,7 @@ export const Handler = async ({
 			persistTo,
 			showInteractiveDevSession: undefined,
 			inspect: true,
-			logLevel: "error",
+			logLevel: "warn",
 			logPrefix: "pages",
 		},
 		{ testMode: false, disableExperimentalWarning: true }
@@ -544,9 +667,9 @@ async function spawnProxyProcess({
 	return port;
 }
 
-const blockWorkerJsImports: Plugin = {
+const blockWorkerJsImports: esbuild.Plugin = {
 	name: "block-worker-js-imports",
-	setup(build) {
+	setup(build: esbuild.PluginBuild) {
 		build.onResolve({ filter: /.*/g }, (_args) => {
 			logger.error(
 				`_worker.js is importing from another file. This will throw an error if deployed.\nYou should bundle your Worker or remove the import if it is unused.`