@justanarthur/payload-www 1.4.2 → 2.0.1

package/dist/render-pages.js

@@ -1,7 +1,4 @@
-
-
 // src/render/pages/FooterPage.tsx
-import"server-only";
 import { jsx, jsxs } from "react/jsx-runtime";
 function FooterPage({ data }) {
   const nav = data.nav ?? [];
@@ -59,7 +56,6 @@ function FooterPage({ data }) {
 }
 
 // src/render/pages/HeaderPage.tsx
-import"server-only";
 import { jsx as jsx2, jsxs as jsxs2 } from "react/jsx-runtime";
 function HeaderPage({ data }) {
   const nav = data.nav ?? [];
@@ -208,7 +204,7 @@ async function PostsPage({ doc, locale, ...props }) {
 }
 
 // src/render/pages/createCollectionPageExports.tsx
-import"server-only";
+import * as React from "react";
 
 // src/render/metadata/slug.ts
 var SLUG_NESTED_DIVIDER = "_";
@@ -229,135 +225,112 @@ function slugToPath(slug) {
 }
 
 // src/render/metadata/query.ts
+import { createCacheHelpers } from "@pro-laico/payload-revalidate/cache";
+import { tagsFor } from "@pro-laico/payload-revalidate";
+import { cacheLife } from "next/cache";
 import { getPayload } from "payload";
-
-// src/collections/hooks/createRevalidateCollectionGlobalHook.ts
-import { revalidateTag } from "next/cache";
-function createRevalidateCollectionGlobalHook() {
-  const afterChangeDeleteHook = async ({ doc, req, ...args }) => {
-    const previousDoc = "previousDoc" in args ? args.previousDoc : null, locale = req.locale;
-    function revalidate(args2) {
-      try {
-        revalidateTag(createCollectionCacheKey({ ...args2, locale }), "max");
-      } catch (error) {
-        const msg = error instanceof Error ? error.message : String(error);
-        if (msg.includes("static generation store missing"))
-          return;
-        console.error(error);
-      }
-    }
-    if ("collection" in args) {
-      [
-        doc && doc._status !== "draft" && doc.slug,
-        previousDoc && previousDoc._status === "published" && previousDoc.slug
-      ].filter((slug) => slug !== undefined && slug !== false).map((slug) => revalidate({ collectionSlug: args.collection.slug, slug }));
-    } else {
-      revalidate({ globalSlug: args.global.slug });
-    }
-    return doc;
-  };
-  return { afterChange: afterChangeDeleteHook, afterDelete: afterChangeDeleteHook };
-}
-function createCollectionCacheKey(args) {
-  return `${"globalSlug" in args ? args.globalSlug : args.collectionSlug + args.slug}_${args.locale}`;
+var _helpers = null;
+var _seedPromise = null;
+function seedPayloadCache({ config }) {
+  if (_helpers || _seedPromise)
+    return;
+  _seedPromise = (async () => {
+    const payload = await getPayload({ config: await config });
+    _helpers = createCacheHelpers(payload);
+  })();
 }
-
-// src/render/metadata/query.ts
-async function withUnstableCache(keyParts, tags, fn) {
-  const { unstable_cache } = await import("next/cache");
-  return unstable_cache(fn, keyParts.map(String), { tags })();
+async function requireCacheHelpers() {
+  if (_helpers)
+    return _helpers;
+  if (_seedPromise) {
+    await _seedPromise;
+    if (_helpers)
+      return _helpers;
+  }
+  throw new Error("[payload-www] seedPayloadCache({ config }) must be called before any query getter. " + "Call it from createCollectionPageExports / createRootLayoutExports factory, or in your root layout.");
 }
-async function queryDoc(args, { config: configPromise }) {
-  return withUnstableCache(Object.values(args), [createCollectionCacheKey(args)], async () => {
-    if ("globalSlug" in args)
-      return queryGlobal({ ...args, config: configPromise });
-    else
-      return queryDocBySlug({ ...args, config: configPromise });
+async function queryDocBySlug(args) {
+  "use cache";
+  cacheLife("weeks");
+  const { findDoc } = await requireCacheHelpers();
+  const slugField = args.slugField ?? "slug";
+  const result = await findDoc(args.collectionSlug, {
+    where: { [slugField]: { equals: args.slug } },
+    locale: args.locale,
+    draft: args.draft ?? false,
+    depth: args.depth
   });
+  return result ?? null;
 }
-async function queryDocBySlug({
-  collectionSlug,
-  slug,
-  slugField = "slug",
-  locale,
-  draft = false,
-  config
-}) {
-  return withUnstableCache([collectionSlug, slug, locale, draft], [createCollectionCacheKey({ collectionSlug, slug, locale })], async () => {
-    const payload = await getPayload({ config });
-    const result = await payload.find({
-      collection: collectionSlug,
-      draft,
-      limit: 1,
-      pagination: false,
-      overrideAccess: draft,
-      where: { [slugField]: { equals: slug } },
-      locale
+async function queryGlobal(args) {
+  "use cache";
+  cacheLife("weeks");
+  const { findGlobal } = await requireCacheHelpers();
+  try {
+    const result = await findGlobal(args.globalSlug, {
+      locale: args.locale,
+      draft: args.draft ?? false,
+      depth: args.depth
     });
-    return result.docs?.[0] ?? null;
-  });
+    return result ?? null;
+  } catch (error) {
+    console.warn("[WWW] queryGlobal failed", { globalSlug: args.globalSlug, locale: args.locale, error: String(error) });
+    return null;
+  }
 }
-async function queryGlobal({
-  globalSlug,
-  locale,
-  draft = false,
-  config
-}) {
-  return withUnstableCache([globalSlug, locale, draft], [createCollectionCacheKey({ globalSlug, locale })], async () => {
-    const payload = await getPayload({ config });
-    try {
-      return await payload.findGlobal({ slug: globalSlug, draft, locale });
-    } catch (error) {
-      console.warn("[WWW] queryGlobal failed", { globalSlug, locale, error: String(error) });
-      return null;
-    }
-  });
+async function queryAllDocs(args) {
+  "use cache";
+  cacheLife("weeks");
+  const { findIds, findDocByID } = await requireCacheHelpers();
+  const collection = args.collectionSlug;
+  const { ids } = await findIds(collection, { locale: args.locale });
+  if (ids.length === 0)
+    return [];
+  const docs = await Promise.all(ids.map((id) => findDocByID(collection, id, { locale: args.locale })));
+  return docs.filter((d) => d !== null);
 }
-async function queryAllDocs({
-  collectionSlug,
-  slugField = "slug",
-  locale,
-  config
-}) {
-  return withUnstableCache([collectionSlug, slugField, locale], [createCollectionCacheKey({ collectionSlug, slug: "__all__", locale })], async () => {
-    const payload = await getPayload({ config });
-    const result = await payload.find({
-      collection: collectionSlug,
-      draft: false,
-      limit: 1000,
-      pagination: false,
-      overrideAccess: false,
-      select: { [slugField]: true },
-      locale
-    });
-    return result.docs ?? [];
-  });
+async function queryDoc(args) {
+  if ("globalSlug" in args)
+    return queryGlobal(args);
+  return queryDocBySlug(args);
 }
-async function queryAllLocaleSlugs({
-  collectionSlug,
-  id,
-  slugField = "slug",
-  config
-}) {
-  const payload = await getPayload({ config });
-  const doc = await payload.findByID({
-    collection: collectionSlug,
-    id,
-    locale: "all",
-    select: { [slugField]: true }
+async function queryAllLocaleSlugs(args) {
+  "use cache";
+  cacheLife("weeks");
+  const { findDocByID } = await requireCacheHelpers();
+  const slugField = args.slugField ?? "slug";
+  const doc = await findDocByID(args.collectionSlug, args.id, { locale: "all", select: { [slugField]: true } });
+  const localeMap = doc?.[slugField];
+  if (localeMap && typeof localeMap === "object")
+    return localeMap;
+  return null;
+}
+async function queryDocByID(args) {
+  "use cache";
+  cacheLife("weeks");
+  const { findDocByID } = await requireCacheHelpers();
+  return await findDocByID(args.collectionSlug, args.id, {
+    locale: args.locale,
+    draft: args.draft ?? false,
+    depth: args.depth
   });
-  return doc?.[slugField];
 }
 
 // src/render/pages/createCollectionPageExports.tsx
 import { setRequestLocale } from "next-intl/server";
 
 // src/render/pages/utils/buildLocalizedPath.ts
+function resolvePagePathPrefix(prefix, locale, routing) {
+  if (typeof prefix !== "object")
+    return prefix;
+  return prefix[locale] ?? prefix[routing.defaultLocale];
+}
 function buildLocalizedPath(locale, prefix, slug, { routing }) {
   const path = slugToPath(slug);
+  const localePrefix = resolvePagePathPrefix(prefix, locale, routing);
   return `${routing.localePrefix === "never" ? "" : routing.localePrefix === "always" ? locale : routing.localePrefix === "as-needed" ? locale === routing.defaultLocale ? "" : "/" + locale : (() => {
     throw new Error("Unsupported locale prefix");
-  })()}${prefix ? "/" + prefix : ""}${path ? "/" + path : ""}`;
+  })()}${localePrefix ? "/" + localePrefix : ""}${path ? "/" + path : ""}`;
 }
 function buildLocalizedPaths(localesSlug, pagePathPrefix, { routing }) {
   const blankIsHome = !localesSlug[routing.defaultLocale];
@@ -412,25 +385,31 @@ async function renderWWWDataModule(data, {
 import { jsx as jsx7, Fragment as Fragment2 } from "react/jsx-runtime";
 function createCollectionPageExports({
   slug: collectionSlug = "pages",
-  config: configPromise,
+  _payloadConfig,
   importMap,
   routing,
   slugShape = "single"
 }, {
   getServerSideURL,
-  pagePathPrefix
+  pagePathPrefix,
+  fallback
 }) {
+  seedPayloadCache({ config: _payloadConfig });
   const siteUrl = getServerSideURL();
   async function fetchDoc(locale, slug) {
     return queryDoc({
       slug,
       locale,
       collectionSlug
-    }, {
-      config: configPromise
     });
   }
-  const default_ = async (props) => {
+  const default_ = (props) => /* @__PURE__ */ jsx7(React.Suspense, {
+    fallback: fallback ?? null,
+    children: /* @__PURE__ */ jsx7(CollectionDocument, {
+      ...props
+    })
+  });
+  const CollectionDocument = async (props) => {
     const params = await props.params;
     const locale = params.locale;
     if (!routing.locales.includes(locale)) {
@@ -444,22 +423,25 @@ function createCollectionPageExports({
       const { notFound } = await import("next/navigation");
       notFound();
     }
-    const rendered = renderWWWDataModule(doc, { collectionSlug, config: configPromise, importMap }, { ...props, locale });
+    const rendered = renderWWWDataModule(doc, { collectionSlug, config: _payloadConfig, importMap }, { ...props, locale });
     return /* @__PURE__ */ jsx7(Fragment2, {
       children: rendered
     });
   };
   async function generateMetadata(props) {
     const params = await props.params;
-    const locale = params.locale, slug = paramsSlugToSlug(params.slug, slugShape);
+    const locale = params.locale;
+    if (!routing.locales.includes(locale)) {
+      return {};
+    }
+    const slug = paramsSlugToSlug(params.slug, slugShape);
     const doc = await fetchDoc(locale, slug);
     const [localesSlug, siteDefaults] = await Promise.all([
       doc ? queryAllLocaleSlugs({
         id: doc.id,
-        collectionSlug,
-        config: configPromise
+        collectionSlug
       }) : Promise.resolve({}),
-      createSiteDefaults({ config: configPromise, locale })
+      createSiteDefaults({ config: _payloadConfig, locale })
     ]);
     if (!doc)
       return {};
@@ -476,22 +458,23 @@ function createCollectionPageExports({
     return { ...meta, alternates };
   }
   async function generateStaticParams(props) {
-    const locale = (await props.params).locale;
-    const docs = await queryAllDocs({ locale, collectionSlug, config: configPromise });
-    return docs.filter((doc) => typeof doc.slug === "string" && doc.slug.length > 0).map((doc) => ({ slug: slugToParamsSlug(doc.slug, slugShape) }));
+    await props.params;
+    const perLocaleEntries = await Promise.all(routing.locales.map(async (locale) => {
+      const docs = await queryAllDocs({ locale, collectionSlug });
+      return docs.filter((doc) => typeof doc.slug === "string" && doc.slug.length > 0).map((doc) => ({ locale, slug: slugToParamsSlug(doc.slug, slugShape) }));
+    }));
+    return perLocaleEntries.flat();
   }
   async function generateSitemap() {
     const locale = routing.defaultLocale;
     const docs = await queryAllDocs({
       collectionSlug,
-      locale,
-      config: configPromise
+      locale: routing.defaultLocale
     });
     return await Promise.all(docs.map(async (doc) => {
       const localesSlug = await queryAllLocaleSlugs({
         id: doc.id,
-        collectionSlug,
-        config: configPromise
+        collectionSlug
       }) ?? {};
       const alternates = buildAlternates(locale, localesSlug, pagePathPrefix, { routing, siteUrl });
       return {
@@ -502,7 +485,7 @@ function createCollectionPageExports({
     }));
   }
   generateSitemap.getServerSideURL = getServerSideURL;
-  generateSitemap.pagePathPrefix = pagePathPrefix;
+  generateSitemap.pagePathPrefix = resolvePagePathPrefix(pagePathPrefix, routing.defaultLocale, routing);
   return {
     default: default_,
     generateMetadata,
@@ -526,13 +509,23 @@ ${sitemaps.map((url) => `  <sitemap><loc>${url}</loc></sitemap>`).join(`
 }
 
 // src/render/pages/createRootLayoutExports.tsx
-import"server-only";
+import { Activity } from "react";
 import { setRequestLocale as setRequestLocale2 } from "next-intl/server";
 import { NextIntlClientProvider } from "next-intl";
 import { RootJsonLd } from "@justanarthur/payload-plugin-seo/root-jsonld";
+import * as rootParams from "next/root-params";
 import { jsx as jsx8, jsxs as jsxs4 } from "react/jsx-runtime";
+var readLocaleRootParam = rootParams.locale;
+async function resolveLocale(props) {
+  if (readLocaleRootParam) {
+    const locale = await readLocaleRootParam();
+    if (locale)
+      return locale;
+  }
+  return (await props.params).locale;
+}
 function createRootLayoutExports({
-  config: configPromise,
+  _payloadConfig,
   importMap,
   routing
 }, {
@@ -540,9 +533,9 @@ function createRootLayoutExports({
   htmlAttrs,
   getServerSideURL
 } = {}) {
+  seedPayloadCache({ config: _payloadConfig });
   async function RootLayout(props) {
-    const params = await props.params;
-    const locale = params.locale;
+    const locale = await resolveLocale(props);
     if (!routing.locales.includes(locale)) {
       const { notFound } = await import("next/navigation");
       return notFound();
@@ -552,17 +545,17 @@ function createRootLayoutExports({
       header,
       footer
     ] = await Promise.all([
-      queryDoc({ globalSlug: "header", locale }, { config: configPromise }),
-      queryDoc({ globalSlug: "footer", locale }, { config: configPromise })
+      queryDoc({ globalSlug: "header", locale }),
+      queryDoc({ globalSlug: "footer", locale })
     ]);
-    const renderedHeader = renderWWWDataModule(header, { collectionSlug: "header", configPath: "globals", config: configPromise, importMap }, { ...props, locale }), renderedFooter = renderWWWDataModule(footer, { collectionSlug: "footer", configPath: "globals", config: configPromise, importMap }, { ...props, locale });
+    const renderedHeader = renderWWWDataModule(header, { collectionSlug: "header", configPath: "globals", config: _payloadConfig, importMap }, { ...props, locale }), renderedFooter = renderWWWDataModule(footer, { collectionSlug: "footer", configPath: "globals", config: _payloadConfig, importMap }, { ...props, locale });
     const mergedHtmlAttrs = {
       lang: locale,
       suppressHydrationWarning: true,
       ...htmlAttrs?.(locale) ?? {}
     };
     const rootJsonLd = getServerSideURL ? /* @__PURE__ */ jsx8(RootJsonLd, {
-      config: configPromise,
+      config: _payloadConfig,
       locale,
       getServerSideURL,
       locales: routing.locales
@@ -573,9 +566,13 @@ function createRootLayoutExports({
         children: /* @__PURE__ */ jsxs4(NextIntlClientProvider, {
           children: [
             rootJsonLd,
-            renderedHeader,
+            /* @__PURE__ */ jsx8(Activity, {
+              children: renderedHeader
+            }),
             providers ? providers({ children: props.children, locale }) : props.children,
-            renderedFooter
+            /* @__PURE__ */ jsx8(Activity, {
+              children: renderedFooter
+            })
           ]
         })
       })
@@ -592,12 +589,12 @@ import { RootJsonLd as RootJsonLd2 } from "@justanarthur/payload-plugin-seo/root
 var renderPages = { createCollectionPageExports, createRootLayoutExports, PagesPage, PostsPage, HeaderPage, FooterPage, RootJsonLd: RootJsonLd2 };
 var render_pages_default = renderPages;
 export {
-  render_pages_default as default,
-  createRootLayoutExports,
-  createCollectionPageExports,
-  RootJsonLd2 as RootJsonLd,
-  PostsPage,
-  PagesPage,
+  FooterPage,
   HeaderPage,
-  FooterPage
+  PagesPage,
+  PostsPage,
+  RootJsonLd2 as RootJsonLd,
+  createCollectionPageExports,
+  createRootLayoutExports,
+  render_pages_default as default
 };

package/dist/sitemap.d.ts

@@ -1,10 +1,26 @@
+import { ReactNode as ReactNode2 } from "react";
+/**
+* URL segment a collection is mounted under. A string is used for every locale; a record
+* localizes it (`{ en: 'posts', sk: 'prispevky' }`), so a host serving localized routes
+* gets canonical/hreflang URLs that match the URLs it actually serves. Locales missing
+* from the record fall back to the default locale.
+*/
+type PagePathPrefix = string | Record<string, string>;
 type CreateCollectionPageExportsDeps<S extends string> = {
 	getServerSideURL: () => string;
-	pagePathPrefix?: string;
+	pagePathPrefix?: PagePathPrefix;
+	/** Rendered while the document streams. Defaults to nothing. */
+	fallback?: ReactNode2;
 };
 type GenerateSitemapPageExportsArgs = CreateCollectionPageExportsDeps<any>;
 declare function createSitemapFromCollections(...args: GenerateSitemapPageExportsArgs[]): () => Response;
+import { SanitizedConfig as SanitizedConfig2 } from "payload";
+type SeedPayloadCacheArgs = {
+	config: SanitizedConfig2 | Promise<SanitizedConfig2>;
+};
+declare function seedPayloadCache({ config }: SeedPayloadCacheArgs): void;
 declare const _default: {
 	createSitemapFromCollections: typeof createSitemapFromCollections;
+	seedPayloadCache: typeof seedPayloadCache;
 };
-export { _default as default, createSitemapFromCollections };
+export { createSitemapFromCollections, _default as default, seedPayloadCache };