wrangler 2.0.22 → 2.0.25

package/src/pages/functions/buildPlugin.ts

@@ -29,6 +29,10 @@ export function buildPlugin({
 		bundle: true,
 		format: "esm",
 		target: "esnext",
+		loader: {
+			".html": "text",
+			".txt": "text",
+		},
 		outfile,
 		minify,
 		sourcemap,

package/src/pages/functions/buildWorker.ts

@@ -34,6 +34,10 @@ export function buildWorker({
 		bundle: true,
 		format: "esm",
 		target: "esnext",
+		loader: {
+			".html": "text",
+			".txt": "text",
+		},
 		outfile,
 		minify,
 		sourcemap,

package/src/pages/functions/routes-consolidation.test.ts

@@ -0,0 +1,66 @@
+import { consolidateRoutes } from "./routes-consolidation";
+
+describe("route-consolidation", () => {
+	describe("consolidateRoutes()", () => {
+		it("should consolidate redundant routes", () => {
+			expect(consolidateRoutes(["/api/foo", "/api/*"])).toEqual(["/api/*"]);
+			expect(
+				consolidateRoutes([
+					"/api/foo",
+					"/api/foo/*",
+					"/api/bar/*",
+					"/api/*",
+					"/foo",
+					"/foo/bar",
+					"/bar/*",
+					"/bar/baz/*",
+					"/bar/baz/hello",
+				])
+			).toEqual(["/api/*", "/foo", "/foo/bar", "/bar/*"]);
+		});
+		it("should consolidate thousands of redundant routes", () => {
+			// Test to make sure the consolidator isn't horribly slow
+			const routes: string[] = [];
+			const limit = 1000;
+			for (let i = 0; i < limit; i++) {
+				// Add 3 routes per id
+				const id = `some-id-${i}`;
+				routes.push(`/${id}/*`, `/${id}/foo`, `/${id}/bar/*`);
+			}
+			const consolidated = consolidateRoutes(routes);
+			expect(consolidated.length).toEqual(limit);
+			// Should be all unique
+			expect(Array.from(new Set(consolidated)).length).toEqual(limit);
+			// Should all have pattern `/$id/*`
+			expect(
+				consolidated.every((route) => route.match(/\/[a-z0-9-]+\/\*/) !== null)
+			).toEqual(true);
+		});
+
+		it("should consolidate many redundant sub-routes", () => {
+			const routes: string[] = [];
+			const limit = 15;
+
+			// Create $limit of top-level catch-all routes, with a lot of sub-routes
+			for (let i = 0; i < limit; i++) {
+				routes.push(`/foo-${i}/*`);
+				for (let j = 0; j < limit; j++) {
+					routes.push(`/foo-${i}/bar-${j}/hello`);
+					for (let k = 0; k < limit; k++) {
+						routes.push(`/foo-${i}/bar-${j}/baz-${k}/*`);
+						routes.push(`/foo-${i}/bar-${j}/baz-${k}/profile`);
+					}
+				}
+			}
+
+			const consolidated = consolidateRoutes(routes);
+			expect(consolidated.length).toEqual(limit);
+			// Should be all unique
+			expect(Array.from(new Set(consolidated)).length).toEqual(limit);
+			// Should all have pattern `/$id/*`
+			expect(
+				consolidated.every((route) => route.match(/\/[a-z0-9-]+\/\*/) !== null)
+			).toEqual(true);
+		});
+	});
+});

package/src/pages/functions/routes-consolidation.ts

@@ -0,0 +1,29 @@
+/**
+ * consolidateRoutes consolidates redundant routes - eg. ["/api/*"", "/api/foo"] -> ["/api/*""]
+ * @param routes If this is the same order as Functions routes (with most-specific first),
+ *   it will be more efficient to reverse it first. Should be in the format: /api/foo, /api/*
+ * @returns Non-redundant list of routes
+ */
+export function consolidateRoutes(routes: string[]): string[] {
+	// create a map of the routes
+	const routesMap = new Map<string, boolean>();
+	for (const route of routes) {
+		routesMap.set(route, true);
+	}
+	// Find routes that might render other routes redundant
+	for (const route of routes.filter((r) => r.endsWith("/*"))) {
+		// Make sure the route still exists in the map
+		if (routesMap.has(route)) {
+			// Remove splat at the end, leaving the /
+			// eg. /api/* -> /api/
+			const routeTrimmed = route.substring(0, route.length - 1);
+			for (const nextRoute of routesMap.keys()) {
+				// Delete any route that has the wildcard route as a prefix
+				if (nextRoute !== route && nextRoute.startsWith(routeTrimmed)) {
+					routesMap.delete(nextRoute);
+				}
+			}
+		}
+	}
+	return Array.from(routesMap.keys());
+}

package/src/pages/functions/routes-transformation.test.ts

@@ -0,0 +1,271 @@
+import { toUrlPath } from "../../paths";
+import { MAX_FUNCTIONS_ROUTES_RULES, ROUTES_SPEC_VERSION } from "../constants";
+import {
+	compareRoutes,
+	convertRoutesToGlobPatterns,
+	convertRoutesToRoutesJSONSpec,
+	optimizeRoutesJSONSpec,
+} from "./routes-transformation";
+
+// TODO: make a convenience function for creating a list
+// of `convertRoutesToGlobPatterns` inputs from a string array
+describe("route-paths-to-glob-patterns", () => {
+	describe("convertRoutePathsToGlobPatterns()", () => {
+		it("should pass through routes with no wildcards", () => {
+			expect(
+				convertRoutesToGlobPatterns([{ routePath: toUrlPath("/api/foo") }])
+			).toEqual(["/api/foo"]);
+			expect(
+				convertRoutesToGlobPatterns([
+					{ routePath: toUrlPath("/api/foo") },
+					{ routePath: toUrlPath("/api/bar") },
+				])
+			).toEqual(["/api/foo", "/api/bar"]);
+			expect(
+				convertRoutesToGlobPatterns([
+					{ routePath: toUrlPath("/api/foo") },
+					{ routePath: toUrlPath("/api/bar/foo") },
+					{ routePath: toUrlPath("/foo/bar") },
+				])
+			).toEqual(["/api/foo", "/api/bar/foo", "/foo/bar"]);
+		});
+
+		it("should escalate a single param route to a wildcard", () => {
+			expect(
+				convertRoutesToGlobPatterns([{ routePath: toUrlPath("/api/:foo") }])
+			).toEqual(["/api/*"]);
+			expect(
+				convertRoutesToGlobPatterns([{ routePath: toUrlPath("/api/foo/:bar") }])
+			).toEqual(["/api/foo/*"]);
+			expect(
+				convertRoutesToGlobPatterns([
+					{ routePath: toUrlPath("/bar/:barId/foo") },
+				])
+			).toEqual(["/bar/*"]);
+			expect(
+				convertRoutesToGlobPatterns([
+					{ routePath: toUrlPath("/bar/:barId/foo/:fooId") },
+				])
+			).toEqual(["/bar/*"]);
+			expect(
+				convertRoutesToGlobPatterns([
+					{ routePath: toUrlPath("/api/:foo") },
+					{ routePath: toUrlPath("/bar/:barName/profile") },
+					{ routePath: toUrlPath("/foo/bar/:barId/:fooId") },
+				])
+			).toEqual(["/api/*", "/bar/*", "/foo/bar/*"]);
+		});
+
+		it("should pass through a single wildcard route", () => {
+			expect(
+				convertRoutesToGlobPatterns([{ routePath: toUrlPath("/api/:baz*") }])
+			).toEqual(["/api/*"]);
+			expect(
+				convertRoutesToGlobPatterns([
+					{ routePath: toUrlPath("/api/foo/bar/:baz*") },
+				])
+			).toEqual(["/api/foo/bar/*"]);
+			expect(
+				convertRoutesToGlobPatterns([
+					{ routePath: toUrlPath("/api/:foo/:bar*") },
+				])
+			).toEqual(["/api/*"]);
+			expect(
+				convertRoutesToGlobPatterns([
+					{ routePath: toUrlPath("/foo/:foo*/bar/:bar*") },
+				])
+			).toEqual(["/foo/*"]);
+			expect(
+				convertRoutesToGlobPatterns([
+					{ routePath: toUrlPath("/foo/:foo/bar/:bar*") },
+				])
+			).toEqual(["/foo/*"]);
+			expect(
+				convertRoutesToGlobPatterns([
+					{ routePath: toUrlPath("/api/:baz*") },
+					{ routePath: toUrlPath("/api/foo/bar/:baz*") },
+					{ routePath: toUrlPath("/api/:foo/:bar*") },
+				])
+			).toEqual(["/api/*", "/api/foo/bar/*"]);
+		});
+
+		it("should deduplicate identical rules", () => {
+			expect(
+				convertRoutesToGlobPatterns([
+					{ routePath: toUrlPath("/api/foo") },
+					{ routePath: toUrlPath("/api/foo") },
+				])
+			).toEqual(["/api/foo"]);
+			expect(
+				convertRoutesToGlobPatterns([
+					{ routePath: toUrlPath("/api/foo/bar") },
+					{ routePath: toUrlPath("/foo/bar") },
+					{ routePath: toUrlPath("/api/foo/bar") },
+				])
+			).toEqual(["/api/foo/bar", "/foo/bar"]);
+			expect(
+				convertRoutesToGlobPatterns([
+					{ routePath: toUrlPath("/api/foo/:bar") },
+					{ routePath: toUrlPath("/api/foo") },
+					{ routePath: toUrlPath("/api/foo/:fooId/bar") },
+					{ routePath: toUrlPath("/api/foo/*") },
+				])
+			).toEqual(["/api/foo/*", "/api/foo"]);
+			expect(
+				convertRoutesToGlobPatterns([
+					{ routePath: toUrlPath("/api/:baz*") },
+					{ routePath: toUrlPath("/api/:foo") },
+				])
+			).toEqual(["/api/*"]);
+		});
+
+		it("should handle middleware mounting", () => {
+			expect(
+				convertRoutesToGlobPatterns([
+					{
+						routePath: toUrlPath("/middleware"),
+						middleware: ["./some-middleware.ts"],
+					},
+				])
+			).toEqual(["/middleware/*"]);
+
+			expect(
+				convertRoutesToGlobPatterns([
+					{
+						routePath: toUrlPath("/middleware"),
+						middleware: "./some-middleware.ts",
+					},
+				])
+			).toEqual(["/middleware/*"]);
+
+			expect(
+				convertRoutesToGlobPatterns([
+					{
+						routePath: toUrlPath("/middleware"),
+						middleware: [],
+					},
+				])
+			).toEqual(["/middleware"]);
+		});
+	});
+
+	describe("convertRoutesToRoutesJSONSpec()", () => {
+		it("should convert and consolidate routes into JSONSpec", () => {
+			expect(
+				convertRoutesToRoutesJSONSpec([
+					{ routePath: toUrlPath("/api/foo/bar") },
+					{ routePath: toUrlPath("/foo/bar") },
+					{ routePath: toUrlPath("/foo/:bar") },
+					{ routePath: toUrlPath("/api/foo/bar") },
+					{
+						routePath: toUrlPath("/middleware"),
+						middleware: "./some-middleware.ts",
+					},
+				])
+			).toEqual({
+				version: ROUTES_SPEC_VERSION,
+				include: ["/middleware/*", "/foo/*", "/api/foo/bar"],
+				exclude: [],
+			});
+		});
+
+		it("should truncate all routes if over limit", () => {
+			const routes = [];
+			for (let i = 0; i < MAX_FUNCTIONS_ROUTES_RULES + 1; i++) {
+				routes.push({ routePath: toUrlPath(`/api/foo-${i}`) });
+			}
+			expect(convertRoutesToRoutesJSONSpec(routes)).toEqual({
+				version: ROUTES_SPEC_VERSION,
+				include: ["/*"],
+				exclude: [],
+			});
+		});
+
+		it("should allow max routes", () => {
+			const routes = [];
+			for (let i = 0; i < MAX_FUNCTIONS_ROUTES_RULES; i++) {
+				routes.push({ routePath: toUrlPath(`/api/foo-${i}`) });
+			}
+			expect(convertRoutesToRoutesJSONSpec(routes).include.length).toEqual(
+				MAX_FUNCTIONS_ROUTES_RULES
+			);
+		});
+	});
+
+	describe("optimizeRoutesJSONSpec()", () => {
+		it("should convert and consolidate routes into JSONSpec", () => {
+			expect(
+				optimizeRoutesJSONSpec({
+					version: ROUTES_SPEC_VERSION,
+					exclude: [],
+					include: [
+						"/api/foo/bar",
+						"/foo/bar",
+						"/foo/*",
+						"/api/foo/bar",
+						"/middleware/*",
+					],
+				})
+			).toEqual({
+				version: ROUTES_SPEC_VERSION,
+				include: ["/middleware/*", "/foo/*", "/api/foo/bar"],
+				exclude: [],
+			});
+		});
+
+		it("should truncate all routes if over limit", () => {
+			const include: string[] = [];
+			for (let i = 0; i < MAX_FUNCTIONS_ROUTES_RULES + 1; i++) {
+				include.push(`/api/foo-${i}`);
+			}
+			expect(
+				optimizeRoutesJSONSpec({
+					version: ROUTES_SPEC_VERSION,
+					include,
+					exclude: [],
+				})
+			).toEqual({
+				version: ROUTES_SPEC_VERSION,
+				include: ["/*"],
+				exclude: [],
+			});
+		});
+
+		it("should allow max routes", () => {
+			const include: string[] = [];
+			for (let i = 0; i < MAX_FUNCTIONS_ROUTES_RULES; i++) {
+				include.push(`/api/foo-${i}`);
+			}
+			expect(
+				optimizeRoutesJSONSpec({
+					version: ROUTES_SPEC_VERSION,
+					include,
+					exclude: [],
+				}).include.length
+			).toEqual(MAX_FUNCTIONS_ROUTES_RULES);
+		});
+	});
+
+	describe("compareRoutes()", () => {
+		describe("compareRoutes()", () => {
+			test("routes / last", () => {
+				expect(compareRoutes("/", "/foo")).toBeGreaterThanOrEqual(1);
+				expect(compareRoutes("/", "/*")).toBeGreaterThanOrEqual(1);
+			});
+
+			test("routes with fewer segments come after those with more segments", () => {
+				expect(compareRoutes("/foo", "/foo/bar")).toBeGreaterThanOrEqual(1);
+				expect(compareRoutes("/foo", "/foo/bar/cat")).toBeGreaterThanOrEqual(1);
+			});
+
+			test("routes with wildcard segments come after those without", () => {
+				expect(compareRoutes("/*", "/foo")).toBe(1);
+				expect(compareRoutes("/foo/*", "/foo/bar")).toBe(1);
+			});
+
+			test("routes with dynamic segments occurring earlier come after those with dynamic segments in later positions", () => {
+				expect(compareRoutes("/foo/*/bar", "/foo/bar/*")).toBe(1);
+			});
+		});
+	});
+});

package/src/pages/functions/routes-transformation.ts

@@ -0,0 +1,125 @@
+import { join as pathJoin } from "node:path";
+import { toUrlPath } from "../../paths";
+import { MAX_FUNCTIONS_ROUTES_RULES, ROUTES_SPEC_VERSION } from "../constants";
+import { consolidateRoutes } from "./routes-consolidation";
+import type { RouteConfig } from "./routes";
+
+/** Interface for _routes.json */
+interface RoutesJSONSpec {
+	version: typeof ROUTES_SPEC_VERSION;
+	include: string[];
+	exclude: string[];
+}
+
+type RoutesJSONRouteInput = Pick<RouteConfig, "routePath" | "middleware">[];
+
+/**
+ * TODO can we do better naming?
+ */
+export function convertRoutesToGlobPatterns(
+	routes: RoutesJSONRouteInput
+): string[] {
+	const convertedRoutes = routes.map(({ routePath, middleware }) => {
+		const globbedRoutePath: string = routePath.replace(/:\w+\*?.*/, "*");
+
+		// Middleware mountings need to end in glob so that they can handle their
+		// own sub-path routes
+		if (
+			typeof middleware === "string" ||
+			(Array.isArray(middleware) && middleware.length > 0)
+		) {
+			if (!globbedRoutePath.endsWith("*")) {
+				return toUrlPath(pathJoin(globbedRoutePath, "*"));
+			}
+		}
+
+		return toUrlPath(globbedRoutePath);
+	});
+
+	return Array.from(new Set(convertedRoutes));
+}
+
+/**
+ * Converts Functions routes like /foo/:bar to a Routing object that's used
+ * to determine if a request should run in the Functions user-worker.
+ * Also consolidates redundant routes such as [/foo/bar, /foo/:bar] -> /foo/*
+ *
+ * @returns RoutesJSONSpec to be written to _routes.json
+ */
+export function convertRoutesToRoutesJSONSpec(
+	routes: RoutesJSONRouteInput
+): RoutesJSONSpec {
+	// The initial routes coming in are sorted most-specific to least-specific.
+	// The order doesn't have any affect on the output of this function, but
+	// it should speed up route consolidation with less-specific routes being first.
+	const reversedRoutes = [...routes].reverse();
+	const include = convertRoutesToGlobPatterns(reversedRoutes);
+	return optimizeRoutesJSONSpec({
+		version: ROUTES_SPEC_VERSION,
+		include,
+		exclude: [],
+	});
+}
+
+/**
+ * Optimizes and returns a new Routes JSON Spec instance performing
+ * de-duping, consolidation, truncation, and sorting
+ */
+export function optimizeRoutesJSONSpec(spec: RoutesJSONSpec): RoutesJSONSpec {
+	const optimizedSpec = { ...spec };
+
+	let consolidatedRoutes = consolidateRoutes(optimizedSpec.include);
+	if (consolidatedRoutes.length > MAX_FUNCTIONS_ROUTES_RULES) {
+		consolidatedRoutes = ["/*"];
+	}
+	// Sort so that least-specific routes are first
+	consolidatedRoutes.sort((a, b) => compareRoutes(b, a));
+
+	optimizedSpec.include = consolidatedRoutes;
+
+	return optimizedSpec;
+}
+
+/**
+ * Simplified routes comparison (copied from the one in filepath-routing.)
+ * This version will sort most-specific to least-specific, but the input is simplified
+ * routes like /foo/*, /foo, etc
+ */
+export function compareRoutes(routeA: string, routeB: string) {
+	function parseRoutePath(routePath: string): string[] {
+		return routePath.slice(1).split("/").filter(Boolean);
+	}
+
+	const segmentsA = parseRoutePath(routeA);
+	const segmentsB = parseRoutePath(routeB);
+
+	// sort routes with fewer segments after those with more segments
+	if (segmentsA.length !== segmentsB.length) {
+		return segmentsB.length - segmentsA.length;
+	}
+
+	for (let i = 0; i < segmentsA.length; i++) {
+		const isWildcardA = segmentsA[i].includes("*");
+		const isWildcardB = segmentsB[i].includes("*");
+
+		// sort wildcard segments after non-wildcard segments
+		if (isWildcardA && !isWildcardB) return 1;
+		if (!isWildcardA && isWildcardB) return -1;
+	}
+
+	// all else equal, just sort the paths lexicographically
+	return routeA.localeCompare(routeB);
+}
+
+export function isRoutesJSONSpec(data: unknown): data is RoutesJSONSpec {
+	return (
+		(typeof data === "object" &&
+			data &&
+			"version" in data &&
+			typeof (data as RoutesJSONSpec).version === "number" &&
+			(data as RoutesJSONSpec).version === ROUTES_SPEC_VERSION &&
+			Array.isArray((data as RoutesJSONSpec).include) &&
+			Array.isArray((data as RoutesJSONSpec).exclude)) ||
+		false
+	);
+}

package/src/pages/projects.tsx

@@ -124,12 +124,18 @@ export async function CreateHandler({
 			isGitDir = false;
 		}
 
+		if (isGitDir) {
+			try {
+				productionBranch = execSync(`git rev-parse --abbrev-ref HEAD`)
+					.toString()
+					.trim();
+			} catch (err) {}
+		}
+
 		productionBranch = await prompt(
 			"Enter the production branch name:",
 			"text",
-			isGitDir
-				? execSync(`git rev-parse --abbrev-ref HEAD`).toString().trim()
-				: "production"
+			productionBranch ?? "production"
 		);
 	}
 

package/src/pages/publish.tsx

@@ -16,22 +16,24 @@ import * as metrics from "../metrics";
 import { requireAuth } from "../user";
 import { buildFunctions } from "./build";
 import { PAGES_CONFIG_CACHE_FILENAME } from "./constants";
+import {
+	isRoutesJSONSpec,
+	optimizeRoutesJSONSpec,
+} from "./functions/routes-transformation";
 import { listProjects } from "./projects";
 import { upload } from "./upload";
 import { pagesBetaWarning } from "./utils";
-import type { Deployment, PagesConfigCache, Project } from "./types";
-import type { ArgumentsCamelCase, Argv } from "yargs";
-
-type PublishArgs = {
-	directory: string;
-	"project-name"?: string;
-	branch?: string;
-	"commit-hash"?: string;
-	"commit-message"?: string;
-	"commit-dirty"?: boolean;
-};
+import type {
+	Deployment,
+	PagesConfigCache,
+	Project,
+	YargsOptionsToInterface,
+} from "./types";
+import type { Argv } from "yargs";
+
+type PublishArgs = YargsOptionsToInterface<typeof Options>;
 
-export function Options(yargs: Argv): Argv<PublishArgs> {
+export function Options(yargs: Argv) {
 	return yargs
 		.positional("directory", {
 			type: "string",
@@ -77,7 +79,7 @@ export const Handler = async ({
 	commitMessage,
 	commitDirty,
 	config: wranglerConfig,
-}: ArgumentsCamelCase<PublishArgs>) => {
+}: PublishArgs) => {
 	if (wranglerConfig) {
 		throw new FatalError("Pages does not support wrangler.toml", 1);
 	}
@@ -251,6 +253,7 @@ export const Handler = async ({
 
 	let builtFunctions: string | undefined = undefined;
 	const functionsDirectory = join(cwd(), "functions");
+	const routesOutputPath = join(tmpdir(), `_routes-${Math.random()}.json`);
 	if (existsSync(functionsDirectory)) {
 		const outfile = join(tmpdir(), `./functionsWorker-${Math.random()}.js`);
 
@@ -260,6 +263,7 @@ export const Handler = async ({
 				functionsDirectory,
 				onEnd: () => resolve(null),
 				buildOutputDirectory: dirname(outfile),
+				routesOutputPath,
 			})
 		);
 
@@ -290,6 +294,7 @@ export const Handler = async ({
 
 	let _headers: string | undefined,
 		_redirects: string | undefined,
+		_routes: string | undefined,
 		_workerJS: string | undefined;
 
 	try {
@@ -300,6 +305,10 @@ export const Handler = async ({
 		_redirects = readFileSync(join(directory, "_redirects"), "utf-8");
 	} catch {}
 
+	try {
+		_routes = readFileSync(routesOutputPath, "utf-8");
+	} catch {}
+
 	try {
 		_workerJS = readFileSync(join(directory, "_worker.js"), "utf-8");
 	} catch {}
@@ -312,12 +321,45 @@ export const Handler = async ({
 		formData.append("_redirects", new File([_redirects], "_redirects"));
 	}
 
+	if (_routes) {
+		formData.append("_routes.json", new File([_routes], "_routes.json"));
+	}
+
 	if (builtFunctions) {
 		formData.append("_worker.js", new File([builtFunctions], "_worker.js"));
 	} else if (_workerJS) {
+		// Advanced Mode
+		// https://developers.cloudflare.com/pages/platform/functions/#advanced-mode
 		formData.append("_worker.js", new File([_workerJS], "_worker.js"));
-	}
 
+		try {
+			// In advanced mode, developers can specify a custom _routes.json
+			// file. In which case, we need to run it through optimization
+			// to potentially reduce the overall worker pipeline size
+			const routesPath = join(directory, "_routes.json");
+			const advancedModeRoutesString = readFileSync(routesPath, "utf-8");
+			const advancedModeRoutes = JSON.parse(advancedModeRoutesString);
+
+			if (!isRoutesJSONSpec(advancedModeRoutes)) {
+				throw new FatalError(
+					"Invalid _routes.json file found at:" + routesPath,
+					1
+				);
+			}
+
+			_routes = JSON.stringify(optimizeRoutesJSONSpec(advancedModeRoutes));
+
+			logger.warn(
+				`🚨 _routes.json is an experimental feature and is subject to change. Don't use unless you really must!`
+			);
+		} catch (e) {
+			// Ignore file not existing errors for _routes.json but forward the potential
+			// FatalError from an invalid spec
+			if (e instanceof FatalError) {
+				throw e;
+			}
+		}
+	}
 	const deploymentResponse = await fetchResult<Deployment>(
 		`/accounts/${accountId}/pages/projects/${projectName}/deployments`,
 		{
@@ -334,5 +376,5 @@ export const Handler = async ({
 	logger.log(
 		`✨ Deployment complete! Take a peek over at ${deploymentResponse.url}`
 	);
-	await metrics.sendMetricsEvent("deploy pages project");
+	await metrics.sendMetricsEvent("create pages deployment");
 };

package/src/pages/types.ts

@@ -1,3 +1,12 @@
+import type { ArgumentsCamelCase, Argv } from "yargs";
+
+/**
+ * Given some Yargs Options function factory, extract the interface
+ * that corresponds to the yargs arguments
+ */
+export type YargsOptionsToInterface<T extends (yargs: Argv) => Argv> =
+	T extends (yargs: Argv) => Argv<infer P> ? ArgumentsCamelCase<P> : never;
+
 export type Project = {
 	name: string;
 	subdomain: string;