bsmnt 0.4.3 → 0.5.0

package/src/modules/features/cms/sanity/files/app/blog/page.tsx

@@ -0,0 +1,54 @@
+import Link from "next/link";
+import { sanityFetch } from "@/lib/integrations/sanity/live";
+import { ALL_ARTICLES_QUERY } from "@/lib/integrations/sanity/queries";
+
+export const metadata = {
+	title: "Blog",
+	alternates: {
+		types: { "application/rss+xml": "/feed.xml" },
+	},
+};
+
+export default async function BlogIndexPage() {
+	const { data: articles } = await sanityFetch({ query: ALL_ARTICLES_QUERY });
+
+	return (
+		<main className="container mx-auto px-4 py-8 max-w-4xl">
+			<h1 className="text-4xl font-bold mb-8">Blog</h1>
+
+			{articles && articles.length > 0 ? (
+				<ul className="flex flex-col gap-8">
+					{articles.map((article) => {
+						const slug = article.slug?.current;
+						if (!slug) return null;
+
+						return (
+							<li key={article._id}>
+								<article>
+									<h2 className="text-2xl font-semibold mb-2">
+										<Link href={`/blog/${slug}`} className="hover:underline">
+											{article.title}
+										</Link>
+									</h2>
+									{article.excerpt && (
+										<p className="text-gray-600 mb-2">{article.excerpt}</p>
+									)}
+									<div className="flex gap-4 text-sm text-gray-500">
+										{article.author && <span>By {article.author}</span>}
+										{article.publishedAt && (
+											<time dateTime={article.publishedAt}>
+												{new Date(article.publishedAt).toLocaleDateString()}
+											</time>
+										)}
+									</div>
+								</article>
+							</li>
+						);
+					})}
+				</ul>
+			) : (
+				<p className="text-gray-600">No articles published yet.</p>
+			)}
+		</main>
+	);
+}

package/src/modules/features/cms/sanity/files/app/feed.xml/route.ts

@@ -0,0 +1,36 @@
+import { client } from "@/lib/integrations/sanity/client";
+import { ALL_ARTICLES_QUERY } from "@/lib/integrations/sanity/queries";
+import { generateRssFeed, rssErrorResponse } from "@/lib/utils/rss";
+import { getBaseUrl } from "@/lib/utils/url";
+
+export const dynamic = "force-dynamic";
+
+export async function GET() {
+	const baseUrl = getBaseUrl();
+	if (!client) return rssErrorResponse();
+
+	try {
+		const articles = await client.fetch(ALL_ARTICLES_QUERY);
+
+		const items = (articles ?? [])
+			.filter((article) => article.slug?.current && !article.metadata?.noIndex)
+			.map((article) => ({
+				title: article.title ?? "Untitled",
+				link: `${baseUrl}/blog/${article.slug?.current}`,
+				description: article.excerpt ?? undefined,
+				pubDate: article.publishedAt ?? undefined,
+				authors: article.author ? [article.author] : undefined,
+			}));
+
+		return generateRssFeed({
+			title: `${new URL(baseUrl).hostname} Blog`,
+			link: `${baseUrl}/blog`,
+			description: "Latest articles",
+			feedUrl: `${baseUrl}/feed.xml`,
+			items,
+		});
+	} catch (error) {
+		console.error("Error generating RSS feed:", error);
+		return rssErrorResponse();
+	}
+}

package/src/modules/features/cms/sanity/files/lib/integrations/sanity/components/disable-draft-mode.tsx

@@ -2,14 +2,14 @@
 
 import Link from "next/link";
 import { usePathname } from "next/navigation";
-import { useDraftModeEnvironment } from "next-sanity/hooks";
+import { useIsPresentationTool } from "next-sanity/hooks";
 
 export function DisableDraftMode() {
-	const environment = useDraftModeEnvironment();
+	const isPresentationTool = useIsPresentationTool();
 	const pathname = usePathname();
 
 	// Only show the disable draft mode button when outside of Presentation Tool
-	if (environment !== "live" && environment !== "unknown") {
+	if (isPresentationTool) {
 		return null;
 	}
 

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

@@ -1,13 +1,6 @@
 import { defineField, defineType } from "sanity";
 
 const articleFields = [
-	defineField({
-		name: "title",
-		title: "Title",
-		type: "string",
-		description: "The title of the article",
-		validation: (Rule) => Rule.required(),
-	}),
 	defineField({
 		name: "excerpt",
 		title: "Excerpt",
@@ -66,6 +59,13 @@ export const article = defineType({
 	title: "Article",
 	type: "document",
 	fields: [
+		defineField({
+			name: "title",
+			title: "Title",
+			type: "string",
+			description: "The title of the article",
+			validation: (Rule) => Rule.required(),
+		}),
 		defineField({
 			name: "slug",
 			title: "Slug",

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;

package/src/modules/features/cms/sanity-pagebuilder/files/app/api/revalidate/route.ts

@@ -0,0 +1,126 @@
+import { revalidatePath, revalidateTag } from "next/cache";
+import { type NextRequest, NextResponse } from "next/server";
+import { parseBody } from "next-sanity/webhook";
+import { client } from "@/lib/integrations/sanity/client";
+import { SANITY_LAYOUT_TAGS } from "@/lib/integrations/sanity/fetchers/layout";
+import { SANITY_REDIRECTS_TAG } from "@/lib/integrations/sanity/fetchers/redirects";
+import { pageBuilderReferenceMembers as pbrm } from "@/lib/integrations/sanity/page-builder-config";
+import {
+	P_REF_PB_COMP_QUERY,
+	P_REV_SLUGS_QUERY,
+} from "@/lib/integrations/sanity/queries";
+import type { P_REF_PB_COMP_QUERY_RESULT } from "@/lib/integrations/sanity/sanity.types";
+import { getPagePath } from "@/lib/utils/sitemap";
+
+const ERRORS = {
+	BAD_REQ: ["Bad Request", { status: 400 }],
+	INVALID_SIG: ["Invalid signature", { status: 401 }],
+} as const;
+
+type WebhookSlug = {
+	current?: string | null;
+};
+
+type WebhookDocument = {
+	_id: string;
+	_type: string;
+	resolvedSlug?: string | null;
+	slug?: WebhookSlug | null;
+};
+
+type MutationOperation = "create" | "update" | "delete";
+
+type RevalidateWebhookBody = WebhookDocument & {
+	operation?: MutationOperation;
+	before?: Partial<WebhookDocument> | null;
+	after?: Partial<WebhookDocument> | null;
+};
+
+const pageBuilderComponent = new Set<string>(pbrm.map((m) => m.documentType));
+
+const normalizeRevalidationSlug = (slug: string | null | undefined) => {
+	if (slug === undefined) return null;
+	if (slug === null) return "/";
+	return `/${slug}`;
+};
+
+const getCanonicalPageSlug = async (documentId: string) => {
+	if (!client) return null;
+
+	const pageSlugs = await client.fetch<Array<{ slug: string | null }>>(
+		P_REV_SLUGS_QUERY,
+		{ documentIds: [documentId] },
+	);
+
+	return normalizeRevalidationSlug(
+		pageSlugs.find((page) => page.slug !== undefined)?.slug,
+	);
+};
+
+const getPagesThatReferenceComp = async (documentId: string) => {
+	if (!client) return [];
+
+	const pages = await client.fetch<P_REF_PB_COMP_QUERY_RESULT>(
+		P_REF_PB_COMP_QUERY,
+		{
+			documentId,
+		},
+	);
+
+	return (pages ?? []).map((page) => normalizeRevalidationSlug(page.slug));
+};
+
+const getAffectedPageSlugsForWebhook = async (body: RevalidateWebhookBody) => {
+	const pages: Array<string | null> = [];
+
+	if (body.operation === "delete" && body?.before?.slug?.current) {
+		revalidateTag(body.before.slug.current, "max");
+	}
+
+	// If the document is a page, get its slug
+	if (body._type === "page") {
+		const data = await getCanonicalPageSlug(body._id);
+		if (data !== null) pages.push(data);
+	}
+
+	// If the document is a page builder component, get the page slugs that reference it
+	if (pageBuilderComponent.has(body._type)) {
+		const data = await getPagesThatReferenceComp(body._id);
+		pages.push(...data);
+	}
+
+	return pages.filter((page): page is string => page !== null);
+};
+
+export async function POST(request: NextRequest) {
+	try {
+		const { body, isValidSignature } = await parseBody<RevalidateWebhookBody>(
+			request,
+			process.env.SANITY_REVALIDATE_SECRET,
+		);
+
+		if (!isValidSignature) return new Response(...ERRORS.INVALID_SIG);
+		if (!(body?._type && body._id)) return new Response(...ERRORS.BAD_REQ);
+		if (body._id.startsWith("drafts."))
+			return NextResponse.json({ status: 200, now: Date.now(), skipped: true });
+
+		const affectedPageSlugs = await getAffectedPageSlugsForWebhook(body);
+
+		for (const slug of affectedPageSlugs) {
+			revalidatePath(getPagePath(slug));
+		}
+
+		if (SANITY_LAYOUT_TAGS.includes(body?._type)) {
+			revalidateTag(body._type, "max");
+		}
+
+		if (body._type === SANITY_REDIRECTS_TAG) {
+			revalidateTag(SANITY_REDIRECTS_TAG, "max");
+		}
+
+		return NextResponse.json({ status: 200, now: Date.now() });
+	} catch (error) {
+		console.error("Revalidation error:", error);
+		return new Response("Internal Server Error", { status: 500 });
+	}
+}

package/src/modules/features/cms/sanity-pagebuilder/files/app/feed.xml/route.ts

@@ -0,0 +1,40 @@
+import { ALL_BLOG_ARTICLES_QUERY } from "@/lib/integrations/sanity/queries";
+import { generateRssFeed, rssErrorResponse } from "@/lib/utils/rss";
+import { getPageUrl, getSitemapBaseUrl } from "@/lib/utils/sitemap";
+
+export const dynamic = "force-dynamic";
+
+export async function GET() {
+	const baseUrl = getSitemapBaseUrl();
+
+	try {
+		const sanityModule = await import("@/lib/integrations/sanity/client");
+		const client = sanityModule?.client;
+		if (!client) return rssErrorResponse();
+
+		const articles = await client.fetch(ALL_BLOG_ARTICLES_QUERY);
+
+		const items = (articles ?? [])
+			.filter((article) => article.resolvedSlug && !article.noIndex)
+			.map((article) => ({
+				title: article.title ?? "Untitled",
+				link: getPageUrl(baseUrl, article.resolvedSlug),
+				description: article.metadata?.metaDescription ?? undefined,
+				pubDate: article.blogContent?.date ?? undefined,
+				authors: article.blogContent?.author?.name
+					? [article.blogContent.author.name]
+					: undefined,
+			}));
+
+		return generateRssFeed({
+			title: `${new URL(baseUrl).hostname} Blog`,
+			link: `${baseUrl}/blog`,
+			description: "Latest articles",
+			feedUrl: `${baseUrl}/feed.xml`,
+			items,
+		});
+	} catch (error) {
+		console.error("Error generating RSS feed:", error);
+		return rssErrorResponse();
+	}
+}