@websolutespa/bom-next 3.0.2 → 4.0.0-next.1

package/src/server/context.ts

@@ -1,13 +1,28 @@
-'use server';
+import 'server-only';
 
-import { headers as getHeaders } from 'next/headers';
+import { getIsDevelopment, type ILayout } from '@websolutespa/bom-core';
+import type { User } from '@websolutespa/payload-plugin-bowl';
 import type { CollectionSlug, SanitizedConfig } from 'payload';
 import { cache } from 'react';
+import { DEFAULT_LAYOUT_DEPTH, DEFAULT_PAGE_DEPTH } from '../lib/const';
 import { getLabelFromLabels } from '../lib/label';
 import { getLink } from '../lib/link';
-import type { IPageContext, TypedPageContext } from '../types';
+import type {
+  IPageContext,
+  LayoutContextOptions,
+  LayoutOption,
+  LayoutOptions,
+  MixerContext,
+  PageContextOptions,
+  PageSelect,
+  ReadOptions,
+  ReadonlyHeaders,
+  TypedPage,
+  TypedPageContext
+} from '../types';
 import { getLayout } from './layout';
-import { getPayload } from './mixer';
+import { getPayload, resolveDraft } from './mixer';
+import type { MixerPayload } from './mixer-payload';
 import { getPage } from './page';
 
 /**
@@ -18,6 +33,104 @@ const PageContext = cache(() => {
   return new Map<string, any>();
 });
 
+/**
+ * Per-request memo of page and layout loads, keyed by a serialized string.
+ * React `cache` compares object arguments by identity, so options objects
+ * built inline by each caller would never hit: the key is serialized instead.
+ */
+const RequestMemo = cache(() => {
+  return new Map<string, Promise<unknown>>();
+});
+
+/** Payload instance + authenticated user, resolved once per request. */
+const getRequestPayload = cache((config: Promise<SanitizedConfig>, headers: ReadonlyHeaders | undefined, draft: boolean) => {
+  return getPayload({ config, headers, draft });
+});
+
+function memoize<T>(key: string, factory: () => Promise<T>): Promise<T> {
+  const memo = RequestMemo();
+  let promise = memo.get(key) as Promise<T> | undefined;
+  if (!promise) {
+    promise = factory();
+    memo.set(key, promise);
+    promise.catch(() => memo.delete(key));
+  }
+  return promise;
+}
+
+/** JSON serialization with sorted keys, so equivalent options produce the same key. */
+export function stableStringify(value: unknown): string {
+  return JSON.stringify(value, (_, item) => {
+    if (item && typeof item === 'object' && !Array.isArray(item)) {
+      return Object.keys(item).sort().reduce((sorted, key) => {
+        sorted[key] = item[key];
+        return sorted;
+      }, {} as Record<string, unknown>);
+    }
+    return item;
+  });
+}
+
+function getUserKey(user: User | null | undefined): string {
+  if (user && 'id' in user && user.id !== undefined && user.id !== null) {
+    return `${(user as { collection?: string }).collection || 'user'}:${user.id}`;
+  }
+  return 'guest';
+}
+
+function isPromiseLike(value: unknown): value is Promise<SanitizedConfig> {
+  return !!value && typeof (value as PromiseLike<unknown>).then === 'function';
+}
+
+const warnedLegacySignatures = new Set<string>();
+
+function warnLegacySignature(name: string, signature: string) {
+  if (getIsDevelopment() && !warnedLegacySignatures.has(name)) {
+    warnedLegacySignatures.add(name);
+    console.warn(`[bom-next] ${name}(..., config, headers) is deprecated. Use ${name}(${signature}, { config, headers }) instead.`);
+  }
+}
+
+function toPageOptions<TSlug extends CollectionSlug, TSelect extends PageSelect<TSlug>, TLayout extends LayoutOption>(
+  name: string,
+  optionsOrConfig: PageContextOptions<TSlug, TSelect, TLayout> | Promise<SanitizedConfig>,
+  headers?: ReadonlyHeaders
+): PageContextOptions<TSlug, TSelect, TLayout> {
+  if (isPromiseLike(optionsOrConfig)) {
+    warnLegacySignature(name, 'market, locale, slug, id');
+    return { config: optionsOrConfig, headers };
+  }
+  return optionsOrConfig;
+}
+
+function loadLayout(
+  market: string,
+  locale: string,
+  payload: MixerPayload,
+  user: User,
+  mixerContext: MixerContext,
+  readOptions: { depth?: number; draft: boolean }
+): Promise<ILayout> {
+  const read = { depth: readOptions.depth ?? DEFAULT_LAYOUT_DEPTH, draft: readOptions.draft };
+  const key = stableStringify(['layout', market, locale, getUserKey(user), read]);
+  return memoize(key, () => getLayout(market, locale, payload, user, mixerContext, read));
+}
+
+function toPageContext<TSlug extends CollectionSlug, TSelect extends PageSelect<TSlug>, TLayout extends LayoutOption>(
+  layout: ILayout | undefined,
+  page: TypedPage<TSlug, TSelect> | undefined,
+  user: User
+): TypedPageContext<TSlug, TSelect, TLayout> {
+  return {
+    layout,
+    // shallow copy: the memoized document is shared by every caller in the request
+    page: page ? { ...page } : undefined,
+    user,
+    label: getLabelFromLabels(layout?.labels ?? []),
+    link: (category: string) => layout ? getLink(category, layout) : undefined,
+  } as TypedPageContext<TSlug, TSelect, TLayout>;
+}
+
 export async function getPageContext<TSlug extends CollectionSlug = CollectionSlug>(): Promise<TypedPageContext<TSlug>> {
   return {
     layout: PageContext().get('layout'),
@@ -28,7 +141,9 @@ export async function getPageContext<TSlug extends CollectionSlug = CollectionSl
   } as TypedPageContext<TSlug>;
 }
 
-export async function setPageContext<TSlug extends CollectionSlug>(data: TypedPageContext<TSlug>) {
+export async function setPageContext<TSlug extends CollectionSlug, TSelect extends PageSelect<TSlug> = undefined, TLayout extends LayoutOption = LayoutOptions>(
+  data: Partial<TypedPageContext<TSlug, TSelect, TLayout>>
+) {
   const context = PageContext();
   for (const key in data) {
     context.set(key, data[key as keyof IPageContext]);
@@ -36,112 +151,156 @@ export async function setPageContext<TSlug extends CollectionSlug>(data: TypedPa
 }
 
 /**
- * Same as createPageContext but without draft mode — used for error/not-found pages
- * that should always show published content regardless of draft mode state.
+ * Initialises the full page context using Payload local API.
+ *
+ * Page and layout are fetched in parallel and memoized per request, so
+ * `getMetadata` and the page component share the same reads. The mixer
+ * context (routes + categories) is passed to every payload read so that
+ * payload-plugin-bowl can enrich responses, including populated documents.
+ *
+ * @example
+ * const { page, label, link } = await createPageContext(market, locale, 'post_detail', id, {
+ *   config,
+ *   depth: 2,
+ *   select: { title: true, abstract: true, media: true, components: true },
+ *   populate: { media: { url: true, alt: true, width: true, height: true, type: true } },
+ * });
  */
-export async function createNotFoundContext<TSlug extends CollectionSlug>(
+export function createPageContext<TSlug extends CollectionSlug, TSelect extends PageSelect<TSlug> = undefined, TLayout extends LayoutOption = LayoutOptions>(
+  market: string,
+  locale: string,
+  slug: TSlug,
+  id: string,
+  options: PageContextOptions<TSlug, TSelect, TLayout>
+): Promise<TypedPageContext<TSlug, TSelect, TLayout>>;
+/** @deprecated Use `createPageContext(market, locale, slug, id, { config, headers })`. */
+export function createPageContext<TSlug extends CollectionSlug>(
   market: string,
   locale: string,
   slug: TSlug,
   id: string,
   config: Promise<SanitizedConfig>,
-  headers?: Awaited<ReturnType<typeof getHeaders>>
-): Promise<TypedPageContext<TSlug>> {
-  const { payload, user, getContext } = await getPayload({ config, headers });
+  headers?: ReadonlyHeaders
+): Promise<TypedPageContext<TSlug>>;
+export async function createPageContext<TSlug extends CollectionSlug, TSelect extends PageSelect<TSlug> = undefined, TLayout extends LayoutOption = LayoutOptions>(
+  market: string,
+  locale: string,
+  slug: TSlug,
+  id: string,
+  optionsOrConfig: PageContextOptions<TSlug, TSelect, TLayout> | Promise<SanitizedConfig>,
+  headers?: ReadonlyHeaders
+): Promise<TypedPageContext<TSlug, TSelect, TLayout>> {
+  const options = toPageOptions<TSlug, TSelect, TLayout>('createPageContext', optionsOrConfig, headers);
+
+  const draft = await resolveDraft(options.draft);
+  const { payload, user, getContext } = await getRequestPayload(options.config, options.headers, draft);
   const context = await getContext(market, locale);
 
-  const layout = await getLayout(market, locale, payload, user, context);
-  const page = await getPage(slug, id, market, locale, payload, user, context);
+  const pageRead: ReadOptions = {
+    draft,
+    depth: options.depth ?? DEFAULT_PAGE_DEPTH,
+    select: options.select as ReadOptions['select'],
+    populate: options.populate,
+    joins: options.joins as ReadOptions['joins'],
+  };
+  const pageKey = stableStringify(['page', market, locale, slug, id, getUserKey(user), pageRead]);
+  const pagePromise = memoize(pageKey, () =>
+    getPage<TSlug, TSelect>(slug, id, market, locale, payload, user, context, pageRead)
+  );
 
-  const label = getLabelFromLabels(layout.labels);
-  const link = (category: string) => getLink(category, layout);
+  const layoutOptions = options.layout;
+  const layoutPromise = layoutOptions === false
+    ? Promise.resolve(undefined)
+    : (async () => loadLayout(market, locale, payload, user, context, {
+      depth: layoutOptions?.depth,
+      draft: layoutOptions?.draft === undefined ? draft : await resolveDraft(layoutOptions.draft),
+    }))();
 
-  const pageContext = {
-    layout,
-    page,
-    user,
-    label,
-    link,
-  } as TypedPageContext<TSlug>;
+  const [layout, page] = await Promise.all([layoutPromise, pagePromise]);
+
+  const pageContext = toPageContext<TSlug, TSelect, TLayout>(layout, page, user);
 
-  setPageContext(pageContext);
+  if (layout) {
+    await setPageContext(pageContext);
+  } else {
+    // layout skipped: keep any layout already stored for this request
+    await setPageContext({ page: pageContext.page, user: pageContext.user });
+  }
 
   return pageContext;
 }
 
 /**
- * Initialises the full page context using Payload local API.
- *
- * Replaces the @websolutespa/bom-next/server createPageContext that goes through the store
- * abstraction. All data is fetched directly from Payload; the mixer context
- * (routes + categories) is passed to every payload.find call so that
- * payload-plugin-bowl can enrich responses.
+ * Same as createPageContext but without draft mode — used for error/not-found pages
+ * that should always show published content regardless of draft mode state.
  */
-export async function createPageContext<TSlug extends CollectionSlug>(
+export function createNotFoundContext<TSlug extends CollectionSlug, TSelect extends PageSelect<TSlug> = undefined, TLayout extends LayoutOption = LayoutOptions>(
+  market: string,
+  locale: string,
+  slug: TSlug,
+  id: string,
+  options: PageContextOptions<TSlug, TSelect, TLayout>
+): Promise<TypedPageContext<TSlug, TSelect, TLayout>>;
+/** @deprecated Use `createNotFoundContext(market, locale, slug, id, { config, headers })`. */
+export function createNotFoundContext<TSlug extends CollectionSlug>(
   market: string,
   locale: string,
   slug: TSlug,
   id: string,
   config: Promise<SanitizedConfig>,
-  headers?: Awaited<ReturnType<typeof getHeaders>>
-): Promise<TypedPageContext<TSlug>> {
-
-  // const draft = await draftMode();
-  const draft = { isEnabled: false };
-
-  const { payload, user, getContext } = await getPayload({ config, headers });
-  const context = await getContext(market, locale);
-
-  const layout = await getLayout(market, locale, payload, user, context, draft.isEnabled);
-  const page = await getPage(slug, id, market, locale, payload, user, context, draft.isEnabled);
-
-  const label = getLabelFromLabels(layout.labels);
-  const link = (category: string) => getLink(category, layout);
-
-  const pageContext = {
-    layout,
-    page,
-    user,
-    label,
-    link,
-  } as TypedPageContext<TSlug>;
-
-  setPageContext(pageContext);
-
-  /*
-  if (draft.isEnabled) {
-    draft.disable();
-  }
-  */
-
-  return pageContext;
+  headers?: ReadonlyHeaders
+): Promise<TypedPageContext<TSlug>>;
+export async function createNotFoundContext<TSlug extends CollectionSlug, TSelect extends PageSelect<TSlug> = undefined, TLayout extends LayoutOption = LayoutOptions>(
+  market: string,
+  locale: string,
+  slug: TSlug,
+  id: string,
+  optionsOrConfig: PageContextOptions<TSlug, TSelect, TLayout> | Promise<SanitizedConfig>,
+  headers?: ReadonlyHeaders
+): Promise<TypedPageContext<TSlug, TSelect, TLayout>> {
+  const options = toPageOptions<TSlug, TSelect, TLayout>('createNotFoundContext', optionsOrConfig, headers);
+  const layout = (options.layout === false ? false : { ...options.layout, draft: false }) as TLayout;
+  return createPageContext<TSlug, TSelect, TLayout>(market, locale, slug, id, { ...options, draft: false, layout });
 }
 
 /**
  * Layout-only context — no page fetch. Used by RootLayout server components.
  */
-export async function createLayoutContext(
+export function createLayoutContext(
+  market: string,
+  locale: string,
+  options: LayoutContextOptions
+): Promise<IPageContext>;
+/** @deprecated Use `createLayoutContext(market, locale, { config, headers })`. */
+export function createLayoutContext(
   market: string,
   locale: string,
   config: Promise<SanitizedConfig>,
-  headers?: Awaited<ReturnType<typeof getHeaders>>
-) {
-  const { payload, user, getContext } = await getPayload({ config, headers });
-  const context = await getContext(market, locale);
+  headers?: ReadonlyHeaders
+): Promise<IPageContext>;
+export async function createLayoutContext(
+  market: string,
+  locale: string,
+  optionsOrConfig: LayoutContextOptions | Promise<SanitizedConfig>,
+  headers?: ReadonlyHeaders
+): Promise<IPageContext> {
+  let options: LayoutContextOptions;
+  if (isPromiseLike(optionsOrConfig)) {
+    warnLegacySignature('createLayoutContext', 'market, locale');
+    options = { config: optionsOrConfig, headers };
+  } else {
+    options = optionsOrConfig;
+  }
 
-  const layout = await getLayout(market, locale, payload, user, context);
+  const draft = await resolveDraft(options.draft);
+  const { payload, user, getContext } = await getRequestPayload(options.config, options.headers, draft);
+  const context = await getContext(market, locale);
 
-  const label = getLabelFromLabels(layout.labels);
-  const link = (category: string) => getLink(category, layout);
+  const layout = await loadLayout(market, locale, payload, user, context, { depth: options.depth, draft });
 
-  const pageContext = {
-    layout,
-    user,
-    label,
-    link,
-  } as unknown as IPageContext;
+  const { page: _page, ...pageContext } = toPageContext<CollectionSlug, undefined, LayoutOptions>(layout, undefined, user);
 
-  setPageContext(pageContext);
+  await setPageContext(pageContext);
 
-  return pageContext;
+  return pageContext as IPageContext;
 }

package/src/server/context.type-test.ts

@@ -0,0 +1,106 @@
+import type { SanitizedConfig } from 'payload';
+import type { ILayout } from '@websolutespa/bom-core';
+import type { LayoutOption, Populated, ReadonlyHeaders, TypedPageContext } from '../types';
+import { createLayoutContext, createNotFoundContext, createPageContext } from './context';
+import { createContextHelpers } from './helpers';
+
+declare const config: Promise<SanitizedConfig>;
+
+type Expect<T extends true> = T;
+type Equal<A, B> = (<T>() => T extends A ? 1 : 2) extends (<T>() => T extends B ? 1 : 2) ? true : false;
+
+// options form, full document
+const full = createPageContext('ww', 'it', 'page', 'id', { config, depth: 1, draft: 'auto' });
+full.then(({ page, layout, label, link }) => {
+  page?.title;
+  page?.href;
+  page?.breadcrumb;
+  layout.tree;
+  label('key');
+  link('category');
+});
+
+// select narrows the page document type
+const narrowed = createPageContext('ww', 'it', 'page', 'id', {
+  config,
+  select: { title: true, slug: true },
+  populate: { media: { url: true } },
+  layout: false,
+});
+narrowed.then(({ page }) => {
+  page?.title;
+  // envelope fields are always selected
+  page?.category;
+  page?.template;
+  page?.href;
+  page?.breadcrumb;
+  // @ts-expect-error not selected
+  page?.order;
+});
+
+// exclude mode keeps the envelope fields
+createPageContext('ww', 'it', 'page', 'id', { config, select: { title: false, order: false } }).then(({ page }) => {
+  page?.title;
+  page?.media;
+  // @ts-expect-error excluded
+  page?.order;
+});
+
+// legacy positional form still compiles
+const legacy = createPageContext('ww', 'it', 'page', 'id', config);
+legacy.then((context) => {
+  type _check = Expect<Equal<typeof context, TypedPageContext<'page'>>>;
+});
+createNotFoundContext('ww', 'it', 'page', 'id', config);
+createNotFoundContext('ww', 'it', 'page', 'id', { config, depth: 0 });
+createLayoutContext('ww', 'it', config);
+createLayoutContext('ww', 'it', { config, depth: 1 });
+
+// @ts-expect-error config is required
+createPageContext('ww', 'it', 'page', 'id', { depth: 1 });
+
+const helpers = createContextHelpers({ config, defaults: { depth: 2 } });
+helpers.createPageContext('ww', 'it', 'page', 'id').then(({ page }) => page?.title);
+helpers.createPageContext('ww', 'it', 'page', 'id', { select: { title: true } }).then(({ page }) => {
+  // @ts-expect-error not selected
+  page?.order;
+});
+helpers.createLayoutContext('ww', 'it');
+helpers.getMetadata('page');
+
+// Populated narrows ids out of relation unions
+type _populated = Expect<Equal<Populated<string | { url: string }>, { url: string }>>;
+type _populatedArray = Expect<Equal<Populated<(number | { url: string })[]>, { url: string }[]>>;
+
+// layout follows the layout option
+declare const layoutOption: LayoutOption;
+createPageContext('ww', 'it', 'page', 'id', { config }).then(({ layout }) => {
+  type _check = Expect<Equal<typeof layout, ILayout>>;
+});
+createPageContext('ww', 'it', 'page', 'id', { config, layout: { depth: 0 } }).then(({ layout }) => {
+  type _check = Expect<Equal<typeof layout, ILayout>>;
+});
+createPageContext('ww', 'it', 'page', 'id', { config, layout: false }).then(({ layout }) => {
+  type _check = Expect<Equal<typeof layout, undefined>>;
+});
+createPageContext('ww', 'it', 'page', 'id', { config, layout: layoutOption }).then(({ layout }) => {
+  type _check = Expect<Equal<typeof layout, ILayout | undefined>>;
+});
+createNotFoundContext('ww', 'it', 'page', 'id', { config, layout: false }).then(({ layout }) => {
+  type _check = Expect<Equal<typeof layout, undefined>>;
+});
+helpers.createPageContext('ww', 'it', 'page', 'id', { layout: false }).then(({ layout }) => {
+  type _check = Expect<Equal<typeof layout, undefined>>;
+});
+helpers.createPageContext('ww', 'it', 'page', 'id').then(({ layout }) => {
+  type _check = Expect<Equal<typeof layout, ILayout>>;
+});
+
+// headers are request scoped: per call only, never a bound default
+declare const headers: ReadonlyHeaders;
+// @ts-expect-error headers is not a default
+createContextHelpers({ config, defaults: { headers } });
+// @ts-expect-error skipping the layout is a per-call choice
+createContextHelpers({ config, defaults: { layout: false } });
+helpers.createPageContext('ww', 'it', 'page', 'id', { headers });
+helpers.createLayoutContext('ww', 'it', { headers });

package/src/server/helpers.ts

@@ -0,0 +1,58 @@
+import type { CollectionSlug, SanitizedConfig } from 'payload';
+import type { LayoutContextOptions, LayoutOption, LayoutOptions, PageContextOptions, PageSelect } from '../types';
+import { createLayoutContext, createNotFoundContext, createPageContext } from './context';
+import { getMetadata } from './metadata';
+
+/**
+ * Options bound once for every call. Request-scoped values (`headers`) and
+ * per-page values (`select`, `populate`, `joins`) are passed per call;
+ * skipping the layout (`layout: false`) is a per-call choice too.
+ */
+type ContextDefaults = Omit<PageContextOptions, 'config' | 'headers' | 'select' | 'populate' | 'joins' | 'layout'> & {
+  layout?: LayoutOptions;
+};
+
+type PageOptions<TSlug extends CollectionSlug, TSelect extends PageSelect<TSlug>, TLayout extends LayoutOption> =
+  Omit<PageContextOptions<TSlug, TSelect, TLayout>, 'config'> & { config?: Promise<SanitizedConfig> };
+
+/**
+ * Binds `config` and default options once, so templates don't pass them every time.
+ * Per-call options override the defaults.
+ *
+ * @example
+ * // src/lib/context.ts in the app
+ * export const { createPageContext, createLayoutContext, getMetadata } =
+ *   createContextHelpers({ config, defaults: { depth: 2 } });
+ */
+export function createContextHelpers({
+  config,
+  defaults = {},
+}: {
+  config: Promise<SanitizedConfig>;
+  defaults?: ContextDefaults;
+}) {
+  const layoutDefaults: Omit<LayoutContextOptions, 'config'> = {
+    draft: defaults.draft,
+    ...defaults.layout,
+  };
+  return {
+    createPageContext<TSlug extends CollectionSlug, TSelect extends PageSelect<TSlug> = undefined, TLayout extends LayoutOption = LayoutOptions>(
+      market: string, locale: string, slug: TSlug, id: string, options?: PageOptions<TSlug, TSelect, TLayout>
+    ) {
+      return createPageContext<TSlug, TSelect, TLayout>(market, locale, slug, id, { config, ...defaults as PageOptions<TSlug, TSelect, TLayout>, ...options });
+    },
+    createNotFoundContext<TSlug extends CollectionSlug, TSelect extends PageSelect<TSlug> = undefined, TLayout extends LayoutOption = LayoutOptions>(
+      market: string, locale: string, slug: TSlug, id: string, options?: PageOptions<TSlug, TSelect, TLayout>
+    ) {
+      return createNotFoundContext<TSlug, TSelect, TLayout>(market, locale, slug, id, { config, ...defaults as PageOptions<TSlug, TSelect, TLayout>, ...options });
+    },
+    createLayoutContext(market: string, locale: string, options?: Partial<LayoutContextOptions>) {
+      return createLayoutContext(market, locale, { config, ...layoutDefaults, ...options });
+    },
+    getMetadata<TSlug extends CollectionSlug, TSelect extends PageSelect<TSlug> = undefined>(
+      slug: TSlug, options?: Omit<PageContextOptions<TSlug, TSelect, LayoutOption>, 'config'>
+    ) {
+      return getMetadata<TSlug, TSelect>(slug, config, { ...defaults, ...options });
+    },
+  };
+}

package/src/server/layout.ts

@@ -1,11 +1,12 @@
-'use server';
+import 'server-only';
 
 import { IApp, IAppExtended, ICategory, ILabel, ILayout, ILocale, ILocalizedMenu, IMarket, IRoute, IRouteLink, getRootCategory } from '@websolutespa/bom-core';
 import type { User } from '@websolutespa/payload-plugin-bowl';
 import type { CollectionSlug, GlobalSlug } from 'payload';
 import { getRouteLinkCategory } from '../lib/route';
-import type { MixerContext } from '../types';
-import { buildBaseOptions } from './mixer';
+import { DEFAULT_LAYOUT_DEPTH } from '../lib/const';
+import type { MixerContext, ReadOptions } from '../types';
+import { buildReadOptions } from './mixer';
 import type { MixerPayload } from './mixer-payload';
 
 /**
@@ -23,6 +24,9 @@ import type { MixerPayload } from './mixer-payload';
  *
  * The route link tree is built from mixerContext.currentRoutes + mixerContext.categories
  * using getRouteLinkCategory (pure fn, no store calls) from bom-mixer-models/server.
+ *
+ * The last argument accepts read options (depth, draft); depth defaults to
+ * DEFAULT_LAYOUT_DEPTH. A boolean is still accepted as the legacy draft flag.
  */
 export async function getLayout<T extends IAppExtended = IAppExtended>(
   market: string,
@@ -30,49 +34,51 @@ export async function getLayout<T extends IAppExtended = IAppExtended>(
   payload: MixerPayload,
   user: User,
   mixerContext: MixerContext,
-  draft?: boolean
+  readOptions?: Pick<ReadOptions, 'depth' | 'draft'> | boolean
 ): Promise<ILayout<T>> {
-  const base = buildBaseOptions(user, locale, draft);
+  const options = typeof readOptions === 'object' ? readOptions : { draft: readOptions };
+  const base = buildReadOptions({
+    user,
+    locale,
+    draft: options.draft,
+    depth: options.depth ?? DEFAULT_LAYOUT_DEPTH,
+  });
   const findOpts = { ...base, pagination: false, limit: 10000 } as const;
 
-  // markets
-  const marketsResult = await payload.find({
-    ...findOpts,
-    collection: 'market' as CollectionSlug,
-    context: mixerContext,
-  });
-  const markets = marketsResult.docs as unknown as IMarket[];
+  // independent reads: markets, locales (global with an `items` array), labels, app global, menus
+  const [marketsResult, localeGlobal, labelsResult, app, menusResult] = await Promise.all([
+    payload.find({
+      ...findOpts,
+      collection: 'market' as CollectionSlug,
+      context: mixerContext,
+    }),
+    payload.findGlobal({
+      ...base,
+      slug: 'locale' as GlobalSlug,
+      context: mixerContext,
+    }) as unknown as Promise<{ items: ILocale[] }>,
+    payload.find({
+      ...findOpts,
+      collection: 'label' as CollectionSlug,
+      context: mixerContext,
+    }),
+    // app global (slug 'app', registered by payload-plugin-bowl)
+    payload.findGlobal({
+      ...base,
+      slug: 'app' as GlobalSlug,
+      context: mixerContext,
+    }) as unknown as Promise<IApp<T>>,
+    payload.find({
+      ...findOpts,
+      collection: 'menu' as CollectionSlug,
+      context: mixerContext,
+    }),
+  ]);
 
-  // locales (global with an `items` array)
-  const localeGlobal = await payload.findGlobal({
-    ...base,
-    slug: 'locale' as GlobalSlug,
-    context: mixerContext,
-  }) as unknown as { items: ILocale[] };
+  const markets = marketsResult.docs as unknown as IMarket[];
   const locales = (localeGlobal?.items ?? []).filter(x => x.isActive);
-
-  // labels
-  const labelsResult = await payload.find({
-    ...findOpts,
-    collection: 'label' as CollectionSlug,
-    context: mixerContext,
-  });
   const labels = labelsResult.docs as unknown as ILabel[];
 
-  // app global (slug 'app', registered by payload-plugin-bowl)
-  const app = await payload.findGlobal({
-    ...base,
-    slug: 'app' as GlobalSlug,
-    context: mixerContext,
-  }) as unknown as IApp<T>;
-
-  // menus
-  const menusResult = await payload.find({
-    ...findOpts,
-    collection: 'menu' as CollectionSlug,
-    context: mixerContext,
-  });
-
   const menu: Record<string, ILocalizedMenu> = {};
   (menusResult.docs as unknown as ILocalizedMenu[]).forEach(x => {
     menu[String(x.id)] = x;

package/src/server/lazy.ts

@@ -1,4 +1,4 @@
-'use server';
+import 'server-only';
 
 import type { IComponent } from '@websolutespa/bom-core';
 import type { ILazyComponent, ILazyStaticProps, ILazyStaticPropsFunc } from '../types';