wrangler 0.0.0-e7a0cd5b → 0.0.0-e7cf0caa

package/src/module-collection.ts

@@ -1,6 +1,7 @@
 import crypto from "node:crypto";
 import { readFile } from "node:fs/promises";
 import path from "node:path";
+import chalk from "chalk";
 import globToRegExp from "glob-to-regexp";
 import { logger } from "./logger";
 import type { Config, ConfigModuleRuleType } from "./config";
@@ -38,28 +39,8 @@ export const DEFAULT_MODULE_RULES: Config["rules"] = [
 	{ type: "CompiledWasm", globs: ["**/*.wasm"] },
 ];
 
-export default function createModuleCollector(props: {
-	format: CfScriptFormat;
-	rules?: Config["rules"];
-	// a collection of "legacy" style module references, which are just file names
-	// we will eventually deprecate this functionality, hence the verbose greppable name
-	wrangler1xlegacyModuleReferences: {
-		rootDirectory: string;
-		fileNames: Set<string>;
-	};
-}): {
-	modules: CfModule[];
-	plugin: esbuild.Plugin;
-} {
-	const rules: Config["rules"] = [
-		...(props.rules || []),
-		// eslint-disable-next-line @typescript-eslint/no-non-null-assertion
-		...DEFAULT_MODULE_RULES!,
-	];
-
-	// First, we want to add some validations to the module rules
-	// We want to warn if rules are accidentally configured in such a way that
-	// subsequent rules will never match because `fallthrough` hasn't been set
+export function parseRules(userRules: Config["rules"] = []) {
+	const rules: Config["rules"] = [...userRules, ...DEFAULT_MODULE_RULES];
 
 	const completedRuleLocations: Record<string, number> = {};
 	let index = 0;
@@ -67,7 +48,7 @@ export default function createModuleCollector(props: {
 	for (const rule of rules) {
 		if (rule.type in completedRuleLocations) {
 			if (rules[completedRuleLocations[rule.type]].fallthrough !== false) {
-				if (index < (props.rules || []).length) {
+				if (index < userRules.length) {
 					logger.warn(
 						`The module rule at position ${index} (${JSON.stringify(
 							rule
@@ -101,6 +82,89 @@ export default function createModuleCollector(props: {
 	// eslint-disable-next-line @typescript-eslint/no-non-null-assertion
 	rulesToRemove.forEach((rule) => rules!.splice(rules!.indexOf(rule), 1));
 
+	return { rules, removedRules: rulesToRemove };
+}
+
+export async function matchFiles(
+	files: string[],
+	relativeTo: string,
+	{
+		rules,
+		removedRules,
+	}: { rules: Config["rules"]; removedRules: Config["rules"] }
+) {
+	const modules: CfModule[] = [];
+
+	// Deduplicate modules. This is usually a poorly specified `wrangler.toml` configuration, but duplicate modules will cause a crash at runtime
+	const moduleNames = new Set<string>();
+	for (const rule of rules) {
+		for (const glob of rule.globs) {
+			const regexp = globToRegExp(glob, {
+				globstar: true,
+			});
+			const newModules = await Promise.all(
+				files
+					.filter((f) => regexp.test(f))
+					.map(async (name) => {
+						const filePath = name;
+						const fileContent = await readFile(path.join(relativeTo, filePath));
+
+						return {
+							name: filePath,
+							content: fileContent,
+							type: RuleTypeToModuleType[rule.type],
+						};
+					})
+			);
+			for (const module of newModules) {
+				if (!moduleNames.has(module.name)) {
+					moduleNames.add(module.name);
+					modules.push(module);
+				} else {
+					logger.warn(
+						`Ignoring duplicate module: ${chalk.blue(
+							module.name
+						)} (${chalk.green(module.type ?? "")})`
+					);
+				}
+			}
+		}
+	}
+
+	// This is just a sanity check verifying that no files match rules that were removed
+	for (const rule of removedRules) {
+		for (const glob of rule.globs) {
+			const regexp = globToRegExp(glob);
+			for (const file of files) {
+				if (regexp.test(file)) {
+					throw new Error(
+						`The file ${file} matched a module rule in your configuration (${JSON.stringify(
+							rule
+						)}), but was ignored because a previous rule with the same type was not marked as \`fallthrough = true\`.`
+					);
+				}
+			}
+		}
+	}
+	return modules;
+}
+
+export default function createModuleCollector(props: {
+	format: CfScriptFormat;
+	rules?: Config["rules"];
+	// a collection of "legacy" style module references, which are just file names
+	// we will eventually deprecate this functionality, hence the verbose greppable name
+	wrangler1xlegacyModuleReferences: {
+		rootDirectory: string;
+		fileNames: Set<string>;
+	};
+	preserveFileNames?: boolean;
+}): {
+	modules: CfModule[];
+	plugin: esbuild.Plugin;
+} {
+	const { rules, removedRules } = parseRules(props.rules);
+
 	const modules: CfModule[] = [];
 	return {
 		modules,
@@ -206,7 +270,9 @@ export default function createModuleCollector(props: {
 									.createHash("sha1")
 									.update(fileContent)
 									.digest("hex");
-								const fileName = `./${fileHash}-${path.basename(args.path)}`;
+								const fileName = props.preserveFileNames
+									? filePath
+									: `./${fileHash}-${path.basename(args.path)}`;
 
 								// add the module to the array
 								modules.push({
@@ -245,7 +311,7 @@ export default function createModuleCollector(props: {
 					});
 				});
 
-				rulesToRemove.forEach((rule) => {
+				removedRules.forEach((rule) => {
 					rule.globs.forEach((glob) => {
 						build.onResolve(
 							{ filter: globToRegExp(glob) },

package/src/mtls-certificate/cli.ts

@@ -0,0 +1,155 @@
+import {
+	uploadMTlsCertificateFromFs,
+	listMTlsCertificates,
+	deleteMTlsCertificate,
+	getMTlsCertificate,
+	getMTlsCertificateByName,
+	type MTlsCertificateResponse,
+} from "../api/mtls-certificate";
+import { withConfig } from "../config";
+import { confirm } from "../dialogs";
+import { logger } from "../logger";
+import { requireAuth } from "../user";
+import type {
+	CommonYargsOptions,
+	CommonYargsArgv,
+	StrictYargsOptionsToInterface,
+} from "../yargs-types";
+import type { BuilderCallback } from "yargs";
+
+function uploadMTlsCertificateOptions(yargs: CommonYargsArgv) {
+	return yargs
+		.option("cert", {
+			describe:
+				"The path to a certificate file (.pem) containing a chain of certificates to upload",
+			type: "string",
+			demandOption: true,
+		})
+		.option("key", {
+			describe:
+				"The path to a file containing the private key for your leaf certificate",
+			type: "string",
+			demandOption: true,
+		})
+		.option("name", {
+			describe: "The name for the certificate",
+			type: "string",
+		});
+}
+
+const uploadMTlsCertificateHandler = withConfig<
+	StrictYargsOptionsToInterface<typeof uploadMTlsCertificateOptions>
+>(async ({ config, cert, key, name }) => {
+	const accountId = await requireAuth(config);
+	logger.log(
+		name
+			? `Uploading mTLS Certificate ${name}...`
+			: `Uploading mTLS Certificate...`
+	);
+	const certResponse = await uploadMTlsCertificateFromFs(accountId, {
+		certificateChainFilename: cert,
+		privateKeyFilename: key,
+		name: name,
+	});
+	const expiresOn = new Date(certResponse.expires_on).toLocaleDateString();
+	logger.log(
+		name
+			? `Success! Uploaded mTLS Certificate ${name}`
+			: `Success! Uploaded mTLS Certificate`
+	);
+	logger.log(`ID: ${certResponse.id}`);
+	logger.log(`Issuer: ${certResponse.issuer}`);
+	logger.log(`Expires on ${expiresOn}`);
+});
+
+const listMTlsCertificatesHandler = withConfig(async ({ config }) => {
+	const accountId = await requireAuth(config);
+	const certificates = await listMTlsCertificates(accountId, {});
+	for (const certificate of certificates) {
+		logger.log(`ID: ${certificate.id}`);
+		if (certificate.name) {
+			logger.log(`Name: ${certificate.name}`);
+		}
+		logger.log(`Issuer: ${certificate.issuer}`);
+		logger.log(
+			`Created on: ${new Date(certificate.uploaded_on).toLocaleDateString()}`
+		);
+		logger.log(
+			`Expires on: ${new Date(certificate.expires_on).toLocaleDateString()}`
+		);
+		logger.log("\n");
+	}
+});
+
+function deleteMTlsCertificateOptions(yargs: CommonYargsArgv) {
+	return yargs
+		.option("id", {
+			describe: "The id of the mTLS certificate to delete",
+			type: "string",
+		})
+		.option("name", {
+			describe: "The name of the mTLS certificate record to delete",
+			type: "string",
+		});
+}
+
+const deleteMTlsCertificateHandler = withConfig<
+	StrictYargsOptionsToInterface<typeof deleteMTlsCertificateOptions>
+>(async ({ config, id, name }) => {
+	const accountId = await requireAuth(config);
+	if (id && name) {
+		return logger.error(`Error: can't provide both --id and --name.`);
+	} else if (!id && !name) {
+		return logger.error(`Error: must provide --id or --name.`);
+	}
+	let certificate: MTlsCertificateResponse;
+	if (id) {
+		certificate = await getMTlsCertificate(accountId, id);
+	} else {
+		certificate = await getMTlsCertificateByName(accountId, name as string);
+	}
+
+	const response = await confirm(
+		certificate.name
+			? `Are you sure you want to delete certificate ${certificate.id} (${certificate.name})?`
+			: `Are you sure you want to delete certificate ${certificate.id}?`
+	);
+	if (!response) {
+		logger.log("Not deleting");
+		return;
+	}
+
+	await deleteMTlsCertificate(accountId, certificate.id);
+
+	logger.log(
+		certificate.name
+			? `Deleted certificate ${certificate.id} (${certificate.name}) successfully`
+			: `Deleted certificate ${certificate.id} successfully`
+	);
+});
+
+export const mTlsCertificateCommands: BuilderCallback<
+	CommonYargsOptions,
+	unknown
+> = (yargs) => {
+	yargs.command(
+		"upload",
+		"Upload an mTLS certificate",
+		uploadMTlsCertificateOptions,
+		uploadMTlsCertificateHandler
+	);
+
+	yargs.command(
+		"list",
+		"List uploaded mTLS certificates",
+		(a) => a,
+		listMTlsCertificatesHandler
+	);
+
+	yargs.command(
+		"delete",
+		"Delete an mTLS certificate",
+		deleteMTlsCertificateOptions,
+		deleteMTlsCertificateHandler
+	);
+};

package/src/pages/build.ts

@@ -0,0 +1,410 @@
+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";
+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,
+} from "./errors";
+import { buildRawWorker } from "./functions/buildWorker";
+import { pagesBetaWarning } from "./utils";
+import type { BundleResult } from "../bundle";
+import type {
+	CommonYargsArgv,
+	StrictYargsOptionsToInterface,
+} from "../yargs-types";
+
+export type PagesBuildArgs = StrictYargsOptionsToInterface<typeof Options>;
+
+export function Options(yargs: CommonYargsArgv) {
+	return yargs
+		.positional("directory", {
+			type: "string",
+			default: "functions",
+			description: "The directory of Pages Functions",
+		})
+		.options({
+			outfile: {
+				type: "string",
+				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",
+			},
+			"output-routes-path": {
+				type: "string",
+				description: "The location for the output _routes.json file",
+			},
+			minify: {
+				type: "boolean",
+				default: false,
+				description: "Minify the output Worker script",
+			},
+			sourcemap: {
+				type: "boolean",
+				default: false,
+				description: "Generate a sourcemap for the output Worker script",
+			},
+			"fallback-service": {
+				type: "string",
+				default: "ASSETS",
+				description:
+					"The service to fallback to at the end of the `next` chain. Setting to '' will fallback to the global `fetch`.",
+			},
+			watch: {
+				type: "boolean",
+				default: false,
+				description:
+					"Watch for changes to the functions and automatically rebuild the Worker script",
+			},
+			plugin: {
+				type: "boolean",
+				default: false,
+				description: "Build a plugin rather than a Worker script",
+			},
+			"build-output-directory": {
+				type: "string",
+				description: "The directory to output static assets to",
+			},
+			"node-compat": {
+				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:
+					"Bindings used in Functions (used to register beta product shims)",
+				deprecated: true,
+				hidden: true,
+			},
+		})
+		.epilogue(pagesBetaWarning);
+}
+
+export const Handler = async (args: PagesBuildArgs) => {
+	if (!isInPagesCI) {
+		// Beta message for `wrangler pages <commands>` usage
+		logger.log(pagesBetaWarning);
+	}
+
+	const validatedArgs = validateArgs(args);
+
+	let bundle: BundleResult | undefined = undefined;
+
+	if (validatedArgs.plugin) {
+		const {
+			directory,
+			outfile,
+			outdir,
+			outputConfigPath,
+			outputRoutesPath: routesOutputPath,
+			minify,
+			sourcemap,
+			fallbackService,
+			watch,
+			plugin,
+			nodejsCompat,
+			legacyNodeCompat,
+		} = validatedArgs;
+
+		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({
+				outfile,
+				outdir,
+				outputConfigPath,
+				functionsDirectory: directory,
+				minify,
+				sourcemap,
+				fallbackService,
+				watch,
+				plugin,
+				legacyNodeCompat,
+				nodejsCompat,
+				routesOutputPath,
+				local: false,
+			});
+		} catch (e) {
+			if (e instanceof FunctionsNoRoutesError) {
+				throw new FatalError(
+					getFunctionsNoRoutesWarning(directory),
+					EXIT_CODE_FUNCTIONS_NO_ROUTES_ERROR
+				);
+			} else {
+				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())
+			);
+		}
+	}
+
+	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
+		);
+	}
+
+	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."
+		);
+	}
+
+	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;
+};