wrangler 0.0.0-e33294b0 → 0.0.0-e351afcf

package/src/pages/dev.ts

@@ -1,5 +1,5 @@
 import { execSync, spawn } from "node:child_process";
-import { existsSync, readFileSync } from "node:fs";
+import { existsSync, lstatSync, readFileSync } from "node:fs";
 import { homedir, tmpdir } from "node:os";
 import { join, resolve } from "node:path";
 import { watch } from "chokidar";
@@ -85,16 +85,9 @@ export function Options(yargs: CommonYargsArgv) {
 				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`",
+				description: "Whether to run bundling on `_worker.js`",
 			},
 			binding: {
 				type: "array",
@@ -147,7 +140,7 @@ export function Options(yargs: CommonYargsArgv) {
 				requiresArg: true,
 			},
 			"node-compat": {
-				describe: "Enable node.js compatibility",
+				describe: "Enable Node.js compatibility",
 				default: false,
 				type: "boolean",
 				hidden: true,
@@ -181,7 +174,6 @@ export const Handler = async ({
 	proxy: requestedProxyPort,
 	bundle,
 	noBundle,
-	experimentalWorkerBundle,
 	scriptPath: singleWorkerScriptPath,
 	binding: bindings = [],
 	kv: kvs = [],
@@ -193,7 +185,7 @@ export const Handler = async ({
 	experimentalEnableLocalPersistence,
 	persist,
 	persistTo,
-	nodeCompat,
+	nodeCompat: legacyNodeCompat,
 	experimentalLocal,
 	config: config,
 	_: [_pages, _dev, ...remaining],
@@ -263,22 +255,26 @@ export const Handler = async ({
 		directory !== undefined
 			? join(directory, singleWorkerScriptPath)
 			: singleWorkerScriptPath;
+	const usingWorkerDirectory =
+		existsSync(workerScriptPath) && lstatSync(workerScriptPath).isDirectory();
 	const usingWorkerScript = existsSync(workerScriptPath);
+	// 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;
 
 	const functionsDirectory = "./functions";
 	let usingFunctions = !usingWorkerScript && existsSync(functionsDirectory);
 
 	let scriptPath = "";
 
+	const nodejsCompat = compatibilityFlags?.includes("nodejs_compat");
+
 	if (usingWorkerScript) {
 		scriptPath = workerScriptPath;
 		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) || 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
@@ -287,14 +283,16 @@ export const Handler = async ({
 			runBuild = async () => {
 				try {
 					await buildRawWorker({
-						workerScriptPath,
+						workerScriptPath: usingWorkerDirectory
+							? join(workerScriptPath, "index.js")
+							: workerScriptPath,
 						outfile: scriptPath,
 						directory: directory ?? ".",
+						nodejsCompat,
 						local: true,
 						sourcemap: true,
 						watch: true,
 						onEnd: () => scriptReadyResolve(),
-						experimentalWorkerBundle,
 					});
 				} catch (e: unknown) {
 					logger.warn("Failed to bundle _worker.js.", e);
@@ -303,7 +301,7 @@ export const Handler = async ({
 		}
 
 		await runBuild();
-		watch([scriptPath], {
+		watch([workerScriptPath], {
 			persistent: true,
 			ignoreInitial: true,
 		}).on("all", async () => {
@@ -313,9 +311,16 @@ export const Handler = async ({
 		// Try to use Functions
 		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
 			);
 		}
 
@@ -330,9 +335,9 @@ export const Handler = async ({
 					watch: true,
 					onEnd,
 					buildOutputDirectory: directory,
-					nodeCompat,
+					legacyNodeCompat,
+					nodejsCompat,
 					local: true,
-					experimentalWorkerBundle,
 				});
 				await metrics.sendMetricsEvent("build pages functions");
 			};
@@ -395,7 +400,10 @@ export const Handler = async ({
 	let entrypoint = scriptPath;
 
 	// custom _routes.json apply only to Functions or Advanced Mode Pages projects
-	if (directory && (usingFunctions || usingWorkerScript)) {
+	if (
+		directory &&
+		(usingFunctions || usingWorkerScript || usingWorkerDirectory)
+	) {
 		const routesJSONPath = join(directory, "_routes.json");
 
 		if (existsSync(routesJSONPath)) {
@@ -503,7 +511,7 @@ export const Handler = async ({
 		localProtocol,
 		compatibilityDate,
 		compatibilityFlags,
-		nodeCompat,
+		nodeCompat: legacyNodeCompat,
 		vars: Object.fromEntries(
 			bindings
 				.map((binding) => binding.toString().split("="))
@@ -537,11 +545,21 @@ export const Handler = async ({
 		r2: r2s.map((binding) => {
 			return { binding: binding.toString(), bucket_name: "" };
 		}),
+		processEntrypoint: true,
+		moduleRoot: workerScriptPath,
+		rules: usingWorkerDirectory
+			? [
+					{
+						type: "ESModule",
+						globs: ["**/*.js"],
+					},
+			  ]
+			: undefined,
+		bundle: enableBundling,
 		persist,
 		persistTo,
 		inspect: undefined,
-		logPrefix: "pages",
-		logLevel: logLevel ?? "warn",
+		logLevel,
 		experimental: {
 			d1Databases: d1s.map((binding) => ({
 				binding: binding.toString(),

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,21 +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,
@@ -25,14 +28,20 @@ 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}`
@@ -43,43 +52,57 @@ export function buildPlugin({
 				{
 					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",

package/src/pages/functions/buildWorker.ts

@@ -1,61 +1,66 @@
 import { access, cp, lstat, rm } from "node:fs/promises";
+import { tmpdir } from "node:os";
 import { join, resolve } from "node:path";
 import { build as esBuild } from "esbuild";
 import { nanoid } from "nanoid";
 import { bundleWorker } from "../../bundle";
+import { FatalError } from "../../errors";
 import { logger } from "../../logger";
 import { getBasePath } from "../../paths";
+import traverseModuleGraph from "../../traverse-module-graph";
 import { D1_BETA_PREFIX } from "../../worker";
+import type { BundleResult } from "../../bundle";
 import type { Plugin } from "esbuild";
 
 export type Options = {
 	routesModule: string;
-	outfile: string;
+	outfile?: string;
+	outdir?: string;
 	minify?: boolean;
 	sourcemap?: boolean;
 	fallbackService?: string;
 	watch?: boolean;
 	onEnd?: () => void;
 	buildOutputDirectory?: string;
-	nodeCompat?: boolean;
+	legacyNodeCompat?: boolean;
+	nodejsCompat?: boolean;
 	functionsDirectory: string;
 	local: boolean;
 	betaD1Shims?: string[];
-	experimentalWorkerBundle?: boolean;
 };
 
 export function buildWorker({
 	routesModule,
-	outfile = "bundle.js",
+	outfile = join(tmpdir(), `./functionsWorker-${Math.random()}.js`),
+	outdir,
 	minify = false,
 	sourcemap = false,
 	fallbackService = "ASSETS",
 	watch = false,
 	onEnd = () => {},
 	buildOutputDirectory,
-	nodeCompat,
+	legacyNodeCompat,
+	nodejsCompat,
 	functionsDirectory,
 	local,
 	betaD1Shims,
-	experimentalWorkerBundle = false,
 }: Options) {
 	return bundleWorker(
 		{
 			file: resolve(getBasePath(), "templates/pages-template-worker.ts"),
 			directory: functionsDirectory,
 			format: "modules",
+			moduleRoot: functionsDirectory,
 		},
-		resolve(outfile),
+		outdir ? resolve(outdir) : resolve(outfile),
 		{
 			inject: [routesModule],
+			...(outdir ? { entryName: "index" } : {}),
 			minify,
 			sourcemap,
 			watch,
-			nodeCompat,
-			loader: {
-				".txt": "text",
-				".html": "text",
-			},
+			legacyNodeCompat,
+			nodejsCompat,
 			define: {
 				__FALLBACK_SERVICE__: JSON.stringify(fallbackService),
 			},
@@ -140,9 +145,9 @@ export function buildWorker({
 					},
 				},
 			],
-			isOutfile: true,
+			isOutfile: !outdir,
 			serveAssetsFromWorker: false,
-			disableModuleCollection: experimentalWorkerBundle ? false : true,
+			disableModuleCollection: false,
 			rules: [],
 			checkFetch: local,
 			targetConsumer: local ? "dev" : "publish",
@@ -154,18 +159,20 @@ export function buildWorker({
 
 export type RawOptions = {
 	workerScriptPath: string;
-	outfile: string;
+	outfile?: string;
+	outdir?: string;
 	directory: string;
+	bundle?: boolean;
 	minify?: boolean;
 	sourcemap?: boolean;
 	watch?: boolean;
 	plugins?: Plugin[];
 	onEnd?: () => void;
 	buildOutputDirectory?: string;
-	nodeCompat?: boolean;
+	legacyNodeCompat?: boolean;
+	nodejsCompat?: boolean;
 	local: boolean;
 	betaD1Shims?: string[];
-	experimentalWorkerBundle?: boolean;
 };
 
 /**
@@ -177,43 +184,44 @@ export type RawOptions = {
  */
 export function buildRawWorker({
 	workerScriptPath,
-	outfile,
+	outfile = join(tmpdir(), `./functionsWorker-${Math.random()}.js`),
+	outdir,
 	directory,
+	bundle = true,
 	minify = false,
 	sourcemap = false,
 	watch = false,
 	plugins = [],
 	onEnd = () => {},
-	nodeCompat,
+	legacyNodeCompat,
+	nodejsCompat,
 	local,
 	betaD1Shims,
-	experimentalWorkerBundle = false,
 }: RawOptions) {
 	return bundleWorker(
 		{
 			file: workerScriptPath,
 			directory: resolve(directory),
 			format: "modules",
+			moduleRoot: resolve(directory),
 		},
-		resolve(outfile),
+		outdir ? resolve(outdir) : resolve(outfile),
 		{
+			bundle,
 			minify,
 			sourcemap,
 			watch,
-			nodeCompat,
-			loader: {
-				".txt": "text",
-				".html": "text",
-			},
+			legacyNodeCompat,
+			nodejsCompat,
 			define: {},
 			betaD1Shims: (betaD1Shims || []).map(
 				(binding) => `${D1_BETA_PREFIX}${binding}`
 			),
 			doBindings: [], // Pages functions don't support internal Durable Objects
 			plugins: [...plugins, buildNotifierPlugin(onEnd)],
-			isOutfile: true,
+			isOutfile: !outdir,
 			serveAssetsFromWorker: false,
-			disableModuleCollection: experimentalWorkerBundle ? false : true,
+			disableModuleCollection: false,
 			rules: [],
 			checkFetch: local,
 			targetConsumer: local ? "dev" : "publish",
@@ -223,6 +231,58 @@ export function buildRawWorker({
 	);
 }
 
+export async function traverseAndBuildWorkerJSDirectory({
+	workerJSDirectory,
+	buildOutputDirectory,
+	d1Databases,
+	nodejsCompat,
+}: {
+	workerJSDirectory: string;
+	buildOutputDirectory: string;
+	d1Databases?: string[];
+	nodejsCompat?: boolean;
+}): Promise<BundleResult> {
+	const entrypoint = resolve(join(workerJSDirectory, "index.js"));
+
+	const traverseModuleGraphResult = await traverseModuleGraph(
+		{
+			file: entrypoint,
+			directory: resolve(workerJSDirectory),
+			format: "modules",
+			moduleRoot: resolve(workerJSDirectory),
+		},
+		[
+			{
+				type: "ESModule",
+				globs: ["**/*.js"],
+			},
+		]
+	);
+
+	const outfile = join(tmpdir(), `./bundledWorker-${Math.random()}.mjs`);
+	const bundleResult = await buildRawWorker({
+		workerScriptPath: entrypoint,
+		bundle: false,
+		outfile,
+		directory: buildOutputDirectory,
+		local: false,
+		sourcemap: true,
+		watch: false,
+		onEnd: () => {},
+		betaD1Shims: d1Databases,
+		nodejsCompat,
+	});
+
+	return {
+		modules: traverseModuleGraphResult.modules,
+		dependencies: bundleResult.dependencies,
+		resolvedEntryPointPath: bundleResult.resolvedEntryPointPath,
+		bundleType: bundleResult.bundleType,
+		stop: bundleResult.stop,
+		sourceMapPath: bundleResult.sourceMapPath,
+	};
+}
+
 /**
  * Creates an esbuild plugin that can notify Wrangler (via the `onEnd()`)
  * when the build completes.
@@ -277,12 +337,12 @@ const blockWorkerJsImports: Plugin = {
 				};
 			}
 			// Otherwise, block any imports that the file is requesting
-			logger.error(
+			throw new FatalError(
 				"_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`."
+					"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`.",
+				1
 			);
-			process.exit(1);
 		});
 	},
 };