bsmnt 0.4.3 → 0.6.0

package/src/modules/features/cms/sanity/files/lib/integrations/sanity/schemas/structured-data.ts

@@ -0,0 +1,100 @@
+import { defineField, defineType } from "sanity";
+
+export const structuredData = defineType({
+	name: "structuredData",
+	title: "Structured Data",
+	type: "document",
+	description:
+		"Site-wide identity emitted as JSON-LD (schema.org Organization + WebSite) on every page for search engines.",
+	fields: [
+		defineField({
+			name: "name",
+			title: "Organization Name",
+			type: "string",
+			description: "Public name of the organization (shown in rich results).",
+			validation: (Rule) => Rule.required(),
+		}),
+		defineField({
+			name: "legalName",
+			title: "Legal Name",
+			type: "string",
+			description:
+				"Registered legal entity name, if different from the public name.",
+		}),
+		defineField({
+			name: "logo",
+			title: "Logo",
+			type: "image",
+			description:
+				"Square or wide logo used in rich results. Min 112x112px, transparent PNG/SVG recommended.",
+			options: { hotspot: true },
+		}),
+		defineField({
+			name: "description",
+			title: "Description",
+			type: "text",
+			rows: 3,
+			description: "Short sentence describing the organization.",
+		}),
+		defineField({
+			name: "url",
+			title: "Canonical URL",
+			type: "url",
+			description:
+				"Optional override for the canonical site URL. Defaults to the deployed origin.",
+		}),
+		defineField({
+			name: "sameAs",
+			title: "Same-As Profiles",
+			type: "array",
+			description:
+				"Official profiles representing this organization (LinkedIn, X, GitHub, Crunchbase, Wikipedia, etc.).",
+			of: [{ type: "url" }],
+		}),
+		defineField({
+			name: "contactPoint",
+			title: "Contact Point",
+			type: "object",
+			options: { collapsible: true, collapsed: true },
+			fields: [
+				defineField({ name: "email", title: "Email", type: "string" }),
+				defineField({ name: "telephone", title: "Telephone", type: "string" }),
+				defineField({
+					name: "contactType",
+					title: "Contact Type",
+					type: "string",
+					description:
+						"e.g. 'customer support', 'sales', 'press'. See schema.org/ContactPoint.",
+				}),
+			],
+		}),
+		defineField({
+			name: "address",
+			title: "Address",
+			type: "object",
+			options: { collapsible: true, collapsed: true },
+			fields: [
+				defineField({
+					name: "streetAddress",
+					title: "Street Address",
+					type: "string",
+				}),
+				defineField({ name: "locality", title: "City", type: "string" }),
+				defineField({
+					name: "region",
+					title: "Region / State",
+					type: "string",
+				}),
+				defineField({
+					name: "postalCode",
+					title: "Postal Code",
+					type: "string",
+				}),
+				defineField({ name: "country", title: "Country", type: "string" }),
+			],
+		}),
+	],
+	preview: {
+		prepare: () => ({ title: "Structured Data" }),
+	},
+});

package/src/modules/features/cms/sanity/files/lib/integrations/sanity/structure.ts

@@ -1,5 +1,40 @@
+import {
+	ComponentIcon,
+	DocumentsIcon,
+	MenuIcon,
+	SchemaIcon,
+	ThLargeIcon,
+} from "@sanity/icons";
 import type { StructureResolver } from "sanity/structure";
 
-// https://www.sanity.io/docs/structure-builder-cheat-sheet
+// Explicit menu: new schema types must be listed here, which keeps plugin
+// types (e.g. media.tag) out of the Studio.
 export const structure: StructureResolver = (S) =>
-	S.list().title("Content").items(S.documentTypeListItems());
+	S.list()
+		.title("Content")
+		.items([
+			S.documentTypeListItem("article").title("Articles").icon(DocumentsIcon),
+			S.documentTypeListItem("example").title("Examples").icon(ComponentIcon),
+			S.documentTypeListItem("navigation").title("Navigation").icon(MenuIcon),
+			S.divider(),
+			// Layout — site-wide singletons.
+			S.listItem()
+				.title("Layout")
+				.id("layout")
+				.icon(ThLargeIcon)
+				.child(
+					S.list()
+						.title("Layout")
+						.items([
+							S.listItem()
+								.title("Structured Data")
+								.id("structuredData")
+								.icon(SchemaIcon)
+								.child(
+									S.document()
+										.schemaType("structuredData")
+										.documentId("structuredData"),
+								),
+						]),
+				),
+		]);

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

@@ -0,0 +1,208 @@
+import { stegaClean } from "next-sanity";
+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/files/lib/scripts/setup-ci-secrets.ts

@@ -0,0 +1,117 @@
+/**
+ * Push CI environment to GitHub Actions for this repository.
+ *
+ * Reads values from `.env.local` and sets them on the current repo via the
+ * GitHub CLI (`gh`), matching the `build` step in `.github/workflows/ci.yml`:
+ * the public Sanity project ID and dataset become repository *variables*, and
+ * the read token becomes a *secret*.
+ *
+ * Run once the repo exists on GitHub:  `bun run ci:secrets`
+ * Requires the GitHub CLI, authenticated (`gh auth login`).
+ */
+import { execFileSync } from "node:child_process";
+import { existsSync, readFileSync } from "node:fs";
+import path from "node:path";
+
+const ENV_FILE = ".env.local";
+
+/** Public config — stored as GitHub Actions repository variables. */
+const VARIABLES = [
+	"NEXT_PUBLIC_SANITY_PROJECT_ID",
+	"NEXT_PUBLIC_SANITY_DATASET",
+] as const;
+
+/** Sensitive config — stored as GitHub Actions secrets. */
+const SECRETS = ["SANITY_API_READ_TOKEN"] as const;
+
+function parseEnvFile(file: string): Record<string, string> {
+	const env: Record<string, string> = {};
+	if (!existsSync(file)) return env;
+
+	for (const rawLine of readFileSync(file, "utf8").split("\n")) {
+		const line = rawLine.trim();
+		if (!line || line.startsWith("#")) continue;
+
+		const eq = line.indexOf("=");
+		if (eq === -1) continue;
+
+		const key = line.slice(0, eq).trim();
+		let value = line.slice(eq + 1).trim();
+		if (
+			(value.startsWith('"') && value.endsWith('"')) ||
+			(value.startsWith("'") && value.endsWith("'"))
+		) {
+			value = value.slice(1, -1);
+		}
+		env[key] = value;
+	}
+
+	return env;
+}
+
+function ensureGitHubRepo(): void {
+	try {
+		execFileSync("gh", ["--version"], { stdio: "pipe" });
+	} catch {
+		console.error(
+			"✖ GitHub CLI (gh) not found. Install it: https://cli.github.com",
+		);
+		process.exit(1);
+	}
+
+	try {
+		execFileSync("gh", ["repo", "view", "--json", "nameWithOwner"], {
+			stdio: "pipe",
+		});
+	} catch {
+		console.error("✖ No GitHub repository detected for this directory.");
+		console.error(
+			"  Create and push the repo first (e.g. `gh repo create`), then re-run.",
+		);
+		process.exit(1);
+	}
+}
+
+ensureGitHubRepo();
+
+const env = parseEnvFile(path.resolve(ENV_FILE));
+let pushed = 0;
+let skipped = 0;
+
+for (const name of VARIABLES) {
+	const value = env[name] ?? process.env[name];
+	if (!value) {
+		console.info(`- ${name}: not found in ${ENV_FILE}, skipping`);
+		skipped++;
+		continue;
+	}
+	// Public value — safe to pass on the command line.
+	execFileSync("gh", ["variable", "set", name, "--body", value], {
+		stdio: "pipe",
+	});
+	console.info(`✓ variable  ${name}`);
+	pushed++;
+}
+
+for (const name of SECRETS) {
+	const value = env[name] ?? process.env[name];
+	if (!value) {
+		console.info(`- ${name}: not found in ${ENV_FILE}, skipping`);
+		skipped++;
+		continue;
+	}
+	// Sensitive — pipe via stdin so the token never appears in the process args.
+	execFileSync("gh", ["secret", "set", name], { input: value, stdio: "pipe" });
+	console.info(`✓ secret    ${name}`);
+	pushed++;
+}
+
+if (pushed === 0) {
+	console.info(
+		`\nNothing to sync. Add your Sanity values to ${ENV_FILE} (or run Sanity setup) first.`,
+	);
+} else {
+	console.info(
+		`\nDone — ${String(pushed)} value(s) pushed to GitHub Actions${skipped ? `, ${String(skipped)} skipped` : ""}.`,
+	);
+}

package/src/modules/features/cms/sanity/files/lib/utils/rss.ts

@@ -0,0 +1,96 @@
+export interface RssFeedItem {
+	title: string;
+	link: string;
+	description?: string | undefined;
+	pubDate?: string | undefined;
+	authors?: string[] | undefined;
+	category?: string | undefined;
+}
+
+export interface RssFeedConfig {
+	title: string;
+	link: string;
+	description: string;
+	feedUrl: string;
+	language?: string;
+	items: RssFeedItem[];
+}
+
+function escapeXml(str: string): string {
+	return str
+		.replace(/&/g, "&")
+		.replace(/</g, "&lt;")
+		.replace(/>/g, "&gt;")
+		.replace(/"/g, "&quot;")
+		.replace(/'/g, "&apos;");
+}
+
+export function generateRssFeed(config: RssFeedConfig): Response {
+	const {
+		title,
+		link,
+		description,
+		feedUrl,
+		language = "en-us",
+		items,
+	} = config;
+
+	const itemsXml = items
+		.map((item) => {
+			const lines = [
+				`      <title>${escapeXml(item.title)}</title>`,
+				`      <link>${escapeXml(item.link)}</link>`,
+				`      <guid isPermaLink="true">${escapeXml(item.link)}</guid>`,
+			];
+
+			if (item.description) {
+				lines.push(
+					`      <description>${escapeXml(item.description)}</description>`,
+				);
+			}
+
+			const pubDate = item.pubDate ? new Date(item.pubDate) : null;
+			if (pubDate && !Number.isNaN(pubDate.getTime())) {
+				lines.push(`      <pubDate>${pubDate.toUTCString()}</pubDate>`);
+			}
+
+			for (const author of item.authors ?? []) {
+				lines.push(`      <dc:creator>${escapeXml(author)}</dc:creator>`);
+			}
+
+			if (item.category) {
+				lines.push(`      <category>${escapeXml(item.category)}</category>`);
+			}
+
+			return `    <item>\n${lines.join("\n")}\n    </item>`;
+		})
+		.join("\n");
+
+	const xml = `<?xml version="1.0" encoding="UTF-8"?>
+<rss version="2.0" xmlns:dc="http://purl.org/dc/elements/1.1/" xmlns:atom="http://www.w3.org/2005/Atom">
+  <channel>
+    <title>${escapeXml(title)}</title>
+    <link>${escapeXml(link)}</link>
+    <description>${escapeXml(description)}</description>
+    <language>${language}</language>
+    <atom:link href="${escapeXml(feedUrl)}" rel="self" type="application/rss+xml" />
+${itemsXml}
+  </channel>
+</rss>`;
+
+	return new Response(xml, {
+		headers: {
+			"Content-Type": "application/rss+xml",
+		},
+	});
+}
+
+export function rssErrorResponse(): Response {
+	return new Response(
+		'<?xml version="1.0" encoding="UTF-8"?><rss version="2.0"><channel><title>Error</title></channel></rss>',
+		{
+			status: 500,
+			headers: { "Content-Type": "application/xml" },
+		},
+	);
+}

package/src/modules/features/cms/sanity-pagebuilder/files/.knip.json

@@ -0,0 +1,8 @@
+{
+	"$schema": "https://unpkg.com/knip@6/schema.json",
+	"entry": [
+		"lib/integrations/sanity/sanity.cli.ts",
+		"lib/integrations/sanity/sanity.config.ts"
+	],
+	"ignore": ["lib/integrations/sanity/sanity.types.ts"]
+}

package/src/modules/features/cms/sanity-pagebuilder/files/app/api/[[...slug]]/route.ts

@@ -0,0 +1,100 @@
+import { NextResponse } from "next/server";
+import { isSanityConfigured } from "@/lib/integrations/check-integration";
+import { sanityFetch } from "@/lib/integrations/sanity/live";
+import { PAGE_QUERY } from "@/lib/integrations/sanity/queries";
+import type { PAGE_QUERY_RESULT } from "@/lib/integrations/sanity/sanity.types";
+import { renderPageBuilderMarkdown } from "@/lib/integrations/sanity/utils/page-builder-markdown";
+import { getBaseUrl } from "@/lib/utils/base-url";
+
+type PageResult = NonNullable<PAGE_QUERY_RESULT>;
+
+const getSlugPath = (slugParts?: string[]) => {
+	if (!slugParts?.length) return null;
+
+	const lastSegment = slugParts.at(-1);
+
+	if (!lastSegment?.endsWith(".md")) return null;
+
+	const pathSegments = [...slugParts];
+	pathSegments[pathSegments.length - 1] = lastSegment.slice(0, -3);
+
+	const slug = pathSegments.filter(Boolean).join("/");
+	if (!slug) return null;
+
+	return slug === "index" ? null : slug;
+};
+
+export async function GET(
+	_request: Request,
+	props: { params: Promise<{ slug?: string[] }> },
+) {
+	const { slug: rawSlugParts } = await props.params;
+	const slug = getSlugPath(rawSlugParts);
+
+	if (
+		rawSlugParts?.length &&
+		slug === null &&
+		rawSlugParts.join("/") !== "index.md"
+	) {
+		return new NextResponse(null, { status: 404 });
+	}
+
+	if (!rawSlugParts?.length) {
+		return new NextResponse(null, { status: 404 });
+	}
+
+	if (!isSanityConfigured()) {
+		return new NextResponse("# 404 Not Found\n\nCMS not configured.", {
+			status: 404,
+			headers: { "Content-Type": "text/markdown; charset=utf-8" },
+		});
+	}
+
+	const { data } = await sanityFetch({
+		query: PAGE_QUERY,
+		params: { slug },
+	});
+
+	const page = data as PageResult | null;
+
+	const baseUrl = getBaseUrl();
+
+	if (!page) {
+		return new NextResponse("# 404 Not Found\n\nPage not found.", {
+			status: 404,
+			headers: { "Content-Type": "text/markdown; charset=utf-8" },
+		});
+	}
+
+	const body = renderPageBuilderMarkdown(page.pageBuilder);
+	const canonicalPath = slug ? `/${slug}` : "/";
+
+	return new NextResponse(
+		[
+			`# ${page.title}`,
+			"",
+			page._updatedAt
+				? `**Updated:** ${new Date(page._updatedAt).toLocaleDateString()}`
+				: null,
+			"",
+			`Canonical URL: ${baseUrl}${canonicalPath}`,
+			"",
+			"---",
+			"",
+			body || "No page builder content yet.",
+			"",
+			"---",
+			"",
+			`[View all content](${baseUrl}/sitemap.md)`,
+		]
+			.filter((part): part is string => part !== null)
+			.join("\n"),
+		{
+			headers: {
+				"Content-Type": "text/markdown; charset=utf-8",
+				Vary: "Accept",
+				"X-Content-Type-Options": "nosniff",
+			},
+		},
+	);
+}

package/src/modules/features/cms/sanity-pagebuilder/files/app/api/draft-mode/disable/route.ts

@@ -0,0 +1,7 @@
+import { draftMode } from "next/headers";
+import { type NextRequest, NextResponse } from "next/server";
+
+export async function GET(request: NextRequest) {
+	(await draftMode()).disable();
+	return NextResponse.redirect(new URL("/", request.url));
+}

package/src/modules/features/cms/sanity-pagebuilder/files/app/api/draft-mode/enable/route.ts

@@ -0,0 +1,20 @@
+import { NextResponse } from "next/server";
+import { defineEnableDraftMode } from "next-sanity/draft-mode";
+import { isSanityConfigured } from "@/lib/integrations/check-integration";
+import { client } from "@/lib/integrations/sanity/client";
+import { sanityToken } from "@/lib/integrations/sanity/env";
+
+const draftModeHandler =
+	isSanityConfigured() && client
+		? defineEnableDraftMode({
+				client: client.withConfig({ token: sanityToken }),
+			})
+		: {
+				GET: () =>
+					NextResponse.json(
+						{ error: "Sanity is not configured" },
+						{ status: 503 },
+					),
+			};
+
+export const { GET } = draftModeHandler;