wrangler 0.0.0-fe5dcfd → 0.0.0-ff2e7cb

package/src/pages/functions/buildPlugin.ts

@@ -0,0 +1,105 @@
+import { access, lstat } from "node:fs/promises";
+import { dirname, relative, resolve } from "node:path";
+import NodeGlobalsPolyfills from "@esbuild-plugins/node-globals-polyfill";
+import NodeModulesPolyfills from "@esbuild-plugins/node-modules-polyfill";
+import { build } from "esbuild";
+
+type Options = {
+	routesModule: string;
+	outfile: string;
+	minify?: boolean;
+	sourcemap?: boolean;
+	watch?: boolean;
+	nodeCompat?: boolean;
+	onEnd?: () => void;
+};
+
+export function buildPlugin({
+	routesModule,
+	outfile = "bundle.js",
+	minify = false,
+	sourcemap = false,
+	watch = false,
+	nodeCompat,
+	onEnd = () => {},
+}: Options) {
+	return build({
+		entryPoints: [resolve(__dirname, "../templates/pages-template-plugin.ts")],
+		inject: [routesModule],
+		bundle: true,
+		format: "esm",
+		target: "esnext",
+		outfile,
+		minify,
+		sourcemap,
+		watch,
+		allowOverwrite: true,
+		define: { ...(nodeCompat ? { global: "globalThis" } : {}) },
+		plugins: [
+			{
+				name: "wrangler notifier and monitor",
+				setup(pluginBuild) {
+					pluginBuild.onEnd((result) => {
+						if (result.errors.length > 0) {
+							console.error(
+								`${result.errors.length} error(s) and ${result.warnings.length} warning(s) when compiling Worker.`
+							);
+						} else if (result.warnings.length > 0) {
+							console.warn(
+								`${result.warnings.length} warning(s) when compiling Worker.`
+							);
+							onEnd();
+						} else {
+							console.log("Compiled Worker successfully.");
+							onEnd();
+						}
+					});
+				},
+			},
+			{
+				name: "Assets",
+				setup(pluginBuild) {
+					if (pluginBuild.initialOptions.outfile) {
+						const outdir = dirname(pluginBuild.initialOptions.outfile);
+
+						pluginBuild.onResolve({ filter: /^assets:/ }, async (args) => {
+							const directory = resolve(
+								args.resolveDir,
+								args.path.slice("assets:".length)
+							);
+
+							const exists = await access(directory)
+								.then(() => true)
+								.catch(() => false);
+
+							const isDirectory =
+								exists && (await lstat(directory)).isDirectory();
+
+							if (!isDirectory) {
+								return {
+									errors: [
+										{
+											text: `'${directory}' does not exist or is not a directory.`,
+										},
+									],
+								};
+							}
+
+							const path = `assets:./${relative(outdir, directory)}`;
+
+							return { path, external: true, namespace: "assets" };
+						});
+					}
+				},
+			},
+			...(nodeCompat
+				? [
+						NodeGlobalsPolyfills({
+							buffer: true,
+						}),
+						NodeModulesPolyfills(),
+				  ]
+				: []),
+		],
+	});
+}

package/src/pages/functions/buildWorker.ts

@@ -0,0 +1,151 @@
+import { access, cp, lstat, rm } from "node:fs/promises";
+import { join, resolve } from "node:path";
+import NodeGlobalsPolyfills from "@esbuild-plugins/node-globals-polyfill";
+import NodeModulesPolyfills from "@esbuild-plugins/node-modules-polyfill";
+import { build } from "esbuild";
+import { nanoid } from "nanoid";
+
+type Options = {
+	routesModule: string;
+	outfile: string;
+	minify?: boolean;
+	sourcemap?: boolean;
+	fallbackService?: string;
+	watch?: boolean;
+	onEnd?: () => void;
+	buildOutputDirectory?: string;
+	nodeCompat?: boolean;
+};
+
+export function buildWorker({
+	routesModule,
+	outfile = "bundle.js",
+	minify = false,
+	sourcemap = false,
+	fallbackService = "ASSETS",
+	watch = false,
+	onEnd = () => {},
+	buildOutputDirectory,
+	nodeCompat,
+}: Options) {
+	return build({
+		entryPoints: [resolve(__dirname, "../templates/pages-template-worker.ts")],
+		inject: [routesModule],
+		bundle: true,
+		format: "esm",
+		target: "esnext",
+		outfile,
+		minify,
+		sourcemap,
+		watch,
+		allowOverwrite: true,
+		define: {
+			__FALLBACK_SERVICE__: JSON.stringify(fallbackService),
+			...(nodeCompat ? { global: "globalThis" } : {}),
+		},
+		plugins: [
+			{
+				name: "wrangler notifier and monitor",
+				setup(pluginBuild) {
+					pluginBuild.onEnd((result) => {
+						if (result.errors.length > 0) {
+							console.error(
+								`${result.errors.length} error(s) and ${result.warnings.length} warning(s) when compiling Worker.`
+							);
+						} else if (result.warnings.length > 0) {
+							console.warn(
+								`${result.warnings.length} warning(s) when compiling Worker.`
+							);
+							onEnd();
+						} else {
+							console.log("Compiled Worker successfully.");
+							onEnd();
+						}
+					});
+				},
+			},
+			{
+				name: "Assets",
+				setup(pluginBuild) {
+					const identifiers = new Map<string, string>();
+
+					pluginBuild.onResolve({ filter: /^assets:/ }, async (args) => {
+						const directory = resolve(
+							args.resolveDir,
+							args.path.slice("assets:".length)
+						);
+
+						const exists = await access(directory)
+							.then(() => true)
+							.catch(() => false);
+
+						const isDirectory =
+							exists && (await lstat(directory)).isDirectory();
+
+						if (!isDirectory) {
+							return {
+								errors: [
+									{
+										text: `'${directory}' does not exist or is not a directory.`,
+									},
+								],
+							};
+						}
+
+						// TODO: Consider hashing the contents rather than using a unique identifier every time?
+						identifiers.set(directory, nanoid());
+						if (!buildOutputDirectory) {
+							console.warn(
+								"You're attempting to import static assets as part of your Pages Functions, but have not specified a directory in which to put them. You must use 'wrangler pages dev <directory>' rather than 'wrangler pages dev -- <command>' to import static assets in Functions."
+							);
+						}
+						return { path: directory, namespace: "assets" };
+					});
+
+					pluginBuild.onLoad(
+						{ filter: /.*/, namespace: "assets" },
+						async (args) => {
+							const identifier = identifiers.get(args.path);
+
+							if (buildOutputDirectory) {
+								const staticAssetsOutputDirectory = join(
+									buildOutputDirectory,
+									"cdn-cgi",
+									"pages-plugins",
+									identifier as string
+								);
+								await rm(staticAssetsOutputDirectory, {
+									force: true,
+									recursive: true,
+								});
+								await cp(args.path, staticAssetsOutputDirectory, {
+									force: true,
+									recursive: true,
+								});
+
+								return {
+									// TODO: Watch args.path for changes and re-copy when updated
+									contents: `export const onRequest = ({ request, env, functionPath }) => {
+                    const url = new URL(request.url)
+                    const relativePathname = \`/\${url.pathname.split(functionPath)[1] || ''}\`.replace(/^\\/\\//, '/');
+                    url.pathname = '/cdn-cgi/pages-plugins/${identifier}' + relativePathname
+                    request = new Request(url.toString(), request)
+                    return env.ASSETS.fetch(request)
+                  }`,
+								};
+							}
+						}
+					);
+				},
+			},
+			...(nodeCompat
+				? [
+						NodeGlobalsPolyfills({
+							buffer: true,
+						}),
+						NodeModulesPolyfills(),
+				  ]
+				: []),
+		],
+	});
+}

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

@@ -0,0 +1,234 @@
+import { writeFileSync, mkdirSync } from "fs";
+import { runInTempDir } from "../../__tests__/helpers/run-in-tmp";
+import { toUrlPath } from "../../paths";
+import { compareRoutes, generateConfigFromFileTree } from "./filepath-routing";
+import type { UrlPath } from "../../paths";
+import type { HTTPMethod, RouteConfig } from "./routes";
+
+describe("filepath-routing", () => {
+	describe("compareRoutes()", () => {
+		test("routes / last", () => {
+			expect(
+				compareRoutes(routeConfig("/"), routeConfig("/foo"))
+			).toBeGreaterThanOrEqual(1);
+			expect(
+				compareRoutes(routeConfig("/"), routeConfig("/:foo"))
+			).toBeGreaterThanOrEqual(1);
+			expect(
+				compareRoutes(routeConfig("/"), routeConfig("/:foo*"))
+			).toBeGreaterThanOrEqual(1);
+		});
+
+		test("routes with fewer segments come after those with more segments", () => {
+			expect(
+				compareRoutes(routeConfig("/foo"), routeConfig("/foo/bar"))
+			).toBeGreaterThanOrEqual(1);
+			expect(
+				compareRoutes(routeConfig("/foo"), routeConfig("/foo/bar/cat"))
+			).toBeGreaterThanOrEqual(1);
+		});
+
+		test("routes with wildcard segments come after those without", () => {
+			expect(compareRoutes(routeConfig("/:foo*"), routeConfig("/foo"))).toBe(1);
+			expect(compareRoutes(routeConfig("/:foo*"), routeConfig("/:foo"))).toBe(
+				1
+			);
+		});
+
+		test("routes with dynamic segments come after those without", () => {
+			expect(compareRoutes(routeConfig("/:foo"), routeConfig("/foo"))).toBe(1);
+		});
+
+		test("routes with dynamic segments occurring earlier come after those with dynamic segments in later positions", () => {
+			expect(
+				compareRoutes(routeConfig("/foo/:id/bar"), routeConfig("/foo/bar/:id"))
+			).toBe(1);
+		});
+
+		test("routes with no HTTP method come after those specifying a method", () => {
+			expect(
+				compareRoutes(routeConfig("/foo"), routeConfig("/foo", "GET"))
+			).toBe(1);
+		});
+
+		test("two equal routes are sorted according to their original position in the list", () => {
+			expect(
+				compareRoutes(routeConfig("/foo", "GET"), routeConfig("/foo", "GET"))
+			).toBe(0);
+		});
+
+		test("it returns -1 if the first argument should appear first in the list", () => {
+			expect(
+				compareRoutes(routeConfig("/foo", "GET"), routeConfig("/foo"))
+			).toBe(-1);
+		});
+	});
+
+	describe("generateConfigFromFileTree", () => {
+		runInTempDir();
+
+		it("should generate a route entry for each file in the tree", async () => {
+			writeFileSync(
+				"foo.ts",
+				`
+      export function onRequestGet() {}
+      export function onRequestPost() {}
+      `
+			);
+			writeFileSync(
+				"bar.ts",
+				`
+      export function onRequestPut() {}
+      export function onRequestDelete() {}
+      `
+			);
+
+			mkdirSync("todos");
+
+			writeFileSync(
+				"todos/[id].ts",
+				`
+      export function onRequestPost() {}
+      export function onRequestDelete() {}
+      `
+			);
+
+			mkdirSync("authors");
+			mkdirSync("authors/[authorId]");
+			mkdirSync("authors/[authorId]/todos");
+
+			writeFileSync(
+				"authors/[authorId]/todos/[todoId].ts",
+				`
+      export function onRequestPost() {}
+      `
+			);
+
+			mkdirSync("books");
+
+			writeFileSync(
+				"books/[[title]].ts",
+				`
+      export function onRequestPost() {}
+      `
+			);
+
+			mkdirSync("cats");
+			mkdirSync("cats/[[breed]]");
+
+			writeFileSync(
+				"cats/[[breed]]/blah.ts",
+				`
+      export function onRequestPost() {}
+      `
+			);
+
+			// This won't actually work at runtime.
+			writeFileSync(
+				"cats/[[breed]]/[[name]].ts",
+				`
+      export function onRequestPost() {}
+      `
+			);
+
+			const entries = await generateConfigFromFileTree({
+				baseDir: ".",
+				baseURL: "/base" as UrlPath,
+			});
+			expect(entries).toMatchInlineSnapshot(`
+        Object {
+          "routes": Array [
+            Object {
+              "method": "POST",
+              "module": Array [
+                "authors/[authorId]/todos/[todoId].ts:onRequestPost",
+              ],
+              "mountPath": "/base/authors/:authorId/todos",
+              "routePath": "/base/authors/:authorId/todos/:todoId",
+            },
+            Object {
+              "method": "POST",
+              "module": Array [
+                "cats/[[breed]]/blah.ts:onRequestPost",
+              ],
+              "mountPath": "/base/cats/:breed*",
+              "routePath": "/base/cats/:breed*/blah",
+            },
+            Object {
+              "method": "POST",
+              "module": Array [
+                "cats/[[breed]]/[[name]].ts:onRequestPost",
+              ],
+              "mountPath": "/base/cats/:breed*",
+              "routePath": "/base/cats/:breed*/:name*",
+            },
+            Object {
+              "method": "DELETE",
+              "module": Array [
+                "todos/[id].ts:onRequestDelete",
+              ],
+              "mountPath": "/base/todos",
+              "routePath": "/base/todos/:id",
+            },
+            Object {
+              "method": "POST",
+              "module": Array [
+                "todos/[id].ts:onRequestPost",
+              ],
+              "mountPath": "/base/todos",
+              "routePath": "/base/todos/:id",
+            },
+            Object {
+              "method": "POST",
+              "module": Array [
+                "books/[[title]].ts:onRequestPost",
+              ],
+              "mountPath": "/base/books",
+              "routePath": "/base/books/:title*",
+            },
+            Object {
+              "method": "DELETE",
+              "module": Array [
+                "bar.ts:onRequestDelete",
+              ],
+              "mountPath": "/base/",
+              "routePath": "/base/bar",
+            },
+            Object {
+              "method": "PUT",
+              "module": Array [
+                "bar.ts:onRequestPut",
+              ],
+              "mountPath": "/base/",
+              "routePath": "/base/bar",
+            },
+            Object {
+              "method": "GET",
+              "module": Array [
+                "foo.ts:onRequestGet",
+              ],
+              "mountPath": "/base/",
+              "routePath": "/base/foo",
+            },
+            Object {
+              "method": "POST",
+              "module": Array [
+                "foo.ts:onRequestPost",
+              ],
+              "mountPath": "/base/",
+              "routePath": "/base/foo",
+            },
+          ],
+        }
+      `);
+		});
+	});
+});
+
+function routeConfig(routePath: string, method?: string): RouteConfig {
+	return {
+		routePath: toUrlPath(routePath),
+		mountPath: toUrlPath("/"),
+		method: method as HTTPMethod,
+	};
+}

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;
+}