wrangler 0.0.0-e64812e → 0.0.0-e6c71262

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

@@ -0,0 +1,250 @@
+import { consolidateRoutes, shortenRoute } from "./routes-consolidation";
+
+describe("route-consolidation", () => {
+	const maxRuleLength = 100; // from constants.MAX_FUNCTIONS_ROUTES_RULE_LENGTH
+	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);
+		});
+
+		it("should truncate long single-level path into catch-all path, removing other paths", () => {
+			expect(
+				consolidateRoutes([
+					// [/aaaaaaa, /foo] -> [/*]
+					"/" + "a".repeat(maxRuleLength * 2),
+					"/foo",
+					"/bar/*",
+					"/baz/bagel/coffee",
+				])
+			).toEqual(["/*"]);
+		});
+
+		it("should truncate long nested path, removing other paths", () => {
+			expect(
+				consolidateRoutes([
+					// [/aaaaaaa, /foo] -> [/*]
+					"/foo/" + "a".repeat(maxRuleLength * 2),
+					"/foo/bar",
+				])
+			).toEqual(["/foo/*"]);
+		});
+	});
+
+	describe(`shortenRoute()`, () => {
+		it("should allow max length path", () => {
+			const route = "/" + "a".repeat(maxRuleLength - 1);
+			// Make sure we don't have an off-by-one error, that'd be embarrassing...
+			expect(route.length).toEqual(maxRuleLength);
+			expect(
+				// Should stay the same
+				shortenRoute(route)
+			).toEqual(route);
+		});
+
+		it("should allow max length path (with slash)", () => {
+			const route = "/" + "a".repeat(maxRuleLength - 2) + "/";
+			expect(route.length).toEqual(maxRuleLength);
+			expect(
+				// Should stay the same
+				shortenRoute(route)
+			).toEqual(route);
+		});
+
+		it("should allow max length wildcard path", () => {
+			const route = "/" + "a".repeat(maxRuleLength - 3) + "/*";
+			expect(route.length).toEqual(maxRuleLength);
+			expect(
+				// Should stay the same
+				shortenRoute(route)
+			).toEqual(route);
+		});
+
+		it("should truncate long specific path to shorter wildcard path", () => {
+			const short = shortenRoute(
+				// /aaa/bbb -> /aaa/*
+				"/" +
+					"a".repeat(maxRuleLength * 0.6) +
+					"/" +
+					"b".repeat(maxRuleLength * 0.6)
+			);
+			expect(short).toEqual("/" + "a".repeat(maxRuleLength * 0.6) + "/*");
+			expect(short.length).toBeLessThanOrEqual(maxRuleLength);
+		});
+
+		it("should truncate long specific path (with slash) to shorter wildcard path", () => {
+			const short = shortenRoute(
+				// /aaa/bbb/ -> /aaa/*
+				"/" +
+					"a".repeat(maxRuleLength * 0.6) +
+					"/" +
+					"b".repeat(maxRuleLength * 0.6) +
+					"/"
+			);
+			expect(short).toEqual("/" + "a".repeat(maxRuleLength * 0.6) + "/*");
+			expect(short.length).toBeLessThanOrEqual(maxRuleLength);
+		});
+
+		it("should truncate long wildcard path to shorter wildcard path", () => {
+			const short = shortenRoute(
+				// /aaa/bbb/* -> /aaa/*
+				"/" +
+					"a".repeat(maxRuleLength * 0.6) +
+					"/" +
+					"b".repeat(maxRuleLength * 0.6) +
+					"/*"
+			);
+			expect(short).toEqual("/" + "a".repeat(maxRuleLength * 0.6) + "/*");
+			expect(short.length).toBeLessThanOrEqual(maxRuleLength);
+		});
+
+		it("should truncate long single-level specific path to catch-all path", () => {
+			expect(
+				shortenRoute(
+					// /aaa -> /*
+					"/" + "a".repeat(maxRuleLength * 2)
+				)
+			).toEqual("/*");
+		});
+
+		it("should truncate long single-level specific path (with slash) to catch-all path", () => {
+			expect(
+				shortenRoute(
+					// /aaa/ -> /*
+					"/" + "a".repeat(maxRuleLength * 2) + "/"
+				)
+			).toEqual("/*");
+		});
+
+		it("should truncate long single-level wildcard path to catch-all path", () => {
+			expect(
+				shortenRoute(
+					// /aaa/* -> /*
+					"/" + "a".repeat(maxRuleLength * 2) + "/*"
+				)
+			).toEqual("/*");
+		});
+
+		it("should truncate many single-character segements", () => {
+			const short = shortenRoute(
+				// /a/a/a -> /a/a/*
+				"/a".repeat(maxRuleLength) // 2x limit
+			);
+			expect(short).toEqual("/a".repeat(maxRuleLength / 2 - 1) + "/*");
+			// Should be the exact max length
+			expect(short.length).toEqual(maxRuleLength);
+		});
+
+		it("should truncate many double-character segements", () => {
+			// === odd ===
+			const short = shortenRoute(
+				// /aa/aa/aa -> /aa/aa/*
+				"/aa".repeat(maxRuleLength) // 3x limit
+			);
+			expect(short).toEqual("/aa".repeat(maxRuleLength / 3 - 1) + "/*");
+			// Should be the exact max length
+			expect(short.length).toEqual(maxRuleLength - 2); // -2 because of the odd number
+		});
+
+		it("should truncate many single-character segements with wildcard", () => {
+			const short = shortenRoute(
+				// /a/a/a -> /a/a/*
+				"/a".repeat(maxRuleLength) + "/*" // 2x limit
+			);
+			expect(short).toEqual("/a".repeat(maxRuleLength / 2 - 1) + "/*");
+			// Should be the exact max length
+			expect(short.length).toEqual(maxRuleLength);
+		});
+
+		it("should truncate many double-character segements with wildcard", () => {
+			const short = shortenRoute(
+				// /aa/aa/aa -> /aa/*
+				"/aa".repeat(maxRuleLength) + "/*" // 2x limit
+			);
+			expect(short).toEqual("/aa".repeat(maxRuleLength / 3 - 1) + "/*");
+			// Should be the exact max length
+			expect(short.length).toEqual(maxRuleLength - 2); // -2 because of the odd number
+		});
+
+		// This is probably the best test here - tests variable-length segments, up until the max.
+		// This ensures that it's always able to shorten rules, without failing and returning "/*"
+		// The other tests are great for ensuring exact sequences instead of only asserting length, though.
+		for (const suffix of ["", "/", "/*"]) {
+			// Test each type of path: /a, /a/a, /a/*
+			it(`should truncate many variable-character segements (suffix="${suffix}") without truncating to /*`, () => {
+				// "/" + 97 chars + "/*" === 100
+				for (let i = 1; i < maxRuleLength - 2; i++) {
+					const segment = "/" + "a".repeat(i);
+					// make sure the segment isn't too long since we are testing not resulting to /*
+					expect(segment.length).toBeLessThanOrEqual(maxRuleLength);
+					const route =
+						segment.repeat((maxRuleLength / segment.length) * 2) + suffix;
+					// Make sure we made the rule too long
+					expect(route.length).toBeGreaterThan(maxRuleLength);
+					const short = shortenRoute(route);
+
+					// Make sure it's not over the limit
+					expect(short.length).toBeLessThanOrEqual(maxRuleLength);
+					// It should never have to fall back to /*
+					expect(short).not.toEqual("/*");
+				}
+			});
+		}
+	});
+});

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

@@ -0,0 +1,73 @@
+import { MAX_FUNCTIONS_ROUTES_RULE_LENGTH } from "../constants";
+
+/**
+ * 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[] {
+	// First we need to trim any rules that are too long and deduplicate the result
+	const routesShortened = Array.from(
+		new Set(routes.map((route) => shortenRoute(route)))
+	);
+
+	// create a map of the routes
+	const routesMap = new Map<string, boolean>();
+	for (const route of routesShortened) {
+		routesMap.set(route, true);
+	}
+	// Find routes that might render other routes redundant
+	for (const route of routesShortened.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());
+}
+
+/**
+ * Shortens a route until it's within the rule length limit defined in
+ * constants.MAX_FUNCTIONS_ROUTES_RULE_LENGTH
+ * Eg. /aaa/bbb -> /aaa/*
+ * @param routeToShorten Route to shorten if needed
+ * @param maxLength Max length of route to try to shorten to
+ */
+export function shortenRoute(
+	routeToShorten: string,
+	maxLength: number = MAX_FUNCTIONS_ROUTES_RULE_LENGTH
+): string {
+	if (routeToShorten.length <= maxLength) {
+		return routeToShorten;
+	}
+
+	let route = routeToShorten;
+	// May have to try multiple times for longer segments
+	for (let i = 0; i < routeToShorten.length; i++) {
+		// Shorten to the first slash within the limit
+		for (let j = maxLength - 1 - i; j > 0; j--) {
+			if (route[j] === "/") {
+				route = route.slice(0, j) + "/*";
+				break;
+			}
+		}
+		if (route.length <= maxLength) {
+			break;
+		}
+	}
+
+	// If we failed to shorten it, fall back to include-all rather than breaking
+	if (route.length > maxLength) {
+		route = "/*";
+	}
+	return route;
+}

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

@@ -0,0 +1,282 @@
+import { toUrlPath } from "../../paths";
+import {
+	MAX_FUNCTIONS_ROUTES_RULES,
+	ROUTES_SPEC_VERSION,
+	ROUTES_SPEC_DESCRIPTION,
+} 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,
+				description: ROUTES_SPEC_DESCRIPTION,
+				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,
+				description: ROUTES_SPEC_DESCRIPTION,
+				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,
+					description: ROUTES_SPEC_DESCRIPTION,
+					exclude: [],
+					include: [
+						"/api/foo/bar",
+						"/foo/bar",
+						"/foo/*",
+						"/api/foo/bar",
+						"/middleware/*",
+					],
+				})
+			).toEqual({
+				version: ROUTES_SPEC_VERSION,
+				description: ROUTES_SPEC_DESCRIPTION,
+				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,
+					description: ROUTES_SPEC_DESCRIPTION,
+					include,
+					exclude: [],
+				})
+			).toEqual({
+				version: ROUTES_SPEC_VERSION,
+				description: ROUTES_SPEC_DESCRIPTION,
+				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,
+					description: ROUTES_SPEC_DESCRIPTION,
+					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);
+			});
+		});
+	});
+});