wrangler 0.0.0-e6e1daba → 0.0.0-e7cf0caa

package/src/pages/build.ts

@@ -1,6 +1,5 @@
-import { existsSync, writeFileSync } from "node:fs";
-import { tmpdir } from "node:os";
-import { basename, dirname, join, resolve as resolvePath } from "node:path";
+import { existsSync, mkdirSync, writeFileSync } from "node:fs";
+import { basename, dirname, relative, resolve as resolvePath } from "node:path";
 import { createUploadWorkerBundleContents } from "../api/pages/create-worker-bundle-contents";
 import { FatalError } from "../errors";
 import { logger } from "../logger";
@@ -8,6 +7,7 @@ import * as metrics from "../metrics";
 import { buildFunctions } from "./buildFunctions";
 import { isInPagesCI } from "./constants";
 import {
+	EXIT_CODE_FUNCTIONS_NOTHING_TO_BUILD_ERROR,
 	EXIT_CODE_FUNCTIONS_NO_ROUTES_ERROR,
 	FunctionsNoRoutesError,
 	getFunctionsNoRoutesWarning,
@@ -32,9 +32,12 @@ export function Options(yargs: CommonYargsArgv) {
 		.options({
 			outfile: {
 				type: "string",
-				default: "_worker.js",
 				description: "The location of the output Worker script",
 			},
+			outdir: {
+				type: "string",
+				description: "Output directory for the bundled Worker",
+			},
 			"output-config-path": {
 				type: "string",
 				description: "The location for the output config file",
@@ -75,11 +78,23 @@ export function Options(yargs: CommonYargsArgv) {
 				description: "The directory to output static assets to",
 			},
 			"node-compat": {
-				describe: "Enable node.js compatibility",
+				describe: "Enable Node.js compatibility",
 				default: false,
 				type: "boolean",
 				hidden: true,
 			},
+			"compatibility-date": {
+				describe: "Date to use for compatibility checks",
+				type: "string",
+				requiresArg: true,
+			},
+			"compatibility-flags": {
+				describe: "Flags to use for compatibility checks",
+				alias: "compatibility-flag",
+				type: "string",
+				requiresArg: true,
+				array: true,
+			},
 			bindings: {
 				type: "string",
 				describe:
@@ -87,97 +102,36 @@ export function Options(yargs: CommonYargsArgv) {
 				deprecated: true,
 				hidden: true,
 			},
-			"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`",
-			},
 		})
 		.epilogue(pagesBetaWarning);
 }
 
-export const Handler = async ({
-	directory,
-	outfile,
-	outputConfigPath,
-	outputRoutesPath: routesOutputPath,
-	minify,
-	sourcemap,
-	fallbackService,
-	watch,
-	plugin,
-	buildOutputDirectory,
-	nodeCompat,
-	bindings,
-	experimentalWorkerBundle,
-}: PagesBuildArgs) => {
+export const Handler = async (args: PagesBuildArgs) => {
 	if (!isInPagesCI) {
 		// Beta message for `wrangler pages <commands>` usage
 		logger.log(pagesBetaWarning);
 	}
 
-	if (nodeCompat) {
-		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."
-		);
-	}
-
-	let d1Databases: string[] | undefined = undefined;
-	if (bindings) {
-		try {
-			const decodedBindings = JSON.parse(bindings);
-			d1Databases = Object.keys(decodedBindings?.d1_databases || {});
-		} catch {
-			throw new FatalError("Could not parse a valid set of 'bindings'.", 1);
-		}
-	}
-
-	buildOutputDirectory ??= dirname(outfile);
+	const validatedArgs = validateArgs(args);
 
-	const workerScriptPath = resolvePath(buildOutputDirectory, "_worker.js");
-	const foundWorkerScript = existsSync(workerScriptPath);
 	let bundle: BundleResult | undefined = undefined;
 
-	if (!foundWorkerScript && !existsSync(directory)) {
-		throw new FatalError(`Could not find anything to build.
-We first looked inside the build output directory (${basename(
-			resolvePath(buildOutputDirectory)
-		)}), then looked for the Functions directory (${basename(
-			directory
-		)}) but couldn't find anything to build.
-	➤ If you are trying to build _worker.js, please make sure you provide the [--build-output-directory] containing your static files.
-	➤ If you are trying to build Pages Functions, please make sure [--directory] points to the location of your Functions files.`);
-	}
-
-	/**
-	 * prioritize building `_worker.js` over Pages Functions, if both exist
-	 * and if we were able to resolve _worker.js
-	 */
-	if (experimentalWorkerBundle && foundWorkerScript) {
-		/**
-		 * `buildRawWorker` builds `_worker.js`, but doesn't give us the bundle
-		 * we want to return, which includes the external dependencies (like wasm,
-		 * binary, text). Let's output that build result to memory and only write
-		 * to disk once we have the final bundle
-		 */
-		const workerOutfile = experimentalWorkerBundle
-			? join(tmpdir(), `./bundledWorker-${Math.random()}.mjs`)
-			: outfile;
+	if (validatedArgs.plugin) {
+		const {
+			directory,
+			outfile,
+			outdir,
+			outputConfigPath,
+			outputRoutesPath: routesOutputPath,
+			minify,
+			sourcemap,
+			fallbackService,
+			watch,
+			plugin,
+			nodejsCompat,
+			legacyNodeCompat,
+		} = validatedArgs;
 
-		bundle = await buildRawWorker({
-			workerScriptPath,
-			outfile: workerOutfile,
-			directory: buildOutputDirectory,
-			local: false,
-			sourcemap: true,
-			watch: false,
-			onEnd: () => {},
-			betaD1Shims: d1Databases,
-			experimentalWorkerBundle,
-		});
-	} else {
 		try {
 			/**
 			 * `buildFunctions` builds `/functions`, but doesn't give us the bundle
@@ -185,12 +139,9 @@ We first looked inside the build output directory (${basename(
 			 * binary, text). Let's output that build result to memory and only write
 			 * to disk once we have the final bundle
 			 */
-			const functionsOutfile = experimentalWorkerBundle
-				? join(tmpdir(), `./functionsWorker-${Math.random()}.js`)
-				: outfile;
-
 			bundle = await buildFunctions({
-				outfile: functionsOutfile,
+				outfile,
+				outdir,
 				outputConfigPath,
 				functionsDirectory: directory,
 				minify,
@@ -198,12 +149,10 @@ We first looked inside the build output directory (${basename(
 				fallbackService,
 				watch,
 				plugin,
-				buildOutputDirectory,
-				nodeCompat,
+				legacyNodeCompat,
+				nodejsCompat,
 				routesOutputPath,
 				local: false,
-				d1Databases,
-				experimentalWorkerBundle,
 			});
 		} catch (e) {
 			if (e instanceof FunctionsNoRoutesError) {
@@ -215,18 +164,247 @@ We first looked inside the build output directory (${basename(
 				throw e;
 			}
 		}
+
+		if (outfile && outfile !== bundle.resolvedEntryPointPath) {
+			writeFileSync(
+				outfile,
+				`export { default } from './${relative(
+					dirname(outfile),
+					bundle.resolvedEntryPointPath
+				)}'`
+			);
+		}
+	} else {
+		const {
+			directory,
+			outfile,
+			outdir,
+			outputConfigPath,
+			outputRoutesPath: routesOutputPath,
+			minify,
+			sourcemap,
+			fallbackService,
+			watch,
+			plugin,
+			buildOutputDirectory,
+			nodejsCompat,
+			legacyNodeCompat,
+			bindings,
+			workerScriptPath,
+		} = validatedArgs;
+
+		let d1Databases: string[] | undefined = undefined;
+		if (bindings) {
+			try {
+				const decodedBindings = JSON.parse(bindings);
+				d1Databases = Object.keys(decodedBindings?.d1_databases || {});
+			} catch {
+				throw new FatalError("Could not parse a valid set of 'bindings'.", 1);
+			}
+		}
+
+		/**
+		 * prioritize building `_worker.js` over Pages Functions, if both exist
+		 * and if we were able to resolve _worker.js
+		 */
+		if (workerScriptPath) {
+			/**
+			 * `buildRawWorker` builds `_worker.js`, but doesn't give us the bundle
+			 * we want to return, which includes the external dependencies (like wasm,
+			 * binary, text). Let's output that build result to memory and only write
+			 * to disk once we have the final bundle
+			 */
+			bundle = await buildRawWorker({
+				workerScriptPath,
+				outdir,
+				directory: buildOutputDirectory,
+				local: false,
+				sourcemap,
+				watch,
+				betaD1Shims: d1Databases,
+			});
+		} else {
+			try {
+				/**
+				 * `buildFunctions` builds `/functions`, but doesn't give us the bundle
+				 * we want to return, which includes the external dependencies (like wasm,
+				 * binary, text). Let's output that build result to memory and only write
+				 * to disk once we have the final bundle
+				 */
+				bundle = await buildFunctions({
+					outdir,
+					outputConfigPath,
+					functionsDirectory: directory,
+					minify,
+					sourcemap,
+					fallbackService,
+					watch,
+					plugin,
+					buildOutputDirectory,
+					legacyNodeCompat,
+					nodejsCompat,
+					routesOutputPath,
+					local: false,
+					d1Databases,
+				});
+			} catch (e) {
+				if (e instanceof FunctionsNoRoutesError) {
+					throw new FatalError(
+						getFunctionsNoRoutesWarning(directory),
+						EXIT_CODE_FUNCTIONS_NO_ROUTES_ERROR
+					);
+				} else {
+					throw e;
+				}
+			}
+		}
+
+		if (outfile) {
+			const workerBundleContents = await createUploadWorkerBundleContents(
+				bundle as BundleResult
+			);
+
+			mkdirSync(dirname(outfile), { recursive: true });
+			writeFileSync(
+				outfile,
+				Buffer.from(await workerBundleContents.arrayBuffer())
+			);
+		}
 	}
 
-	if (experimentalWorkerBundle) {
-		const workerBundleContents = await createUploadWorkerBundleContents(
-			bundle as BundleResult
+	await metrics.sendMetricsEvent("build pages functions");
+};
+
+type WorkerBundleArgs = Omit<PagesBuildArgs, "nodeCompat"> & {
+	plugin: false;
+	buildOutputDirectory: string;
+	legacyNodeCompat: boolean;
+	nodejsCompat: boolean;
+
+	workerScriptPath: string;
+};
+type PluginArgs = Omit<
+	PagesBuildArgs,
+	"buildOutputDirectory" | "bindings" | "nodeCompat"
+> & {
+	plugin: true;
+	outdir: string;
+	legacyNodeCompat: boolean;
+	nodejsCompat: boolean;
+};
+
+type ValidatedArgs = WorkerBundleArgs | PluginArgs;
+
+const validateArgs = (args: PagesBuildArgs): ValidatedArgs => {
+	if (args.outdir && args.outfile) {
+		throw new FatalError(
+			"Cannot specify both an `--outdir` and an `--outfile`.",
+			1
 		);
+	}
 
-		writeFileSync(
-			outfile,
-			Buffer.from(await workerBundleContents.arrayBuffer())
+	if (args.plugin) {
+		if (args.outfile) {
+			// Explicit old behavior. Encourage to migrate to `--outdir` instead.
+			logger.warn(
+				"Creating a Pages Plugin with `--outfile` is now deprecated. Please use `--outdir` instead."
+			);
+
+			args.outdir = dirname(resolvePath(args.outfile));
+		} else if (!args.outfile && !args.outdir) {
+			// Didn't specify `--outfile`, but didn't specify `--outdir` either. Implicit old behavior defaults. Encourage to migrate to `--outdir`.
+			args.outfile ??= "_worker.js";
+			args.outdir = ".";
+
+			logger.warn(
+				"Creating a Pages Plugin without `--outdir` is now deprecated. Please add an `--outdir` argument."
+			);
+		}
+
+		if (args.bindings) {
+			throw new FatalError(
+				"The `--bindings` flag cannot be used when creating a Pages Plugin with `--plugin`.",
+				1
+			);
+		}
+
+		if (args.buildOutputDirectory) {
+			throw new FatalError(
+				"The `--build-output-directory` flag cannot be used when creating a Pages Plugin with `--plugin`.",
+				1
+			);
+		}
+	} else {
+		if (!args.outdir) {
+			args.outfile ??= "_worker.bundle";
+		}
+
+		args.buildOutputDirectory ??= args.outfile ? dirname(args.outfile) : ".";
+	}
+
+	if (args.buildOutputDirectory) {
+		args.buildOutputDirectory = resolvePath(args.buildOutputDirectory);
+	}
+	if (args.outdir) {
+		args.outdir = resolvePath(args.outdir);
+	}
+	if (args.outfile) {
+		args.outfile = resolvePath(args.outfile);
+	}
+
+	const { nodeCompat: legacyNodeCompat, ...argsExceptNodeCompat } = args;
+	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."
+		);
+	}
+	const nodejsCompat = !!args.compatibilityFlags?.includes("nodejs_compat");
+	if (legacyNodeCompat && nodejsCompat) {
+		throw new Error(
+			"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."
 		);
 	}
 
-	await metrics.sendMetricsEvent("build pages functions");
+	let workerScriptPath: string | undefined;
+
+	if (args.buildOutputDirectory) {
+		const prospectiveWorkerScriptPath = resolvePath(
+			args.buildOutputDirectory,
+			"_worker.js"
+		);
+
+		const foundWorkerScript = existsSync(prospectiveWorkerScriptPath);
+
+		if (foundWorkerScript) {
+			workerScriptPath = prospectiveWorkerScriptPath;
+		} else if (!foundWorkerScript && !existsSync(args.directory)) {
+			throw new FatalError(
+				`Could not find anything to build.
+We first looked inside the build output directory (${basename(
+					resolvePath(args.buildOutputDirectory)
+				)}), then looked for the Functions directory (${basename(
+					args.directory
+				)}) but couldn't find anything to build.
+	➤ If you are trying to build _worker.js, please make sure you provide the [--build-output-directory] containing your static files.
+	➤ If you are trying to build Pages Functions, please make sure [directory] points to the location of your Functions files.`,
+				EXIT_CODE_FUNCTIONS_NOTHING_TO_BUILD_ERROR
+			);
+		}
+	} else if (!existsSync(args.directory)) {
+		throw new FatalError(
+			`Could not find anything to build.
+We looked for the Functions directory (${basename(
+				args.directory
+			)}) but couldn't find anything to build.
+	➤ Please make sure [directory] points to the location of your Functions files.`,
+			EXIT_CODE_FUNCTIONS_NOTHING_TO_BUILD_ERROR
+		);
+	}
+
+	return {
+		...argsExceptNodeCompat,
+		workerScriptPath,
+		nodejsCompat,
+		legacyNodeCompat,
+	} as ValidatedArgs;
 };

package/src/pages/buildFunctions.ts

@@ -1,6 +1,7 @@
 import { writeFileSync } from "node:fs";
 import { tmpdir } from "node:os";
 import { join, resolve } from "node:path";
+import { FatalError } from "../errors";
 import { toUrlPath } from "../paths";
 import { FunctionsNoRoutesError } from "./errors";
 import { buildPlugin } from "./functions/buildPlugin";
@@ -20,6 +21,7 @@ import type { Config } from "./functions/routes";
 
 export async function buildFunctions({
 	outfile,
+	outdir,
 	outputConfigPath,
 	functionsDirectory,
 	minify = false,
@@ -30,13 +32,15 @@ export async function buildFunctions({
 	plugin = false,
 	buildOutputDirectory,
 	routesOutputPath,
-	nodeCompat,
+	legacyNodeCompat,
+	nodejsCompat,
 	local,
 	d1Databases,
-	experimentalWorkerBundle = false,
 }: Partial<
 	Pick<
 		PagesBuildArgs,
+		| "outfile"
+		| "outdir"
 		| "outputConfigPath"
 		| "minify"
 		| "sourcemap"
@@ -44,16 +48,15 @@ export async function buildFunctions({
 		| "watch"
 		| "plugin"
 		| "buildOutputDirectory"
-		| "nodeCompat"
 	>
 > & {
 	functionsDirectory: string;
 	onEnd?: () => void;
-	outfile: Required<PagesBuildArgs>["outfile"];
 	routesOutputPath?: PagesBuildArgs["outputRoutesPath"];
 	local: boolean;
 	d1Databases?: string[];
-	experimentalWorkerBundle?: boolean;
+	legacyNodeCompat?: boolean;
+	nodejsCompat?: boolean;
 }) {
 	RUNNING_BUILDERS.forEach(
 		(runningBuilder) => runningBuilder.stop && runningBuilder.stop()
@@ -95,22 +98,29 @@ export async function buildFunctions({
 	let bundle: BundleResult;
 
 	if (plugin) {
+		if (outdir === undefined) {
+			throw new FatalError(
+				"Must specify an output directory when building a Plugin.",
+				1
+			);
+		}
+
 		bundle = await buildPlugin({
 			routesModule,
-			outfile,
+			outdir,
 			minify,
 			sourcemap,
 			watch,
-			nodeCompat,
+			legacyNodeCompat,
 			functionsDirectory: absoluteFunctionsDirectory,
 			local,
 			betaD1Shims: d1Databases,
-			onEnd,
 		});
 	} else {
 		bundle = await buildWorker({
 			routesModule,
 			outfile,
+			outdir,
 			minify,
 			sourcemap,
 			fallbackService,
@@ -120,8 +130,8 @@ export async function buildFunctions({
 			betaD1Shims: d1Databases,
 			onEnd,
 			buildOutputDirectory,
-			nodeCompat,
-			experimentalWorkerBundle,
+			legacyNodeCompat,
+			nodejsCompat,
 		});
 	}
 

package/src/pages/deployments.tsx

@@ -1,12 +1,13 @@
-import { render } from "ink";
 import Table from "ink-table";
 import React from "react";
 import { format as timeagoFormat } from "timeago.js";
 import { fetchResult } from "../cfetch";
 import { getConfigCache, saveToConfigCache } from "../config-cache";
 import { FatalError } from "../errors";
+import { logger } from "../logger";
 import * as metrics from "../metrics";
 import { requireAuth } from "../user";
+import { renderToString } from "../utils/render";
 import { PAGES_CONFIG_CACHE_FILENAME } from "./constants";
 import { promptSelectProject } from "./prompt-select-project";
 import { pagesBetaWarning } from "./utils";
@@ -78,9 +79,6 @@ export async function ListHandler({ projectName }: ListArgs) {
 		account_id: accountId,
 	});
 
-	const { unmount } = render(<Table data={data}></Table>, {
-		patchConsole: false,
-	});
-	unmount();
+	logger.log(renderToString(<Table data={data}></Table>));
 	await metrics.sendMetricsEvent("list pages deployments");
 }

package/src/pages/dev.ts

@@ -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],
@@ -270,6 +262,8 @@ export const Handler = async ({
 
 	let scriptPath = "";
 
+	const nodejsCompat = compatibilityFlags?.includes("nodejs_compat");
+
 	if (usingWorkerScript) {
 		scriptPath = workerScriptPath;
 		let runBuild = async () => {
@@ -278,7 +272,7 @@ export const Handler = async ({
 
 		// 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;
+		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
@@ -290,11 +284,11 @@ export const Handler = async ({
 						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 +297,7 @@ export const Handler = async ({
 		}
 
 		await runBuild();
-		watch([scriptPath], {
+		watch([workerScriptPath], {
 			persistent: true,
 			ignoreInitial: true,
 		}).on("all", async () => {
@@ -313,9 +307,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 +331,9 @@ export const Handler = async ({
 					watch: true,
 					onEnd,
 					buildOutputDirectory: directory,
-					nodeCompat,
+					legacyNodeCompat,
+					nodejsCompat,
 					local: true,
-					experimentalWorkerBundle,
 				});
 				await metrics.sendMetricsEvent("build pages functions");
 			};
@@ -503,7 +504,7 @@ export const Handler = async ({
 		localProtocol,
 		compatibilityDate,
 		compatibilityFlags,
-		nodeCompat,
+		nodeCompat: legacyNodeCompat,
 		vars: Object.fromEntries(
 			bindings
 				.map((binding) => binding.toString().split("="))
@@ -540,8 +541,7 @@ export const Handler = async ({
 		persist,
 		persistTo,
 		inspect: undefined,
-		logPrefix: "pages",
-		logLevel: logLevel ?? "warn",
+		logLevel,
 		experimental: {
 			d1Databases: d1s.map((binding) => ({
 				binding: binding.toString(),