wrangler 0.0.0-e3e3243 → 0.0.0-e41c7e41

package/src/package-manager.ts

@@ -1,126 +1,219 @@
 import { existsSync } from "node:fs";
 import { join } from "node:path";
+import { env } from "node:process";
 import { execa, execaCommandSync } from "execa";
+import { logger } from "./logger";
 
 export interface PackageManager {
-  cwd: string;
-  type: "npm" | "yarn";
-  addDevDeps(...packages: string[]): Promise<void>;
-  install(): Promise<void>;
+	cwd: string;
+	type: "npm" | "yarn" | "pnpm";
+	addDevDeps(...packages: string[]): Promise<void>;
+	install(): Promise<void>;
 }
 
 export async function getPackageManager(cwd: string): Promise<PackageManager> {
-  const [hasYarn, hasNpm] = await Promise.all([supportsYarn(), supportsNpm()]);
-  const hasYarnLock = existsSync(join(cwd, "yarn.lock"));
-  const hasNpmLock = existsSync(join(cwd, "package-lock.json"));
-
-  if (hasNpmLock) {
-    if (hasNpm) {
-      console.log(
-        "Using npm as package manager, as there is already a package-lock.json file."
-      );
-      return { ...NpmPackageManager, cwd };
-    } else if (hasYarn) {
-      console.log("Using yarn as package manager.");
-      console.warn(
-        "There is already a package-lock.json file but could not find npm on the PATH."
-      );
-      return { ...YarnPackageManager, cwd };
-    }
-  } else if (hasYarnLock) {
-    if (hasYarn) {
-      console.log(
-        "Using yarn as package manager, as there is already a yarn.lock file."
-      );
-      return { ...YarnPackageManager, cwd };
-    } else if (hasNpm) {
-      console.log("Using npm as package manager.");
-      console.warn(
-        "There is already a yarn.lock file but could not find yarn on the PATH."
-      );
-      return { ...NpmPackageManager, cwd };
-    }
-  }
-
-  if (hasNpm) {
-    console.log("Using npm as package manager.");
-    return { ...NpmPackageManager, cwd };
-  } else if (hasYarn) {
-    console.log("Using yarn as package manager.");
-    return { ...YarnPackageManager, cwd };
-  } else {
-    throw new Error(
-      "Unable to find a package manager. Supported managers are: npm and yarn."
-    );
-  }
+	const [hasYarn, hasNpm, hasPnpm] = await Promise.all([
+		supportsYarn(),
+		supportsNpm(),
+		supportsPnpm(),
+	]);
+	const hasYarnLock = existsSync(join(cwd, "yarn.lock"));
+	const hasNpmLock = existsSync(join(cwd, "package-lock.json"));
+	const hasPnpmLock = existsSync(join(cwd, "pnpm-lock.yaml"));
+	const userAgent = sniffUserAgent();
+
+	// check for lockfiles
+	if (hasNpmLock) {
+		if (hasNpm) {
+			logger.log(
+				"Using npm as package manager, as there is already a package-lock.json file."
+			);
+			return { ...NpmPackageManager, cwd };
+		} else if (hasYarn) {
+			logger.log("Using yarn as package manager.");
+			logger.warn(
+				"There is already a package-lock.json file but could not find npm on the PATH."
+			);
+			return { ...YarnPackageManager, cwd };
+		}
+	} else if (hasPnpmLock) {
+		if (hasPnpm) {
+			logger.log(
+				"Using pnpm as package manager, as there is already a pnpm-lock.yaml file."
+			);
+			return { ...PnpmPackageManager, cwd };
+		} else {
+			logger.warn(
+				"There is already a pnpm-lock.yaml file but could not find pnpm on the PATH."
+			);
+			// will simply fallback to the first found of [npm, yaml, pnpm] in the next if round.
+		}
+	} else if (hasYarnLock) {
+		if (hasYarn) {
+			logger.log(
+				"Using yarn as package manager, as there is already a yarn.lock file."
+			);
+			return { ...YarnPackageManager, cwd };
+		} else if (hasNpm) {
+			logger.log("Using npm as package manager.");
+			logger.warn(
+				"There is already a yarn.lock file but could not find yarn on the PATH."
+			);
+			return { ...NpmPackageManager, cwd };
+		}
+	}
+
+	// check the user agent
+	if (userAgent === "npm" && hasNpm) {
+		logger.log("Using npm as package manager.");
+		return { ...NpmPackageManager, cwd };
+	} else if (userAgent === "pnpm" && hasPnpm) {
+		logger.log("Using pnpm as package manager.");
+		return { ...PnpmPackageManager, cwd };
+	} else if (userAgent === "yarn" && hasYarn) {
+		logger.log("Using yarn as package manager.");
+		return { ...YarnPackageManager, cwd };
+	}
+
+	// lastly, check what's installed
+	if (hasNpm) {
+		logger.log("Using npm as package manager.");
+		return { ...NpmPackageManager, cwd };
+	} else if (hasYarn) {
+		logger.log("Using yarn as package manager.");
+		return { ...YarnPackageManager, cwd };
+	} else if (hasPnpm) {
+		logger.log("Using pnpm as package manager.");
+		return { ...PnpmPackageManager, cwd };
+	} else {
+		throw new Error(
+			"Unable to find a package manager. Supported managers are: npm, yarn, and pnpm."
+		);
+	}
 }
 
 /**
  * Get the name of the given `packageManager`.
  */
 export function getPackageManagerName(packageManager: PackageManager): string {
-  return packageManager.type ?? "unknown";
+	return packageManager.type ?? "unknown";
 }
 
 /**
  * Manage packages using npm
  */
 const NpmPackageManager: PackageManager = {
-  cwd: process.cwd(),
-  type: "npm",
-  /** Add and install a new devDependency into the local package.json. */
-  async addDevDeps(...packages: string[]): Promise<void> {
-    await execa("npm", ["install", ...packages, "--save-dev"], {
-      stdio: "inherit",
-      cwd: this.cwd,
-    });
-  },
-
-  /** Install all the dependencies in the local package.json. */
-  async install(): Promise<void> {
-    await execa("npm", ["install"], {
-      stdio: "inherit",
-      cwd: this.cwd,
-    });
-  },
+	cwd: process.cwd(),
+	type: "npm",
+	/** Add and install a new devDependency into the local package.json. */
+	async addDevDeps(...packages: string[]): Promise<void> {
+		await execa("npm", ["install", ...packages, "--save-dev"], {
+			stdio: "inherit",
+			cwd: this.cwd,
+		});
+	},
+
+	/** Install all the dependencies in the local package.json. */
+	async install(): Promise<void> {
+		await execa("npm", ["install"], {
+			stdio: "inherit",
+			cwd: this.cwd,
+		});
+	},
+};
+
+/**
+ * Manage packages using pnpm
+ */
+const PnpmPackageManager: PackageManager = {
+	cwd: process.cwd(),
+	type: "pnpm",
+	/** Add and install a new devDependency into the local package.json. */
+	async addDevDeps(...packages: string[]): Promise<void> {
+		await execa("pnpm", ["install", ...packages, "--save-dev"], {
+			stdio: "inherit",
+			cwd: this.cwd,
+		});
+	},
+
+	/** Install all the dependencies in the local package.json. */
+	async install(): Promise<void> {
+		await execa("pnpm", ["install"], {
+			stdio: "inherit",
+			cwd: this.cwd,
+		});
+	},
 };
 
 /**
  * Manage packages using yarn
  */
 const YarnPackageManager: PackageManager = {
-  cwd: process.cwd(),
-  type: "yarn",
-  /** Add and install a new devDependency into the local package.json. */
-  async addDevDeps(...packages: string[]): Promise<void> {
-    await execa("yarn", ["add", ...packages, "--dev"], {
-      stdio: "inherit",
-      cwd: this.cwd,
-    });
-  },
-
-  /** Install all the dependencies in the local package.json. */
-  async install(): Promise<void> {
-    await execa("yarn", ["install"], {
-      stdio: "inherit",
-      cwd: this.cwd,
-    });
-  },
+	cwd: process.cwd(),
+	type: "yarn",
+	/** Add and install a new devDependency into the local package.json. */
+	async addDevDeps(...packages: string[]): Promise<void> {
+		await execa("yarn", ["add", ...packages, "--dev"], {
+			stdio: "inherit",
+			cwd: this.cwd,
+		});
+	},
+
+	/** Install all the dependencies in the local package.json. */
+	async install(): Promise<void> {
+		await execa("yarn", ["install"], {
+			stdio: "inherit",
+			cwd: this.cwd,
+		});
+	},
 };
 
 async function supports(name: string): Promise<boolean> {
-  try {
-    execaCommandSync(`${name} --version`, { stdio: "ignore" });
-    return true;
-  } catch {
-    return false;
-  }
+	try {
+		execaCommandSync(`${name} --version`, { stdio: "ignore" });
+		return true;
+	} catch {
+		return false;
+	}
 }
 
 function supportsYarn(): Promise<boolean> {
-  return supports("yarn");
+	return supports("yarn");
 }
 
 function supportsNpm(): Promise<boolean> {
-  return supports("npm");
+	return supports("npm");
+}
+
+function supportsPnpm(): Promise<boolean> {
+	return supports("pnpm");
+}
+
+/**
+ * The environment variable `npm_config_user_agent` can be used to
+ * guess the package manager that was used to execute wrangler.
+ * It's imperfect (just like regular user agent sniffing!)
+ * but the package managers we support all set this property:
+ *
+ * - [npm](https://github.com/npm/cli/blob/1415b4bdeeaabb6e0ba12b6b1b0cc56502bd64ab/lib/utils/config/definitions.js#L1945-L1979)
+ * - [pnpm](https://github.com/pnpm/pnpm/blob/cd4f9341e966eb8b411462b48ff0c0612e0a51a7/packages/plugin-commands-script-runners/src/makeEnv.ts#L14)
+ * - [yarn](https://yarnpkg.com/advanced/lifecycle-scripts#environment-variables)
+ */
+function sniffUserAgent(): "npm" | "pnpm" | "yarn" | undefined {
+	const userAgent = env.npm_config_user_agent;
+	if (userAgent === undefined) {
+		return undefined;
+	}
+
+	if (userAgent.includes("yarn")) {
+		return "yarn";
+	}
+
+	if (userAgent.includes("pnpm")) {
+		return "pnpm";
+	}
+
+	if (userAgent.includes("npm")) {
+		return "npm";
+	}
 }

package/src/pages/build.tsx

@@ -0,0 +1,270 @@
+import { writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { dirname, join, resolve } from "node:path";
+import { FatalError } from "../errors";
+import { logger } from "../logger";
+import * as metrics from "../metrics";
+import { toUrlPath } from "../paths";
+import { isInPagesCI } from "./constants";
+import {
+	EXIT_CODE_FUNCTIONS_NO_ROUTES_ERROR,
+	FunctionsNoRoutesError,
+	getFunctionsNoRoutesWarning,
+} 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 { pagesBetaWarning, RUNNING_BUILDERS } from "./utils";
+import type { YargsOptionsToInterface } from "../yargs-types";
+import type { Config } from "./functions/routes";
+import type { Argv } from "yargs";
+
+type PagesBuildArgs = YargsOptionsToInterface<typeof Options>;
+
+export function Options(yargs: Argv) {
+	return yargs
+		.positional("directory", {
+			type: "string",
+			default: "functions",
+			description: "The directory of Pages Functions",
+		})
+		.options({
+			outfile: {
+				type: "string",
+				default: "_worker.js",
+				description: "The location of the output Worker script",
+			},
+			"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,
+			},
+			bindings: {
+				type: "string",
+				describe:
+					"Bindings used in Functions (used to register beta product shims)",
+				deprecated: true,
+				hidden: true,
+			},
+		})
+		.epilogue(pagesBetaWarning);
+}
+
+export const Handler = async ({
+	directory,
+	outfile,
+	outputConfigPath,
+	outputRoutesPath: routesOutputPath,
+	minify,
+	sourcemap,
+	fallbackService,
+	watch,
+	plugin,
+	buildOutputDirectory,
+	nodeCompat,
+	bindings,
+}: 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);
+	try {
+		await buildFunctions({
+			outfile,
+			outputConfigPath,
+			functionsDirectory: directory,
+			minify,
+			sourcemap,
+			fallbackService,
+			watch,
+			plugin,
+			buildOutputDirectory,
+			nodeCompat,
+			routesOutputPath,
+			local: false,
+			d1Databases,
+		});
+	} catch (e) {
+		if (e instanceof FunctionsNoRoutesError) {
+			throw new FatalError(
+				getFunctionsNoRoutesWarning(directory),
+				EXIT_CODE_FUNCTIONS_NO_ROUTES_ERROR
+			);
+		} else {
+			throw e;
+		}
+	}
+	await metrics.sendMetricsEvent("build pages functions");
+};
+
+/**
+ * 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,
+}: 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[];
+}) {
+	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,
+			})
+		);
+	}
+}

package/src/pages/constants.ts

@@ -0,0 +1,18 @@
+import { version as wranglerVersion } from "../../package.json";
+
+export const MAX_ASSET_COUNT = 20_000;
+export const MAX_ASSET_SIZE = 25 * 1024 * 1024;
+export const PAGES_CONFIG_CACHE_FILENAME = "pages.json";
+export const MAX_BUCKET_SIZE = 50 * 1024 * 1024;
+export const MAX_BUCKET_FILE_COUNT = 5000;
+export const BULK_UPLOAD_CONCURRENCY = 3;
+export const MAX_UPLOAD_ATTEMPTS = 5;
+export const MAX_CHECK_MISSING_ATTEMPTS = 5;
+export const SECONDS_TO_WAIT_FOR_PROXY = 5;
+export const isInPagesCI = !!process.env.CF_PAGES;
+/** Max number of rules in _routes.json */
+export const MAX_FUNCTIONS_ROUTES_RULES = 100;
+/** Max char length of each rule in _routes.json */
+export const MAX_FUNCTIONS_ROUTES_RULE_LENGTH = 100;
+export const ROUTES_SPEC_VERSION = 1;
+export const ROUTES_SPEC_DESCRIPTION = `Generated by wrangler@${wranglerVersion}`;