bsmnt 0.13.1 → 0.15.0

package/src/modules/features/cms/sanity-pagebuilder-cache/files/lib/integrations/sanity/redirect-import.ts

@@ -0,0 +1,651 @@
+import type { SanityClient } from "sanity";
+import { parseCsvRecords } from "./csv";
+import {
+	REDIRECT_PATH_PATTERN,
+	REDIRECT_SOURCE_MAX_LENGTH,
+} from "./schemas/layout/redirect";
+
+export const MAX_FILE_BYTES = 5 * 1024 * 1024;
+const MAX_ROWS = 5000;
+const IMPORT_BATCH_SIZE = 100;
+
+const PLACEHOLDER_ORIGIN = "https://redirect.invalid";
+const REPLACEMENT_CHARACTER = String.fromCharCode(0xfffd);
+const SCHEME = /^[a-z][a-z\d+.-]*:/i;
+const ABSOLUTE_URL = /^https?:\/\//i;
+
+export const REDIRECT_CSV_TEMPLATE = `source,destination,type
+old-page,new-page,permanent
+/blog/old-post,/blog/new-post,308
+/retired-section,/,permanent
+spring-promo,https://example.com/campaign,temporary
+`;
+
+const HEADERS = {
+	source: [
+		"source",
+		"from",
+		"old",
+		"old url",
+		"old path",
+		"source url",
+		"source path",
+		"redirect from",
+		"url",
+	],
+	destination: [
+		"destination",
+		"to",
+		"target",
+		"new",
+		"new url",
+		"new path",
+		"destination url",
+		"target url",
+		"redirect to",
+	],
+	type: ["type", "status", "code", "status code", "redirect type"],
+};
+
+const PERMANENT: Record<string, boolean> = {
+	"": true,
+	permanent: true,
+	"301": true,
+	"308": true,
+	temporary: false,
+	"302": false,
+	"303": false,
+	"307": false,
+};
+
+interface CsvRedirectRow {
+	line: number;
+	source: string;
+	destination: string;
+	type: string;
+}
+
+type ReadRedirectCsvResult =
+	| { rows: CsvRedirectRow[]; notes: string[] }
+	| { error: string };
+
+const headerKey = (value: string) =>
+	value
+		.trim()
+		.toLowerCase()
+		.replace(/[^a-z0-9]+/g, " ")
+		.trim();
+
+const looksLikeUrl = (value: string) => /^(\/|https?:\/\/)/i.test(value.trim());
+
+export const readRedirectCsv = (text: string): ReadRedirectCsvResult => {
+	if (text.startsWith("PK") || text.includes("\u0000")) {
+		return {
+			error:
+				"This looks like a spreadsheet file rather than CSV. Export it as CSV (UTF-8) and try again.",
+		};
+	}
+
+	let records: string[][];
+	try {
+		records = parseCsvRecords(text);
+	} catch (error) {
+		return { error: error instanceof Error ? error.message : String(error) };
+	}
+	const firstIndex = records.findIndex((record) =>
+		record.some((value) => value.trim()),
+	);
+	const first = records[firstIndex];
+	if (!first) return { error: "The file is empty." };
+
+	const keys = first.map(headerKey);
+	const column = (names: string[]) =>
+		keys.findIndex((key) => names.includes(key));
+	let columns = {
+		source: column(HEADERS.source),
+		destination: column(HEADERS.destination),
+		type: column(HEADERS.type),
+	};
+	let bodyStart = firstIndex + 1;
+	const notes: string[] = [];
+
+	if (columns.source < 0 || columns.destination < 0) {
+		if (!(looksLikeUrl(first[0] ?? "") && first.length >= 2)) {
+			return {
+				error: `Couldn't find the source and destination columns. The first row reads: ${first.join(", ")}.`,
+			};
+		}
+		columns = { source: 0, destination: 1, type: 2 };
+		bodyStart = firstIndex;
+		notes.push(
+			"There's no header row, so the columns are read as source, destination, type.",
+		);
+	}
+
+	const cell = (record: string[], index: number) =>
+		index < 0 ? "" : (record[index]?.trim() ?? "");
+	const rows = records.flatMap((record, index) =>
+		index >= bodyStart && record.some((value) => value.trim())
+			? [
+					{
+						line: index + 1,
+						source: cell(record, columns.source),
+						destination: cell(record, columns.destination),
+						type: cell(record, columns.type),
+					},
+				]
+			: [],
+	);
+
+	if (rows.length === 0) return { error: "The file has no redirects in it." };
+	if (rows.length > MAX_ROWS) {
+		return {
+			error: `The file has ${rows.length} redirects; split it into files of ${MAX_ROWS} or fewer.`,
+		};
+	}
+	return { rows, notes };
+};
+
+const isAbsoluteUrl = (value: string) => ABSOLUTE_URL.test(value);
+
+// Redirect sources and internal destinations are stored without slashes at either end.
+export const normalizePath = (path: string) =>
+	path.replace(/\/{2,}/g, "/").replace(/^\/+|\/+$/g, "");
+
+export const describePath = (value: string) =>
+	isAbsoluteUrl(value) ? value : `/${normalizePath(value)}`;
+
+const destinationKey = (destination: string) =>
+	isAbsoluteUrl(destination) ? destination : normalizePath(destination);
+
+// Answered by their own routes; the catch-all that checks redirects never sees them.
+const isReservedPath = (path: string) => {
+	const [first] = path.split("/");
+	return first === "studio" || first === "api" || path === "components";
+};
+
+type Parsed = { value: string; notes: string[] } | { error: string };
+
+const parsePath = (
+	raw: string,
+	role: "source" | "destination",
+	siteHosts: readonly string[],
+): Parsed | { external: string } => {
+	if (raw.includes(REPLACEMENT_CHARACTER)) {
+		return {
+			error:
+				"has characters that didn't survive the file's encoding. Save the file as CSV (UTF-8)",
+		};
+	}
+	const absolute = raw.startsWith("//") || isAbsoluteUrl(raw);
+	if (!absolute && SCHEME.test(raw)) {
+		return { error: `"${raw}" isn't a path or a web address` };
+	}
+
+	let url: URL;
+	try {
+		url = new URL(
+			raw.startsWith("//") ? `https:${raw}` : raw,
+			`${PLACEHOLDER_ORIGIN}/`,
+		);
+	} catch {
+		return { error: `"${raw}" isn't a valid address` };
+	}
+	if (absolute && !siteHosts.includes(url.host)) {
+		return role === "source"
+			? { error: `is on ${url.host}, not this site` }
+			: { external: url.href };
+	}
+	if (url.search) {
+		return {
+			error:
+				role === "source"
+					? `has a query string (${url.search}), which redirects can't match`
+					: `has a query string (${url.search}), which only a full URL to another site can keep`,
+		};
+	}
+
+	const notes: string[] = [];
+	if (url.hash) {
+		notes.push(
+			role === "source"
+				? `Dropped ${url.hash} from the source: browsers never send the anchor.`
+				: `Dropped ${url.hash} from the destination: a path can't carry an anchor.`,
+		);
+	}
+	const path = normalizePath(url.pathname);
+	if (path && !REDIRECT_PATH_PATTERN.test(path)) {
+		return {
+			error: `/${path} can only use lowercase letters, numbers, hyphens and slashes`,
+		};
+	}
+	return { value: path, notes };
+};
+
+const parseSource = (raw: string, siteHosts: readonly string[]): Parsed => {
+	const parsed = parsePath(raw, "source", siteHosts);
+	if ("external" in parsed) return { error: "isn't on this site" };
+	if ("error" in parsed) return parsed;
+	if (!parsed.value) return { error: "is the homepage, which can't redirect" };
+	if (isReservedPath(parsed.value)) {
+		return {
+			error: `/${parsed.value} is answered before redirects run, so it can't redirect`,
+		};
+	}
+	if (parsed.value.length > REDIRECT_SOURCE_MAX_LENGTH) {
+		return { error: `is longer than ${REDIRECT_SOURCE_MAX_LENGTH} characters` };
+	}
+	return parsed;
+};
+
+const parseDestination = (
+	raw: string,
+	siteHosts: readonly string[],
+): Parsed => {
+	const parsed = parsePath(raw, "destination", siteHosts);
+	if ("external" in parsed) return { value: parsed.external, notes: [] };
+	if ("error" in parsed) return parsed;
+	return { value: parsed.value || "/", notes: parsed.notes };
+};
+
+export interface ExistingRedirect {
+	_id: string;
+	_rev: string;
+	source: string | null;
+	destination: string | null;
+	permanent: boolean | null;
+}
+
+interface PlannedRedirect {
+	_id: string;
+	source: string;
+	destination: string;
+	permanent: boolean;
+}
+
+export type RowStatus =
+	| "create"
+	| "update"
+	| "unchanged"
+	| "duplicate"
+	| "skipped"
+	| "error";
+
+export interface PlannedRow extends CsvRedirectRow {
+	status: RowStatus;
+	problem?: string;
+	notes: string[];
+	redirect?: PlannedRedirect;
+	previous?: { destination: string; permanent: boolean };
+	revision?: string;
+}
+
+interface PlanContext {
+	existing: readonly ExistingRedirect[];
+	/** Normalized paths of published pages; the homepage is "". */
+	routes: ReadonlySet<string>;
+	siteHosts: readonly string[];
+}
+
+const baseId = (id: string) => id.replace(/^(drafts|versions\.[^.]+)\./, "");
+
+// cyrb53, since the Studio has no node:crypto; a re-run derives the same id.
+const hash = (value: string) => {
+	let h1 = 0xdeadbeef;
+	let h2 = 0x41c6ce57;
+	for (let index = 0; index < value.length; index++) {
+		const code = value.charCodeAt(index);
+		h1 = Math.imul(h1 ^ code, 2654435761);
+		h2 = Math.imul(h2 ^ code, 1597334677);
+	}
+	h1 = Math.imul(h1 ^ (h1 >>> 16), 2246822507);
+	h1 ^= Math.imul(h2 ^ (h2 >>> 13), 3266489909);
+	h2 = Math.imul(h2 ^ (h2 >>> 16), 2246822507);
+	h2 ^= Math.imul(h1 ^ (h1 >>> 13), 3266489909);
+	return (4294967296 * (2097151 & h2) + (h1 >>> 0)).toString(36);
+};
+
+const fail = (row: PlannedRow, problem: string) => {
+	row.status = "error";
+	row.problem = problem;
+	delete row.redirect;
+};
+
+const isWrite = (
+	row: PlannedRow,
+): row is PlannedRow & { redirect: PlannedRedirect } =>
+	row.redirect !== undefined &&
+	(row.status === "create" || row.status === "update");
+
+/**
+ * Where a visitor to `source` ends up, or null for a loop. The catch-all only
+ * checks redirects when no page matches, so a chain stops at the first page.
+ */
+const finalDestination = (
+	rules: ReadonlyMap<string, string>,
+	routes: ReadonlySet<string>,
+	source: string,
+) => {
+	const seen = new Set([source]);
+	let destination = rules.get(source) ?? "";
+	for (;;) {
+		if (isAbsoluteUrl(destination)) return destination;
+		const path = normalizePath(destination);
+		if (routes.has(path)) return path;
+		const next = rules.get(path);
+		if (next === undefined) return path;
+		if (seen.has(path)) return null;
+		seen.add(path);
+		destination = next;
+	}
+};
+
+export const planRedirectImport = (
+	csvRows: readonly CsvRedirectRow[],
+	{ existing, routes, siteHosts }: PlanContext,
+): PlannedRow[] => {
+	const rows: PlannedRow[] = csvRows.map((row) => {
+		const planned: PlannedRow = { ...row, status: "create", notes: [] };
+		if (!row.source) {
+			fail(planned, "No source.");
+			return planned;
+		}
+		const source = parseSource(row.source, siteHosts);
+		if ("error" in source) {
+			fail(planned, `The source ${source.error}.`);
+			return planned;
+		}
+		planned.notes.push(...source.notes);
+
+		if (!row.destination) {
+			planned.status = "skipped";
+			planned.problem = "No destination yet.";
+			return planned;
+		}
+		const permanent = PERMANENT[row.type.toLowerCase()];
+		if (permanent === undefined) {
+			fail(
+				planned,
+				`Unknown type "${row.type}". Use permanent (308) or temporary (307).`,
+			);
+			return planned;
+		}
+		const destination = parseDestination(row.destination, siteHosts);
+		if ("error" in destination) {
+			fail(planned, `The destination ${destination.error}.`);
+			return planned;
+		}
+		planned.notes.push(...destination.notes);
+
+		if (destinationKey(destination.value) === source.value) {
+			fail(planned, "The destination is the source itself.");
+			return planned;
+		}
+
+		planned.redirect = {
+			_id: "",
+			source: source.value,
+			destination: destination.value,
+			permanent,
+		};
+		return planned;
+	});
+
+	const bySource = new Map<string, PlannedRow[]>();
+	for (const row of rows) {
+		if (!row.redirect) continue;
+		const group = bySource.get(row.redirect.source) ?? [];
+		group.push(row);
+		bySource.set(row.redirect.source, group);
+	}
+	for (const [source, group] of bySource) {
+		const [first, ...rest] = group;
+		if (!first?.redirect || rest.length === 0) continue;
+		const { destination, permanent } = first.redirect;
+		const agrees = rest.every(
+			(row) =>
+				row.redirect &&
+				destinationKey(row.redirect.destination) ===
+					destinationKey(destination) &&
+				row.redirect.permanent === permanent,
+		);
+		if (agrees) {
+			for (const row of rest) {
+				row.status = "duplicate";
+				row.problem = `Same as row ${first.line}.`;
+				delete row.redirect;
+			}
+			continue;
+		}
+		const lines = group.map((row) => row.line).join(", ");
+		for (const row of group) {
+			fail(row, `Rows ${lines} send /${source} to different places.`);
+		}
+	}
+
+	const published = existing.filter(({ _id }) => baseId(_id) === _id);
+	const publishedIds = new Set(published.map(({ _id }) => _id));
+	const pendingIds = new Set(
+		existing
+			.filter(({ _id }) => baseId(_id) !== _id)
+			.map(({ _id }) => baseId(_id)),
+	);
+	const takenIds = new Set(existing.map(({ _id }) => baseId(_id)));
+	const publishedBySource = new Map<string, ExistingRedirect[]>();
+	const unpublishedSources = new Set<string>();
+	for (const redirect of existing) {
+		const key = normalizePath(redirect.source ?? "");
+		if (publishedIds.has(redirect._id)) {
+			publishedBySource.set(key, [
+				...(publishedBySource.get(key) ?? []),
+				redirect,
+			]);
+		} else {
+			// Includes drafts of published redirects, whose source may have changed.
+			unpublishedSources.add(key);
+		}
+	}
+
+	for (const row of rows) {
+		const redirect = row.redirect;
+		if (!redirect) continue;
+		const [current, ...others] = publishedBySource.get(redirect.source) ?? [];
+
+		if (!current) {
+			if (unpublishedSources.has(redirect.source)) {
+				fail(
+					row,
+					`An unpublished redirect in the Studio already uses /${redirect.source}. Publish or discard it, then import again.`,
+				);
+				continue;
+			}
+			let id = `redirect-${hash(redirect.source)}`;
+			for (let suffix = 2; takenIds.has(id); suffix++) {
+				id = `redirect-${hash(redirect.source)}-${suffix}`;
+			}
+			takenIds.add(id);
+			redirect._id = id;
+			continue;
+		}
+
+		if (pendingIds.has(current._id)) {
+			fail(
+				row,
+				`/${redirect.source} has unpublished changes in the Studio. Publish or discard them, then import again.`,
+			);
+			continue;
+		}
+		// The site follows whichever one it reads first, so an update can't be trusted to win.
+		if (others.length > 0) {
+			fail(
+				row,
+				`${others.length + 1} published redirects already use /${redirect.source}. Delete all but one, then import again.`,
+			);
+			continue;
+		}
+		redirect._id = current._id;
+		row.revision = current._rev;
+		const previous = {
+			destination: current.destination ?? "",
+			permanent: current.permanent !== false,
+		};
+		if (
+			destinationKey(previous.destination) ===
+				destinationKey(redirect.destination) &&
+			previous.permanent === redirect.permanent
+		) {
+			row.status = "unchanged";
+			continue;
+		}
+		row.status = "update";
+		row.previous = previous;
+	}
+
+	const compile = () => {
+		const writes = rows.filter(isWrite);
+		const replaced = new Set(writes.map(({ redirect }) => redirect._id));
+		const rules = new Map<string, string>();
+		for (const { _id, source, destination } of published) {
+			if (!replaced.has(_id) && source && destination) {
+				rules.set(normalizePath(source), destination);
+			}
+		}
+		for (const { redirect } of writes) {
+			rules.set(redirect.source, redirect.destination);
+		}
+		return { writes, rules };
+	};
+
+	for (let changed = true; changed; ) {
+		changed = false;
+		const { writes, rules } = compile();
+		for (const row of writes) {
+			if (finalDestination(rules, routes, row.redirect.source) === null) {
+				fail(row, "This would send visitors round in a redirect loop.");
+				changed = true;
+			}
+		}
+	}
+
+	const { writes, rules } = compile();
+	for (const row of writes) {
+		const { source, destination } = row.redirect;
+		if (routes.has(source)) {
+			row.notes.push(
+				`A published page lives at /${source}, so the redirect only takes effect once that page is unpublished.`,
+			);
+		}
+		const final = finalDestination(rules, routes, source);
+		if (final === null || isAbsoluteUrl(final)) continue;
+		if (final !== destinationKey(destination)) {
+			row.notes.push(
+				`${describePath(destination)} redirects again, so visitors end up at ${describePath(final)}.`,
+			);
+		}
+		if (!routes.has(final) && !isReservedPath(final)) {
+			row.notes.push(`Nothing is published at ${describePath(final)} yet.`);
+		}
+	}
+
+	return rows;
+};
+
+export const rowsToWrite = (rows: readonly PlannedRow[]) =>
+	rows.filter(isWrite);
+
+export class RedirectImportError extends Error {
+	constructor(
+		message: string,
+		readonly written: ReadonlySet<PlannedRow>,
+	) {
+		super(message);
+	}
+}
+
+/**
+ * Updates go first, in one transaction: only an update can break an existing
+ * chain, so every state the site passes through is a subset of the loop-free
+ * plan, even if a later batch fails. Creates follow in batches.
+ */
+export const commitRedirectImport = async (
+	client: SanityClient,
+	rows: readonly PlannedRow[],
+	onProgress: (written: number) => void,
+) => {
+	const writes = rowsToWrite(rows);
+	const updates = writes.filter((row) => row.status === "update");
+	const creates = writes.filter((row) => row.status === "create");
+	const batches = updates.length > 0 ? [updates] : [];
+	for (let index = 0; index < creates.length; index += IMPORT_BATCH_SIZE) {
+		batches.push(creates.slice(index, index + IMPORT_BATCH_SIZE));
+	}
+
+	const written = new Set<PlannedRow>();
+	for (const batch of batches) {
+		const transaction = client.transaction();
+		for (const row of batch) {
+			const { _id, source, destination, permanent } = row.redirect;
+			if (row.status === "create") {
+				transaction.create({
+					_id,
+					_type: "redirect",
+					source: { _type: "slug", current: source },
+					destination,
+					permanent,
+				});
+			} else {
+				transaction.patch(_id, (patch) =>
+					(row.revision ? patch.ifRevisionId(row.revision) : patch).set({
+						destination,
+						permanent,
+					}),
+				);
+			}
+		}
+
+		try {
+			await transaction.commit();
+		} catch (error) {
+			throw new RedirectImportError(
+				error instanceof Error ? error.message : String(error),
+				written,
+			);
+		}
+		for (const row of batch) written.add(row);
+		onProgress(written.size);
+	}
+
+	return written;
+};
+
+const RESULT_LABELS: Record<RowStatus, string> = {
+	create: "New",
+	update: "Changed",
+	unchanged: "Unchanged",
+	duplicate: "Duplicate",
+	skipped: "Skipped",
+	error: "Error",
+};
+
+export const statusLabel = (status: RowStatus) => RESULT_LABELS[status];
+
+const resultOf = (row: PlannedRow, written: ReadonlySet<PlannedRow>) => {
+	if (row.status !== "create" && row.status !== "update") {
+		return RESULT_LABELS[row.status];
+	}
+	if (!written.has(row)) return "Not written";
+	return row.status === "create" ? "Created" : "Updated";
+};
+
+export const importReportRows = (
+	rows: readonly PlannedRow[],
+	written: ReadonlySet<PlannedRow>,
+) =>
+	rows.map((row) => ({
+		row: row.line,
+		source: row.source,
+		destination: row.destination,
+		type: row.type,
+		result: resultOf(row, written),
+		details: [row.problem, ...row.notes].filter(Boolean).join(" "),
+	}));

package/src/modules/features/cms/sanity-pagebuilder-cache/files/lib/integrations/sanity/sanity.config.ts

@@ -2,12 +2,12 @@ import { table } from "@sanity/table";
 import { defineConfig } from "sanity";
 import { structureTool } from "sanity/structure";
 import { media } from "sanity-plugin-media";
+import { StudioLayout } from "./components/redirect-import-dialog";
 import { createConfirmPublishAction } from "./confirm-publish-action";
 import { dataset, projectId } from "./env";
 import { PINNED_PAGE_ENTRIES, PINNED_PAGE_IDS } from "./pinned-pages";
 import { presentation } from "./presentation";
 import { schema } from "./schemas";
-import { singletonComponentTypes } from "./singletons";
 import { structure } from "./structure";
 
 const isProd = process.env.NODE_ENV === "production";
@@ -19,10 +19,9 @@ const singletonDocumentActions = new Set([
 ]);
 
 const isSingletonDocument = (schemaType: string, documentId?: string) =>
-	singletonComponentTypes.has(schemaType) ||
-	(schemaType === "page" &&
-		documentId !== undefined &&
-		PINNED_PAGE_IDS.has(documentId));
+	schemaType === "page" &&
+	documentId !== undefined &&
+	PINNED_PAGE_IDS.has(documentId);
 
 export default defineConfig({
 	basePath: "/studio",
@@ -107,10 +106,9 @@ export default defineConfig({
 		},
 		newDocumentOptions: (previousOptions) =>
 			previousOptions.filter(
-				(option) =>
-					!singletonComponentTypes.has(option.templateId) &&
-					!PINNED_PAGE_IDS.has(option.templateId),
+				(option) => !PINNED_PAGE_IDS.has(option.templateId),
 			),
 	},
+	studio: { components: { layout: StudioLayout } },
 	plugins: [structureTool({ structure }), presentation, media(), table()],
 });

package/src/modules/features/cms/sanity-pagebuilder-cache/files/lib/integrations/sanity/schemas/components/index.ts

@@ -4,4 +4,3 @@ export { gatedContent } from "./reusable/gated-content";
 export { hero } from "./reusable/hero";
 export { richTextBlock } from "./reusable/rich-text-block";
 export { blogCollection } from "./singleton/content-collection";
-export { studioPreview } from "./studio-preview";