wrangler 0.0.0-e7cf0caa → 0.0.0-e7fce2523

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

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

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