bsmnt 0.2.10 → 0.3.0

package/src/templates/next-pagebuilder/app/(content)/[[...slug]]/page.tsx

@@ -0,0 +1,68 @@
+import { notFound } from "next/navigation"
+import { client } from "@/lib/integrations/sanity/client"
+import { sanityFetch } from "@/lib/integrations/sanity/live"
+import {
+  ALL_PAGE_SLUGS_QUERY,
+  PAGE_QUERY,
+} from "@/lib/integrations/sanity/queries"
+import type {
+  ALL_PAGE_SLUGS_QUERY_RESULT,
+  PAGE_QUERY_RESULT,
+} from "@/lib/integrations/sanity/sanity.types"
+import { generateSanityMetadata } from "@/lib/utils/metadata"
+import { getSlugTag } from "@/lib/utils/slug-tag"
+import { PageDocument } from "@/components/page-document"
+
+const getPageDocument = async (slug: string | null, stega = true) =>
+  sanityFetch({
+    query: PAGE_QUERY,
+    params: { slug },
+    tags: [getSlugTag(slug)],
+    stega,
+  })
+
+const toPath = (segments?: string[]) =>
+  segments?.filter(Boolean).join("/") || null
+
+const getResolvedPage = async (
+  path: string | null,
+  stega = true
+): Promise<NonNullable<PAGE_QUERY_RESULT> | null> => {
+  const { data: page } = await getPageDocument(path, stega)
+  return (page as NonNullable<PAGE_QUERY_RESULT> | null) ?? null
+}
+
+export const generateStaticParams = async () => {
+  if (!client) return []
+
+  const slugs =
+    await client.fetch<ALL_PAGE_SLUGS_QUERY_RESULT>(ALL_PAGE_SLUGS_QUERY)
+
+  return (slugs ?? []).flatMap((page) => {
+    if (!page.slug) return []
+    return { slug: page.slug.split("/") }
+  })
+}
+
+type Props = { params: Promise<{ slug?: string[] }> }
+
+export const generateMetadata = async ({ params }: Props) => {
+  const { slug } = await params
+  const path = toPath(slug)
+  const page = await getResolvedPage(path, false)
+
+  return page
+    ? generateSanityMetadata({ document: page, url: path ? `/${path}` : "/" })
+    : {}
+}
+
+export default async function CatchAllPage({ params }: Props) {
+  const { slug } = await params
+
+  const path = toPath(slug)
+  const page = await getResolvedPage(path)
+
+  if (!page) return notFound()
+
+  return <PageDocument page={page} path={path} />
+}

package/src/templates/next-pagebuilder/app/(content)/layout.tsx

@@ -0,0 +1,13 @@
+import { JsonLd } from "@/components/layout/json-ld"
+import { Wrapper } from "@/components/layout/wrapper"
+import { SanityVisualEditing } from "@/components/sanity/visual-editing"
+
+const Layout = async ({ children }: { children: React.ReactNode }) => (
+  <>
+    <JsonLd />
+    <Wrapper>{children}</Wrapper>
+    <SanityVisualEditing />
+  </>
+)
+
+export default Layout

package/src/templates/next-pagebuilder/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/templates/next-pagebuilder/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/templates/next-pagebuilder/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/templates/next-pagebuilder/app/api/revalidate/route.ts

@@ -0,0 +1,121 @@
+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 { 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")
+    }
+
+    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/templates/next-pagebuilder/app/layout.tsx

@@ -0,0 +1,80 @@
+import "@/lib/styles/global.css"
+
+import type { Metadata } from "next"
+import { Geist } from "next/font/google"
+import type { PropsWithChildren } from "react"
+import { cn } from "@/lib/styles/cn"
+import { getBaseUrl } from "@/lib/utils/base-url"
+import AppData from "@/package.json"
+
+const APP_NAME = AppData.name
+const APP_DEFAULT_TITLE = "My Site"
+const APP_TITLE_TEMPLATE = "%s"
+const APP_DESCRIPTION = AppData.description
+const APP_BASE_URL = getBaseUrl()
+
+const geist = Geist({
+  subsets: ["latin"],
+  variable: "--font-geist-variable",
+})
+
+export const metadata: Metadata = {
+  alternates: {
+    canonical: "/",
+    languages: {
+      "en-US": "/en-US",
+    },
+  },
+  appleWebApp: {
+    capable: true,
+    statusBarStyle: "default",
+    title: APP_DEFAULT_TITLE,
+  },
+  applicationName: APP_NAME,
+  authors: [{ name: "basement.studio", url: "https://basement.studio" }],
+  description: APP_DESCRIPTION,
+  formatDetection: { telephone: false },
+  metadataBase: new URL(APP_BASE_URL),
+  openGraph: {
+    description: APP_DESCRIPTION,
+    images: [
+      {
+        alt: APP_DEFAULT_TITLE,
+        height: 630,
+        url: "/opengraph-image.jpg",
+        width: 1200,
+      },
+    ],
+    locale: "en_US",
+    siteName: APP_NAME,
+    title: {
+      default: APP_DEFAULT_TITLE,
+      template: APP_TITLE_TEMPLATE,
+    },
+    type: "website",
+    url: APP_BASE_URL,
+  },
+  other: {
+    "fb:app_id": process.env.NEXT_PUBLIC_FACEBOOK_APP_ID || "",
+  },
+  title: {
+    default: APP_DEFAULT_TITLE,
+    template: APP_TITLE_TEMPLATE,
+  },
+  twitter: {
+    card: "summary_large_image",
+    description: APP_DESCRIPTION,
+    title: {
+      default: APP_DEFAULT_TITLE,
+      template: APP_TITLE_TEMPLATE,
+    },
+  },
+}
+
+const Layout = ({ children }: PropsWithChildren) => (
+  <html lang="en" dir="ltr" className={cn(geist.variable)}>
+    <body className="text-black">{children}</body>
+  </html>
+)
+
+export default Layout

package/src/templates/next-pagebuilder/app/robots.ts

@@ -0,0 +1,15 @@
+import type { MetadataRoute } from "next";
+
+const APP_BASE_URL =
+  process.env.NEXT_PUBLIC_BASE_URL ?? "http://localhost:3000";
+
+export default function robots(): MetadataRoute.Robots {
+  return {
+    rules: {
+      userAgent: "*",
+      allow: "/",
+      disallow: [],
+    },
+    sitemap: `${APP_BASE_URL}/sitemap.xml`,
+  };
+}

package/src/templates/next-pagebuilder/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/templates/next-pagebuilder/app/sitemap.xml/route.ts

@@ -0,0 +1,80 @@
+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 { getPageUrl, getSitemap, getSitemapBaseUrl } from "@/lib/utils/sitemap"
+
+export const dynamic = "force-dynamic"
+
+type PageDoc = PAGE_SITEMAP_QUERY_RESULT[number]
+
+interface SitemapEntry {
+  url: string
+  lastModified?: string | null
+}
+
+const createPageEntry = (
+  baseUrl: string,
+  slug: string | null,
+  updatedAt?: string | null
+): SitemapEntry => ({
+  url: getPageUrl(baseUrl, slug),
+  lastModified: updatedAt ?? null,
+})
+
+const escapeXml = (value: string) =>
+  value
+    .replaceAll("&", "&")
+    .replaceAll("<", "&lt;")
+    .replaceAll(">", "&gt;")
+    .replaceAll('"', "&quot;")
+    .replaceAll("'", "&apos;")
+
+const renderUrl = (entry: SitemapEntry) => {
+  const parts = ["  <url>", `    <loc>${escapeXml(entry.url)}</loc>`]
+
+  if (entry.lastModified) {
+    parts.push(
+      `    <lastmod>${new Date(entry.lastModified).toISOString()}</lastmod>`
+    )
+  }
+
+  parts.push("  </url>")
+
+  return parts.join("\n")
+}
+
+const renderSitemap = (entries: SitemapEntry[]) =>
+  [
+    '<?xml version="1.0" encoding="UTF-8"?>',
+    '<urlset xmlns="http://www.sitemaps.org/schemas/sitemap/0.9">',
+    ...entries.map(renderUrl),
+    "</urlset>",
+  ].join("\n")
+
+const getSitemapResponse = (entries: SitemapEntry[]) =>
+  new NextResponse(renderSitemap(entries))
+
+export const GET = async () => {
+  const baseUrl = getSitemapBaseUrl()
+  const homepageEntry = createPageEntry(baseUrl, null)
+
+  if (!isSanityConfigured()) return getSitemapResponse([homepageEntry])
+
+  try {
+    const allPages = await getSitemap()
+
+    if (!allPages) return getSitemapResponse([homepageEntry])
+
+    const pages = (allPages ?? []).filter((page) => !page.noIndex)
+    const sitemapEntries = pages.map((page: PageDoc) =>
+      createPageEntry(baseUrl, page.slug ?? null, page._updatedAt)
+    )
+
+    return getSitemapResponse(
+      sitemapEntries.length > 0 ? sitemapEntries : [homepageEntry]
+    )
+  } catch (error) {
+    console.error("Error generating sitemap.xml:", error)
+    return getSitemapResponse([homepageEntry])
+  }
+}

package/src/templates/next-pagebuilder/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