@websolutespa/bom-next 3.0.0

package/src/server/mixer.ts

@@ -0,0 +1,439 @@
+import { collectRoutes, defaultLocale, defaultMarket, ICategory, ILocale, IMarket, IMedia, IRoute, isDevelopment, isObject } from '@websolutespa/bom-core';
+import type { Config, User } from '@websolutespa/payload-plugin-bowl';
+import { InMemoryCache } from '@websolutespa/payload-plugin-bowl';
+import { NextRequest } from 'next/server';
+import { BasePayload, getPayload as getPayload_, SanitizedConfig, TypedFallbackLocale, TypedLocale } from 'payload';
+import { cache } from 'react';
+import { guest } from '../lib/const';
+import type { BaseOptions, IContext, MixerContext, ReadonlyHeaders } from '../types';
+import type { MixerPayload } from './mixer-payload';
+
+// !!! todo check when to use in memory cache
+
+const USE_CACHE = true || !(isDevelopment);
+
+const getRouteCache = (): InMemoryCache<IRoute[]> => {
+  let cache: InMemoryCache<IRoute[]> | undefined = (globalThis as any)._route;
+  if (!cache) {
+    cache = new InMemoryCache<IRoute[]>();
+    (globalThis as any)._route = cache;
+  }
+  return cache;
+};
+
+const getMixerCache = (): InMemoryCache<MixerContext> => {
+  let cache: InMemoryCache<MixerContext> | undefined = (globalThis as any)._mixer;
+  if (!cache) {
+    cache = new InMemoryCache<MixerContext>();
+    (globalThis as any)._mixer = cache;
+  }
+  return cache;
+};
+
+export function getCacheKey({
+  market = 'all',
+  locale = 'all',
+  user = guest,
+  draft = 'false',
+}: {
+  market?: string;
+  locale?: string;
+  user?: User & Config['user'];
+  draft?: string;
+}) {
+  const roles = (user?.roles || ['guest']) as string[];
+  const tenants = ('tenants' in user && Array.isArray(user.tenants) ?
+    user.tenants.map((x: any) => isObject(x) ? x.id : x) :
+    []
+  ) as string[];
+  roles.sort();
+  tenants.sort();
+  const keys = [market, locale, draft === 'false' ? 'published' : 'draft', ...roles, ...tenants];
+  const key = `context-${keys.join('-')}`;
+  return key;
+}
+
+export async function getContext() {
+  let context: IContext | undefined = (globalThis as any)._context;
+  if (!context) {
+    context = {
+      payload: undefined,
+      context: undefined,
+    } as unknown as IContext;
+    (globalThis as any)._context = context;
+  }
+  return context;
+}
+
+export async function setContext(data: Partial<IContext>) {
+  const context = await getContext();
+  if (data.payload) {
+    context.payload = data.payload;
+  }
+  if (data.context) {
+    context.context = data.context;
+  }
+}
+
+export function getSearchParams(request: NextRequest) {
+  const searchParams = request.nextUrl.searchParams;
+  const params = Object.fromEntries(searchParams.entries());
+  return {
+    market: params.market || defaultMarket,
+    locale: params.locale || defaultLocale,
+    defaultMarket,
+    defaultLocale,
+    params,
+    searchParams: request.nextUrl.searchParams,
+  };
+}
+
+export const getPayloadInstance = cache(
+  async (props: { config: SanitizedConfig | Promise<SanitizedConfig> }) => await getPayload_(props)
+);
+
+export function getOptions({
+  locale = 'all',
+  user = guest,
+  draft = false,
+}: {
+  locale?: string;
+  user?: User & Config['user'];
+  draft?: boolean;
+}) {
+  const localized: BaseOptions = {
+    locale: locale as TypedLocale,
+    fallbackLocale: defaultLocale as TypedLocale,
+    draft,
+    depth: 0,
+    pagination: false,
+    limit: 10000,
+    user,
+    overrideAccess: false,
+  };
+  const unlocalized: BaseOptions = {
+    locale: 'all',
+    fallbackLocale: defaultLocale as TypedLocale,
+    draft,
+    depth: 0,
+    pagination: false,
+    limit: 10000,
+    user,
+    overrideAccess: false,
+  };
+  return { localized, unlocalized };
+}
+
+export async function getRoutes({
+  payload,
+  market = 'all',
+  locale = 'all',
+  user = guest,
+  draft = false,
+}: {
+  payload: BasePayload;
+  market?: string;
+  locale?: string;
+  user?: User & Config['user'];
+  draft?: boolean;
+}): Promise<IRoute[]> {
+  const cacheKey = getCacheKey({ market, locale, user, draft: draft ? 'true' : 'false' });
+
+  const routeCache = getRouteCache();
+  if (USE_CACHE && routeCache.has(cacheKey)) {
+    console.log('getRoutes from cache', cacheKey);
+    return routeCache.get(cacheKey);
+  }
+
+  let routes: IRoute[] = [];
+  if (!user) {
+    return routes;
+  }
+
+  const { localized, unlocalized } = getOptions({ locale, user, draft });
+
+  const marketRequest = await payload.find({
+    ...localized,
+    collection: 'market',
+    where: { isActive: { equals: true } },
+  });
+  const markets = marketRequest.docs;
+
+  const localeResult = await payload.findGlobal({
+    ...localized,
+    slug: 'locale',
+  }) as { items: ILocale[] };
+  const locales = localeResult.items.filter(x => x.isActive);
+
+  if (locales.length > 0 && markets.length > 0) {
+    const pageCollections = payload.config.collections.filter(x => {
+      return x.fields.find(x => 'name' in x && x.name === 'slug');
+    });
+    const keys = pageCollections.map(x => x.slug);
+    // console.log(payload.config.collections.find(x => x.slug === 'homepage'));
+    // const keys = Object.keys(store.pages) as CollectionSlug[];
+    const pages: Record<string, any[]> = Object.fromEntries(keys.map(x => [x, []]));
+    for (const key of keys) {
+      const pageResult = await payload.find({ ...unlocalized, collection: key });
+      pages[key] = pageResult.docs;
+    }
+    const categoryRequest = await payload.find({
+      ...unlocalized,
+      collection: 'category',
+      depth: 1,
+    });
+    const categories = categoryRequest.docs;
+    const mediaRequest = await payload.find({
+      ...unlocalized,
+      collection: 'media',
+      depth: 1,
+    });
+    const medias = mediaRequest.docs;
+    routes = collectRoutes(
+      pages,
+      categories as unknown as ICategory[],
+      markets as unknown as IMarket[],
+      locales,
+      medias as unknown as IMedia[]
+    );
+  }
+  routeCache.set(cacheKey, routes);
+  return routes;
+}
+
+export async function getMixerContext({
+  payload,
+  market,
+  locale,
+  user = guest,
+  draft = false,
+}: {
+  payload: BasePayload;
+  market: string;
+  locale: string;
+  user?: User & Config['user'];
+  draft?: boolean;
+}): Promise<MixerContext> {
+  const cacheKey = getCacheKey({ market, locale, user, draft: draft ? 'true' : 'false' });
+
+  const mixerCache = getMixerCache();
+  if (mixerCache.has(cacheKey) && USE_CACHE) {
+    console.log('getContext from cache', cacheKey);
+    return mixerCache.get(cacheKey);
+  }
+
+  const { localized } = getOptions({ locale, user, draft });
+  const localeResult = await payload.findGlobal({
+    ...localized,
+    slug: 'locale',
+  }) as { items: ILocale[] };
+  const locales = localeResult.items.filter(x => x.isActive) as unknown as ILocale[];
+  const localeIds = locales.map(x => x.id) as string[];
+
+  const marketRequest = await payload.find({
+    ...localized,
+    collection: 'market',
+  });
+  const marketItems = marketRequest.docs;
+  const markets = marketItems.filter(x => x.isActive) as unknown as IMarket[];
+  const marketIds = markets.map(x => x.id);
+
+  const categoryRequest = await payload.find({
+    ...localized,
+    collection: 'category',
+    depth: 2,
+  });
+  const categories = categoryRequest.docs;
+
+  const routes = await getRoutes({ payload, market, locale, user, draft });
+  const currentRoutes = filterRoutes(routes, market, locale);
+
+  const richText = false;
+
+  const context: MixerContext = {
+    locale,
+    localeIds,
+    locales,
+    market,
+    marketIds,
+    markets,
+    routes,
+    currentRoutes,
+    categories: categories as unknown as MixerContext['categories'],
+    richText,
+  };
+
+  mixerCache.set(cacheKey, context);
+  await setContext({ context });
+
+  return context;
+}
+
+/**
+ * Runtime (request-time) payload accessor.
+ *
+ * By default, operates as the guest user for static generation. For auth:
+ * call getHeaders() directly in your page/route/layout, then pass it here.
+ *
+ * Example:
+ *   const headers = await getHeaders();
+ *   const { payload, user, getContext } = await getPayload({ config, headers });
+ */
+export async function getPayload({
+  config,
+  headers,
+}: {
+  config: Promise<SanitizedConfig>;
+  headers?: ReadonlyHeaders;
+}) {
+  const payload = await getPayload_({ config });
+  await setContext({ payload: payload as MixerPayload });
+
+  let user: User & Config['user'] = guest;
+  if (headers) {
+    try {
+      const auth = await payload.auth({ headers, canSetHeaders: false });
+      if (auth.user) {
+        user = auth.user as typeof user;
+      }
+      // console.log('getPayload', user, token);
+    } catch (error) {
+      console.log('getPayload.error', error);
+    }
+  }
+
+  const draft = false;
+
+  return {
+    payload: payload as MixerPayload,
+    user,
+    getContext: (market: string, locale: string) => getMixerContext({ payload, market, locale, user, draft }),
+  };
+}
+
+export function filterRoutes(routes: IRoute[], market: string, locale: string): IRoute[] {
+  market = market === 'all' ? defaultMarket : market;
+  locale = locale === 'all' ? defaultLocale : locale;
+  return routes.filter(x => x.market === market && x.locale === locale);
+}
+
+export function getAuthHeaders(token: { value: string } | undefined): Headers {
+  if (token) {
+    return new Headers({ Authorization: `JWT ${token.value}` });
+  } else {
+    return new Headers({ Authorization: `users API-Key ${process.env.STORE_API_KEY}` });
+  }
+}
+
+/**
+ * Produces the common option block shared across all payload.find / payload.findGlobal calls.
+ * For payload.find, add pagination: false and limit: 10000 at the call site.
+ * For payload.findByID, spread directly — extra find-only fields are ignored.
+ */
+export function buildBaseOptions(user: any, locale: string, draft?: boolean) {
+  return {
+    locale: locale as TypedLocale,
+    fallbackLocale: defaultLocale as TypedFallbackLocale,
+    draft: draft ?? false,
+    depth: 0,
+    user,
+    overrideAccess: false,
+  };
+}
+
+
+/**
+ * Payload proxy example
+ *
+ *
+ * import type { Payload, PayloadRequest } from '../types/index.js'
+
+import { commitTransaction } from './commitTransaction.js'
+import { initTransaction } from './initTransaction.js'
+import { killTransaction } from './killTransaction.js'
+
+const localOperations = [
+  'count',
+  'countGlobalVersions',
+  'countVersions',
+  'create',
+  'delete',
+  'duplicate',
+  'find',
+  'findByID',
+  'delete',
+  'duplicate',
+  'find',
+  'findByID',
+  'findGlobal',
+  'findGlobalVersionByID',
+  'findGlobalVersions',
+  'findVersionByID',
+  'findVersionByID',
+  'login',
+  'update',
+  'updateGlobal',
+  'restoreVersion',
+  'restoreGlobalVersion',
+] satisfies (keyof Payload)[]
+
+type LocalOperation = (typeof localOperations)[number]
+
+const isLocalOperation = (key: string): key is LocalOperation => {
+  return localOperations.includes(key as LocalOperation)
+}
+
+export const withTransaction = async <T>(
+  payload: Payload,
+  callback: (transaction: Payload) => Promise<T>,
+) => {
+  const transactionReq = { payload } as PayloadRequest
+  await initTransaction(transactionReq)
+
+  const proxy = new Proxy(payload, {
+    get(target, property: keyof Payload, receiver) {
+      if (isLocalOperation(property)) {
+        const operation = Reflect.get(target, property, receiver)
+
+        return function (options) {
+          let req: Partial<PayloadRequest> = options.req
+
+          if (!req) {
+            req = {}
+          }
+
+          if (!req.transactionID) {
+            req = { ...req, transactionID: transactionReq.transactionID }
+          }
+
+          return (operation as (...args: unknown[]) => void)({
+            ...options,
+            req,
+          })
+        }
+      }
+
+      return Reflect.get(target, property, receiver)
+    },
+  })
+
+  try {
+    const result = await callback(proxy)
+    await commitTransaction(transactionReq)
+    return result
+  } catch (e) {
+    await killTransaction(transactionReq)
+    throw e
+  }
+}
+
+// -----------------
+
+const { one, two } = await withTransaction(payload, async (transaction) => {
+  const one = await transaction.create({ collection: 'posts', data: { title: 'one' } })
+  const two = await transaction.create({ collection: 'posts', data: { title: 'two' } })
+
+  return { one, two }
+})
+
+ */

package/src/server/mock/category.ts

@@ -0,0 +1,34 @@
+import { ICollectionDescription, IEntity, ILocalizedString, ISerializedCollection } from '@websolutespa/bom-core';
+import { textToSlug } from './route';
+
+export function toCategory(description: ICollectionDescription, collection: (IEntity & { category?: string })[]): ISerializedCollection {
+  const mapToCategory = (x: (IEntity & { category?: string }), i: number) => {
+    // !!! loose
+    if (typeof x.slug !== 'string' && x.category != null) {
+      if (x.title != null) {
+        if (typeof x.title === 'string') {
+          x.slug = textToSlug(x.title);
+        } else {
+          const slug: ILocalizedString = { ...x.title };
+          x.slug = Object.fromEntries(
+            Object.entries(slug).map(([k, v]) => [k, textToSlug(v)])
+          );
+        }
+      }
+    } else {
+      x.slug = '';
+    }
+    const data = {
+      ...x,
+    };
+    if (!data.schema) {
+      data.schema = description.singularName;
+    }
+    return data;
+  };
+  return {
+    ...description,
+    items: collection.map((x, i) => mapToCategory(x, i)),
+  };
+}
+

package/src/server/mock/collection.ts

@@ -0,0 +1,21 @@
+import { ICollectionDescription, IEntity, ISerializedCollection } from '@websolutespa/bom-core';
+
+export function toCollection(description: ICollectionDescription, collection: IEntity[], createdAt?: string | Date, updatedAt?: string | Date): ISerializedCollection {
+  const mapToCollection = (x: IEntity, i: number) => {
+    const data = {
+      ...((createdAt && createdAt) ? {
+        createdAt,
+        updatedAt,
+      } : {}),
+      ...x,
+    };
+    if (!data.schema) {
+      data.schema = description.singularName;
+    }
+    return data;
+  };
+  return {
+    ...description,
+    items: collection.map((x, i) => mapToCollection(x, i)),
+  };
+}

package/src/server/mock/page.ts

@@ -0,0 +1,62 @@
+import { getCollectionDescription, ICategorized, ICollectionDescription, IEntity, ILocalizable, ILocalizedString, ISerializedCollection, ISerializedStore } from '@websolutespa/bom-core';
+import { textToSlug } from './route';
+
+export function createPageService(store: ISerializedStore, pageKeys: string[]): ISerializedCollection<ICategorized> {
+  const pages: ICategorized[] = [];
+  for (const key of pageKeys) {
+    const collection = store[key];
+    if (collection) {
+      const items = collection.items as ICategorized[];
+      pages.push(...items);
+    } else {
+      console.warn(`BomCli.createPageService.collection not found [${key}]`);
+    }
+  }
+  const pageDescription = getCollectionDescription('page');
+  const pageService = {
+    ...pageDescription,
+    items: pages,
+  };
+  return pageService;
+}
+
+export function toPage(description: ICollectionDescription, collection: IEntity[], createdAt: string | Date, updatedAt: string | Date): ISerializedCollection {
+  const mapToPage = (x: IEntity, i: number) => {
+    if (typeof x.slug !== 'string') {
+      if (x.title != null) {
+        if (typeof x.title === 'string') {
+          x.slug = textToSlug(x.title);
+        } else {
+          const slug: ILocalizedString = { ...x.title };
+          x.slug = Object.fromEntries(
+            Object.entries(slug).map(([k, v]) => [k, textToSlug(v)])
+          );
+        }
+      } else {
+        throw `${description.singularName} error: invalid page missing title or slug`;
+      }
+    }
+    if (!x.title) {
+      throw `${description.singularName} error: invalid page missing title`;
+    }
+    const meta: { [key: string]: ILocalizable } = x.meta || ({} as any);
+    meta.title = meta.title || (x.title as ILocalizable);
+    meta.description = meta.description || (x.abstract as ILocalizable);
+    meta.keywords = meta.keywords || 'keywords';
+    meta.robots = meta.robots || 'all';
+    x.meta = meta;
+    const page = {
+      createdAt,
+      updatedAt,
+      ...x,
+    };
+    if (!page.schema) {
+      page.schema = description.singularName;
+    }
+    return page;
+  };
+  return {
+    ...description,
+    items: collection.map((x, i) => mapToPage(x, i)),
+  };
+}

package/src/server/mock/route.ts

@@ -0,0 +1,36 @@
+import { collectRoutes, getCollectionDescription, ICategorized, ICategory, ILocale, IMarket, IMemoryStore, IRoute, ISerializedCollection, ISerializedStore } from '@websolutespa/bom-core';
+import { slugify } from 'transliteration';
+
+export function createRouteService(store: ISerializedStore, pageKeys: string[]): ISerializedCollection {
+  const routes: IRoute[] = getRoutes(store, pageKeys);
+  const routeDescription = getCollectionDescription('route');
+  const routeService = {
+    ...routeDescription,
+    items: routes,
+  };
+  return routeService;
+}
+
+export function getRoutes(store: ISerializedStore, pageKeys: string[]): IRoute[] {
+  let routes: IRoute[] = [];
+  const locales = store.locale!.items as ILocale[];
+  const markets = store.market!.items as IMarket[];
+  if (locales.length > 0 && markets.length > 0) {
+    const categories = store.category!.items as ICategory[];
+    const categorized: IMemoryStore<ICategorized> = {};
+    for (const key of pageKeys) {
+      const collection = store[key];
+      if (collection) {
+        categorized[key] = collection.items as ICategorized[];
+      } else {
+        console.warn('BomCli.getRoutes', `collection not found [${key}]`);
+      }
+    }
+    routes = collectRoutes(categorized, categories, markets, locales);
+  }
+  return routes;
+}
+
+export function textToSlug(value: string): string {
+  return slugify(value);
+}