bsmnt 0.4.3 → 0.6.0

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();
+	}
+}

package/src/modules/features/cms/sanity-pagebuilder/files/app/sitemap.md/route.ts

@@ -0,0 +1,124 @@
+import { NextResponse } from "next/server";
+import { isSanityConfigured } from "@/lib/integrations/check-integration";
+import type { PAGE_SITEMAP_QUERY_RESULT } from "@/lib/integrations/sanity/sanity.types";
+import {
+	getMarkdownPath,
+	getSitemap,
+	getSitemapBaseUrl,
+} from "@/lib/utils/sitemap";
+
+export const dynamic = "force-dynamic";
+
+type PageDoc = PAGE_SITEMAP_QUERY_RESULT[number];
+
+const ROOT_GROUP = "__root__";
+
+const getFolderGroup = (slug: string | null) => {
+	if (!slug) return ROOT_GROUP;
+
+	const segments = slug.split("/").filter(Boolean);
+
+	if (segments.length <= 1) return ROOT_GROUP;
+
+	return segments.slice(0, -1).join("/");
+};
+
+const getGroupHeading = (group: string) => {
+	if (group === ROOT_GROUP) return "### Root Pages";
+
+	return `### /${group}`;
+};
+
+const sortPages = (left: PageDoc, right: PageDoc) => {
+	const leftLabel = left.title || left.slug || "Homepage";
+	const rightLabel = right.title || right.slug || "Homepage";
+
+	return leftLabel.localeCompare(rightLabel);
+};
+
+export const GET = async () => {
+	const baseUrl = getSitemapBaseUrl();
+
+	if (!isSanityConfigured()) {
+		return new NextResponse(
+			[
+				"# Sitemap",
+				"",
+				"## Pages",
+				"",
+				`- [Homepage](${baseUrl}/index.md)`,
+				"",
+				"CMS not configured. No additional content available.",
+			].join("\n"),
+			{
+				headers: { "Content-Type": "text/markdown; charset=utf-8" },
+			},
+		);
+	}
+
+	try {
+		const allPages = await getSitemap();
+
+		if (!allPages) {
+			return new NextResponse("# Sitemap\n\nUnable to connect to CMS.", {
+				status: 503,
+				headers: { "Content-Type": "text/markdown; charset=utf-8" },
+			});
+		}
+
+		const pages = (allPages ?? []).filter((page) => !page.noIndex);
+		const pageGroups = new Map<string, PageDoc[]>();
+
+		for (const page of pages) {
+			const group = getFolderGroup(page.slug ?? null);
+			const groupedPages = pageGroups.get(group) ?? [];
+
+			groupedPages.push(page);
+			pageGroups.set(group, groupedPages);
+		}
+
+		const sortedGroupNames = [...pageGroups.keys()].sort((left, right) => {
+			if (left === ROOT_GROUP) return -1;
+			if (right === ROOT_GROUP) return 1;
+
+			return left.localeCompare(right);
+		});
+
+		const parts = [
+			`# ${new URL(baseUrl).hostname} - Content Sitemap`,
+			"",
+			"> This sitemap lists all available markdown content for AI agents.",
+			"",
+			"## Pages",
+			"",
+		];
+
+		if (pages.length > 0) {
+			for (const groupName of sortedGroupNames) {
+				const groupedPages = (pageGroups.get(groupName) ?? []).sort(sortPages);
+
+				if (groupedPages.length === 0) continue;
+
+				parts.push(getGroupHeading(groupName), "");
+
+				for (const page of groupedPages) {
+					parts.push(
+						`- [${page.title || page.slug || "Homepage"}](${getMarkdownPath(baseUrl, page.slug ?? null)})`,
+					);
+				}
+
+				parts.push("");
+			}
+		}
+
+		if (pages.length === 0) parts.push("No content published yet.", "");
+
+		return new NextResponse(parts.join("\n"));
+	} catch (error) {
+		console.error("Error generating sitemap.md:", error);
+		return new NextResponse("# Sitemap\n\nError fetching content.", {
+			status: 500,
+			headers: { "Content-Type": "text/markdown; charset=utf-8" },
+		});
+	}
+};

package/src/modules/features/cms/sanity-pagebuilder/files/app/studio/[[...tool]]/page.tsx

@@ -0,0 +1,8 @@
+"use client";
+
+import { NextStudio } from "next-sanity/studio";
+import config from "@/lib/integrations/sanity/sanity.config";
+
+const StudioPage = () => <NextStudio config={config} />;
+
+export default StudioPage;

package/src/modules/features/cms/sanity-pagebuilder/files/components/sanity/draft-mode-toggle.tsx

@@ -0,0 +1,27 @@
+"use client";
+
+import { useRouter } from "next/navigation";
+import { useTransition } from "react";
+
+export function DraftModeToggle() {
+	const router = useRouter();
+	const [isPending, startTransition] = useTransition();
+
+	const handleDisable = () => {
+		startTransition(async () => {
+			await fetch("/api/draft-mode/disable");
+			router.refresh();
+		});
+	};
+
+	return (
+		<button
+			type="button"
+			onClick={handleDisable}
+			disabled={isPending}
+			className="fixed bottom-4 left-1/2 z-50 -translate-x-1/2 rounded-full border border-white/10 bg-black/80 px-2 py-1 font-medium text-sm text-white shadow-lg backdrop-blur-sm transition-colors hover:bg-black/90 disabled:opacity-50"
+		>
+			{isPending ? "Disabling..." : "Disable Draft Mode"}
+		</button>
+	);
+}

package/src/modules/features/cms/sanity-pagebuilder/files/components/sanity/rich-text.tsx

@@ -0,0 +1,87 @@
+import { PortableText, type PortableTextProps } from "@portabletext/react";
+import { Link } from "@/components/ui/link";
+import { SanityImage } from "@/components/ui/sanity-image";
+import {
+	getLinkAttributes,
+	urlForReference,
+} from "../../lib/integrations/sanity/utils/link";
+
+interface RichTextProps {
+	content: PortableTextProps["value"];
+}
+
+type LinkMarkProps = {
+	children: React.ReactNode;
+	value?: unknown;
+};
+
+const LinkMark = ({ children, value }: LinkMarkProps) => {
+	const href = urlForReference(value as Parameters<typeof urlForReference>[0]);
+	const attrs = getLinkAttributes(
+		value as Parameters<typeof getLinkAttributes>[0],
+	);
+
+	return (
+		<Link
+			href={href}
+			target={attrs.target}
+			rel={attrs.rel}
+			data-sanity-edit-target
+		>
+			{children}
+		</Link>
+	);
+};
+
+export const RichText = ({ content }: RichTextProps) => {
+	if (!content) return null;
+
+	return (
+		<PortableText
+			value={content}
+			components={{
+				types: {
+					image: ({ value }) => <SanityImage image={value} maxWidth={1920} />,
+					table: ({ value }) => {
+						const rows = value?.rows as
+							| Array<{ _key?: string; cells?: string[] }>
+							| undefined;
+						if (!rows?.length) return null;
+						return (
+							<table>
+								<tbody>
+									{rows.map((row, i) => (
+										<tr key={row._key ?? `row-${i}`}>
+											{row.cells?.map((cell) => {
+												const cellKey = `${row._key}-${cell}`;
+												return i === 0 ? (
+													<th key={cellKey}>{cell}</th>
+												) : (
+													<td key={cellKey}>{cell}</td>
+												);
+											})}
+										</tr>
+									))}
+								</tbody>
+							</table>
+						);
+					},
+				},
+				marks: {
+					link: LinkMark,
+					pageReference: LinkMark,
+					externalLink: LinkMark,
+				},
+				block: {
+					h1: ({ children }) => <h1 className="h1">{children}</h1>,
+					h2: ({ children }) => <h2 className="h2">{children}</h2>,
+					h3: ({ children }) => <h3 className="h3">{children}</h3>,
+					h4: ({ children }) => <h4 className="h4">{children}</h4>,
+					h5: ({ children }) => <h5 className="h5">{children}</h5>,
+					h6: ({ children }) => <h6 className="h6">{children}</h6>,
+					normal: ({ children }) => <p className="p">{children}</p>,
+				},
+			}}
+		/>
+	);
+};

package/src/modules/features/cms/sanity-pagebuilder/files/components/sanity/visual-editing.tsx

@@ -0,0 +1,28 @@
+import { draftMode } from "next/headers";
+import { VisualEditing } from "next-sanity/visual-editing";
+import { Suspense } from "react";
+import { refreshAction } from "@/app/actions/refresh";
+import { DraftModeToggle } from "@/components/sanity/draft-mode-toggle";
+import { isSanityConfigured } from "@/lib/integrations/check-integration";
+import { SanityLive } from "@/lib/integrations/sanity/live";
+
+async function VisualEditingInner() {
+	const { isEnabled: isDraftMode } = await draftMode();
+	const sanityConfigured = isSanityConfigured();
+
+	if (!(sanityConfigured && isDraftMode)) return null;
+
+	return (
+		<>
+			<DraftModeToggle />
+			<VisualEditing />
+			<SanityLive action={refreshAction} />
+		</>
+	);
+}
+
+export const SanityVisualEditing = () => (
+	<Suspense fallback={null}>
+		<VisualEditingInner />
+	</Suspense>
+);

package/src/modules/features/cms/sanity-pagebuilder/files/components/ui/sanity-image/index.tsx

@@ -0,0 +1,41 @@
+import { getImageDimensions } from "@sanity/asset-utils";
+import { Image, type ImageProps } from "@/components/ui/image";
+import { urlForImage } from "@/lib/integrations/sanity/utils/image";
+
+interface SanityImageProps extends Omit<ImageProps, "src" | "aspectRatio"> {
+	image: {
+		asset?: {
+			_ref: string;
+			_type: "reference";
+		};
+		alt?: string;
+		hotspot?: object;
+		crop?: object;
+	};
+	maxWidth?: number;
+}
+
+export function SanityImage({
+	image,
+	maxWidth = 1920,
+	alt,
+	fill,
+	...props
+}: SanityImageProps) {
+	if (!image?.asset) return null;
+
+	const { width, height } = getImageDimensions(image.asset);
+	const aspectRatio = width / height;
+
+	const imageProps = fill ? { fill: true } : { width, height };
+
+	return (
+		<Image
+			src={urlForImage(image).width(maxWidth).url()}
+			alt={alt || image.alt || ""}
+			aspectRatio={aspectRatio}
+			{...imageProps}
+			{...props}
+		/>
+	);
+}

package/src/modules/features/cms/sanity-pagebuilder/files/lib/integrations/check-integration.ts

@@ -0,0 +1,5 @@
+export const isSanityConfigured = () =>
+	Boolean(
+		process.env.NEXT_PUBLIC_SANITY_PROJECT_ID &&
+			process.env.NEXT_PUBLIC_SANITY_DATASET,
+	);

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

@@ -0,0 +1,27 @@
+import { createClient, type SanityClient } from "next-sanity";
+import { isSanityConfigured } from "@/lib/integrations/check-integration";
+import { apiVersion, dataset, projectId, sanityToken, studioUrl } from "./env";
+
+/**
+ * Sanity client instance
+ *
+ * Returns null if Sanity is not configured (missing env vars).
+ * Always check with isSanityConfigured() before using.
+ */
+export const client: SanityClient | null = isSanityConfigured()
+	? createClient({
+			projectId,
+			dataset,
+			apiVersion,
+			useCdn: true,
+			perspective: "published",
+			token: sanityToken,
+			stega: {
+				studioUrl,
+				filter: (props) => {
+					if (props.sourcePath.at(-1) === "title") return true;
+					return props.filterDefault(props);
+				},
+			},
+		})
+	: null;

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

@@ -0,0 +1,23 @@
+"use client";
+
+import Link from "next/link";
+import { usePathname } from "next/navigation";
+import { useIsPresentationTool } from "next-sanity/hooks";
+
+export function DisableDraftMode() {
+	const isPresentationTool = useIsPresentationTool();
+	const pathname = usePathname();
+
+	if (isPresentationTool) return null;
+	if (pathname.startsWith("/studio")) return null;
+
+	return (
+		<Link
+			href="/api/draft-mode/disable"
+			scroll={false}
+			className="dr-p-4 fixed top-safe right-safe z-50 bg-red font-mono text-primary text-sm uppercase"
+		>
+			Disable Draft Mode
+		</Link>
+	);
+}

package/src/modules/features/cms/sanity-pagebuilder/files/lib/integrations/sanity/components/page-builder-input.tsx

@@ -0,0 +1,39 @@
+import { type ArrayOfObjectsInputProps, useFormValue } from "sanity";
+import {
+	getVisiblePageBuilderInsertMenuGroups,
+	getVisiblePageBuilderReferenceMembers,
+	type PageBuilderGroupName,
+} from "@/lib/integrations/sanity/page-builder-config";
+
+export function PageBuilderInput(props: ArrayOfObjectsInputProps) {
+	const pageTypeValue = useFormValue(["type"]);
+	const pageType =
+		typeof pageTypeValue === "string"
+			? (pageTypeValue as PageBuilderGroupName)
+			: undefined;
+
+	const visibleMemberNames = new Set(
+		getVisiblePageBuilderReferenceMembers(pageType).map(
+			(member) => member.name,
+		),
+	);
+
+	return props.renderDefault({
+		...props,
+		schemaType: {
+			...props.schemaType,
+			of: props.schemaType.of.filter(
+				(member) =>
+					typeof member.name === "string" &&
+					visibleMemberNames.has(member.name),
+			),
+			options: {
+				...props.schemaType.options,
+				insertMenu: {
+					...props.schemaType.options?.insertMenu,
+					groups: getVisiblePageBuilderInsertMenuGroups(pageType),
+				},
+			},
+		},
+	});
+}

package/src/modules/features/cms/sanity-pagebuilder/files/lib/integrations/sanity/components/page-category-input.tsx

@@ -0,0 +1,50 @@
+import { Select } from "@sanity/ui";
+import { useEffect } from "react";
+import { type StringInputProps, set, setIfMissing } from "sanity";
+
+type PageCategoryOption = {
+	title: string;
+	value: string;
+};
+
+const isPageCategoryOption = (option: unknown): option is PageCategoryOption =>
+	typeof option === "object" &&
+	option !== null &&
+	"title" in option &&
+	"value" in option &&
+	typeof option.title === "string" &&
+	typeof option.value === "string";
+
+export function PageCategoryInput(props: StringInputProps) {
+	useEffect(() => {
+		if (props.value === undefined) {
+			props.onChange(setIfMissing("generic"));
+		}
+	}, [props.onChange, props.value]);
+
+	const options = Array.isArray(props.schemaType.options?.list)
+		? props.schemaType.options.list.filter(isPageCategoryOption)
+		: [];
+
+	if (options.length === 0) {
+		return props.renderDefault({ ...props, value: props.value ?? "generic" });
+	}
+
+	return (
+		<Select
+			{...props.elementProps}
+			disabled={props.readOnly}
+			onChange={(event) => props.onChange(set(event.currentTarget.value))}
+			value={props.value ?? "generic"}
+			{...(props.validationError
+				? { customValidity: props.validationError }
+				: {})}
+		>
+			{options.map((option) => (
+				<option key={option.value} value={option.value}>
+					{option.title}
+				</option>
+			))}
+		</Select>
+	);
+}