@justanarthur/payload-www 1.4.2 → 2.0.1

package/README.md

@@ -13,14 +13,14 @@ The composition root is `createWWWConfig()` — see [Quick start](#quick-start)
 | piece | exported from | purpose |
 |---|---|---|
 | Composer | [`/config`](#quick-start) | `createWWWConfig()` — returns `{ withWWWConfig }`. One call wires Pages + Posts + Header + Footer + the default plugin set. |
-| Pages + Posts collections | `createPagesCollection`, `createPostsCollection` (internal — composed by the composer) | Pages (title, blocks tab, slug, drafts, revalidation); Posts (title, excerpt, richText, drafts, revalidation). |
+| Pages + Posts collections | `createPagesCollection`, `createPostsCollection` (internal — composed by the composer) | Pages (title, blocks tab, slug, drafts); Posts (title, excerpt, richText, drafts). Caching comes from the host's `revalidatePlugin()` registration. |
 | Header + Footer globals | `createHeaderGlobal`, `createFooterGlobal` (internal) | Both nav blocks with `navColumn` / `navItem`. Extend via `link({ extraFields })`. |
 | Static-page collection | `createWWWCollectionGlobal` ([`/collections`](#collections)) | Generic factory for system pages (404, 500, search-empty) — keyed by a discriminator, no slug. |
 | Default plugins | composed by `createWWWConfig()` | `seoPlugin`, `imageHashPlugin`, `translator`, `mcpPlugin`. Tune via `defaultPluginsConfigs`. |
 | Fields | [`/fields`](#fields) | `link`, `linkGroup` (with `disableLabel` / `appearances` / `localized` / `relationTo` / `extraFields`), `slugField`, `appearanceOptions`. |
 | Access | [`/access`](#access) | `anyone`, `authenticated`, `authenticatedOrPublished`. |
-| Revalidation hooks | [`/collections`](#collections) (`createRevalidateCollectionGlobalHook`, `createCollectionCacheKey`, `populatePublishedAt`) | Tag-based cache invalidation + published-at population. |
-| Metadata | [`/metadata`](#metadata) | `buildArticleLd`, `buildBreadcrumbsLd`, `buildOrganizationLd`, `buildWebSiteLd`, `buildProductLd`, `buildRootJsonLd`; slug transforms; `queryDocBySlug`, `queryAllDocs`, `queryAllLocaleSlugs`. |
+| Caching | [`Caching`](#caching) | Cached query getters wrap `@pro-laico/payload-revalidate` finders; tag-based invalidation via `revalidatePlugin()`; `seedPayloadCache` singleton seed. |
+| Metadata | [`/metadata`](#metadata) | `buildArticleLd`, `buildBreadcrumbsLd`, `buildOrganizationLd`, `buildWebSiteLd`, `buildProductLd`, `buildRootJsonLd`; slug transforms; `queryDocBySlug`, `queryDocByID`, `queryGlobal`, `queryAllDocs`, `queryAllLocaleSlugs`; `seedPayloadCache`, `tagsFor`. |
 | Next.js page renderers | [`/render-pages`](#render-pages) | `createCollectionPageExports`, `createRootLayoutExports`; default render components `PagesPage`, `PostsPage`, `HeaderPage`, `FooterPage`, `RootJsonLd`. |
 | Sitemap | [`/sitemap`](#sitemap) | `createSitemapFromCollections` (Next.js file-convention helper). |
 | Plugin re-exports | [`/imagehash`](#plugin-re-exports), [`/translator`](#plugin-re-exports) | Drop-in for hosts that don't want to import the sibling packages directly. |
@@ -140,7 +140,7 @@ const { default: PostPage, generateMetadata, generateStaticParams } = createColl
 | dep | type | notes |
 |---|---|---|
 | `getServerSideURL` | `() => string` | host's absolute-URL helper |
-| `pagePathPrefix` | `string` | optional URL prefix for `generateSitemap` only — not used for rendering |
+| `pagePathPrefix` | `string \| Record<locale, string>` | URL segment the collection is mounted under, used for `generateSitemap` and for canonical/hreflang URLs. Pass a record to localize the segment (`{ en: 'posts', sk: 'prispevky' }`); locales absent from it fall back to the default locale. The sitemap *index* route always uses the default locale's segment. |
 
 ### What you get back
 
@@ -193,9 +193,10 @@ export default createSitemapFromCollections({
 `createCollectionPageExports`'s deps accept) and returns a Next.js `MetadataRoute.Sitemap`-compatible
 function. Mount one per collection under a sub-route, or a single call for the root.
 
-The lib's Pages `afterChange` hook fires `revalidateTag(collection_pages_<slug>_<locale>, 'max')`,
-which is the key `createCollectionPageExports` / `createSitemapFromCollections` reads from — so
-edits refresh the sitemap without manual rebuilds.
+The lib reads through `@pro-laico/payload-revalidate`'s cached finders, so registering
+`revalidatePlugin()` in `payload.config.ts` makes every collection / global save revalidate
+its tags automatically — no lib-side hooks to wire. Edits refresh the sitemap without
+manual rebuilds.
 
 ## Static pages (404 / 500 / system)
 
@@ -213,16 +214,14 @@ const { default: NotFound } = createCollectionPageExports(
 export default NotFound
 ```
 
-The `static-pages` collection is built via `createWWWCollectionGlobal({...}, { slug: 'static-pages', renderPath: '@/components/StaticPage/Component#StaticPage', isDraft: false })`. Editors pick a `kind` (`'not-found'`, `'server-error'`, `'search-empty'`, `'offline'`), populate the `blocks` tab with the same block set you passed to `createWWWConfig`, and the host's not-found / server-error route renders the row. `populatePublishedAt` and the revalidation hooks are wired automatically.
+The `static-pages` collection is built via `createWWWCollectionGlobal({...}, { slug: 'static-pages', renderPath: '@/components/StaticPage/Component#StaticPage', isDraft: false })`. Editors pick a `kind` (`'not-found'`, `'server-error'`, `'search-empty'`, `'offline'`), populate the `blocks` tab with the same block set you passed to `createWWWConfig`, and the host's not-found / server-error route renders the row. `populatePublishedAt` is wired automatically; revalidation comes from the host's `revalidatePlugin()` registration.
 
 ## Collections
 
 ```ts
 import {
   createWWWCollectionGlobal,         // generic factory (used internally for static-pages)
-  createRevalidateCollectionGlobalHook, // the afterChange/afterDelete pair
-  createCollectionCacheKey,          // produces the tag string
-  queryDoc                          // server-side helper used by renderers
+  queryDoc                           // server-side helper used by renderers
 } from '@justanarthur/payload-www/collections'
 ```
 
@@ -230,32 +229,71 @@ import {
 
 | arg | type | notes |
 |---|---|---|
-| `fields` | `Field[]` | the collection's field set (the factory adds `slug`, `publishedAt`, access, hooks) |
+| `fields` | `Field[]` | the collection's field set (the factory adds `slug`, `publishedAt`, access, the `populatePublishedAt` `beforeChange`) |
 | `slug` | `string` | collection slug |
 | `renderPath` | `string` | import-map path to the render component (`'@/components/Foo/Component#Foo'`) |
 | `isGlobalConfig` | `boolean` | `true` for globals, `false` (default) for collections |
 | `isDraft` | `boolean` | `true` (default) enables Payload's drafts + autosave; `false` for system pages |
 
 The factory wires `custom[packageName] = { path: renderPath }`, access (`create`/`update`/`delete`
-require auth, `read` is `anyone` or `authenticatedOrPublished` depending on `isDraft`), the
-`afterChange`/`afterDelete` revalidation hook, and `populatePublishedAt` (`beforeChange`).
+require auth, `read` is `anyone` or `authenticatedOrPublished` depending on `isDraft`), and
+`populatePublishedAt` (`beforeChange`). It does **not** install revalidation hooks — those live
+in the host's `revalidatePlugin()` registration (see [Caching](#caching) below).
 
-### Revalidation
+### Caching
 
-`createRevalidateCollectionGlobalHook()` returns `{ afterChange, afterDelete }` — the same function
-used for both. On every save / delete of a published doc it fires:
+The lib's cached query layer (`queryDocBySlug`, `queryGlobal`, `queryAllDocs`, `queryAllLocaleSlugs`,
+`queryDocByID`) wraps `@pro-laico/payload-revalidate`'s finders in `'use cache'` + `cacheLife('weeks')`
+scopes. Setup:
 
-```
-revalidateTag(`<slug><slug>_<locale>`, 'max')   // collections
-revalidateTag(`<globalSlug>_<locale>`, 'max')  // globals
-```
+1. **Install the peer deps at the workspace root** (not in the lib's `dependencies` — `file:` links
+   in a published `package.json` break downstream installs):
+
+   ```bash
+   bun add @pro-laico/core @pro-laico/payload-revalidate
+   ```
+
+2. **Register `revalidatePlugin()` last in `payload.config.ts#plugins`:**
+
+   ```ts
+   import { revalidatePlugin } from '@pro-laico/payload-revalidate'
+
+   export default buildConfig({
+     // ...
+     plugins: [...otherPlugins, revalidatePlugin()],
+   })
+   ```
+
+3. **Turn on Next's cacheComponents pipeline** in `next.config.ts`:
+
+   ```ts
+   const nextConfig: NextConfig = { cacheComponents: true, /* ... */ }
+   ```
+
+4. **Use the lib's getters in renderers** — they're `'use cache'`-wrapped already. No need to
+   re-wrap or hand-tag:
+
+   ```ts
+   import { queryDocBySlug, queryGlobal } from '@justanarthur/payload-www/metadata'
+
+   const doc = await queryDocBySlug({ collectionSlug: 'pages', slug, locale })
+   const header = await queryGlobal({ globalSlug: 'header', locale })
+   ```
+
+5. **`seedPayloadCache({ config })`** runs once per process to initialize the pro-laico cache
+   helpers from the host's Payload config. `createCollectionPageExports` and
+   `createRootLayoutExports` call it automatically — hosts with custom layouts call it directly:
+
+   ```ts
+   import { seedPayloadCache } from '@justanarthur/payload-www/metadata'
 
-`createCollectionCacheKey({ collectionSlug, slug, locale })` produces the same key string — use it
-in your own `unstable_cache` / `fetch` cache keys if you want them invalidated by the lib's hooks.
+   seedPayloadCache({ config })
+   ```
 
-> The `// @ts-expect-error` and `// todo sitemap caching and revalidation` markers in
-> `createRevalidateCollectionGlobalHook.ts` are intentional, not bugs — the hook covers tag-based
-> invalidation; URL revalidation and the unified sitemap tag are still TODO.
+The cached profile is `cacheLife('weeks')` — Next 16's built-in long-tail profile (5 m stale,
+1 w revalidate, 30 d expire). No custom `cacheLife` config entry needed. Invalidations are
+purely tag-based: `revalidatePlugin()` fires the same tags the finders emit, so every save /
+delete / publish of a Payload doc revalidates the cached render without manual rebuilds.
 
 ## Fields
 
@@ -292,9 +330,13 @@ import {
   buildWebSiteLd,
   buildProductLd,
   buildRootJsonLd,          // combined Organization + WebSite + Product (used by RootJsonLd)
-  queryDocBySlug,
+  queryDocBySlug,           // cached collection fetch
+  queryDocByID,             // cached collection fetch by id
+  queryGlobal,              // cached global fetch
   queryAllDocs,             // for generateStaticParams
   queryAllLocaleSlugs,      // for hreflang alternates
+  seedPayloadCache,         // one-time seed for the pro-laico cache helpers
+  tagsFor,                  // build cache tags by hand (passthrough of @pro-laico/payload-revalidate)
   paramsSlugToSlug,         // turn [locale]/[[...slug]] params → stored slug
   slugToParamsSlug          // turn stored slug → params for generateStaticParams
 } from '@justanarthur/payload-www/metadata'
@@ -340,10 +382,10 @@ The package's `package.json#exports` map:
 | `@justanarthur/payload-www/pages` | subset of `/render-pages` (no `createRootLayoutExports`, no `PostsPage`, no `RootJsonLd`) |
 | `@justanarthur/payload-www/sitemap` | `createSitemapFromCollections` |
 | `@justanarthur/payload-www/blocks` | `RenderBlocks`, `RenderBlocksProps` |
-| `@justanarthur/payload-www/collections` | `createWWWCollectionGlobal`, `createRevalidateCollectionGlobalHook`, `createCollectionCacheKey`, `queryDoc` |
+| `@justanarthur/payload-www/collections` | `createWWWCollectionGlobal`, `queryDoc` |
 | `@justanarthur/payload-www/fields` | `link`, `linkGroup`, `appearanceOptions`, `slugField`, `LinkAppearances`, `LinkOptions` |
 | `@justanarthur/payload-www/access` | `anyone`, `authenticated`, `authenticatedOrPublished` |
-| `@justanarthur/payload-www/metadata` | `buildArticleLd`, `buildBreadcrumbsLd`, `buildOrganizationLd`, `buildWebSiteLd`, `buildProductLd`, `buildRootJsonLd`, `queryDocBySlug`, `queryAllDocs`, `queryAllLocaleSlugs`, `paramsSlugToSlug`, `slugToParamsSlug` + types |
+| `@justanarthur/payload-www/metadata` | `buildArticleLd`, `buildBreadcrumbsLd`, `buildOrganizationLd`, `buildWebSiteLd`, `buildProductLd`, `buildRootJsonLd`, `queryDocBySlug`, `queryDocByID`, `queryGlobal`, `queryAllDocs`, `queryAllLocaleSlugs`, `seedPayloadCache`, `tagsFor`, `paramsSlugToSlug`, `slugToParamsSlug` + types |
 | `@justanarthur/payload-www/utils` | `generateImportName`, `getFromImportMap` |
 | `@justanarthur/payload-www/imagehash` | `imageHashPlugin`, `BlurhashPluginOptions` (re-export of `@justanarthur/payload-imagehash-plugin`) |
 | `@justanarthur/payload-www/translator` | `translator` (re-export of `@justanarthur/payload-plugin-translator`) |
@@ -363,10 +405,16 @@ For agents migrating from older docs:
   Payload `localization` config; `blocks` come from the `WWWInputConfig.blocks` field.
 - `defaultPlugins` callback → now `defaultPluginsConfigs: { seo, imageHash, translator, mcp }` map
   on `WWWInputConfig`.
-- `createRevalidateCollectionHook({ collectionSlug, urlPathPrefix, … })` (CHANGELOG `[Unreleased]`)
-  → **not implemented yet**. The current hook is `createRevalidateCollectionGlobalHook()` (no args),
-  exported from `/collections`. Per-locale URL fan-out + `revalidatePath` does not happen — only
-  `revalidateTag` fires.
+- `createRevalidateCollectionHook({ collectionSlug, urlPathPrefix, … })` (older CHANGELOG) and
+  `createRevalidateCollectionGlobalHook()` (no args, 1.0.0) → **both removed**. Caching now goes
+  through `@pro-laico/payload-revalidate`: install it as a peer dep, register `revalidatePlugin()`
+  last in `payload.config.ts#plugins`, and the lib's cached query getters (`queryDocBySlug`,
+  `queryGlobal`, `queryAllDocs`, `queryAllLocaleSlugs`, `queryDocByID`) wrap its finders so the
+  revalidation tags line up automatically. See [Caching](#caching) above.
+- `@justanarthur/payload-www/cache-keys` subpath (older `[Unreleased]`) → **removed**. There is
+  no in-tree tag vocabulary to export — tags come from `@pro-laico/payload-revalidate`'s finders.
+- `defaultPluginsConfigs.revalidate` slot (older `[Unreleased]`) → **removed**. The in-lib
+  revalidation composer is gone; revalidation is the host's responsibility via `revalidatePlugin()`.
 - `createSitemapFile` → **not implemented**. The current export is `createSitemapFromCollections`,
   used per-collection from your `app/(frontend)/sitemap.ts`.
 - `createPreviewHandler`, `LocaleSwitcher`, `LivePreviewListener`, `PageShowcase`, `HomePage`,

package/dist/access.d.ts

@@ -8,4 +8,4 @@ declare const access: {
 	authenticated: Access_wc6ft0;
 	authenticatedOrPublished: Access_wc6ft0;
 };
-export { access as default, authenticatedOrPublished, authenticated, anyone };
+export { anyone, authenticated, authenticatedOrPublished, access as default };

package/dist/access.js

@@ -1,5 +1,3 @@
-
-
 // src/collections/access/index.ts
 var anyone = () => true;
 var authenticated = ({ req: { user } }) => Boolean(user);
@@ -13,8 +11,8 @@ var authenticatedOrPublished = ({ req: { user } }) => {
 var access = { anyone, authenticated, authenticatedOrPublished };
 var access_default = access;
 export {
-  access_default as default,
-  authenticatedOrPublished,
+  anyone,
   authenticated,
-  anyone
+  authenticatedOrPublished,
+  access_default as default
 };

package/dist/blocks.d.ts

@@ -16,4 +16,4 @@ type RenderBlocksProps = {
 	searchParams?: Record<string, string | string[] | undefined>;
 };
 declare const RenderBlocks: FC<RenderBlocksProps>;
-export { RenderBlocks as default, RenderBlocksProps, RenderBlocks };
+export { RenderBlocks, RenderBlocksProps, RenderBlocks as default };

package/dist/blocks.js

@@ -1,5 +1,3 @@
-
-
 // src/render/getFromImportMap.ts
 function getFromImportMap(key, importMap) {
   if (!key)
@@ -55,6 +53,6 @@ var RenderBlocks = async ({ blocks, blockProps, config, importMap, locale, searc
 // src/exports/blocks.ts
 var blocks_default = RenderBlocks;
 export {
-  blocks_default as default,
-  RenderBlocks
+  RenderBlocks,
+  blocks_default as default
 };

package/dist/cli.js

@@ -1,6 +1,4 @@
 #!/usr/bin/env node
-import { createRequire } from "node:module";
-var __require = /* @__PURE__ */ createRequire(import.meta.url);
 
 // src/cli/index.ts
 import { register } from "tsx/esm/api";

package/dist/collections.d.ts

@@ -4,34 +4,34 @@ type CreateWWWCollectionArgs<IsGlobalConfig extends boolean> = {
 	renderPath: string;
 	isGlobalConfig?: IsGlobalConfig;
 	isDraft?: boolean;
+	useAsTitle?: string;
 };
 declare function createWWWCollectionGlobal<
 	IsGlobalConfig extends boolean = false,
 	Config = IsGlobalConfig extends true ? GlobalConfig : CollectionConfig
->(fields: Field[], { slug: collectionSlug, renderPath, isGlobalConfig, isDraft }: CreateWWWCollectionArgs<IsGlobalConfig>): Config;
-import { CollectionAfterChangeHook, CollectionAfterDeleteHook, GlobalAfterChangeHook } from "payload";
-declare function createRevalidateCollectionGlobalHook(): {
-	afterChange: (CollectionAfterChangeHook & CollectionAfterDeleteHook) | GlobalAfterChangeHook;
-	afterDelete: (CollectionAfterChangeHook & CollectionAfterDeleteHook) | GlobalAfterChangeHook;
+>(fields: Field[], { slug: collectionSlug, renderPath, isGlobalConfig, isDraft, useAsTitle }: CreateWWWCollectionArgs<IsGlobalConfig>): Config;
+import { SanitizedConfig } from "payload";
+import { JsonObject as JsonObject_wrdbbt } from "payload";
+type SeedPayloadCacheArgs = {
+	config: SanitizedConfig | Promise<SanitizedConfig>;
 };
-type CollectionGlobalLocaleIdentifiersArgs = ({
+declare function seedPayloadCache({ config }: SeedPayloadCacheArgs): void;
+type QueryDocArgs = ({
+	globalSlug: string;
+	locale: string;
+	draft?: boolean;
+}) | ({
 	collectionSlug: string;
 	slug: string;
-} | {
-	globalSlug: string;
-}) & {
+	slugField?: string;
 	locale: string;
-};
-declare function createCollectionCacheKey(args: CollectionGlobalLocaleIdentifiersArgs): string;
-import { SanitizedConfig } from "payload";
-import { JsonObject as JsonObject_wrdbbt } from "payload";
-declare function queryDoc(args: CollectionGlobalLocaleIdentifiersArgs, { config: configPromise }: {
-	config: Promise<SanitizedConfig>;
-}): Promise<JsonObject_wrdbbt | null>;
+	draft?: boolean;
+	depth?: number;
+});
+declare function queryDoc(args: QueryDocArgs): Promise<JsonObject_wrdbbt | null>;
 declare const collections: {
 	createWWWCollectionGlobal: typeof createWWWCollectionGlobal;
-	createRevalidateCollectionGlobalHook: typeof createRevalidateCollectionGlobalHook;
-	createCollectionCacheKey: typeof createCollectionCacheKey;
 	queryDoc: typeof queryDoc;
+	seedPayloadCache: typeof seedPayloadCache;
 };
-export { queryDoc, collections as default, createWWWCollectionGlobal, createRevalidateCollectionGlobalHook, createCollectionCacheKey };
+export { createWWWCollectionGlobal, collections as default, queryDoc, seedPayloadCache };

package/dist/collections.js

@@ -1,5 +1,3 @@
-
-
 // package.json
 var name = "@justanarthur/payload-www";
 
@@ -17,37 +15,6 @@ var populatePublishedAt = ({ data, operation, req }) => {
   return data;
 };
 
-// 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}`;
-}
-
 // src/collections/fields/slug.ts
 var slugField = () => ({
   name: "slug",
@@ -83,7 +50,8 @@ function createWWWCollectionGlobal(fields, {
   slug: collectionSlug,
   renderPath,
   isGlobalConfig = false,
-  isDraft = true
+  isDraft = true,
+  useAsTitle
 }) {
   return {
     slug: collectionSlug,
@@ -96,6 +64,7 @@ function createWWWCollectionGlobal(fields, {
       },
       ...fields
     ],
+    admin: useAsTitle ? { useAsTitle, defaultColumns: useAsTitle === "title" ? [useAsTitle, "slug", "publishedAt"] : undefined } : undefined,
     custom: { [name]: { path: renderPath } },
     access: {
       create: authenticated,
@@ -103,14 +72,9 @@ function createWWWCollectionGlobal(fields, {
       read: isDraft ? authenticatedOrPublished : anyone,
       update: authenticated
     },
-    hooks: (() => {
-      const { afterChange, afterDelete } = createRevalidateCollectionGlobalHook();
-      return {
-        afterChange: [afterChange],
-        beforeChange: [populatePublishedAt],
-        afterDelete: [afterDelete]
-      };
-    })(),
+    hooks: {
+      beforeChange: [populatePublishedAt]
+    },
     ...isDraft && {
       versions: { drafts: { autosave: { interval: 3000 } } }
     }
@@ -118,105 +82,107 @@ function createWWWCollectionGlobal(fields, {
 }
 
 // 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";
-async function withUnstableCache(keyParts, tags, fn) {
-  const { unstable_cache } = await import("next/cache");
-  return unstable_cache(fn, keyParts.map(String), { tags })();
+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);
+  })();
 }
-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 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 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: slugField2 = "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: { [slugField2]: { 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: slugField2 = "slug",
-  locale,
-  config
-}) {
-  return withUnstableCache([collectionSlug, slugField2, 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: { [slugField2]: 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: slugField2 = "slug",
-  config
-}) {
-  const payload = await getPayload({ config });
-  const doc = await payload.findByID({
-    collection: collectionSlug,
-    id,
-    locale: "all",
-    select: { [slugField2]: 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?.[slugField2];
 }
 
 // src/exports/collections.ts
 var collections = {
   createWWWCollectionGlobal,
-  createRevalidateCollectionGlobalHook,
-  createCollectionCacheKey,
-  queryDoc
+  queryDoc,
+  seedPayloadCache
 };
 var collections_default = collections;
 export {
-  queryDoc,
-  collections_default as default,
   createWWWCollectionGlobal,
-  createRevalidateCollectionGlobalHook,
-  createCollectionCacheKey
+  collections_default as default,
+  queryDoc,
+  seedPayloadCache
 };

package/dist/config.d.ts

@@ -15,8 +15,9 @@ type WWWInputConfig = Omit<Config, "collections" | "globals" | "plugins"> & {
 		imageHash?: MergeOrOverride<BlurhashPluginOptions>;
 		translator?: MergeOrOverride<TranslatorConfig>;
 		mcp?: MergeOrOverride<MCPPluginConfig>;
+		revalidate?: false | (<D>(d: D) => D);
 	};
 };
 declare function createWWWConfig(): WWWConfigApi;
 type MergeOrOverride<T> = T | ((defaultValue: T) => T);
-export { createWWWConfig as default, createWWWConfig, WWWInputConfig, WWWConfigApi };
+export { WWWConfigApi, WWWInputConfig, createWWWConfig, createWWWConfig as default };