wrangler 0.0.0-e64812e → 0.0.0-e6c9c5c0

package/{pages → src/pages}/functions/filepath-routing.test.ts

@@ -1,141 +1,141 @@
 import { writeFileSync, mkdirSync } from "fs";
-import { runInTempDir } from "../../src/__tests__/helpers/run-in-tmp";
-import { toUrlPath } from "../../src/paths";
+import { runInTempDir } from "../../__tests__/helpers/run-in-tmp";
+import { toUrlPath } from "../../paths";
 import { compareRoutes, generateConfigFromFileTree } from "./filepath-routing";
-import type { UrlPath } from "../../src/paths";
+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",
-        `
+	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",
-        `
+			);
+			writeFileSync(
+				"bar.ts",
+				`
       export function onRequestPut() {}
       export function onRequestDelete() {}
       `
-      );
+			);
 
-      mkdirSync("todos");
+			mkdirSync("todos");
 
-      writeFileSync(
-        "todos/[id].ts",
-        `
+			writeFileSync(
+				"todos/[id].ts",
+				`
       export function onRequestPost() {}
       export function onRequestDelete() {}
       `
-      );
+			);
 
-      mkdirSync("authors");
-      mkdirSync("authors/[authorId]");
-      mkdirSync("authors/[authorId]/todos");
+			mkdirSync("authors");
+			mkdirSync("authors/[authorId]");
+			mkdirSync("authors/[authorId]/todos");
 
-      writeFileSync(
-        "authors/[authorId]/todos/[todoId].ts",
-        `
+			writeFileSync(
+				"authors/[authorId]/todos/[todoId].ts",
+				`
       export function onRequestPost() {}
       `
-      );
+			);
 
-      mkdirSync("books");
+			mkdirSync("books");
 
-      writeFileSync(
-        "books/[[title]].ts",
-        `
+			writeFileSync(
+				"books/[[title]].ts",
+				`
       export function onRequestPost() {}
       `
-      );
+			);
 
-      mkdirSync("cats");
-      mkdirSync("cats/[[breed]]");
+			mkdirSync("cats");
+			mkdirSync("cats/[[breed]]");
 
-      writeFileSync(
-        "cats/[[breed]]/blah.ts",
-        `
+			writeFileSync(
+				"cats/[[breed]]/blah.ts",
+				`
       export function onRequestPost() {}
       `
-      );
+			);
 
-      // This won't actually work at runtime.
-      writeFileSync(
-        "cats/[[breed]]/[[name]].ts",
-        `
+			// 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(`
+			const entries = await generateConfigFromFileTree({
+				baseDir: ".",
+				baseURL: "/base" as UrlPath,
+			});
+			expect(entries).toMatchInlineSnapshot(`
         Object {
           "routes": Array [
             Object {
@@ -221,14 +221,14 @@ describe("filepath-routing", () => {
           ],
         }
       `);
-    });
-  });
+		});
+	});
 });
 
 function routeConfig(routePath: string, method?: string): RouteConfig {
-  return {
-    routePath: toUrlPath(routePath),
-    mountPath: toUrlPath("/"),
-    method: method as HTTPMethod,
-  };
+	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;
+}

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,
+		"_"
+	);