wrangler 0.0.0-e87ad068 → 0.0.0-e8df68ee

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

@@ -1,115 +0,0 @@
-import { join as pathJoin } from "node:path";
-import { toUrlPath } from "../../paths";
-import {
-	MAX_FUNCTIONS_ROUTES_RULES,
-	ROUTES_SPEC_DESCRIPTION,
-	ROUTES_SPEC_VERSION,
-} from "../constants";
-import { consolidateRoutes } from "./routes-consolidation";
-import type { RouteConfig } from "./routes";
-
-/** Interface for _routes.json */
-export interface RoutesJSONSpec {
-	version: typeof ROUTES_SPEC_VERSION;
-	description?: string;
-	include: string[];
-	exclude: string[];
-}
-
-type RoutesJSONRouteInput = Pick<RouteConfig, "routePath" | "middleware">[];
-
-export function convertRoutesToGlobPatterns(
-	routes: RoutesJSONRouteInput
-): string[] {
-	const convertedRoutes = routes.map(({ routePath, middleware }) => {
-		const globbedRoutePath: string = routePath.replace(/:\w+\*?.*/, "*");
-
-		// Middleware mountings need to end in glob so that they can handle their
-		// own sub-path routes
-		if (
-			typeof middleware === "string" ||
-			(Array.isArray(middleware) && middleware.length > 0)
-		) {
-			if (!globbedRoutePath.endsWith("*")) {
-				return toUrlPath(pathJoin(globbedRoutePath, "*"));
-			}
-		}
-
-		return toUrlPath(globbedRoutePath);
-	});
-
-	return Array.from(new Set(convertedRoutes));
-}
-
-/**
- * Converts Functions routes like /foo/:bar to a Routing object that's used
- * to determine if a request should run in the Functions user-worker.
- * Also consolidates redundant routes such as [/foo/bar, /foo/:bar] -> /foo/*
- *
- * @returns RoutesJSONSpec to be written to _routes.json
- */
-export function convertRoutesToRoutesJSONSpec(
-	routes: RoutesJSONRouteInput
-): RoutesJSONSpec {
-	// The initial routes coming in are sorted most-specific to least-specific.
-	// The order doesn't have any affect on the output of this function, but
-	// it should speed up route consolidation with less-specific routes being first.
-	const reversedRoutes = [...routes].reverse();
-	const include = convertRoutesToGlobPatterns(reversedRoutes);
-	return optimizeRoutesJSONSpec({
-		version: ROUTES_SPEC_VERSION,
-		description: ROUTES_SPEC_DESCRIPTION,
-		include,
-		exclude: [],
-	});
-}
-
-/**
- * Optimizes and returns a new Routes JSON Spec instance performing
- * de-duping, consolidation, truncation, and sorting
- */
-export function optimizeRoutesJSONSpec(spec: RoutesJSONSpec): RoutesJSONSpec {
-	const optimizedSpec = { ...spec };
-
-	let consolidatedRoutes = consolidateRoutes(optimizedSpec.include);
-	if (consolidatedRoutes.length > MAX_FUNCTIONS_ROUTES_RULES) {
-		consolidatedRoutes = ["/*"];
-	}
-	// Sort so that least-specific routes are first
-	consolidatedRoutes.sort((a, b) => compareRoutes(b, a));
-
-	optimizedSpec.include = consolidatedRoutes;
-
-	return optimizedSpec;
-}
-
-/**
- * Simplified routes comparison (copied from the one in filepath-routing.)
- * This version will sort most-specific to least-specific, but the input is simplified
- * routes like /foo/*, /foo, etc
- */
-export function compareRoutes(routeA: string, routeB: string) {
-	function parseRoutePath(routePath: string): string[] {
-		return routePath.slice(1).split("/").filter(Boolean);
-	}
-
-	const segmentsA = parseRoutePath(routeA);
-	const segmentsB = parseRoutePath(routeB);
-
-	// 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("*");
-
-		// sort wildcard segments after non-wildcard segments
-		if (isWildcardA && !isWildcardB) return 1;
-		if (!isWildcardA && isWildcardB) return -1;
-	}
-
-	// all else equal, just sort the paths lexicographically
-	return routeA.localeCompare(routeB);
-}

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;
-}