bsmnt 0.10.0 → 0.12.0

package/src/modules/features/cms/sanity-pagebuilder-cache/files/lib/integrations/sanity/utils/page-json-ld.ts

@@ -0,0 +1,208 @@
+import { stegaClean } from "@sanity/client/stega";
+import type { Thing, WithContext } from "schema-dts";
+import {
+	type FaqJsonLdItem,
+	generateEventJsonLd,
+	generateFaqJsonLd,
+	generateItemListJsonLd,
+	generateJobPostingJsonLd,
+	generateSoftwareApplicationJsonLd,
+	generateVideoJsonLd,
+	type ItemListEntry,
+} from "@/lib/utils/json-ld";
+import { urlForImage } from "./image";
+
+/**
+ * Turns `metadata.jsonLd` blocks from Sanity into renderable JSON-LD —
+ * stega-cleaned, with image refs resolved to absolute CDN URLs.
+ */
+
+type SanityImageRef = Parameters<typeof urlForImage>[0];
+
+type JsonLdBlock = {
+	_type?: string;
+	_key?: string;
+	[key: string]: unknown;
+};
+
+const clean = (value: unknown): string | undefined => {
+	const cleaned = stegaClean(value);
+	return typeof cleaned === "string" && cleaned.trim() !== ""
+		? cleaned
+		: undefined;
+};
+
+const resolveImage = (value: unknown): string | undefined => {
+	if (!value || typeof value !== "object") return undefined;
+	try {
+		return urlForImage(value as SanityImageRef).url();
+	} catch {
+		return undefined;
+	}
+};
+
+const buildFaq = (block: JsonLdBlock): WithContext<Thing> | null => {
+	const questions = Array.isArray(block.questions) ? block.questions : [];
+	const items = questions
+		.map((entry): FaqJsonLdItem | null => {
+			const question = clean((entry as JsonLdBlock)?.question);
+			const answer = clean((entry as JsonLdBlock)?.answer);
+			return question && answer ? { question, answer } : null;
+		})
+		.filter((item): item is FaqJsonLdItem => item !== null);
+	return items.length ? generateFaqJsonLd(items) : null;
+};
+
+const buildJobPosting = (block: JsonLdBlock): WithContext<Thing> | null => {
+	const title = clean(block.title);
+	const description = clean(block.description);
+	const datePosted = clean(block.datePosted);
+	if (!title || !description || !datePosted) return null;
+	return generateJobPostingJsonLd({
+		title,
+		description,
+		datePosted,
+		validThrough: clean(block.validThrough),
+		employmentType: clean(block.employmentType),
+		organizationName: clean(block.organizationName),
+		organizationUrl: clean(block.organizationUrl),
+		remote: block.remote === true,
+		locality: clean(block.locality),
+		region: clean(block.region),
+		country: clean(block.country),
+	});
+};
+
+const buildSoftwareApplication = (
+	block: JsonLdBlock,
+): WithContext<Thing> | null => {
+	const name = clean(block.name);
+	if (!name) return null;
+	const priceValue = stegaClean(block.price);
+	const price =
+		typeof priceValue === "number" && Number.isFinite(priceValue)
+			? priceValue
+			: undefined;
+	return generateSoftwareApplicationJsonLd({
+		name,
+		description: clean(block.description),
+		applicationCategory: clean(block.applicationCategory),
+		operatingSystem: clean(block.operatingSystem),
+		price,
+		currency: clean(block.currency),
+		url: clean(block.url),
+		image: resolveImage(block.image),
+	});
+};
+
+const buildItemList = (block: JsonLdBlock): WithContext<Thing> | null => {
+	const rawItems = Array.isArray(block.items) ? block.items : [];
+	const items = rawItems
+		.map((entry): ItemListEntry | null => {
+			const name = clean((entry as JsonLdBlock)?.name);
+			if (!name) return null;
+			return { name, url: clean((entry as JsonLdBlock)?.url) };
+		})
+		.filter((item): item is ItemListEntry => item !== null);
+	if (!items.length) return null;
+	return generateItemListJsonLd({ name: clean(block.name), items });
+};
+
+const buildEvent = (block: JsonLdBlock): WithContext<Thing> | null => {
+	const name = clean(block.name);
+	const startDate = clean(block.startDate);
+	if (!name || !startDate) return null;
+	return generateEventJsonLd({
+		name,
+		startDate,
+		endDate: clean(block.endDate),
+		description: clean(block.description),
+		locationName: clean(block.locationName),
+		locationAddress: clean(block.locationAddress),
+		url: clean(block.url),
+		image: resolveImage(block.image),
+	});
+};
+
+const buildVideo = (block: JsonLdBlock): WithContext<Thing> | null => {
+	const name = clean(block.name);
+	const description = clean(block.description);
+	const uploadDate = clean(block.uploadDate);
+	const thumbnail = resolveImage(block.thumbnail);
+	if (!name || !description || !uploadDate || !thumbnail) return null;
+	return generateVideoJsonLd({
+		name,
+		description,
+		thumbnail,
+		uploadDate,
+		contentUrl: clean(block.contentUrl),
+		embedUrl: clean(block.embedUrl),
+	});
+};
+
+const buildCustom = (block: JsonLdBlock): WithContext<Thing> | null => {
+	const raw = clean(block.json);
+	if (!raw) return null;
+	try {
+		const parsed = JSON.parse(raw);
+		// Skip structurally-incomplete blocks: schema.org requires an @type.
+		if (
+			typeof parsed !== "object" ||
+			parsed === null ||
+			Array.isArray(parsed) ||
+			!("@type" in parsed)
+		) {
+			return null;
+		}
+		// Default @context so editors can omit the boilerplate (an explicit
+		// @context in the pasted object always wins).
+		return {
+			"@context": "https://schema.org",
+			...parsed,
+		} as WithContext<Thing>;
+	} catch {
+		return null;
+	}
+};
+
+export type PageJsonLd = { key: string; data: WithContext<Thing> };
+
+export function buildPageJsonLd(blocks: unknown): PageJsonLd[] {
+	if (!Array.isArray(blocks)) return [];
+
+	return blocks
+		.map((entry, index): PageJsonLd | null => {
+			const block = entry as JsonLdBlock;
+			let data: WithContext<Thing> | null;
+			switch (block._type) {
+				case "faqJsonLd":
+					data = buildFaq(block);
+					break;
+				case "eventJsonLd":
+					data = buildEvent(block);
+					break;
+				case "videoJsonLd":
+					data = buildVideo(block);
+					break;
+				case "jobPostingJsonLd":
+					data = buildJobPosting(block);
+					break;
+				case "softwareApplicationJsonLd":
+					data = buildSoftwareApplication(block);
+					break;
+				case "itemListJsonLd":
+					data = buildItemList(block);
+					break;
+				case "customJsonLd":
+					data = buildCustom(block);
+					break;
+				default:
+					data = null;
+			}
+			if (!data) return null;
+			const key =
+				typeof block._key === "string" ? block._key : `jsonld-${index}`;
+			return { key, data };
+		})
+		.filter((item): item is PageJsonLd => item !== null);
+}

package/src/modules/features/cms/sanity-pagebuilder-cache/files/lib/scripts/sanity-typegen.ts

@@ -0,0 +1,36 @@
+/**
+ * Wrapper around `sanity schema extract && sanity typegen generate`; skips when
+ * Sanity isn't configured. Reads the project id from `process.env` — the
+ * dotenvx-wrapped script already decrypted `.env` into it — so it runs on Vercel
+ * too, which has no `.env.local`.
+ */
+import { execSync } from "node:child_process";
+import { resolve } from "node:path";
+
+const sanityDir = resolve(import.meta.dir, "../integrations/sanity");
+
+if (!process.env.NEXT_PUBLIC_SANITY_PROJECT_ID) {
+	console.info(
+		"  Skipping sanity:typegen — NEXT_PUBLIC_SANITY_PROJECT_ID not set",
+	);
+	process.exit(0);
+}
+
+// Format the generated file to the project's biome style so the committed types
+// match lint — but only locally. In CI/Vercel the build discards the formatted
+// result, so running biome there is pure per-deploy waste. (Scoped to the one
+// file; linting the whole dir would rewrite unrelated source.)
+const format =
+	process.env.CI || process.env.VERCEL
+		? ""
+		: " && bun biome check --write --unsafe sanity.types.ts";
+
+try {
+	// No `--env-file` — dotenvx already injected the env into process.env.
+	execSync(
+		`cd ${sanityDir} && bun sanity schema extract && bun sanity typegen generate${format}`,
+		{ stdio: "inherit" },
+	);
+} catch {
+	console.warn("  sanity:typegen failed — continuing anyway");
+}

package/src/modules/features/cms/sanity-pagebuilder-cache/files/lib/utils/check-redirect.ts

@@ -0,0 +1,30 @@
+import { stegaClean } from "@sanity/client/stega";
+import type { Route } from "next";
+import { permanentRedirect, redirect } from "next/navigation";
+import { getRedirects } from "@/lib/integrations/sanity/fetchers/redirects";
+
+const normalize = (path: string) =>
+	path.replace(/^\/+/, "").replace(/\/+$/, "");
+
+/** Redirect (308 permanent / 307 temporary) if `path` matches a redirect source. */
+export const checkRedirect = async (path: string | null): Promise<void> => {
+	const redirects = await getRedirects();
+	if (redirects.length === 0) return;
+
+	const source = normalize(path ?? "");
+	const match = redirects.find(
+		(entry) =>
+			entry.source && normalize(stegaClean(entry.source) ?? "") === source,
+	);
+	if (!match?.destination) return;
+
+	const destination = stegaClean(match.destination) ?? "";
+	const href = (
+		/^https?:\/\//.test(destination)
+			? destination
+			: `/${normalize(destination)}`
+	) as Route;
+
+	if (match.permanent === false) redirect(href);
+	permanentRedirect(href);
+};