wrangler 0.0.0-eab9542 → 0.0.0-eaf71b86c

package/src/pages/functions/buildPlugin.ts

@@ -1,105 +0,0 @@
-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

@@ -1,151 +0,0 @@
-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

@@ -1,234 +0,0 @@
-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

@@ -1,189 +0,0 @@
-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;
-}