wrangler 2.7.1 → 2.8.1

package/src/pages/buildFunctions.ts

@@ -0,0 +1,129 @@
+import { writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join, resolve } from "node:path";
+import { toUrlPath } from "../paths";
+import { FunctionsNoRoutesError } from "./errors";
+import { buildPlugin } from "./functions/buildPlugin";
+import { buildWorker } from "./functions/buildWorker";
+import { generateConfigFromFileTree } from "./functions/filepath-routing";
+import { writeRoutesModule } from "./functions/routes";
+import { convertRoutesToRoutesJSONSpec } from "./functions/routes-transformation";
+import { RUNNING_BUILDERS } from "./utils";
+import type { PagesBuildArgs } from "./build";
+import type { Config } from "./functions/routes";
+
+/**
+ * Builds a Functions worker based on the functions directory, with filepath and handler based routing.
+ * @throws FunctionsNoRoutesError when there are no routes found in the functions directory
+ */
+
+export async function buildFunctions({
+	outfile,
+	outputConfigPath,
+	functionsDirectory,
+	minify = false,
+	sourcemap = false,
+	fallbackService = "ASSETS",
+	watch = false,
+	onEnd,
+	plugin = false,
+	buildOutputDirectory,
+	routesOutputPath,
+	nodeCompat,
+	local,
+	d1Databases,
+	experimentalWorkerBundle = false,
+}: Partial<
+	Pick<
+		PagesBuildArgs,
+		| "outputConfigPath"
+		| "minify"
+		| "sourcemap"
+		| "fallbackService"
+		| "watch"
+		| "plugin"
+		| "buildOutputDirectory"
+		| "nodeCompat"
+	>
+> & {
+	functionsDirectory: string;
+	onEnd?: () => void;
+	outfile: Required<PagesBuildArgs>["outfile"];
+	routesOutputPath?: PagesBuildArgs["outputRoutesPath"];
+	local: boolean;
+	d1Databases?: string[];
+	experimentalWorkerBundle?: boolean;
+}) {
+	RUNNING_BUILDERS.forEach(
+		(runningBuilder) => runningBuilder.stop && runningBuilder.stop()
+	);
+
+	const routesModule = join(tmpdir(), `./functionsRoutes-${Math.random()}.mjs`);
+	const baseURL = toUrlPath("/");
+
+	const config: Config = await generateConfigFromFileTree({
+		baseDir: functionsDirectory,
+		baseURL,
+	});
+
+	if (!config.routes || config.routes.length === 0) {
+		throw new FunctionsNoRoutesError(
+			`Failed to find any routes while compiling Functions in: ${functionsDirectory}`
+		);
+	}
+
+	if (routesOutputPath) {
+		const routesJSON = convertRoutesToRoutesJSONSpec(config.routes);
+		writeFileSync(routesOutputPath, JSON.stringify(routesJSON, null, 2));
+	}
+
+	if (outputConfigPath) {
+		writeFileSync(
+			outputConfigPath,
+			JSON.stringify({ ...config, baseURL }, null, 2)
+		);
+	}
+
+	await writeRoutesModule({
+		config,
+		srcDir: functionsDirectory,
+		outfile: routesModule,
+	});
+
+	const absoluteFunctionsDirectory = resolve(functionsDirectory);
+
+	if (plugin) {
+		RUNNING_BUILDERS.push(
+			await buildPlugin({
+				routesModule,
+				outfile,
+				minify,
+				sourcemap,
+				watch,
+				nodeCompat,
+				functionsDirectory: absoluteFunctionsDirectory,
+				local,
+				betaD1Shims: d1Databases,
+				onEnd,
+			})
+		);
+	} else {
+		RUNNING_BUILDERS.push(
+			await buildWorker({
+				routesModule,
+				outfile,
+				minify,
+				sourcemap,
+				fallbackService,
+				watch,
+				functionsDirectory: absoluteFunctionsDirectory,
+				local,
+				betaD1Shims: d1Databases,
+				onEnd,
+				buildOutputDirectory,
+				nodeCompat,
+				experimentalWorkerBundle,
+			})
+		);
+	}
+}

package/src/pages/dev.ts

@@ -10,9 +10,10 @@ 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";
@@ -78,6 +79,23 @@ export function Options(yargs: Argv) {
 				description:
 					"The location of the single Worker script if not using functions",
 			},
+			bundle: {
+				type: "boolean",
+				default: false,
+				hidden: true,
+			},
+			"no-bundle": {
+				type: "boolean",
+				default: true,
+				description: "Whether to run bundling on `_worker.js`",
+			},
+			"experimental-worker-bundle": {
+				type: "boolean",
+				default: false,
+				hidden: true,
+				description:
+					"Whether to process non-JS module imports or not, such as wasm/text/binary, when we run bundling on `functions` or `_worker.js`",
+			},
 			binding: {
 				type: "array",
 				description: "Bind variable/secret (KEY=VALUE)",
@@ -162,6 +180,9 @@ export const Handler = async ({
 	"inspector-port": inspectorPort,
 	proxy: requestedProxyPort,
 	"script-path": singleWorkerScriptPath,
+	bundle,
+	noBundle,
+	experimentalWorkerBundle,
 	binding: bindings = [],
 	kv: kvs = [],
 	do: durableObjects = [],
@@ -252,23 +273,35 @@ export const Handler = async ({
 	let scriptPath = "";
 
 	if (usingWorkerScript) {
-		// eslint-disable-next-line @typescript-eslint/no-non-null-assertion
-		scriptReadyResolve!();
-
 		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());
 		};
 
+		const enableBundling = bundle || !noBundle || experimentalWorkerBundle;
+		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 ?? ".",
+						local: true,
+						sourcemap: true,
+						watch: true,
+						onEnd: () => scriptReadyResolve(),
+						experimentalWorkerBundle,
+					});
+				} catch (e: unknown) {
+					logger.warn("Failed to bundle _worker.js.", e);
+				}
+			};
+		}
+
 		await runBuild();
 		watch([scriptPath], {
 			persistent: true,
@@ -278,8 +311,7 @@ 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) {
 			console.warn(
@@ -287,38 +319,32 @@ export const Handler = async ({
 			);
 		}
 
-		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,
-			});
-			await metrics.sendMetricsEvent("build pages functions");
+			const buildFn = async () => {
+				await buildFunctions({
+					outfile: scriptPath,
+					functionsDirectory,
+					sourcemap: true,
+					watch: true,
+					onEnd,
+					buildOutputDirectory: directory,
+					nodeCompat,
+					local: true,
+					experimentalWorkerBundle,
+				});
+				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,
-					});
-					await metrics.sendMetricsEvent("build pages functions");
+					await buildFn();
 				} catch (e) {
 					if (e instanceof FunctionsNoRoutesError) {
 						logger.warn(
@@ -359,7 +385,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
@@ -441,7 +467,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 =
@@ -688,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/functions/buildPlugin.ts

@@ -3,6 +3,7 @@ import { dirname, 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">;
@@ -36,27 +37,9 @@ export function buildPlugin({
 			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) {

package/src/pages/functions/buildWorker.ts

@@ -1,9 +1,12 @@
 import { access, cp, lstat, rm } from "node:fs/promises";
 import { join, resolve } from "node:path";
+import { build as esBuild } from "esbuild";
 import { nanoid } from "nanoid";
 import { bundleWorker } from "../../bundle";
+import { logger } from "../../logger";
 import { getBasePath } from "../../paths";
 import { D1_BETA_PREFIX } from "../../worker";
+import type { Plugin } from "esbuild";
 
 export type Options = {
 	routesModule: string;
@@ -18,6 +21,7 @@ export type Options = {
 	functionsDirectory: string;
 	local: boolean;
 	betaD1Shims?: string[];
+	experimentalWorkerBundle?: boolean;
 };
 
 export function buildWorker({
@@ -33,6 +37,7 @@ export function buildWorker({
 	functionsDirectory,
 	local,
 	betaD1Shims,
+	experimentalWorkerBundle = false,
 }: Options) {
 	return bundleWorker(
 		{
@@ -57,27 +62,9 @@ export function buildWorker({
 			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) {
@@ -155,7 +142,78 @@ export function buildWorker({
 			],
 			isOutfile: true,
 			serveAssetsFromWorker: false,
-			disableModuleCollection: true,
+			disableModuleCollection: experimentalWorkerBundle ? false : true,
+			rules: [],
+			checkFetch: local,
+			targetConsumer: local ? "dev" : "publish",
+			local,
+			experimentalLocal: false,
+		}
+	);
+}
+
+export type RawOptions = {
+	workerScriptPath: string;
+	outfile: string;
+	directory: string;
+	minify?: boolean;
+	sourcemap?: boolean;
+	watch?: boolean;
+	plugins?: Plugin[];
+	onEnd?: () => void;
+	buildOutputDirectory?: string;
+	nodeCompat?: boolean;
+	local: boolean;
+	betaD1Shims?: string[];
+	experimentalWorkerBundle?: boolean;
+};
+
+/**
+ * This function bundles a raw `_worker.js` Pages file
+ * before it gets deployed.
+ *
+ * This allows Wrangler to add shims and other wrappers
+ * around the handlers, which is useful to support beta features.
+ */
+export function buildRawWorker({
+	workerScriptPath,
+	outfile,
+	directory,
+	minify = false,
+	sourcemap = false,
+	watch = false,
+	plugins = [],
+	onEnd = () => {},
+	nodeCompat,
+	local,
+	betaD1Shims,
+	experimentalWorkerBundle = false,
+}: RawOptions) {
+	return bundleWorker(
+		{
+			file: workerScriptPath,
+			directory: resolve(directory),
+			format: "modules",
+		},
+		resolve(outfile),
+		{
+			minify,
+			sourcemap,
+			watch,
+			nodeCompat,
+			loader: {
+				".txt": "text",
+				".html": "text",
+			},
+			define: {},
+			betaD1Shims: (betaD1Shims || []).map(
+				(binding) => `${D1_BETA_PREFIX}${binding}`
+			),
+			doBindings: [], // Pages functions don't support internal Durable Objects
+			plugins: [...plugins, buildNotifierPlugin(onEnd)],
+			isOutfile: true,
+			serveAssetsFromWorker: false,
+			disableModuleCollection: experimentalWorkerBundle ? false : true,
 			rules: [],
 			checkFetch: local,
 			targetConsumer: local ? "dev" : "publish",
@@ -164,3 +222,67 @@ export function buildWorker({
 		}
 	);
 }
+
+/**
+ * Creates an esbuild plugin that can notify Wrangler (via the `onEnd()`)
+ * when the build completes.
+ */
+export function buildNotifierPlugin(onEnd: () => void): Plugin {
+	return {
+		name: "wrangler notifier and monitor",
+		setup(pluginBuild) {
+			pluginBuild.onEnd((result) => {
+				if (result.errors.length > 0) {
+					logger.error(
+						`${result.errors.length} error(s) and ${result.warnings.length} warning(s) when compiling Worker.`
+					);
+				} else if (result.warnings.length > 0) {
+					logger.warn(
+						`${result.warnings.length} warning(s) when compiling Worker.`
+					);
+					onEnd();
+				} else {
+					logger.log("✨ Compiled Worker successfully");
+					onEnd();
+				}
+			});
+		},
+	};
+}
+
+/**
+ * Runs the script through a simple esbuild bundle step to check for unwanted imports.
+ *
+ * This is useful when the user chooses not to bundle the `_worker.js` file by setting
+ * `--no-bundle` at the command line.
+ */
+export async function checkRawWorker(scriptPath: string, onEnd: () => void) {
+	await esBuild({
+		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, buildNotifierPlugin(onEnd)],
+	});
+}
+
+const blockWorkerJsImports: 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 not being bundled by Wrangler but it is importing from another file.\n" +
+					"This will throw an error if deployed.\n" +
+					"You should bundle the Worker in a pre-build step, remove the import if it is unused, or ask Wrangler to bundle it by setting `--bundle`."
+			);
+			process.exit(1);
+		});
+	},
+};