wrangler 0.0.0-e30d1013 → 0.0.0-e311bbbf

package/src/pages/{dev.tsx → dev.ts}

@@ -10,23 +10,24 @@ import { FatalError } from "../errors";
 import { logger } from "../logger";
 import * as metrics from "../metrics";
 import { getBasePath } from "../paths";
-import { buildFunctions } from "./build";
+import { buildFunctions } from "./buildFunctions";
 import { ROUTES_SPEC_VERSION, SECONDS_TO_WAIT_FOR_PROXY } from "./constants";
 import { FunctionsNoRoutesError, getFunctionsNoRoutesWarning } from "./errors";
+import { buildRawWorker, checkRawWorker } from "./functions/buildWorker";
 import { validateRoutes } from "./functions/routes-validation";
 import { CLEANUP, CLEANUP_CALLBACKS, pagesBetaWarning } from "./utils";
 import type { AdditionalDevProps } from "../dev";
+import type {
+	CommonYargsArgv,
+	StrictYargsOptionsToInterface,
+} from "../yargs-types";
 import type { RoutesJSONSpec } from "./functions/routes-transformation";
-import type { YargsOptionsToInterface } from "./types";
-import type { Argv } from "yargs";
 
 const DURABLE_OBJECTS_BINDING_REGEXP = new RegExp(
 	/^(?<binding>[^=]+)=(?<className>[^@\s]+)(@(?<scriptName>.*)$)?$/
 );
 
-type PagesDevArgs = YargsOptionsToInterface<typeof Options>;
-
-export function Options(yargs: Argv) {
+export function Options(yargs: CommonYargsArgv) {
 	return yargs
 		.positional("directory", {
 			type: "string",
@@ -78,6 +79,16 @@ export function Options(yargs: Argv) {
 				description:
 					"The location of the single Worker script if not using functions",
 			},
+			bundle: {
+				type: "boolean",
+				default: undefined,
+				hidden: true,
+			},
+			"no-bundle": {
+				type: "boolean",
+				default: false,
+				description: "Whether to run bundling on `_worker.js`",
+			},
 			binding: {
 				type: "array",
 				description: "Bind variable/secret (KEY=VALUE)",
@@ -129,11 +140,16 @@ export function Options(yargs: Argv) {
 				requiresArg: true,
 			},
 			"node-compat": {
-				describe: "Enable node.js compatibility",
+				describe: "Enable Node.js compatibility",
 				default: false,
 				type: "boolean",
 				hidden: true,
 			},
+			"experimental-local": {
+				describe: "Run on my machine using the Cloudflare Workers runtime",
+				type: "boolean",
+				default: false,
+			},
 			config: {
 				describe: "Pages does not support wrangler.toml",
 				type: "string",
@@ -150,35 +166,36 @@ export function Options(yargs: Argv) {
 export const Handler = async ({
 	local,
 	directory,
-	"compatibility-date": compatibilityDate,
-	"compatibility-flags": compatibilityFlags,
+	compatibilityDate,
+	compatibilityFlags,
 	ip,
 	port,
-	"inspector-port": inspectorPort,
+	inspectorPort,
 	proxy: requestedProxyPort,
-	"script-path": singleWorkerScriptPath,
+	bundle,
+	noBundle,
+	scriptPath: singleWorkerScriptPath,
 	binding: bindings = [],
 	kv: kvs = [],
 	do: durableObjects = [],
 	d1: d1s = [],
 	r2: r2s = [],
-	"live-reload": liveReload,
-	"local-protocol": localProtocol,
+	liveReload,
+	localProtocol,
 	experimentalEnableLocalPersistence,
 	persist,
 	persistTo,
-	"node-compat": nodeCompat,
+	nodeCompat: legacyNodeCompat,
+	experimentalLocal,
 	config: config,
 	_: [_pages, _dev, ...remaining],
 	logLevel,
-}: PagesDevArgs) => {
+}: StrictYargsOptionsToInterface<typeof Options>) => {
 	// Beta message for `wrangler pages <commands>` usage
 	logger.log(pagesBetaWarning);
 
-	type LogLevelArg = "debug" | "info" | "log" | "warn" | "error" | "none";
 	if (logLevel) {
-		// The YargsOptionsToInterface doesn't handle the passing in of Unions from choices in Yargs
-		logger.loggerLevel = logLevel as LogLevelArg;
+		logger.loggerLevel = logLevel;
 	}
 
 	if (!local) {
@@ -245,26 +262,42 @@ export const Handler = async ({
 
 	let scriptPath = "";
 
-	if (usingWorkerScript) {
-		// eslint-disable-next-line @typescript-eslint/no-non-null-assertion
-		scriptReadyResolve!();
+	const nodejsCompat = compatibilityFlags?.includes("nodejs_compat");
 
+	if (usingWorkerScript) {
 		scriptPath = workerScriptPath;
-
-		const runBuild = async () => {
-			try {
-				await esbuild.build({
-					entryPoints: [scriptPath],
-					write: false,
-					// we need it to be bundled so that any imports that are used are affected by the blocker plugin
-					bundle: true,
-					plugins: [blockWorkerJsImports],
-				});
-			} catch {}
+		let runBuild = async () => {
+			await checkRawWorker(workerScriptPath, () => scriptReadyResolve());
 		};
 
+		// TODO: Here lies a known bug. If you specify both `--bundle` and `--no-bundle`, this behavior is undefined and you will get unexpected results.
+		// There is no sane way to get the true value out of yargs, so here we are.
+		const enableBundling = bundle ?? !noBundle;
+		if (enableBundling) {
+			// We want to actually run the `_worker.js` script through the bundler
+			// So update the final path to the script that will be uploaded and
+			// change the `runBuild()` function to bundle the `_worker.js`.
+			scriptPath = join(tmpdir(), `./bundledWorker-${Math.random()}.mjs`);
+			runBuild = async () => {
+				try {
+					await buildRawWorker({
+						workerScriptPath,
+						outfile: scriptPath,
+						directory: directory ?? ".",
+						nodejsCompat,
+						local: true,
+						sourcemap: true,
+						watch: true,
+						onEnd: () => scriptReadyResolve(),
+					});
+				} catch (e: unknown) {
+					logger.warn("Failed to bundle _worker.js.", e);
+				}
+			};
+		}
+
 		await runBuild();
-		watch([scriptPath], {
+		watch([workerScriptPath], {
 			persistent: true,
 			ignoreInitial: true,
 		}).on("all", async () => {
@@ -272,49 +305,47 @@ export const Handler = async ({
 		});
 	} else if (usingFunctions) {
 		// Try to use Functions
-		const outfile = join(tmpdir(), `./functionsWorker-${Math.random()}.mjs`);
-		scriptPath = outfile;
+		scriptPath = join(tmpdir(), `./functionsWorker-${Math.random()}.mjs`);
 
-		if (nodeCompat) {
+		if (legacyNodeCompat) {
 			console.warn(
-				"Enabling node.js compatibility mode for builtins 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 builtins and globals. This is experimental and has serious tradeoffs. Please see https://github.com/ionic-team/rollup-plugin-node-polyfills/ for more details."
+			);
+		}
+
+		if (legacyNodeCompat && nodejsCompat) {
+			throw new FatalError(
+				"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.",
+				1
 			);
 		}
 
-		logger.log(`Compiling worker to "${outfile}"...`);
+		logger.log(`Compiling worker to "${scriptPath}"...`);
 		const onEnd = () => scriptReadyResolve();
 		try {
-			await buildFunctions({
-				outfile,
-				functionsDirectory,
-				sourcemap: true,
-				watch: true,
-				onEnd,
-				buildOutputDirectory: directory,
-				nodeCompat,
-				local: true,
-				d1Databases: d1s.map((binding) => binding.toString()),
-			});
-			await metrics.sendMetricsEvent("build pages functions");
+			const buildFn = async () => {
+				await buildFunctions({
+					outfile: scriptPath,
+					functionsDirectory,
+					sourcemap: true,
+					watch: true,
+					onEnd,
+					buildOutputDirectory: directory,
+					legacyNodeCompat,
+					nodejsCompat,
+					local: true,
+				});
+				await metrics.sendMetricsEvent("build pages functions");
+			};
 
+			await buildFn();
 			// If Functions found routes, continue using Functions
 			watch([functionsDirectory], {
 				persistent: true,
 				ignoreInitial: true,
 			}).on("all", async () => {
 				try {
-					await buildFunctions({
-						outfile,
-						functionsDirectory,
-						sourcemap: true,
-						watch: true,
-						onEnd,
-						buildOutputDirectory: directory,
-						nodeCompat,
-						local: true,
-						d1Databases: d1s.map((binding) => binding.toString()),
-					});
-					await metrics.sendMetricsEvent("build pages functions");
+					await buildFn();
 				} catch (e) {
 					if (e instanceof FunctionsNoRoutesError) {
 						logger.warn(
@@ -355,7 +386,7 @@ export const Handler = async ({
 
 	if (scriptPath === "") {
 		// Failed to get a script with or without Functions,
-		// something really bad must have happend.
+		// something really bad must have happened.
 		throw new FatalError(
 			"Failed to start wrangler pages dev due to an unknown error",
 			1
@@ -437,7 +468,7 @@ export const Handler = async ({
 					 * 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,
+					 * This basically equates to serving a Functions or _worker.js project as is,
 					 * without applying any additional routing rules on top.
 					 */
 					const error =
@@ -466,77 +497,75 @@ export const Handler = async ({
 		}
 	}
 
-	const { stop, waitUntilExit } = await unstable_dev(
-		entrypoint,
-		{
-			ip,
-			port,
-			inspectorPort,
-			watch: true,
-			localProtocol,
-			liveReload,
-			compatibilityDate,
-			compatibilityFlags,
-			nodeCompat,
-			vars: Object.fromEntries(
-				bindings
-					.map((binding) => binding.toString().split("="))
-					.map(([key, ...values]) => [key, values.join("=")])
-			),
-			kv: kvs.map((binding) => ({
-				binding: binding.toString(),
-				id: "",
-			})),
-			durableObjects: durableObjects
-				.map((durableObject) => {
-					const { binding, className, scriptName } =
-						DURABLE_OBJECTS_BINDING_REGEXP.exec(durableObject.toString())
-							?.groups || {};
-
-					if (!binding || !className) {
-						logger.warn(
-							"Could not parse Durable Object binding:",
-							durableObject.toString()
-						);
-						return;
-					}
-
-					return {
-						name: binding,
-						class_name: className,
-						script_name: scriptName,
-					};
-				})
-				.filter(Boolean) as AdditionalDevProps["durableObjects"],
-			r2: r2s.map((binding) => {
-				return { binding: binding.toString(), bucket_name: "" };
-			}),
+	const { stop, waitUntilExit } = await unstable_dev(entrypoint, {
+		ip,
+		port,
+		inspectorPort,
+		localProtocol,
+		compatibilityDate,
+		compatibilityFlags,
+		nodeCompat: legacyNodeCompat,
+		vars: Object.fromEntries(
+			bindings
+				.map((binding) => binding.toString().split("="))
+				.map(([key, ...values]) => [key, values.join("=")])
+		),
+		kv: kvs.map((binding) => ({
+			binding: binding.toString(),
+			id: "",
+		})),
+		durableObjects: durableObjects
+			.map((durableObject) => {
+				const { binding, className, scriptName } =
+					DURABLE_OBJECTS_BINDING_REGEXP.exec(durableObject.toString())
+						?.groups || {};
+
+				if (!binding || !className) {
+					logger.warn(
+						"Could not parse Durable Object binding:",
+						durableObject.toString()
+					);
+					return;
+				}
 
+				return {
+					name: binding,
+					class_name: className,
+					script_name: scriptName,
+				};
+			})
+			.filter(Boolean) as AdditionalDevProps["durableObjects"],
+		r2: r2s.map((binding) => {
+			return { binding: binding.toString(), bucket_name: "" };
+		}),
+		persist,
+		persistTo,
+		inspect: undefined,
+		logLevel,
+		experimental: {
 			d1Databases: d1s.map((binding) => ({
 				binding: binding.toString(),
 				database_id: "", // Required for types, but unused by dev
 				database_name: `local-${binding}`,
 			})),
-
+			disableExperimentalWarning: true,
 			enablePagesAssetsServiceBinding: {
 				proxyPort,
 				directory,
 			},
+			experimentalLocal,
+			liveReload,
 			forceLocal: true,
-			persist,
-			persistTo,
 			showInteractiveDevSession: undefined,
-			inspect: undefined,
-			logPrefix: "pages",
-			logLevel: logLevel ?? "warn",
+			testMode: false,
+			watch: true,
 		},
-		{ testMode: false, disableExperimentalWarning: true }
-	);
+	});
 	await metrics.sendMetricsEvent("run pages dev");
 
 	CLEANUP_CALLBACKS.push(stop);
 
-	waitUntilExit().then(() => {
+	void waitUntilExit().then(() => {
 		CLEANUP();
 		process.exit(0);
 	});
@@ -685,24 +714,3 @@ async function spawnProxyProcess({
 
 	return port;
 }
-
-// TODO: Kill this once we have https://github.com/cloudflare/wrangler2/issues/2153
-const blockWorkerJsImports: esbuild.Plugin = {
-	name: "block-worker-js-imports",
-	setup(build) {
-		build.onResolve({ filter: /.*/g }, (args) => {
-			// If it's the entrypoint, let it be as is
-			if (args.kind === "entry-point") {
-				return {
-					path: args.path,
-				};
-			}
-			// Otherwise, block any imports that the file is requesting
-			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.`
-			);
-			// Miniflare will error with this briefly down the line -- there's no point in continuing.
-			process.exit(1);
-		});
-	},
-};

package/src/pages/errors.ts

@@ -9,6 +9,7 @@ import { RoutesValidationError } from "./functions/routes-validation";
  * Exit code for `pages functions build` when no routes are found.
  */
 export const EXIT_CODE_FUNCTIONS_NO_ROUTES_ERROR = 156;
+export const EXIT_CODE_FUNCTIONS_NOTHING_TO_BUILD_ERROR = 157;
 
 /**
  * Pages error when no routes are found in the functions directory

package/src/pages/functions/buildPlugin.ts

@@ -1,20 +1,24 @@
 import { access, lstat } from "node:fs/promises";
-import { dirname, relative, resolve } from "node:path";
+import { relative, resolve } from "node:path";
 import { bundleWorker } from "../../bundle";
 import { getBasePath } from "../../paths";
 import { D1_BETA_PREFIX } from "../../worker";
+import { buildNotifierPlugin } from "./buildWorker";
 import type { Options as WorkerOptions } from "./buildWorker";
 
-type Options = Omit<WorkerOptions, "fallbackService" | "buildOutputDirectory">;
+type Options = Omit<
+	WorkerOptions,
+	"outfile" | "fallbackService" | "buildOutputDirectory" | "nodejsCompat"
+> & { outdir: string };
 
 export function buildPlugin({
 	routesModule,
-	outfile = "bundle.js",
+	outdir,
 	minify = false,
 	sourcemap = false,
 	watch = false,
 	onEnd = () => {},
-	nodeCompat,
+	legacyNodeCompat,
 	functionsDirectory,
 	local,
 	betaD1Shims,
@@ -24,83 +28,86 @@ export function buildPlugin({
 			file: resolve(getBasePath(), "templates/pages-template-plugin.ts"),
 			directory: functionsDirectory,
 			format: "modules",
+			moduleRoot: functionsDirectory,
 		},
-		resolve(outfile),
+		resolve(outdir),
 		{
 			inject: [routesModule],
+			entryName: "index",
 			minify,
 			sourcemap,
 			watch,
-			nodeCompat,
+			legacyNodeCompat,
+			// We don't currently have a mechanism for Plugins 'requiring' a specific compat date/flag,
+			// but if someone wants to publish a Plugin which does require this new `nodejs_compat` flag
+			// and they document that on their README.md, we should let them.
+			nodejsCompat: true,
 			define: {},
 			betaD1Shims: (betaD1Shims || []).map(
 				(binding) => `${D1_BETA_PREFIX}${binding}`
 			),
+			doBindings: [], // Pages functions don't support internal Durable Objects
 			plugins: [
-				{
-					name: "wrangler notifier and monitor",
-					setup(pluginBuild) {
-						pluginBuild.onEnd((result) => {
-							if (result.errors.length > 0) {
-								console.error(
-									`${result.errors.length} error(s) and ${result.warnings.length} warning(s) when compiling Worker.`
-								);
-							} else if (result.warnings.length > 0) {
-								console.warn(
-									`${result.warnings.length} warning(s) when compiling Worker.`
-								);
-								onEnd();
-							} else {
-								console.log("Compiled Worker successfully.");
-								onEnd();
-							}
-						});
-					},
-				},
+				buildNotifierPlugin(onEnd),
 				{
 					name: "Assets",
 					setup(pluginBuild) {
-						if (pluginBuild.initialOptions.outfile) {
-							const outdir = dirname(pluginBuild.initialOptions.outfile);
-
-							pluginBuild.onResolve({ filter: /^assets:/ }, async (args) => {
-								const directory = resolve(
-									args.resolveDir,
-									args.path.slice("assets:".length)
-								);
+						pluginBuild.onResolve({ filter: /^assets:/ }, async (args) => {
+							const directory = resolve(
+								args.resolveDir,
+								args.path.slice("assets:".length)
+							);
 
-								const exists = await access(directory)
-									.then(() => true)
-									.catch(() => false);
+							const exists = await access(directory)
+								.then(() => true)
+								.catch(() => false);
 
-								const isDirectory =
-									exists && (await lstat(directory)).isDirectory();
+							const isDirectory =
+								exists && (await lstat(directory)).isDirectory();
 
-								if (!isDirectory) {
-									return {
-										errors: [
-											{
-												text: `'${directory}' does not exist or is not a directory.`,
-											},
-										],
-									};
-								}
+							if (!isDirectory) {
+								return {
+									errors: [
+										{
+											text: `'${directory}' does not exist or is not a directory.`,
+										},
+									],
+								};
+							}
 
-								const path = `assets:./${relative(outdir, directory)}`;
+							const path = `assets:./${relative(outdir, directory)}`;
 
-								return { path, external: true, namespace: "assets" };
-							});
-						}
+							return { path, external: true, namespace: "assets" };
+						});
+					},
+				},
+				// TODO: Replace this with a proper outdir solution for Plugins
+				// But for now, let's just mark all wasm/bin files as external
+				{
+					name: "Mark externals",
+					setup(pluginBuild) {
+						pluginBuild.onResolve(
+							{ filter: /.*\.(wasm|bin)$/ },
+							async (args) => {
+								return {
+									external: true,
+									path: `./${relative(
+										outdir,
+										resolve(args.resolveDir, args.path)
+									)}`,
+								};
+							}
+						);
 					},
 				},
 			],
-			isOutfile: true,
 			serveAssetsFromWorker: false,
-			disableModuleCollection: true,
+			disableModuleCollection: false,
 			rules: [],
 			checkFetch: local,
 			targetConsumer: local ? "dev" : "publish",
 			local,
+			experimentalLocal: false,
 		}
 	);
 }