@websolutespa/bom-next 3.0.0

package/src/server/handlers/vars.handler.ts

@@ -0,0 +1,167 @@
+import { getHost, getOrigin, isDevelopment, isProduction } from '@websolutespa/bom-core';
+import { headers as getHeaders } from 'next/headers';
+import { NextRequest } from 'next/server';
+import { SanitizedConfig } from 'payload';
+import { getLayout } from '../layout';
+import { getPayload, getSearchParams } from '../mixer';
+import { getHandlerErrorResponse } from './error-response';
+
+const DISALLOWED_KEYS = [
+  '__NEXT_PRIVATE_STANDALONE_CONFIG',
+];
+
+const getFilteredEnv = (env: Record<string, unknown>): Record<string, unknown> => {
+  const entries = Object.entries(env).filter(([k, v]) => (
+    !DISALLOWED_KEYS.includes(k) && typeof v === 'string'
+  ));
+  entries.sort();
+  return Object.fromEntries(entries);
+};
+
+const sortKeys = (object?: Record<string, unknown>): Record<string, unknown> => {
+  const entries = Object.entries(object || {});
+  entries.sort();
+  return Object.fromEntries(entries);
+};
+
+export function getVarsHandler(config: Promise<SanitizedConfig>) {
+  return async function (request: NextRequest) {
+    try {
+      const searchParams = request.nextUrl.searchParams;
+      // console.log('getVarsHandler', searchParams);
+      const { market, locale, defaultMarket, defaultLocale, params } = getSearchParams(request);
+      const headers = await getHeaders();
+      const { payload, user, getContext } = await getPayload({ config, headers });
+      if (!(user?.roles || []).includes('admin')) {
+        throw { status: 401, message: 'Unauthorized' };
+      }
+      const context = await getContext(market || defaultMarket, locale || defaultLocale);
+      const layout = await getLayout(market || defaultMarket, locale || defaultLocale, payload, user, context);
+      const info = {
+        production: isProduction,
+        development: isDevelopment,
+        origin: getOrigin(headers),
+        host: getHost(headers),
+        params: {},
+        searchParams: { ...sortKeys(Object.fromEntries(searchParams)) },
+        headers: { ...sortKeys(Object.fromEntries(headers)) },
+        env: { ...getFilteredEnv(process.env) },
+        user: { ...sortKeys(user as unknown as Record<string, unknown>) },
+        context: { ...sortKeys(context) },
+        layout: { ...sortKeys(layout) },
+      };
+      const accept = headers.get('accept');
+      if (!accept || !(accept.includes('text/html'))) {
+        return Response.json(info, {
+          status: 200,
+        });
+      }
+      return new Response(`<!DOCTYPE html>
+<html>
+<head>
+  <meta charSet="utf-8"/>
+  <style>
+    html, body {
+      background: #282828;
+      color: #7cacf8;
+    }
+    body {
+      padding: 0;
+      margin: 0;
+      font-family: monospace;
+      font-size: 14px;
+      line-height: 1.16;
+      font-weight: 100;
+    }
+    json-viewer {
+      padding: 20px;
+      min-height: 100vh;
+      box-sizing: border-box;
+      line-height: 1.2;
+      --background-color: #282828;
+      --color: #e3e3e3;
+      --property-color: #7cacf8;
+      --string-color: #53d5fb;
+      --number-color: #7b80ff;
+      --boolean-color: #9980ff;
+      --null-color: #6f6f6f;
+      --preview-color: #8f8f8f;
+      --highlight-color: #7b0000;
+      --font-family: monospace;
+      --font-size: 14px;
+      --indent-size: 1em;
+      --indentguide-size: 1px;
+      --indentguide-style: solid;
+      --indentguide-color: #333;
+      --indentguide-color-active: #666;
+      --indentguide: var(--indentguide-size) var(--indentguide-style) var(--indentguide-color);
+      --indentguide-active: var(--indentguide-size) var(--indentguide-style) var(--indentguide-color-active);
+    }
+
+    :root {
+      --scrollbar-size: 8px;
+      --scrollbar-border-radius: 2px;
+      --scrollbar-track-color: transparent;
+      --scrollbar-track-hover-color: transparent;
+      --scrollbar-thumb-color: #888888;
+      --scrollbar-thumb-hover-color: #aaaaaa;
+    }
+
+    ::-webkit-scrollbar {
+      width: var(--scrollbar-size);
+      height: var(--scrollbar-size);
+      border-radius: 0;
+    }
+
+    ::-webkit-scrollbar-button {
+      display: none;
+    }
+
+    ::-webkit-scrollbar-button:hover {
+      display: none;
+    }
+
+    ::-webkit-scrollbar-thumb {
+      background-color: var(--scrollbar-thumb-color);
+      box-shadow: none;
+      border-radius: calc(var(--scrollbar-size) * 0.5);
+    }
+
+    ::-webkit-scrollbar-thumb:hover {
+      background-color: var(--scrollbar-thumb-hover-color);
+    }
+
+    ::-webkit-scrollbar-track {
+      background-color: var(--scrollbar-track-color);
+      border-radius: 0;
+    }
+
+    ::-webkit-scrollbar-track:hover {
+      background-color: var(--scrollbar-track-hover-color);
+    }
+
+  </style>
+  <script src="https://unpkg.com/@alenaksu/json-viewer@2.0.0/dist/json-viewer.bundle.js"></script>
+  <script>
+    document.addEventListener('DOMContentLoaded', () => {
+      const viewer = document.querySelector('#json-viewer');
+      viewer.data = ${JSON.stringify(info)};
+      viewer.expand(/headers|env/);
+    });
+  </script>
+</head>
+<body>
+  <json-viewer id="json-viewer"></json-viewer>
+</body>
+</html>`, {
+        status: 200,
+        headers: {
+          'Content-Type': 'text/html',
+        },
+      });
+    } catch (error: unknown) {
+      console.log('getVarsHandler.error', error);
+      return getHandlerErrorResponse(error);
+    }
+  };
+}

package/src/server/layout.ts

@@ -0,0 +1,120 @@
+'use server';
+
+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 type { MixerPayload } from './mixer-payload';
+
+/**
+ * Builds the full ILayout object using Payload local API calls.
+ *
+ * All payload.find / payload.findGlobal calls pass `context: mixerContext` so
+ * payload-plugin-bowl can enrich results (hrefs, richText serialisation, etc.).
+ *
+ * Collection and global slugs use the payload-plugin-bowl defaults:
+ *   market     → 'market'   (collection)
+ *   locale     → 'locale'   (global)
+ *   label      → 'label'    (collection)
+ *   app        → 'app'      (global)  ← defined in payload-plugin-bowl
+ *   menu       → 'menu'     (collection)
+ *
+ * The route link tree is built from mixerContext.currentRoutes + mixerContext.categories
+ * using getRouteLinkCategory (pure fn, no store calls) from bom-mixer-models/server.
+ */
+export async function getLayout<T extends IAppExtended = IAppExtended>(
+  market: string,
+  locale: string,
+  payload: MixerPayload,
+  user: User,
+  mixerContext: MixerContext,
+  draft?: boolean
+): Promise<ILayout<T>> {
+  const base = buildBaseOptions(user, locale, draft);
+  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[];
+
+  // locales (global with an `items` array)
+  const localeGlobal = await payload.findGlobal({
+    ...base,
+    slug: 'locale' as GlobalSlug,
+    context: mixerContext,
+  }) as unknown as { items: ILocale[] };
+  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;
+  });
+
+  // route link tree — pure computation from mixer context data (no store calls)
+  const categories = (mixerContext.categories ?? []) as unknown as ICategory[];
+  const currentRoutes = (mixerContext.currentRoutes ?? []) as IRoute[];
+  const rootCategory = getRootCategory(categories);
+  const treeResult = rootCategory
+    ? getRouteLinkCategory(locale, currentRoutes, categories, rootCategory, rootCategory)
+    : undefined;
+  const tree = Array.isArray(treeResult) ? treeResult[0] : treeResult;
+
+  // derive topLevelRoutes and topLevelHrefs from tree (mirrors layout.service.ts logic)
+  const firstLevelRoutes = tree?.items ?? [];
+  const flatTopLevelRoutes: IRouteLink[] = tree ? [tree, ...firstLevelRoutes] : [];
+
+  const topLevelRoutes = flatTopLevelRoutes.reduce((object, routeLink) => {
+    if (!object[routeLink.schema] || routeLink.schema === String(routeLink.category)) {
+      object[routeLink.schema] = routeLink;
+    }
+    return object;
+  }, {} as Record<string, IRouteLink>);
+
+  const topLevelHrefs = flatTopLevelRoutes.reduce((object, routeLink) => {
+    if (routeLink.href && (!object[routeLink.schema] || routeLink.schema === String(routeLink.category))) {
+      object[routeLink.schema] = routeLink.href;
+    }
+    return object;
+  }, {} as Record<string, string>);
+
+  return {
+    labels,
+    locale,
+    locales,
+    market,
+    markets,
+    app,
+    menu,
+    topLevelHrefs,
+    topLevelRoutes,
+    tree,
+  };
+}

package/src/server/lazy.ts

@@ -0,0 +1,41 @@
+'use server';
+
+import type { IComponent } from '@websolutespa/bom-core';
+import type { ILazyComponent, ILazyStaticProps, ILazyStaticPropsFunc } from '../types';
+import { getPageContext } from './context';
+import { getContext } from './mixer';
+
+const LAZY_PROPS: ILazyStaticProps = {};
+
+export async function withLazyProps<T>(key: string, getComponentProps: ILazyStaticPropsFunc<T>) {
+  LAZY_PROPS[key] = getComponentProps;
+}
+
+export async function decorateLazyComponents(extraComponents?: IComponent[]) {
+  const context = await getContext();
+  const pageContext = await getPageContext();
+  const page = pageContext.page;
+  if (!page) {
+    return;
+  }
+  const components = [
+    ...(page.components || []),
+    ...(extraComponents || []),
+  ];
+  const decoratedComponents: ILazyComponent[] = [];
+  for (const component of components) {
+    const key = (component.blockType || component.schema || 'unkown_type') as keyof typeof LAZY_PROPS;
+    const getComponentProps = LAZY_PROPS[key];
+    if (typeof getComponentProps === 'function') {
+      const decoratedComponent = await getComponentProps({
+        ...context,
+        ...pageContext,
+        component,
+      });
+      decoratedComponents.push(decoratedComponent);
+    } else {
+      decoratedComponents.push(component);
+    }
+  }
+  page.components = decoratedComponents;
+}

package/src/server/local-api.ts

@@ -0,0 +1,63 @@
+'use server';
+
+import { CollectionSlug, getPayload, GlobalSlug, SanitizedConfig } from 'payload';
+
+export async function getLocalApi(config: Promise<SanitizedConfig>, slug: string): Promise<any> {
+  const payload = await getPayload({ config });
+  const collectionSlugs = payload.config.collections.map(x => x.slug);
+  const globalSlugs = payload.config.globals.map(x => x.slug);
+  const keys = [
+    ...collectionSlugs,
+    ...globalSlugs,
+  ];
+  keys.sort();
+  if (collectionSlugs.includes(slug as CollectionSlug)) {
+    const collectionSlug = slug as CollectionSlug;
+    return {
+      findMany: async (params: Parameters<typeof payload.find>) => {
+        const response = await payload.find({
+          ...(params as any),
+          collection: collectionSlug,
+          pagination: false,
+          limit: 10000,
+          overrideAccess: false,
+        });
+        return response.docs;
+      },
+      findPaged: async (params: Parameters<typeof payload.find>) => {
+        const response = await payload.find({
+          ...(params as any),
+          collection: collectionSlug,
+          overrideAccess: false,
+        });
+        return response;
+      },
+      findOne: async (params: Parameters<typeof payload.findByID>) => {
+        return await payload.findByID({
+          id: '',
+          ...params,
+          collection: collectionSlug,
+          disableErrors: true,
+          overrideAccess: false,
+        });
+      },
+    };
+  } else if (globalSlugs.includes(slug as GlobalSlug)) {
+    const globalSlug = slug as GlobalSlug;
+    return {
+      findMany: async (params: Parameters<typeof payload.findGlobal>) => {
+        return await payload.findGlobal({
+          slug: globalSlug,
+          ...params,
+          overrideAccess: false,
+        });
+      },
+      findPaged: async (params: Parameters<typeof payload.find>) => {
+        throw 'Not implemented';
+      },
+      findOne: async (params: Parameters<typeof payload.findByID>) => {
+        throw 'Not implemented';
+      },
+    };
+  }
+}

package/src/server/metadata.ts

@@ -0,0 +1,87 @@
+import type { ResolvingMetadata } from 'next';
+import type { CollectionSlug, SanitizedConfig } from 'payload';
+import type { PageParams } from '../types';
+import { createPageContext } from './context';
+
+/**
+ * Returns a generateMetadata function for a given page collection slug.
+ * Uses bowl's createPageContext (Payload local API) instead of the store abstraction.
+ */
+export function getMetadata<TSlug extends CollectionSlug>(slug: TSlug, config: Promise<SanitizedConfig>) {
+    return async function generateMetadata(
+        props: Readonly<{ params: Promise<PageParams>; }>,
+        parent: ResolvingMetadata
+    ) {
+        const { market, locale, id } = await props.params;
+        const { page } = await createPageContext(market, locale, slug, id, config);
+        return {
+            title: page!.meta?.title || page!.title,
+            description: page!.meta?.description || page!.abstract,
+        };
+    };
+}
+
+/*
+
+{
+    "viewport": null,
+    "themeColor": null,
+    "colorScheme": null,
+    "metadataBase": null,
+    "title": {
+        "absolute": "Mixer",
+        "template": null
+    },
+    "description": "Generated by bom create",
+    "applicationName": "Mixer",
+    "authors": [
+        {
+            "name": "Websolute Spa",
+            "url": "https://www.websolute.it"
+        }
+    ],
+    "generator": "BOM",
+    "keywords": [
+        "Mixer",
+        "Next.js",
+        "React",
+        "JavaScript"
+    ],
+    "referrer": "origin-when-cross-origin",
+    "creator": "Luca Zampetti",
+    "publisher": "Websolute Spa",
+    "robots": null,
+    "manifest": null,
+    "alternates": {
+        "canonical": null,
+        "languages": null,
+        "media": null,
+        "types": null
+    },
+    "icons": null,
+    "openGraph": null,
+    "twitter": null,
+    "verification": {},
+    "appleWebApp": null,
+    "formatDetection": {
+        "email": false,
+        "address": false,
+        "telephone": false
+    },
+    "itunes": null,
+    "facebook": null,
+    "abstract": null,
+    "appLinks": null,
+    "archives": null,
+    "assets": null,
+    "bookmarks": null,
+    "category": null,
+    "classification": null,
+    "pagination": {
+        "previous": null,
+        "next": null
+    },
+    "other": {}
+}
+
+*/

package/src/server/mixer-payload.ts

@@ -0,0 +1,124 @@
+import type { IMenu, IMenuItem } from '@websolutespa/bom-core';
+import type { MixerReadContext } from '@websolutespa/payload-plugin-bowl';
+import type {
+  BasePayload,
+  CollectionSlug,
+  DataFromCollectionSlug,
+  DataFromGlobalSlug,
+  FindOptions,
+  GlobalSlug,
+  PaginatedDocs,
+  RequestContext
+} from 'payload';
+
+/** Fields added to the root document by Bowl's market- and locale-aware reads. */
+export type BowlDocumentDecoration = {
+  schema: string;
+  href?: string | null;
+};
+
+type BowlDecoratedCategory<T> = T extends null
+  ? null
+  : T extends string
+  ? T
+  : T extends readonly (infer TItem)[]
+  ? BowlDecoratedCategory<TItem>[]
+  : T extends object
+  ? BowlDecoratedValue<T> & { href: string | null }
+  : T;
+
+type BowlDecoratedNav<T> = Extract<T, null | undefined> | IMenuItem | IMenuItem[];
+
+type BowlDecoratedNavs<T> = T extends null | undefined ? T : IMenuItem[];
+
+type BowlDecoratedProperty<TKey, TValue> = TValue extends { root: unknown }
+  ? string
+  : TKey extends 'category'
+  ? BowlDecoratedCategory<TValue>
+  : TKey extends 'nav'
+  ? BowlDecoratedNav<TValue>
+  : TKey extends 'navs'
+  ? BowlDecoratedNavs<TValue>
+  : BowlDecoratedValue<TValue>;
+
+type BowlDecoratedObject<T> = {
+  [TKey in keyof T]: BowlDecoratedProperty<TKey, T[TKey]>;
+} & (T extends { mimeType?: unknown; filename?: unknown } ? { type: string } : unknown);
+
+type BowlDecoratedValue<T> = T extends Date
+  ? T
+  : T extends readonly (infer TItem)[]
+  ? BowlDecoratedValue<TItem>[]
+  : T extends object
+  ? BowlDecoratedObject<T>
+  : T;
+
+/**
+ * Represents a document returned by a Bowl-decorated local Payload read.
+ *
+ * Localized values are selected by Payload's `locale` option. Bowl recursively
+ * serializes Lexical rich-text values to HTML, resolves populated category
+ * relationships, normalizes nav fields, and adds upload media types. Bowl menu
+ * collections return their `IMenu` projection rather than their stored shape.
+ */
+export type BowlDecorator<T, TSlug extends string = ''> = TSlug extends 'menu'
+  ? IMenu
+  : BowlDecoratedValue<T> & BowlDocumentDecoration;
+
+/** @deprecated Use `BowlDecorator<T>` for a decorated document result. */
+export type BowlDecoration = BowlDocumentDecoration;
+
+type DecorateForMixer<T, TSlug extends string, TContext> = TContext extends MixerReadContext
+  ? BowlDecorator<T, TSlug>
+  : T;
+
+type MixerFindOptions<
+  TSlug extends CollectionSlug,
+  TContext,
+> = Omit<FindOptions<TSlug, any>, 'context'> & {
+  context?: TContext;
+};
+
+type MixerFindByIDOptions<
+  TSlug extends CollectionSlug,
+  TContext,
+> = Omit<FindOptions<TSlug, any>, 'context'> & {
+  context?: TContext;
+  disableErrors?: boolean;
+  id: number | string;
+};
+
+type MixerFindGlobalOptions<
+  TSlug extends GlobalSlug,
+  TContext,
+> = Omit<FindOptions<CollectionSlug, any>, 'collection' | 'context'> & {
+  context?: TContext;
+  slug: TSlug;
+};
+
+/**
+ * Type-only view returned by BOM Next's getPayload loader.
+ *
+ * It is the same Payload instance at runtime. Standard local reads retain
+ * generated Payload types until their context includes market and locale.
+ */
+export type MixerPayload = Omit<BasePayload, 'find' | 'findByID' | 'findGlobal'> & {
+  find: <
+    TSlug extends CollectionSlug,
+    TContext extends RequestContext | undefined = undefined,
+  >(options: MixerFindOptions<TSlug, TContext>) => Promise<
+    PaginatedDocs<DecorateForMixer<DataFromCollectionSlug<TSlug>, TSlug, TContext>>
+  >;
+  findByID: <
+    TSlug extends CollectionSlug,
+    TContext extends RequestContext | undefined = undefined,
+  >(options: MixerFindByIDOptions<TSlug, TContext>) => Promise<
+    DecorateForMixer<DataFromCollectionSlug<TSlug>, TSlug, TContext> | null
+  >;
+  findGlobal: <
+    TSlug extends GlobalSlug,
+    TContext extends RequestContext | undefined = undefined,
+  >(options: MixerFindGlobalOptions<TSlug, TContext>) => Promise<
+    DecorateForMixer<DataFromGlobalSlug<TSlug>, TSlug, TContext>
+  >;
+};

package/src/server/mixer-payload.type-test.ts

@@ -0,0 +1,27 @@
+import type { MixerPayload } from './mixer-payload';
+
+declare const payload: MixerPayload;
+
+const plainFind = payload.find({ collection: 'page' });
+plainFind.then(result => {
+  result.docs[0].id;
+});
+
+const decoratedFind = payload.find({
+  collection: 'page',
+  context: { market: 'ww', locale: 'it' },
+});
+decoratedFind.then(result => result.docs[0].schema);
+
+const decoratedByID = payload.findByID({
+  collection: 'page',
+  id: 'page-id',
+  context: { market: 'ww', locale: 'it' },
+});
+decoratedByID.then(result => result?.schema);
+
+const decoratedGlobal = payload.findGlobal({
+  slug: 'app',
+  context: { market: 'ww', locale: 'it' },
+});
+decoratedGlobal.then(result => result.schema);