wrangler 0.0.0-e3ce82b → 0.0.0-e41c7e41

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

@@ -0,0 +1,403 @@
+import { FatalError } from "../../errors";
+import {
+	MAX_FUNCTIONS_ROUTES_RULES,
+	MAX_FUNCTIONS_ROUTES_RULE_LENGTH,
+	ROUTES_SPEC_VERSION,
+} from "../constants";
+import { getRoutesValidationErrorMessage } from "../errors";
+import {
+	isRoutesJSONSpec,
+	RoutesValidationError,
+	validateRoutes,
+} from "./routes-validation";
+import type { RoutesJSONSpec } from "./routes-transformation";
+
+describe("routes-validation", () => {
+	describe("isRoutesJSONSpec", () => {
+		it("should return true if the given routes are in a valid RoutesJSONSpec format", () => {
+			const routes = {
+				version: ROUTES_SPEC_VERSION,
+				description: "Test routes Object",
+				include: [],
+				exclude: [],
+			};
+			const routesWithoutDescription = {
+				version: ROUTES_SPEC_VERSION,
+				include: [],
+				exclude: [],
+			};
+
+			expect(isRoutesJSONSpec(routes)).toBeTruthy();
+			expect(isRoutesJSONSpec(routesWithoutDescription)).toBeTruthy();
+		});
+
+		it("should return false otherwise", () => {
+			const routesWithMissingVersion = {
+				include: [],
+				exclude: [],
+			};
+			const routesWithIncorrectVersionNumber = {
+				version: 1000,
+				include: [],
+				exclude: [],
+			};
+			const routesWithIncorrectVersionType = {
+				version: "1000",
+				include: [],
+				exclude: [],
+			};
+			const routesWithMissingInclude = {
+				version: ROUTES_SPEC_VERSION,
+				exclude: [],
+			};
+			const routesWithMissingExclude = {
+				version: ROUTES_SPEC_VERSION,
+				include: [],
+			};
+			const routesWithIncorrectIncludeType = {
+				version: ROUTES_SPEC_VERSION,
+				include: "[]",
+				exclude: [],
+			};
+			const routesWithIncorrectExcludeType = {
+				version: ROUTES_SPEC_VERSION,
+				include: [],
+				exclude: { route: "/hello" },
+			};
+
+			expect(isRoutesJSONSpec(null)).toBeFalsy();
+			expect(isRoutesJSONSpec({})).toBeFalsy();
+			expect(isRoutesJSONSpec([])).toBeFalsy();
+			expect(isRoutesJSONSpec(routesWithMissingVersion)).toBeFalsy();
+			expect(isRoutesJSONSpec(routesWithIncorrectVersionNumber)).toBeFalsy();
+			expect(isRoutesJSONSpec(routesWithIncorrectVersionType)).toBeFalsy();
+			expect(isRoutesJSONSpec(routesWithMissingInclude)).toBeFalsy();
+			expect(isRoutesJSONSpec(routesWithMissingExclude)).toBeFalsy();
+			expect(isRoutesJSONSpec(routesWithIncorrectIncludeType)).toBeFalsy();
+			expect(isRoutesJSONSpec(routesWithIncorrectExcludeType)).toBeFalsy();
+		});
+	});
+
+	describe("validateRoutes", () => {
+		const testRoutesPath = "/public";
+
+		const generateUniqueRoutingRules = (count: number): string[] => {
+			let counter = 0;
+			return Array(count)
+				.fill("/abc")
+				.map((route) => `${route}${counter++}`);
+		};
+
+		const generateRoutingRule = (charCount: number): string => {
+			return `/${Array(charCount).fill("a").join("")}`;
+		};
+
+		it("should return if the given routes are valid", () => {
+			const routes: RoutesJSONSpec = {
+				version: ROUTES_SPEC_VERSION,
+				description: "Test routes Object",
+				include: ["/*"],
+				exclude: [],
+			};
+			const routesWithoutDescription: RoutesJSONSpec = {
+				version: ROUTES_SPEC_VERSION,
+				include: ["/hello"],
+				exclude: [],
+			};
+
+			expect(() => validateRoutes(routes, testRoutesPath)).not.toThrow();
+			expect(() =>
+				validateRoutes(routesWithoutDescription, testRoutesPath)
+			).not.toThrow();
+		});
+
+		it("should throw a fatal error if the routes are not a valid RoutesJSONSpec object", () => {
+			// eslint-disable-next-line @typescript-eslint/ban-ts-comment
+			// @ts-ignore: sanity check
+			const routesWithoutVersion: RoutesJSONSpec = {
+				include: ["/*"],
+				exclude: [],
+			};
+			// eslint-disable-next-line @typescript-eslint/ban-ts-comment
+			// @ts-ignore: sanity check
+			const routesWithoutInclude: RoutesJSONSpec = {
+				version: ROUTES_SPEC_VERSION,
+				exclude: [],
+			};
+
+			expect(() =>
+				// wrap the code in a function, otherwise the error will not be caught
+				// and the assertion will fail
+				validateRoutes(routesWithoutVersion, testRoutesPath)
+			).toThrow(FatalError);
+			expect(() =>
+				validateRoutes(routesWithoutVersion, testRoutesPath)
+			).toThrow(
+				getRoutesValidationErrorMessage(
+					RoutesValidationError.INVALID_JSON_SPEC,
+					testRoutesPath
+				)
+			);
+
+			expect(() =>
+				validateRoutes(routesWithoutInclude, testRoutesPath)
+			).toThrow(FatalError);
+			expect(() =>
+				validateRoutes(routesWithoutInclude, testRoutesPath)
+			).toThrow(
+				getRoutesValidationErrorMessage(
+					RoutesValidationError.INVALID_JSON_SPEC,
+					testRoutesPath
+				)
+			);
+		});
+
+		it("should throw a fatal error if there are no include routing rules", () => {
+			const routesWithoutIncludeRules: RoutesJSONSpec = {
+				version: ROUTES_SPEC_VERSION,
+				description: "Test routes Object",
+				include: [],
+				exclude: [],
+			};
+
+			expect(() =>
+				validateRoutes(routesWithoutIncludeRules, testRoutesPath)
+			).toThrow(FatalError);
+			expect(() =>
+				validateRoutes(routesWithoutIncludeRules, testRoutesPath)
+			).toThrow(
+				getRoutesValidationErrorMessage(
+					RoutesValidationError.NO_INCLUDE_RULES,
+					testRoutesPath
+				)
+			);
+		});
+
+		it("should throw a fatal error if there are more than MAX_FUNCTIONS_ROUTES_RULES include and exclude routing rules combined", () => {
+			const routesWithMaxIncludeRules: RoutesJSONSpec = {
+				version: ROUTES_SPEC_VERSION,
+				description: "Test routes Object",
+				include: generateUniqueRoutingRules(MAX_FUNCTIONS_ROUTES_RULES + 1),
+				exclude: [],
+			};
+			const routesWithMaxExcludeRules: RoutesJSONSpec = {
+				version: ROUTES_SPEC_VERSION,
+				description: "Test routes Object",
+				include: ["/hello"],
+				exclude: generateUniqueRoutingRules(MAX_FUNCTIONS_ROUTES_RULES + 1),
+			};
+			const routesWithMaxIncludeExcludeRulesCombined: RoutesJSONSpec = {
+				version: ROUTES_SPEC_VERSION,
+				description: "Test routes Object",
+				include: generateUniqueRoutingRules(
+					Math.floor(MAX_FUNCTIONS_ROUTES_RULES / 2) + 1
+				),
+				exclude: generateUniqueRoutingRules(
+					Math.floor(MAX_FUNCTIONS_ROUTES_RULES / 2)
+				),
+			};
+
+			expect(() =>
+				validateRoutes(routesWithMaxIncludeRules, testRoutesPath)
+			).toThrow(FatalError);
+			expect(() =>
+				validateRoutes(routesWithMaxIncludeRules, testRoutesPath)
+			).toThrow(
+				getRoutesValidationErrorMessage(
+					RoutesValidationError.TOO_MANY_RULES,
+					testRoutesPath
+				)
+			);
+
+			expect(() =>
+				validateRoutes(routesWithMaxExcludeRules, testRoutesPath)
+			).toThrow(FatalError);
+			expect(() =>
+				validateRoutes(routesWithMaxExcludeRules, testRoutesPath)
+			).toThrow(
+				getRoutesValidationErrorMessage(
+					RoutesValidationError.TOO_MANY_RULES,
+					testRoutesPath
+				)
+			);
+
+			expect(() =>
+				validateRoutes(routesWithMaxIncludeExcludeRulesCombined, testRoutesPath)
+			).toThrow(FatalError);
+			expect(() =>
+				validateRoutes(routesWithMaxIncludeExcludeRulesCombined, testRoutesPath)
+			).toThrow(
+				getRoutesValidationErrorMessage(
+					RoutesValidationError.TOO_MANY_RULES,
+					testRoutesPath
+				)
+			);
+		});
+
+		it("should throw a fatal error if any include or exclude routing rule is more than MAX_FUNCTIONS_ROUTES_RULE_LENGTH chars long", () => {
+			const routesWithMaxCharLengthIncludeRules: RoutesJSONSpec = {
+				version: ROUTES_SPEC_VERSION,
+				description: "Test routes Object",
+				include: [generateRoutingRule(MAX_FUNCTIONS_ROUTES_RULE_LENGTH + 1)],
+				exclude: [],
+			};
+			const routesWithMaxCharLengthExcludeRules: RoutesJSONSpec = {
+				version: ROUTES_SPEC_VERSION,
+				description: "Test routes Object",
+				include: ["/*"],
+				exclude: [generateRoutingRule(MAX_FUNCTIONS_ROUTES_RULE_LENGTH + 1)],
+			};
+			const routesWithMaxCharLengthRules: RoutesJSONSpec = {
+				version: ROUTES_SPEC_VERSION,
+				description: "Test routes Object",
+				include: [generateRoutingRule(MAX_FUNCTIONS_ROUTES_RULE_LENGTH + 1)],
+				exclude: [generateRoutingRule(MAX_FUNCTIONS_ROUTES_RULE_LENGTH + 1)],
+			};
+
+			expect(() =>
+				validateRoutes(routesWithMaxCharLengthIncludeRules, testRoutesPath)
+			).toThrow(FatalError);
+			expect(() =>
+				validateRoutes(routesWithMaxCharLengthIncludeRules, testRoutesPath)
+			).toThrow(
+				getRoutesValidationErrorMessage(
+					RoutesValidationError.RULE_TOO_LONG,
+					testRoutesPath
+				)
+			);
+
+			expect(() =>
+				validateRoutes(routesWithMaxCharLengthExcludeRules, testRoutesPath)
+			).toThrow(FatalError);
+			expect(() =>
+				validateRoutes(routesWithMaxCharLengthExcludeRules, testRoutesPath)
+			).toThrow(
+				getRoutesValidationErrorMessage(
+					RoutesValidationError.RULE_TOO_LONG,
+					testRoutesPath
+				)
+			);
+
+			expect(() =>
+				validateRoutes(routesWithMaxCharLengthRules, testRoutesPath)
+			).toThrow(FatalError);
+			expect(() =>
+				validateRoutes(routesWithMaxCharLengthRules, testRoutesPath)
+			).toThrow(
+				getRoutesValidationErrorMessage(
+					RoutesValidationError.RULE_TOO_LONG,
+					testRoutesPath
+				)
+			);
+		});
+
+		it("should throw a fatal error if any include or exclude routing rule does not start with a `/`", () => {
+			const routesWithInvalidIncludeRules: RoutesJSONSpec = {
+				version: ROUTES_SPEC_VERSION,
+				description: "Test routes Object",
+				include: ["hello"],
+				exclude: [],
+			};
+			const routesWithInvalidExcludeRules: RoutesJSONSpec = {
+				version: ROUTES_SPEC_VERSION,
+				description: "Test routes Object",
+				include: ["/*"],
+				exclude: ["hello"],
+			};
+			const routesWithInvalidRules: RoutesJSONSpec = {
+				version: ROUTES_SPEC_VERSION,
+				description: "Test routes Object",
+				include: ["hello"],
+				exclude: ["goodbye"],
+			};
+
+			expect(() =>
+				validateRoutes(routesWithInvalidIncludeRules, testRoutesPath)
+			).toThrow(FatalError);
+			expect(() =>
+				validateRoutes(routesWithInvalidIncludeRules, testRoutesPath)
+			).toThrow(
+				getRoutesValidationErrorMessage(
+					RoutesValidationError.INVALID_RULES,
+					testRoutesPath
+				)
+			);
+
+			expect(() =>
+				validateRoutes(routesWithInvalidExcludeRules, testRoutesPath)
+			).toThrow(FatalError);
+			expect(() =>
+				validateRoutes(routesWithInvalidExcludeRules, testRoutesPath)
+			).toThrow(
+				getRoutesValidationErrorMessage(
+					RoutesValidationError.INVALID_RULES,
+					testRoutesPath
+				)
+			);
+
+			expect(() =>
+				validateRoutes(routesWithInvalidRules, testRoutesPath)
+			).toThrow(FatalError);
+			expect(() =>
+				validateRoutes(routesWithInvalidRules, testRoutesPath)
+			).toThrow(
+				getRoutesValidationErrorMessage(
+					RoutesValidationError.INVALID_RULES,
+					testRoutesPath
+				)
+			);
+		});
+
+		it("should throw a fatal error if there are overlapping include rules or overlapping exclude rules", () => {
+			const routesWithOverlappingIncludeRules: RoutesJSONSpec = {
+				version: ROUTES_SPEC_VERSION,
+				include: [
+					"/greeting/hello",
+					"/api/time",
+					"/date",
+					"/greeting/*",
+					"/greeting/goodbye",
+					"/api/*",
+				],
+				exclude: [],
+			};
+			const routesWithOverlappingExcludeRules: RoutesJSONSpec = {
+				version: ROUTES_SPEC_VERSION,
+				include: ["/hello"],
+				exclude: [
+					"/greeting/hello",
+					"/api/time",
+					"/date",
+					"/*",
+					"/greeting/*",
+					"/greeting/goodbye",
+					"/api/*",
+				],
+			};
+
+			expect(() =>
+				validateRoutes(routesWithOverlappingIncludeRules, testRoutesPath)
+			).toThrow(FatalError);
+			expect(() =>
+				validateRoutes(routesWithOverlappingIncludeRules, testRoutesPath)
+			).toThrow(
+				getRoutesValidationErrorMessage(
+					RoutesValidationError.OVERLAPPING_RULES,
+					testRoutesPath
+				)
+			);
+
+			expect(() =>
+				validateRoutes(routesWithOverlappingExcludeRules, testRoutesPath)
+			).toThrow(FatalError);
+			expect(() =>
+				validateRoutes(routesWithOverlappingExcludeRules, testRoutesPath)
+			).toThrow(
+				getRoutesValidationErrorMessage(
+					RoutesValidationError.OVERLAPPING_RULES,
+					testRoutesPath
+				)
+			);
+		});
+	});
+});

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

@@ -0,0 +1,202 @@
+import { FatalError } from "../../errors";
+import {
+	MAX_FUNCTIONS_ROUTES_RULES,
+	MAX_FUNCTIONS_ROUTES_RULE_LENGTH,
+	ROUTES_SPEC_VERSION,
+} from "../constants";
+import { getRoutesValidationErrorMessage } from "../errors";
+import type { RoutesJSONSpec } from "./routes-transformation";
+
+/* eslint-disable-next-line no-shadow */
+export enum RoutesValidationError {
+	INVALID_JSON_SPEC,
+	NO_INCLUDE_RULES,
+	INVALID_RULES,
+	TOO_MANY_RULES,
+	RULE_TOO_LONG,
+	OVERLAPPING_RULES,
+}
+
+/**
+ *  Check if given routes data is a valid RoutesJSONSpec
+ */
+export function isRoutesJSONSpec(data: unknown): data is RoutesJSONSpec {
+	return (
+		(typeof data === "object" &&
+			data &&
+			"version" in data &&
+			typeof (data as RoutesJSONSpec).version === "number" &&
+			(data as RoutesJSONSpec).version === ROUTES_SPEC_VERSION &&
+			Array.isArray((data as RoutesJSONSpec).include) &&
+			Array.isArray((data as RoutesJSONSpec).exclude)) ||
+		false
+	);
+}
+
+export function validateRoutes(routesJSON: RoutesJSONSpec, routesPath: string) {
+	if (!isRoutesJSONSpec(routesJSON)) {
+		throw new FatalError(
+			getRoutesValidationErrorMessage(
+				RoutesValidationError.INVALID_JSON_SPEC,
+				routesPath
+			),
+			1
+		);
+	}
+
+	if (!hasIncludeRules(routesJSON)) {
+		throw new FatalError(
+			getRoutesValidationErrorMessage(
+				RoutesValidationError.NO_INCLUDE_RULES,
+				routesPath
+			),
+			1
+		);
+	}
+
+	if (!hasValidRulesCount(routesJSON)) {
+		throw new FatalError(
+			getRoutesValidationErrorMessage(
+				RoutesValidationError.TOO_MANY_RULES,
+				routesPath
+			),
+			1
+		);
+	}
+
+	if (!hasValidRuleCharCount(routesJSON)) {
+		throw new FatalError(
+			getRoutesValidationErrorMessage(
+				RoutesValidationError.RULE_TOO_LONG,
+				routesPath
+			),
+			1
+		);
+	}
+
+	if (!hasValidRules(routesJSON)) {
+		throw new FatalError(
+			getRoutesValidationErrorMessage(
+				RoutesValidationError.INVALID_RULES,
+				routesPath
+			),
+			1
+		);
+	}
+
+	if (
+		hasOverlappingRules(routesJSON.include) ||
+		hasOverlappingRules(routesJSON.exclude)
+	) {
+		throw new FatalError(
+			getRoutesValidationErrorMessage(
+				RoutesValidationError.OVERLAPPING_RULES,
+				routesPath
+			),
+			1
+		);
+	}
+}
+
+/**
+ * Returns true if the given `routingSpec` object contains at least
+ * `MIN_FUNCTIONS_ROUTES_INCLUDE_RULES` include routing rules
+ */
+function hasIncludeRules(routesJSON: RoutesJSONSpec): boolean {
+	// sanity check
+	// this should never be the case, because of the context from which these validation fns are
+	// called, but let's not assume anything
+	if (!routesJSON || !routesJSON.include) {
+		throw new Error(
+			"Function `hasIncludeRules` was called out of context. Attempting to validate include rules for routes that are undefined or an invalid RoutesJSONSpec"
+		);
+	}
+
+	return routesJSON?.include?.length > 0;
+}
+
+/**
+ * Returns true if the given `routesJSON` object contains at most MAX_FUNCTIONS_ROUTES_RULES
+ * include and exclude routing rules, combined
+ */
+function hasValidRulesCount(routesJSON: RoutesJSONSpec): boolean {
+	// sanity check
+	if (!routesJSON || !routesJSON.include || !routesJSON.exclude) {
+		throw new Error(
+			"Function `hasValidRulesCount` was called out of context. Attempting to validate maximum rules count for routes that are undefined or an invalid RoutesJSONSpec"
+		);
+	}
+
+	return (
+		routesJSON.include.length + routesJSON.exclude.length <=
+		MAX_FUNCTIONS_ROUTES_RULES
+	);
+}
+
+/**
+ * Returns true if each individual routing rule of the given `routesJSON` object is at most
+ * MAX_FUNCTIONS_ROUTES_RULE_LENGTH characters long
+ */
+function hasValidRuleCharCount(routesJSON: RoutesJSONSpec): boolean {
+	// sanity check
+	if (!routesJSON || !routesJSON.include || !routesJSON.exclude) {
+		throw new Error(
+			"Function `hasValidRuleCharCount` was called out of context. Attempting to validate rules maximum character count for routes that are undefined or an invalid RoutesJSONSpec"
+		);
+	}
+
+	const rules = [...routesJSON.include, ...routesJSON.exclude];
+	return (
+		rules.filter((rule) => rule.length > MAX_FUNCTIONS_ROUTES_RULE_LENGTH)
+			.length === 0
+	);
+}
+
+/**
+ * Returns true if each individual routing rule of the given `routesJSON` object is valid.
+ * We consider a rule to be valid if it is prefixed by slash ('/')
+ */
+function hasValidRules(routesJSON: RoutesJSONSpec): boolean {
+	// sanity check
+	if (!routesJSON || !routesJSON.include || !routesJSON.exclude) {
+		throw new Error(
+			"Function `hasValidRules` was called out of context. Attempting to validate rules for routes that are undefined or an invalid RoutesJSONSpec"
+		);
+	}
+
+	const rules = [...routesJSON.include, ...routesJSON.exclude];
+	return rules.filter((rule) => !rule.match(/^\//)).length === 0;
+}
+
+/**
+ * Returns true if the given routes array has overlapping routing rules (eg. ["/api/*"", "/api/foo"])
+ *
+ * based on `consolidateRoutes()`
+ * 🚨 O(n2) time complexity 🚨
+ */
+function hasOverlappingRules(routes: string[]): boolean {
+	if (!routes) {
+		throw new Error(
+			"Function `hasverlappingRules` was called out of context. Attempting to validate rules for routes that are undefined"
+		);
+	}
+
+	// Find routes that might render other routes redundant
+	const endingSplatRoutes = routes.filter((route) => route.endsWith("/*"));
+
+	for (let i = 0; i < endingSplatRoutes.length; i++) {
+		const crrRoute = endingSplatRoutes[i];
+		// Remove splat at the end, leaving the /
+		// eg. /api/* -> /api/
+		const crrRouteTrimmed = crrRoute.substring(0, crrRoute.length - 1);
+
+		for (let j = 0; j < routes.length; j++) {
+			const nextRoute = routes[j];
+			if (nextRoute !== crrRoute && nextRoute.startsWith(crrRouteTrimmed)) {
+				return true;
+			}
+		}
+	}
+
+	return false;
+}