wrangler 0.0.0-e978986 → 0.0.0-e9e9872

package/src/pages/functions/filepath-routing.ts

@@ -0,0 +1,189 @@
+import fs from "node:fs/promises";
+import path from "node:path";
+import { build } from "esbuild";
+import { toUrlPath } from "../../paths";
+import type { UrlPath } from "../../paths";
+import type { HTTPMethod, RouteConfig } from "./routes";
+
+export async function generateConfigFromFileTree({
+	baseDir,
+	baseURL,
+}: {
+	baseDir: string;
+	baseURL: UrlPath;
+}) {
+	let routeEntries: RouteConfig[] = [];
+
+	if (!baseURL.startsWith("/")) {
+		baseURL = `/${baseURL}` as UrlPath;
+	}
+
+	if (baseURL.endsWith("/")) {
+		baseURL = baseURL.slice(0, -1) as UrlPath;
+	}
+
+	await forEachFile(baseDir, async (filepath) => {
+		const ext = path.extname(filepath);
+		if (/^\.(mjs|js|ts|tsx|jsx)$/.test(ext)) {
+			const { metafile } = await build({
+				metafile: true,
+				write: false,
+				bundle: false,
+				entryPoints: [path.resolve(filepath)],
+			});
+			const exportNames: string[] = [];
+			if (metafile) {
+				for (const output in metafile?.outputs) {
+					exportNames.push(...metafile.outputs[output].exports);
+				}
+			}
+			for (const exportName of exportNames) {
+				const [match, method = ""] = (exportName.match(
+					/^onRequest(Get|Post|Put|Patch|Delete|Options|Head)?$/
+				) ?? []) as (string | undefined)[];
+
+				if (match) {
+					const basename = path.basename(filepath).slice(0, -ext.length);
+
+					const isIndexFile = basename === "index";
+					// TODO: deprecate _middleware_ in favor of _middleware
+					const isMiddlewareFile =
+						basename === "_middleware" || basename === "_middleware_";
+
+					let routePath = path
+						.relative(baseDir, filepath)
+						.slice(0, -ext.length);
+					let mountPath = path.dirname(routePath);
+
+					if (isIndexFile || isMiddlewareFile) {
+						routePath = path.dirname(routePath);
+					}
+
+					if (routePath === ".") {
+						routePath = "";
+					}
+					if (mountPath === ".") {
+						mountPath = "";
+					}
+
+					routePath = `${baseURL}/${routePath}`;
+					mountPath = `${baseURL}/${mountPath}`;
+
+					routePath = routePath.replace(/\[\[([^\]]+)\]\]/g, ":$1*"); // transform [[id]] => :id*
+					routePath = routePath.replaceAll(/\[([^\]]+)\]/g, ":$1"); // transform [id] => :id
+					mountPath = mountPath.replace(/\[\[([^\]]+)\]\]/g, ":$1*"); // transform [[id]] => :id*
+					mountPath = mountPath.replaceAll(/\[([^\]]+)\]/g, ":$1"); // transform [id] => :id
+
+					// These are used as module specifiers so UrlPaths are okay to use even on Windows
+					const modulePath = toUrlPath(path.relative(baseDir, filepath));
+
+					const routeEntry: RouteConfig = {
+						routePath: toUrlPath(routePath),
+						mountPath: toUrlPath(mountPath),
+						method: method.toUpperCase() as HTTPMethod,
+						[isMiddlewareFile ? "middleware" : "module"]: [
+							`${modulePath}:${exportName}`,
+						],
+					};
+
+					routeEntries.push(routeEntry);
+				}
+			}
+		}
+	});
+	// Combine together any routes (index routes) which contain both a module and a middleware
+	routeEntries = routeEntries.reduce(
+		(acc: typeof routeEntries, { routePath, ...rest }) => {
+			const existingRouteEntry = acc.find(
+				(routeEntry) =>
+					routeEntry.routePath === routePath &&
+					routeEntry.method === rest.method
+			);
+			if (existingRouteEntry !== undefined) {
+				Object.assign(existingRouteEntry, rest);
+			} else {
+				acc.push({ routePath, ...rest });
+			}
+			return acc;
+		},
+		[]
+	);
+
+	routeEntries.sort((a, b) => compareRoutes(a, b));
+
+	return {
+		routes: routeEntries,
+	};
+}
+
+// Ensure routes are produced in order of precedence so that
+// more specific routes aren't occluded from matching due to
+// less specific routes appearing first in the route list.
+export function compareRoutes(
+	{ routePath: routePathA, method: methodA }: RouteConfig,
+	{ routePath: routePathB, method: methodB }: RouteConfig
+) {
+	function parseRoutePath(routePath: UrlPath): string[] {
+		return routePath.slice(1).split("/").filter(Boolean);
+	}
+
+	const segmentsA = parseRoutePath(routePathA);
+	const segmentsB = parseRoutePath(routePathB);
+
+	// 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("*");
+		const isParamA = segmentsA[i].includes(":");
+		const isParamB = segmentsB[i].includes(":");
+
+		// sort wildcard segments after non-wildcard segments
+		if (isWildcardA && !isWildcardB) return 1;
+		if (!isWildcardA && isWildcardB) return -1;
+
+		// sort dynamic param segments after non-param segments
+		if (isParamA && !isParamB) return 1;
+		if (!isParamA && isParamB) return -1;
+	}
+
+	// sort routes that specify an HTTP before those that don't
+	if (methodA && !methodB) return -1;
+	if (!methodA && methodB) return 1;
+
+	// all else equal, just sort the paths lexicographically
+	return routePathA.localeCompare(routePathB);
+}
+
+async function forEachFile<T>(
+	baseDir: string,
+	fn: (filepath: string) => T | Promise<T>
+) {
+	const searchPaths = [baseDir];
+	const returnValues: T[] = [];
+
+	while (isNotEmpty(searchPaths)) {
+		const cwd = searchPaths.shift();
+		const dir = await fs.readdir(cwd, { withFileTypes: true });
+		for (const entry of dir) {
+			const pathname = path.join(cwd, entry.name);
+			if (entry.isDirectory()) {
+				searchPaths.push(pathname);
+			} else if (entry.isFile()) {
+				returnValues.push(await fn(pathname));
+			}
+		}
+	}
+
+	return returnValues;
+}
+
+interface NonEmptyArray<T> extends Array<T> {
+	shift(): T;
+}
+function isNotEmpty<T>(array: T[]): array is NonEmptyArray<T> {
+	return array.length > 0;
+}

package/src/pages/functions/identifiers.ts

@@ -0,0 +1,78 @@
+export const RESERVED_KEYWORDS = [
+	"do",
+	"if",
+	"in",
+	"for",
+	"let",
+	"new",
+	"try",
+	"var",
+	"case",
+	"else",
+	"enum",
+	"eval",
+	"null",
+	"this",
+	"true",
+	"void",
+	"with",
+	"await",
+	"break",
+	"catch",
+	"class",
+	"const",
+	"false",
+	"super",
+	"throw",
+	"while",
+	"yield",
+	"delete",
+	"export",
+	"import",
+	"public",
+	"return",
+	"static",
+	"switch",
+	"typeof",
+	"default",
+	"extends",
+	"finally",
+	"package",
+	"private",
+	"continue",
+	"debugger",
+	"function",
+	"arguments",
+	"interface",
+	"protected",
+	"implements",
+	"instanceof",
+	"NaN",
+	"Infinity",
+	"undefined",
+];
+
+export const reservedKeywordRegex = new RegExp(
+	`^${RESERVED_KEYWORDS.join("|")}$`
+);
+
+export const identifierStartRegex = /[$_\p{ID_Start}]/u;
+
+export const identifierPartRegex = /[$_\u200C\u200D\p{ID_Continue}]/u;
+
+export const identifierNameRegex =
+	/^(?:[$_\p{ID_Start}])(?:[$_\u200C\u200D\p{ID_Continue}])*$/u;
+
+export const validIdentifierRegex = new RegExp(
+	`(?!(${reservedKeywordRegex.source})$)${identifierNameRegex.source}`,
+	"u"
+);
+
+export const isValidIdentifier = (identifier: string) =>
+	validIdentifierRegex.test(identifier);
+
+export const normalizeIdentifier = (identifier: string) =>
+	identifier.replace(
+		/(?:^[^$_\p{ID_Start}])|[^$_\u200C\u200D\p{ID_Continue}]/gu,
+		"_"
+	);

package/src/pages/functions/routes.ts

@@ -0,0 +1,151 @@
+import fs from "node:fs/promises";
+import path from "node:path";
+import { isValidIdentifier, normalizeIdentifier } from "./identifiers";
+import type { UrlPath } from "../../paths";
+
+export const HTTP_METHODS = [
+	"HEAD",
+	"OPTIONS",
+	"GET",
+	"POST",
+	"PUT",
+	"PATCH",
+	"DELETE",
+] as const;
+export type HTTPMethod = typeof HTTP_METHODS[number];
+
+export type RoutesCollection = Array<{
+	routePath: UrlPath;
+	mountPath: UrlPath;
+	method?: HTTPMethod;
+	modules: string[];
+	middlewares: string[];
+}>;
+
+export type Config = {
+	routes?: RouteConfig[];
+	schedules?: unknown;
+};
+
+export type RouteConfig = {
+	routePath: UrlPath;
+	mountPath: UrlPath;
+	method?: HTTPMethod;
+	middleware?: string | string[];
+	module?: string | string[];
+};
+
+type ImportMap = Map<
+	string,
+	{
+		filepath: string;
+		name: string;
+		identifier: string;
+	}
+>;
+
+type Arguments = {
+	config: Config;
+	outfile: string;
+	srcDir: string;
+};
+
+export async function writeRoutesModule({
+	config,
+	srcDir,
+	outfile = "_routes.js",
+}: Arguments) {
+	const { importMap, routes } = parseConfig(config, srcDir);
+	const routesModule = generateRoutesModule(importMap, routes);
+
+	await fs.writeFile(outfile, routesModule);
+
+	return outfile;
+}
+
+export function parseConfig(config: Config, baseDir: string) {
+	const routes: RoutesCollection = [];
+	const importMap: ImportMap = new Map();
+	const identifierCount = new Map<string, number>(); // to keep track of identifier collisions
+
+	function parseModuleIdentifiers(paths: string | string[] | undefined) {
+		if (typeof paths === "undefined") {
+			paths = [];
+		}
+
+		if (typeof paths === "string") {
+			paths = [paths];
+		}
+
+		return paths.map((modulePath) => {
+			const [filepath, name = "default"] = modulePath.split(":");
+			let { identifier } = importMap.get(modulePath) ?? {};
+
+			const resolvedPath = path.resolve(baseDir, filepath);
+
+			// ensure the filepath isn't attempting to resolve to anything outside of the project
+			if (path.relative(baseDir, resolvedPath).startsWith("..")) {
+				throw new Error(`Invalid module path "${filepath}"`);
+			}
+
+			// ensure the module name (if provided) is a valid identifier to guard against injection attacks
+			if (name !== "default" && !isValidIdentifier(name)) {
+				throw new Error(`Invalid module identifier "${name}"`);
+			}
+
+			if (!identifier) {
+				identifier = normalizeIdentifier(`__${filepath}_${name}`);
+
+				let count = identifierCount.get(identifier) ?? 0;
+				identifierCount.set(identifier, ++count);
+
+				if (count > 1) {
+					identifier += `_${count}`;
+				}
+
+				importMap.set(modulePath, { filepath: resolvedPath, name, identifier });
+			}
+
+			return identifier;
+		});
+	}
+
+	for (const { routePath, mountPath, method, ...props } of config.routes ??
+		[]) {
+		routes.push({
+			routePath,
+			mountPath,
+			method,
+			middlewares: parseModuleIdentifiers(props.middleware),
+			modules: parseModuleIdentifiers(props.module),
+		});
+	}
+
+	return { routes, importMap };
+}
+
+export function generateRoutesModule(
+	importMap: ImportMap,
+	routes: RoutesCollection
+) {
+	return `${[...importMap.values()]
+		.map(
+			({ filepath, name, identifier }) =>
+				`import { ${name} as ${identifier} } from ${JSON.stringify(filepath)}`
+		)
+		.join("\n")}
+
+export const routes = [
+  ${routes
+		.map(
+			(route) => `  {
+      routePath: "${route.routePath}",
+      mountPath: "${route.mountPath}",
+      method: "${route.method}",
+      middlewares: [${route.middlewares.join(", ")}],
+      modules: [${route.modules.join(", ")}],
+    },`
+		)
+		.join("\n")}
+  ]`;
+}

package/src/pages/index.tsx

@@ -0,0 +1,84 @@
+/* eslint-disable no-shadow */
+
+import * as Build from "./build";
+import * as Deployments from "./deployments";
+import * as Dev from "./dev";
+import * as Projects from "./projects";
+import * as Publish from "./publish";
+import * as Upload from "./upload";
+import { CLEANUP, pagesBetaWarning } from "./utils";
+import type { BuilderCallback } from "yargs";
+
+process.on("SIGINT", () => {
+	CLEANUP();
+	process.exit();
+});
+process.on("SIGTERM", () => {
+	CLEANUP();
+	process.exit();
+});
+
+export const pages: BuilderCallback<unknown, unknown> = (yargs) => {
+	return yargs
+		.command(
+			"dev [directory] [-- command..]",
+			"🧑‍💻 Develop your full-stack Pages application locally",
+			Dev.Options,
+			Dev.Handler
+		)
+		.command("functions", false, (yargs) =>
+			// we hide this command from help output because
+			// it's not meant to be used directly right now
+			{
+				return yargs.command(
+					"build [directory]",
+					"Compile a folder of Cloudflare Pages Functions into a single Worker",
+					Build.Options,
+					Build.Handler
+				);
+			}
+		)
+		.command("project", "⚡️ Interact with your Pages projects", (yargs) =>
+			yargs
+				.command(
+					"list",
+					"List your Cloudflare Pages projects",
+					Projects.ListOptions,
+					Projects.ListHandler
+				)
+				.command(
+					"create [project-name]",
+					"Create a new Cloudflare Pages project",
+					Projects.CreateOptions,
+					Projects.CreateHandler
+				)
+				.command("upload [directory]", false, Upload.Options, Upload.Handler)
+				.epilogue(pagesBetaWarning)
+		)
+		.command(
+			"deployment",
+			"🚀 Interact with the deployments of a project",
+			(yargs) =>
+				yargs
+					.command(
+						"list",
+						"List deployments in your Cloudflare Pages project",
+						Deployments.ListOptions,
+						Deployments.ListHandler
+					)
+					.command(
+						"create [directory]",
+						"🆙 Publish a directory of static assets as a Pages deployment",
+						Publish.Options,
+						Publish.Handler
+					)
+					.epilogue(pagesBetaWarning)
+		)
+		.command(
+			"publish [directory]",
+			"🆙 Publish a directory of static assets as a Pages deployment",
+			Publish.Options,
+			Publish.Handler
+		)
+		.epilogue(pagesBetaWarning);
+};

package/src/pages/projects.tsx

@@ -0,0 +1,157 @@
+import { execSync } from "node:child_process";
+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 { prompt } from "../dialogs";
+import { FatalError } from "../errors";
+import { logger } from "../logger";
+import { requireAuth } from "../user";
+import { PAGES_CONFIG_CACHE_FILENAME } from "./constants";
+import { pagesBetaWarning } from "./utils";
+import type { PagesConfigCache, Project } from "./types";
+import type { ArgumentsCamelCase, Argv } from "yargs";
+
+// Empty object, as per eslint
+type ListArgs = Record<string, never>;
+
+export function ListOptions(yargs: Argv): Argv<ListArgs> {
+	return yargs.epilogue(pagesBetaWarning);
+}
+
+export async function ListHandler() {
+	const config = getConfigCache<PagesConfigCache>(PAGES_CONFIG_CACHE_FILENAME);
+
+	const accountId = await requireAuth(config);
+
+	const projects: Array<Project> = await listProjects({ accountId });
+
+	const data = projects.map((project) => {
+		return {
+			"Project Name": project.name,
+			"Project Domains": `${project.domains.join(", ")}`,
+			"Git Provider": project.source ? "Yes" : "No",
+			"Last Modified": project.latest_deployment
+				? timeagoFormat(project.latest_deployment.modified_on)
+				: timeagoFormat(project.created_on),
+		};
+	});
+
+	saveToConfigCache<PagesConfigCache>(PAGES_CONFIG_CACHE_FILENAME, {
+		account_id: accountId,
+	});
+
+	render(<Table data={data}></Table>, { patchConsole: false });
+}
+
+export const listProjects = async ({
+	accountId,
+}: {
+	accountId: string;
+}): Promise<Array<Project>> => {
+	const pageSize = 10;
+	let page = 1;
+	const results = [];
+	while (results.length % pageSize === 0) {
+		const json: Array<Project> = await fetchResult(
+			`/accounts/${accountId}/pages/projects`,
+			{},
+			new URLSearchParams({
+				per_page: pageSize.toString(),
+				page: page.toString(),
+			})
+		);
+		page++;
+		results.push(...json);
+		if (json.length < pageSize) {
+			break;
+		}
+	}
+	return results;
+};
+
+type CreateArgs = {
+	"project-name": string;
+	"production-branch"?: string;
+};
+
+export function CreateOptions(yargs: Argv): Argv<CreateArgs> {
+	return yargs
+		.positional("project-name", {
+			type: "string",
+			demandOption: true,
+			description: "The name of your Pages project",
+		})
+		.options({
+			"production-branch": {
+				type: "string",
+				description: "The name of the production branch of your project",
+			},
+		})
+		.epilogue(pagesBetaWarning);
+}
+
+export async function CreateHandler({
+	productionBranch,
+	projectName,
+}: ArgumentsCamelCase<CreateArgs>) {
+	const config = getConfigCache<PagesConfigCache>(PAGES_CONFIG_CACHE_FILENAME);
+	const accountId = await requireAuth(config);
+
+	const isInteractive = process.stdin.isTTY;
+	if (!projectName && isInteractive) {
+		projectName = await prompt("Enter the name of your new project:");
+	}
+
+	if (!projectName) {
+		throw new FatalError("Must specify a project name.", 1);
+	}
+
+	if (!productionBranch && isInteractive) {
+		let isGitDir = true;
+		try {
+			execSync(`git rev-parse --is-inside-work-tree`, {
+				stdio: "ignore",
+			});
+		} catch (err) {
+			isGitDir = false;
+		}
+
+		productionBranch = await prompt(
+			"Enter the production branch name:",
+			"text",
+			isGitDir
+				? execSync(`git rev-parse --abbrev-ref HEAD`).toString().trim()
+				: "production"
+		);
+	}
+
+	if (!productionBranch) {
+		throw new FatalError("Must specify a production branch.", 1);
+	}
+
+	const { subdomain } = await fetchResult<Project>(
+		`/accounts/${accountId}/pages/projects`,
+		{
+			method: "POST",
+			body: JSON.stringify({
+				name: projectName,
+				production_branch: productionBranch,
+			}),
+		}
+	);
+
+	saveToConfigCache<PagesConfigCache>(PAGES_CONFIG_CACHE_FILENAME, {
+		account_id: accountId,
+		project_name: projectName,
+	});
+
+	logger.log(
+		`✨ Successfully created the '${projectName}' project. It will be available at https://${subdomain}/ once you create your first deployment.`
+	);
+	logger.log(
+		`To deploy a folder of assets, run 'wrangler pages publish [directory]'.`
+	);
+}