@justanarthur/payload-www 1.4.2 → 2.0.1

package/dist/pages.d.ts

@@ -22,21 +22,31 @@ type NextPageProps = {
 };
 import { RoutingConfig as GenericRoutingConfig } from "next-intl/routing";
 type RoutingConfig = GenericRoutingConfig<string[], any, any, any>;
+/**
+* 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 CreateCollectionPageExportsArgs<S extends string = "pages"> = {
 	slug?: S;
-	config: Promise<SanitizedConfig2>;
+	_payloadConfig: Promise<SanitizedConfig2>;
 	importMap: ImportMap3;
 	routing: RoutingConfig;
 	slugShape?: SlugShape;
 };
 type CreateCollectionPageExportsDeps<S extends string> = {
 	getServerSideURL: () => string;
-	pagePathPrefix?: string;
+	pagePathPrefix?: PagePathPrefix;
+	/** Rendered while the document streams. Defaults to nothing. */
+	fallback?: ReactNode2;
 };
-declare function createCollectionPageExports<S extends string = "pages">({ slug: collectionSlug, config: configPromise, importMap, routing, slugShape }: CreateCollectionPageExportsArgs<S>, { getServerSideURL, pagePathPrefix }: CreateCollectionPageExportsDeps<S>): {
-	default: (props: NextPageProps) => Promise<ReactNode2>;
+declare function createCollectionPageExports<S extends string = "pages">({ slug: collectionSlug, _payloadConfig, importMap, routing, slugShape }: CreateCollectionPageExportsArgs<S>, { getServerSideURL, pagePathPrefix, fallback }: CreateCollectionPageExportsDeps<S>): {
+	default: (props: NextPageProps) => ReactNode2;
 	generateMetadata: (props: NextPageProps) => Promise<Metadata>;
 	generateStaticParams: (props: NextPageProps) => Promise<{
+		locale: string;
 		slug: string | string[];
 	}[]>;
 	generateSitemap: {
@@ -51,4 +61,4 @@ declare const pages: {
 	HeaderPage: typeof HeaderPage;
 	FooterPage: typeof FooterPage;
 };
-export { pages as default, createCollectionPageExports, PagesPage, HeaderPage, FooterPage, CreateCollectionPageExportsDeps, CreateCollectionPageExportsArgs };
+export { CreateCollectionPageExportsArgs, CreateCollectionPageExportsDeps, FooterPage, HeaderPage, PagesPage, createCollectionPageExports, pages as default };

package/dist/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 ?? [];
@@ -178,7 +174,7 @@ async function PagesPage({ data, locale, ...props }) {
 }
 
 // src/render/pages/createCollectionPageExports.tsx
-import"server-only";
+import * as React from "react";
 
 // src/render/metadata/slug.ts
 var SLUG_NESTED_DIVIDER = "_";
@@ -199,135 +195,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];
@@ -382,25 +355,31 @@ async function renderWWWDataModule(data, {
 import { jsx as jsx6, 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__ */ jsx6(React.Suspense, {
+    fallback: fallback ?? null,
+    children: /* @__PURE__ */ jsx6(CollectionDocument, {
+      ...props
+    })
+  });
+  const CollectionDocument = async (props) => {
     const params = await props.params;
     const locale = params.locale;
     if (!routing.locales.includes(locale)) {
@@ -414,22 +393,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__ */ jsx6(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 {};
@@ -446,22 +428,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 {
@@ -472,7 +455,7 @@ function createCollectionPageExports({
     }));
   }
   generateSitemap.getServerSideURL = getServerSideURL;
-  generateSitemap.pagePathPrefix = pagePathPrefix;
+  generateSitemap.pagePathPrefix = resolvePagePathPrefix(pagePathPrefix, routing.defaultLocale, routing);
   return {
     default: default_,
     generateMetadata,
@@ -499,9 +482,9 @@ ${sitemaps.map((url) => `  <sitemap><loc>${url}</loc></sitemap>`).join(`
 var pages = { createCollectionPageExports, PagesPage, HeaderPage, FooterPage };
 var pages_default = pages;
 export {
-  pages_default as default,
-  createCollectionPageExports,
-  PagesPage,
+  FooterPage,
   HeaderPage,
-  FooterPage
+  PagesPage,
+  createCollectionPageExports,
+  pages_default as default
 };

package/dist/render-pages.d.ts

@@ -31,21 +31,31 @@ type NextLayoutProps = {
 };
 import { RoutingConfig as GenericRoutingConfig } from "next-intl/routing";
 type RoutingConfig = GenericRoutingConfig<string[], any, any, any>;
+/**
+* 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 CreateCollectionPageExportsArgs<S extends string = "pages"> = {
 	slug?: S;
-	config: Promise<SanitizedConfig2>;
+	_payloadConfig: Promise<SanitizedConfig2>;
 	importMap: ImportMap3;
 	routing: RoutingConfig;
 	slugShape?: SlugShape;
 };
 type CreateCollectionPageExportsDeps<S extends string> = {
 	getServerSideURL: () => string;
-	pagePathPrefix?: string;
+	pagePathPrefix?: PagePathPrefix;
+	/** Rendered while the document streams. Defaults to nothing. */
+	fallback?: ReactNode2;
 };
-declare function createCollectionPageExports<S extends string = "pages">({ slug: collectionSlug, config: configPromise, importMap, routing, slugShape }: CreateCollectionPageExportsArgs<S>, { getServerSideURL, pagePathPrefix }: CreateCollectionPageExportsDeps<S>): {
-	default: (props: NextPageProps) => Promise<ReactNode2>;
+declare function createCollectionPageExports<S extends string = "pages">({ slug: collectionSlug, _payloadConfig, importMap, routing, slugShape }: CreateCollectionPageExportsArgs<S>, { getServerSideURL, pagePathPrefix, fallback }: CreateCollectionPageExportsDeps<S>): {
+	default: (props: NextPageProps) => ReactNode2;
 	generateMetadata: (props: NextPageProps) => Promise<Metadata>;
 	generateStaticParams: (props: NextPageProps) => Promise<{
+		locale: string;
 		slug: string | string[];
 	}[]>;
 	generateSitemap: {
@@ -56,9 +66,9 @@ declare function createCollectionPageExports<S extends string = "pages">({ slug:
 };
 import { ImportMap as ImportMap4, SanitizedConfig as SanitizedConfig3 } from "payload";
 import { HTMLAttributes, ReactNode as ReactNode3 } from "react";
-import { JSX as JSX_1kxb2 } from "react/jsx-runtime";
+import { JSX as JSX_1kxb2 } from "react";
 type CreateRootLayoutExportsArgs = {
-	config: Promise<SanitizedConfig3>;
+	_payloadConfig: Promise<SanitizedConfig3>;
 	importMap: ImportMap4;
 	routing: RoutingConfig;
 };
@@ -72,7 +82,7 @@ type CreateRootLayoutExportsDeps = {
 	getServerSideURL?: () => string;
 };
 type Element_12xgc2 = JSX_1kxb2["Element"];
-declare function createRootLayoutExports({ config: configPromise, importMap, routing }: CreateRootLayoutExportsArgs, { providers, htmlAttrs, getServerSideURL }?: CreateRootLayoutExportsDeps): {
+declare function createRootLayoutExports({ _payloadConfig, importMap, routing }: CreateRootLayoutExportsArgs, { providers, htmlAttrs, getServerSideURL }?: CreateRootLayoutExportsDeps): {
 	default: (props: NextLayoutProps) => Promise<Element_12xgc2>;
 	generateStaticParams: () => {
 		locale: string;
@@ -89,4 +99,4 @@ declare const renderPages: {
 	FooterPage: typeof FooterPage;
 	RootJsonLd: any;
 };
-export { renderPages as default, createRootLayoutExports, createCollectionPageExports, RootJsonLdProps, RootJsonLd, PostsPage, PagesPage, HeaderPage, FooterPage, CreateRootLayoutProvidersArgs, CreateRootLayoutExportsDeps, CreateRootLayoutExportsArgs, CreateCollectionPageExportsDeps, CreateCollectionPageExportsArgs };
+export { CreateCollectionPageExportsArgs, CreateCollectionPageExportsDeps, CreateRootLayoutExportsArgs, CreateRootLayoutExportsDeps, CreateRootLayoutProvidersArgs, FooterPage, HeaderPage, PagesPage, PostsPage, RootJsonLd, RootJsonLdProps, createCollectionPageExports, createRootLayoutExports, renderPages as default };