@cloudflare/pages-shared 0.0.1 → 0.0.4

package/src/metadata-generator/parseRedirects.ts

@@ -0,0 +1,129 @@
+import {
+	MAX_LINE_LENGTH,
+	MAX_DYNAMIC_REDIRECT_RULES,
+	MAX_STATIC_REDIRECT_RULES,
+	PERMITTED_STATUS_CODES,
+	SPLAT_REGEX,
+	PLACEHOLDER_REGEX,
+} from "./constants";
+import { validateUrl } from "./validateURL";
+import type {
+	InvalidRedirectRule,
+	ParsedRedirects,
+	RedirectLine,
+	RedirectRule,
+} from "./types";
+
+export function parseRedirects(input: string): ParsedRedirects {
+	const lines = input.split("\n");
+	const rules: RedirectRule[] = [];
+	const seen_paths = new Set<string>();
+	const invalid: InvalidRedirectRule[] = [];
+
+	let staticRules = 0;
+	let dynamicRules = 0;
+	let canCreateStaticRule = true;
+
+	for (let i = 0; i < lines.length; i++) {
+		const line = lines[i].trim();
+		if (line.length === 0 || line.startsWith("#")) continue;
+
+		if (line.length > MAX_LINE_LENGTH) {
+			invalid.push({
+				message: `Ignoring line ${
+					i + 1
+				} as it exceeds the maximum allowed length of ${MAX_LINE_LENGTH}.`,
+			});
+			continue;
+		}
+
+		const tokens = line.split(/\s+/);
+
+		if (tokens.length < 2 || tokens.length > 3) {
+			invalid.push({
+				line,
+				lineNumber: i + 1,
+				message: `Expected exactly 2 or 3 whitespace-separated tokens. Got ${tokens.length}.`,
+			});
+			continue;
+		}
+
+		const [str_from, str_to, str_status = "302"] = tokens as RedirectLine;
+
+		const fromResult = validateUrl(str_from, true, false, false);
+		if (fromResult[0] === undefined) {
+			invalid.push({
+				line,
+				lineNumber: i + 1,
+				message: fromResult[1],
+			});
+			continue;
+		}
+		const from = fromResult[0];
+
+		if (
+			canCreateStaticRule &&
+			!from.match(SPLAT_REGEX) &&
+			!from.match(PLACEHOLDER_REGEX)
+		) {
+			staticRules += 1;
+
+			if (staticRules > MAX_STATIC_REDIRECT_RULES) {
+				invalid.push({
+					message: `Maximum number of static rules supported is ${MAX_STATIC_REDIRECT_RULES}. Skipping line.`,
+				});
+				continue;
+			}
+		} else {
+			dynamicRules += 1;
+			canCreateStaticRule = false;
+
+			if (dynamicRules > MAX_DYNAMIC_REDIRECT_RULES) {
+				invalid.push({
+					message: `Maximum number of dynamic rules supported is ${MAX_DYNAMIC_REDIRECT_RULES}. Skipping remaining ${
+						lines.length - i
+					} lines of file.`,
+				});
+				break;
+			}
+		}
+
+		const toResult = validateUrl(str_to, false, true, true);
+		if (toResult[0] === undefined) {
+			invalid.push({
+				line,
+				lineNumber: i + 1,
+				message: toResult[1],
+			});
+			continue;
+		}
+		const to = toResult[0];
+
+		const status = Number(str_status);
+		if (isNaN(status) || !PERMITTED_STATUS_CODES.has(status)) {
+			invalid.push({
+				line,
+				lineNumber: i + 1,
+				message: `Valid status codes are 301, 302 (default), 303, 307, or 308. Got ${str_status}.`,
+			});
+			continue;
+		}
+
+		if (seen_paths.has(from)) {
+			invalid.push({
+				line,
+				lineNumber: i + 1,
+				message: `Ignoring duplicate rule for path ${from}.`,
+			});
+			continue;
+		}
+		seen_paths.add(from);
+
+		rules.push({ from, to, status, lineNumber: i + 1 });
+	}
+
+	return {
+		rules,
+		invalid,
+	};
+}

package/src/metadata-generator/types.ts

@@ -0,0 +1,89 @@
+/* REDIRECT PARSING TYPES */
+
+export type RedirectLine = [from: string, to: string, status?: number];
+export type RedirectRule = {
+	from: string;
+	to: string;
+	status: number;
+	lineNumber: number;
+};
+
+export type Headers = Record<string, string>;
+export type HeadersRule = {
+	path: string;
+	headers: Headers;
+	unsetHeaders: string[];
+};
+
+export type InvalidRedirectRule = {
+	line?: string;
+	lineNumber?: number;
+	message: string;
+};
+
+export type InvalidHeadersRule = {
+	line?: string;
+	lineNumber?: number;
+	message: string;
+};
+
+export type ParsedRedirects = {
+	invalid: InvalidRedirectRule[];
+	rules: RedirectRule[];
+};
+
+/** Parsed redirects and input file */
+export type ParsedRedirectsWithFile = {
+	parsedRedirects?: ParsedRedirects;
+	file?: string;
+};
+
+export type ParsedHeaders = {
+	invalid: InvalidHeadersRule[];
+	rules: HeadersRule[];
+};
+
+/** Parsed headers and input file */
+export type ParsedHeadersWithFile = {
+	parsedHeaders?: ParsedHeaders;
+	file?: string;
+};
+
+/* METADATA TYPES*/
+
+export type MetadataRedirectEntry = {
+	status: number;
+	to: string;
+};
+
+export type MetadataRedirects = {
+	[path: string]: MetadataRedirectEntry;
+};
+
+export type MetadataHeaders = {
+	[path: string]: MetadataHeaderEntry;
+};
+
+export type MetadataHeaderEntry = {
+	set?: Record<string, string>;
+	unset?: Array<string>;
+};
+
+export type Metadata = {
+	redirects?: {
+		version: number;
+		staticRules: MetadataRedirects;
+		rules: MetadataRedirects;
+	};
+	headers?: {
+		version: number;
+		rules: MetadataHeaders;
+	};
+	analytics?: {
+		version: number;
+		token: string;
+	};
+	deploymentId?: string;
+};
+
+export type Logger = (message: string) => void;

package/src/metadata-generator/validateURL.ts

@@ -0,0 +1,57 @@
+export const extractPathname = (
+	path = "/",
+	includeSearch: boolean,
+	includeHash: boolean
+): string => {
+	if (!path.startsWith("/")) path = `/${path}`;
+	const url = new URL(`//${path}`, "relative://");
+	return `${url.pathname}${includeSearch ? url.search : ""}${
+		includeHash ? url.hash : ""
+	}`;
+};
+
+const URL_REGEX = /^https:\/\/+(?<host>[^/]+)\/?(?<path>.*)/;
+const PATH_REGEX = /^\//;
+
+export const validateUrl = (
+	token: string,
+	onlyRelative = false,
+	includeSearch = false,
+	includeHash = false
+): [undefined, string] | [string, undefined] => {
+	const host = URL_REGEX.exec(token);
+	if (host && host.groups && host.groups.host) {
+		if (onlyRelative)
+			return [
+				undefined,
+				`Only relative URLs are allowed. Skipping absolute URL ${token}.`,
+			];
+
+		return [
+			`https://${host.groups.host}${extractPathname(
+				host.groups.path,
+				includeSearch,
+				includeHash
+			)}`,
+			undefined,
+		];
+	} else {
+		if (!token.startsWith("/") && onlyRelative) token = `/${token}`;
+
+		const path = PATH_REGEX.exec(token);
+		if (path) {
+			try {
+				return [extractPathname(token, includeSearch, includeHash), undefined];
+			} catch {
+				return [undefined, `Error parsing URL segment ${token}. Skipping.`];
+			}
+		}
+	}
+
+	return [
+		undefined,
+		onlyRelative
+			? "URLs should begin with a forward-slash."
+			: 'URLs should either be relative (e.g. begin with a forward-slash), or use HTTPS (e.g. begin with "https://").',
+	];
+};

package/tsconfig.json

@@ -2,6 +2,6 @@
 	"extends": "../../tsconfig.json",
 	"compilerOptions": {
 		"module": "CommonJS",
-		"types": ["@cloudflare/workers-types", "jest"]
+		"types": ["jest"]
 	}
 }