added auto generating for sitemap.

src/modules/frontend/createContentHelpers.ts

@@ -4,10 +4,19 @@ import { getPayload } from 'payload'
 import { cache } from 'react'
 
 import type { ArchiveEntries, ContentOption, ResolvedRoute } from '../content/index.js'
+import type { I18nConfig } from '../i18n/index.js'
+import type { RobotsRules, SitemapEntry } from '../seo/index.js'
 
 import { getArchiveEntries, resolveRoute as resolveRouteRaw } from '../content/index.js'
+import { buildRobots, buildSitemapEntries } from '../seo/index.js'
 
 type CreateContentHelpersArgs = {
+  /**
+   * Absolute site origin for sitemap/robots URLs. Falls back to
+   * NEXT_PUBLIC_SERVER_URL, then to a relative origin (which most crawlers
+   * reject, so set one in production).
+   */
+  baseUrl?: string
   /**
    * The client's payload config promise (the default export of payload.config).
    * Passed in because the plugin never imports the client's config directly.
@@ -15,6 +24,11 @@ type CreateContentHelpersArgs = {
   config: Promise<SanitizedConfig> | SanitizedConfig
   /** Archive-backed collections, same value as the plugin option. */
   content?: ContentOption
+  /**
+   * i18n config. Required only if you want the ready-made `sitemap` / `robots`
+   * handlers — they need the locale list to emit hreflang.
+   */
+  i18n?: I18nConfig
   /** Pages collection slug. Defaults to 'pages'. */
   pagesSlug?: string
   /** SiteSettings global slug. Defaults to 'site-settings'. */
@@ -48,11 +62,14 @@ type CreateContentHelpersArgs = {
  * not the second, and a page component composes them in two obvious lines.
  */
 export function createContentHelpers({
+  baseUrl,
   config,
   content,
+  i18n,
   pagesSlug = 'pages',
   settingsSlug = 'site-settings',
 }: CreateContentHelpersArgs) {
+  const origin = baseUrl ?? process.env.NEXT_PUBLIC_SERVER_URL ?? ''
   const getCachedPayload = cache(async (): Promise<BasePayload> =>
     getPayload({ config: await config }),
   )
@@ -92,5 +109,46 @@ export function createContentHelpers({
     },
   )
 
-  return { getCachedPayload, getConfiguredLocales, getEntries, getSettings, resolveRoute }
+  /**
+   * Ready-made handler for Next's `app/sitemap.ts` — every page and entry with
+   * per-URL hreflang and lastmod. Re-export it directly:
+   *
+   * ```ts
+   * // app/sitemap.ts
+   * export { sitemap as default } from '@/lib/content'
+   * ```
+   */
+  const sitemap = cache(async (): Promise<SitemapEntry[]> => {
+    if (!i18n) {
+      throw new Error('[ipal] createContentHelpers: pass `i18n` to use the sitemap handler.')
+    }
+    return buildSitemapEntries({
+      baseUrl: origin,
+      config: i18n,
+      content,
+      pagesSlug,
+      payload: await getCachedPayload(),
+      settingsSlug,
+    })
+  })
+
+  /**
+   * Ready-made handler for Next's `app/robots.ts`. Re-export directly:
+   *
+   * ```ts
+   * // app/robots.ts
+   * export { robots as default } from '@/lib/content'
+   * ```
+   */
+  const robots = (): RobotsRules => buildRobots({ baseUrl: origin })
+
+  return {
+    getCachedPayload,
+    getConfiguredLocales,
+    getEntries,
+    getSettings,
+    resolveRoute,
+    robots,
+    sitemap,
+  }
 }

src/modules/seo/buildRobots.ts

@@ -0,0 +1,49 @@
+type BuildRobotsArgs = {
+  /** Absolute origin, e.g. 'https://example.com'. */
+  baseUrl: string
+  /** Paths to disallow. Defaults to Payload's admin and API. */
+  disallow?: string[]
+  /** Whether to advertise the sitemap. Defaults to true. */
+  sitemap?: boolean
+}
+
+/**
+ * Shape for Next's `app/robots.ts`.
+ */
+export type RobotsRules = {
+  host?: string
+  rules: { allow?: string; disallow?: string[]; userAgent: string }
+  sitemap?: string
+}
+
+/**
+ * Builds robots rules that allow crawling everything except the admin panel and
+ * API, and point crawlers at the sitemap.
+ *
+ * ```ts
+ * // app/robots.ts
+ * export default function robots() {
+ *   return buildRobots({ baseUrl: process.env.NEXT_PUBLIC_SERVER_URL! })
+ * }
+ * ```
+ *
+ * The admin and API are disallowed by default — no reason for them in the index,
+ * and it keeps crawl budget on real content.
+ */
+export function buildRobots({
+  baseUrl,
+  disallow = ['/admin', '/api'],
+  sitemap = true,
+}: BuildRobotsArgs): RobotsRules {
+  const origin = baseUrl.replace(/\/$/, '')
+
+  return {
+    rules: {
+      allow: '/',
+      disallow,
+      userAgent: '*',
+    },
+    ...(sitemap ? { sitemap: `${origin}/sitemap.xml` } : {}),
+    host: origin,
+  }
+}

src/modules/seo/buildSitemapEntries.ts

@@ -0,0 +1,212 @@
+import type { BasePayload } from 'payload'
+
+import type { ContentOption } from '../content/index.js'
+import type { I18nConfig } from '../i18n/index.js'
+
+import { archiveFieldName } from '../content/index.js'
+import { buildLocalizedPath, getLocalizedSlugs  } from '../i18n/index.js'
+import { buildHreflangAlternates } from './hreflang.js'
+
+/**
+ * One sitemap entry, shaped for Next's `app/sitemap.ts`.
+ *
+ * `alternates.languages` is the important part for a multilingual site: Next
+ * renders it as `<xhtml:link rel="alternate" hreflang=…>` per URL, which is
+ * exactly what Google uses to connect language versions. A sitemap without it
+ * is the common, weaker kind.
+ */
+export type SitemapEntry = {
+  alternates?: { languages: Record<string, string> }
+  changeFrequency?: 'always' | 'daily' | 'hourly' | 'monthly' | 'never' | 'weekly' | 'yearly'
+  lastModified?: Date | string
+  priority?: number
+  url: string
+}
+
+type CollectionEntry = {
+  /** Localized segment for entries (archive page slugs), when applicable. */
+  prefixSlugs?: Record<string, string>
+  slug: string
+}
+
+type BuildSitemapArgs = {
+  /** Absolute origin, e.g. 'https://example.com'. Required for valid sitemap URLs. */
+  baseUrl: string
+  changeFrequency?: SitemapEntry['changeFrequency']
+  config: I18nConfig
+  /** Archive-backed collections, same value as the plugin option. */
+  content?: ContentOption
+  /**
+   * Slug of the page that is the site root (collapses to /{locale}).
+   * Read from System Pages when omitted.
+   */
+  homeSlug?: string
+  /** Pages collection slug. Defaults to 'pages'. */
+  pagesSlug?: string
+  payload: BasePayload
+  /** SiteSettings global slug. Defaults to 'site-settings'. */
+  settingsSlug?: string
+}
+
+type DocRow = {
+  _status?: string
+  id: number | string
+  meta?: { noindex?: boolean } | null
+  slug?: unknown
+  updatedAt?: string
+}
+
+/** Skip drafts and anything flagged noindex in the SEO tab. */
+function isIndexable(doc: DocRow): boolean {
+  if (doc._status && doc._status !== 'published') {return false}
+  if (doc.meta?.noindex) {return false}
+  return true
+}
+
+/**
+ * Turns one document into a sitemap entry per default locale isn't needed —
+ * one entry with all languages as alternates is the correct, de-duplicated
+ * shape. The `url` is the current locale's path; `alternates.languages` carries
+ * every locale (including itself, per Google's guidance).
+ */
+function entryFor(
+  doc: DocRow,
+  locale: string,
+  config: I18nConfig,
+  baseUrl: string,
+  homeSlug: string | undefined,
+  prefix: Record<string, string> | undefined,
+  changeFrequency: SitemapEntry['changeFrequency'],
+): null | SitemapEntry {
+  const slugs =
+    doc.slug && typeof doc.slug === 'object'
+      ? getLocalizedSlugs({ config, slugField: doc.slug as Record<string, unknown> })
+      : {}
+
+  const path = buildLocalizedPath({ config, homeSlug, locale, prefix, slugs })
+  if (!path) {return null}
+
+  const origin = baseUrl.replace(/\/$/, '')
+  const languages = buildHreflangAlternates({ baseUrl, config, homeSlug, prefix, slugs })
+
+  return {
+    url: `${origin}${path}`,
+    ...(doc.updatedAt ? { lastModified: doc.updatedAt } : {}),
+    ...(changeFrequency ? { changeFrequency } : {}),
+    ...(Object.keys(languages).length ? { alternates: { languages } } : {}),
+  }
+}
+
+/**
+ * Collects every public URL — pages and archive entries — as sitemap entries
+ * with per-URL hreflang and lastmod.
+ *
+ * Reuses the same path/hreflang builders as page metadata, so the sitemap can't
+ * drift from what the pages actually render (a classic source of sitemap bugs:
+ * a URL listed one way and served another). Drafts and noindex documents are
+ * omitted.
+ *
+ * ```ts
+ * // app/sitemap.ts
+ * export default async function sitemap() {
+ *   return buildSitemapEntries({
+ *     payload: await getPayload({ config }),
+ *     config: i18nConfig,
+ *     baseUrl: process.env.NEXT_PUBLIC_SERVER_URL!,
+ *     content: contentConfig,
+ *   })
+ * }
+ * ```
+ */
+export async function buildSitemapEntries({
+  baseUrl,
+  changeFrequency = 'weekly',
+  config,
+  content,
+  homeSlug,
+  pagesSlug = 'pages',
+  payload,
+  settingsSlug = 'site-settings',
+}: BuildSitemapArgs): Promise<SitemapEntry[]> {
+  const locales = config.locales.map((l) => l.code)
+  const defaultLocale = config.defaultLocale
+
+  // Resolve homeSlug and archive prefixes from System Pages (read once, in all
+  // locales so archive prefixes are available per language).
+  const settings = (await payload.findGlobal({
+    slug: settingsSlug as never,
+    depth: 1,
+    locale: 'all' as never,
+  })) as Record<string, unknown>
+
+  const resolvedHomeSlug =
+    homeSlug ?? extractSlugInLocale(settings.homepage, defaultLocale) ?? 'home'
+
+  // Which collections to walk: pages (no prefix) + each content collection with
+  // its archive-page slugs as the localized prefix.
+  const collections: CollectionEntry[] = [{ slug: pagesSlug }]
+
+  for (const c of content?.collections ?? []) {
+    const archive = settings[archiveFieldName(c.slug)]
+    const prefixSlugs = archive ? slugMapAllLocales(archive, locales) : undefined
+    collections.push({ slug: c.slug, prefixSlugs })
+  }
+
+  const entries: SitemapEntry[] = []
+
+  for (const collection of collections) {
+    // Read every doc once, across locales, so one row yields all its language
+    // alternates without re-querying per locale.
+    const result = await payload.find({
+      collection: collection.slug as never,
+      depth: 0,
+      limit: 0, // no pagination — sitemap wants everything
+      locale: 'all' as never,
+      pagination: false as never,
+    })
+
+    for (const raw of result.docs as DocRow[]) {
+      if (!isIndexable(raw)) {continue}
+
+      // Emit the entry under the default locale's URL; alternates cover the rest.
+      const entry = entryFor(
+        raw,
+        defaultLocale,
+        config,
+        baseUrl,
+        resolvedHomeSlug,
+        collection.prefixSlugs,
+        changeFrequency,
+      )
+      if (entry) {entries.push(entry)}
+    }
+  }
+
+  return entries
+}
+
+/** Pulls a slug string from a populated relationship in a specific locale. */
+function extractSlugInLocale(rel: unknown, locale: string): string | undefined {
+  if (!rel || typeof rel !== 'object') {return undefined}
+  const slug = (rel as { slug?: unknown }).slug
+  if (typeof slug === 'string') {return slug}
+  if (slug && typeof slug === 'object') {
+    const v = (slug as Record<string, unknown>)[locale]
+    return typeof v === 'string' ? v : undefined
+  }
+  return undefined
+}
+
+/** Builds a locale→slug map from a populated archive relationship. */
+function slugMapAllLocales(rel: unknown, locales: string[]): Record<string, string> | undefined {
+  if (!rel || typeof rel !== 'object') {return undefined}
+  const slug = (rel as { slug?: unknown }).slug
+  if (!slug || typeof slug !== 'object') {return undefined}
+
+  const map: Record<string, string> = {}
+  for (const locale of locales) {
+    const v = (slug as Record<string, unknown>)[locale]
+    if (typeof v === 'string') {map[locale] = v}
+  }
+  return Object.keys(map).length ? map : undefined
+}

src/modules/seo/index.ts

@@ -2,6 +2,10 @@ export { buildAutoFillMetaHook } from './autoFillMeta.js'
 export type { AutoFillMapping } from './autoFillMeta.js'
 export { buildMetadata } from './buildMetadata.js'
 export type { PageMetadata } from './buildMetadata.js'
+export { buildRobots } from './buildRobots.js'
+export type { RobotsRules } from './buildRobots.js'
+export { buildSitemapEntries } from './buildSitemapEntries.js'
+export type { SitemapEntry } from './buildSitemapEntries.js'
 export { composeTitle } from './composeTitle.js'
 export type { TitleOrder } from './composeTitle.js'
 export { createMetadataGenerator } from './createMetadataGenerator.js'