@websolutespa/bom-next 3.0.0

package/src/server/mock/store.ts

@@ -0,0 +1,159 @@
+import { getCollectionDescription, ICollectionDescription, IEntity, IMemoryStore, IMockStore, isArray, ISerializedCollection, ISerializedStore, isProduction, isValidCollectionDescription } from '@websolutespa/bom-core';
+import { toCategory } from './category';
+import { toCollection } from './collection';
+import { toPage } from './page';
+import { createRouteService } from './route';
+
+// storeStrategy
+export enum StoreStrategy {
+  Local = 'local',
+  Api = 'api',
+  DecoratedApi = 'decoratedApi',
+  Data = 'data',
+  Mock = 'mock',
+}
+
+function getStoreStrategy(): StoreStrategy {
+  let storeStrategy = StoreStrategy.Mock;
+  if (typeof process !== 'undefined' && process.env.STORE_STRATEGY) {
+    storeStrategy = process.env.STORE_STRATEGY as StoreStrategy;
+  }
+  return storeStrategy;
+}
+
+export const storeStrategy: StoreStrategy = getStoreStrategy();
+
+export function resolveMockStore(data: IMockStore): IMemoryStore {
+  const mocks = { ...data.collections, ...data.pages };
+  const collectionKeys = Object.keys(data.collections);
+  const pageKeys = Object.keys(data.pages);
+  const keys = collectionKeys.concat(pageKeys);
+  const store: ISerializedStore = {};
+  const createdAt = new Date();
+  const updatedAt = new Date();
+  const collections: ICollectionDescription[] = keys.map((key) => getCollectionDescription(key));
+  collections.forEach((description) => {
+    if (!isValidCollectionDescription(description)) {
+      throw `collection error: invalid singular key ${description.singularName}`;
+    }
+    const mockItems = (mocks[description.singularName as keyof typeof mocks] || []) as IEntity[];
+    const items = mockData(mockItems);
+    let collectionService: ISerializedCollection;
+    if (description.singularName === 'category') {
+      // console.log('store.buildStore', 'categories');
+      collectionService = toCategory(description, items);
+    } else if (pageKeys.includes(description.singularName)) {
+      // console.log('store.buildStore', 'pages');
+      collectionService = toPage(description, items, createdAt, updatedAt);
+    } else {
+      // console.log('store.buildStore', 'data');
+      collectionService = toCollection(description, items, createdAt, updatedAt);
+    }
+    store[description.singularName] = collectionService;
+  });
+  if (!store.category) {
+    store.category = toCategory(getCollectionDescription('category'), []);
+  }
+  if (!store.menu) {
+    store.menu = toCollection(getCollectionDescription('menu'), []);
+  }
+  if (!store.redirect) {
+    store.redirect = toCollection(getCollectionDescription('redirect'), []);
+  }
+  const routeService = createRouteService(store, pageKeys);
+  store.route = routeService;
+  // const serializedCollections: ISerializedCollection[] = Object.keys(store).map((key) => store[key]!);
+  // console.log('serializedCollections', serializedCollections);
+  const mockStore: IMemoryStore = {};
+  Object.keys(store).forEach((key) => {
+    mockStore[key] = store[key]!.items;
+  });
+  console.log('[mock] resolveMockStore');
+  return mockStore;
+}
+
+export function serializeMockStore(mockStore: IMockStore) {
+  if (
+    !isProduction &&
+    storeStrategy === StoreStrategy.Mock
+  ) {
+    const store = resolveMockStore(mockStore);
+    return JSON.stringify(store);
+  } else {
+    return JSON.stringify({});
+  }
+}
+
+export function mockEnv(mockStore: IMockStore) {
+  if (storeStrategy === StoreStrategy.Mock) {
+    return {
+      COLLECTIONS: [
+        ...Object.keys(mockStore.collections),
+        ...Object.keys(mockStore.pages),
+      ].join(','),
+      PAGES: [
+        ...Object.keys(mockStore.pages),
+      ].join(','),
+      STORE: serializeMockStore(mockStore),
+    };
+  } else {
+    return {
+      COLLECTIONS: [
+        'category',
+        'label',
+        'locale',
+        'market',
+        'menu',
+        'redirect',
+        'route',
+        'template',
+      ].join(','),
+      PAGES: [].join(','),
+      STORE: JSON.stringify({
+        category: [],
+        label: [],
+        locale: [],
+        market: [],
+        menu: [],
+        redirect: [],
+        route: [],
+        template: [],
+      }),
+    };
+  }
+}
+
+export function mockData(items: IEntity[]): IEntity[] {
+  items.forEach((item, i) => {
+    if (item.id == null) {
+      item.id = (i + 1);
+    }
+  });
+  if (items.length > 0) {
+    const inherit: boolean = items.find(x => x.$inherit && (x.$inherit === true || isArray(x.$inherit))) !== undefined;
+    if (inherit) {
+      const forbiddenProperties = ['slug', 'meta', 'order', 'isDefault', 'isHidden', 'useSplat'];
+      let lastItem: IEntity | undefined = undefined;
+      const parsedItems = items.map(({ $inherit, ...item }) => {
+        let inheritedItem = item;
+        if (lastItem) {
+          if ($inherit === true) {
+            inheritedItem = { ...lastItem, ...item };
+          } else if (isArray($inherit)) {
+            inheritedItem = { ...pickProps(lastItem, ...($inherit as string[])), ...item };
+          }
+        }
+        lastItem = Object.fromEntries(
+          Object.entries(inheritedItem).filter(([k, v]) => !forbiddenProperties.includes(k))
+        ) as IEntity;
+        return inheritedItem;
+      });
+      return parsedItems;
+    }
+  }
+  return items;
+}
+
+export function pickProps(item: Record<string, unknown>, ...props: string[]): Record<string, unknown> {
+  return Object.fromEntries(Object.entries(item).filter(([k, v]) => props.includes(k)));
+}

package/src/server/page.ts

@@ -0,0 +1,86 @@
+'use server';
+
+import { getCategorySegments, ICategorized, ICategory, IRoute, IRouteLink } from '@websolutespa/bom-core';
+import type { User } from '@websolutespa/payload-plugin-bowl';
+import type { CollectionSlug } from 'payload';
+import { buildBreadcrumb } from '../lib/breadcrumb';
+import type { MixerContext, TypedPage } from '../types';
+import { buildBaseOptions } from './mixer';
+import type { MixerPayload } from './mixer-payload';
+
+/**
+ * Fetches a single page document by ID using Payload local API and assembles
+ * the IPage envelope (routes, alternates, breadcrumb, parentRoute).
+ *
+ * All data required for the envelope comes from mixerContext — no store calls.
+ *   - routes/alternates : mixerContext.routes filtered by schema+id
+ *   - segments          : getCategorySegments() from bom-core (pure)
+ *   - breadcrumb        : findRouteOfCategory() from bom-core + mixerContext.currentRoutes
+ */
+export async function getPage<TSlug extends CollectionSlug>(
+  slug: TSlug,
+  id: string,
+  market: string,
+  locale: string,
+  payload: MixerPayload,
+  user: User,
+  mixerContext: MixerContext,
+  draftMode?: boolean
+): Promise<TypedPage<TSlug> | undefined> {
+  try {
+    const base = buildBaseOptions(user, locale, draftMode);
+    const page = await payload.findByID({
+      collection: slug,
+      id,
+      locale: base.locale,
+      fallbackLocale: base.fallbackLocale,
+      draft: base.draft,
+      depth: base.depth,
+      user: base.user,
+      overrideAccess: base.overrideAccess,
+      disableErrors: true,
+      context: mixerContext,
+    });
+    if (page) {
+      // All routes for this schema+document across every market/locale (for alternates)
+      const routes = (mixerContext.routes as IRoute[]).filter(
+        r => r.schema === slug && String(r.page) === String(id)
+      );
+      const currentRoute = routes.find(r => r.market === market && r.locale === locale);
+      const alternates = routes;
+
+      // Segments derived from categories already present in mixerContext (pure, no I/O)
+      const categories = mixerContext.categories as unknown as ICategory[];
+      const segments = getCategorySegments(categories, page as unknown as ICategorized);
+
+      // Breadcrumb built from currentRoutes (pre-filtered to market+locale by mixer)
+      const currentRoutes = mixerContext.currentRoutes as IRoute[];
+      const breadcrumb: IRouteLink[] = currentRoute
+        ? buildBreadcrumb(segments, currentRoute, currentRoutes)
+        : [];
+
+      const parentRoute: IRouteLink | undefined = breadcrumb.length > 1
+        ? breadcrumb[breadcrumb.length - 2]
+        : undefined;
+
+      return {
+        ...page,
+        href: currentRoute?.id,
+        alternates,
+        breadcrumb,
+        parentRoute,
+      } as unknown as TypedPage<TSlug>;
+    } else {
+      console.log('PageService.getPage.notfound', slug, id, locale);
+      return undefined;
+    }
+  } catch {
+    return undefined;
+  }
+}
+
+/*
+export function asServerProps(props: any): any {
+  return JSON.parse(JSON.stringify(props));
+}
+*/

package/src/server/session/session.ts

@@ -0,0 +1,101 @@
+'server-only';
+
+import { SignJWT, jwtVerify } from 'jose';
+import { cookies as getCookies } from 'next/headers';
+import { cache } from 'react';
+
+type ISession = {
+  token: string;
+  expiresAt: Date;
+}
+
+function getSessionSecret() {
+  const secret = process.env.MIXER_SECRET || '';
+  if (!secret) {
+    throw 'getSessionSecret MIXER_SECRET not defined';
+  }
+  return secret;
+}
+
+function getSessionKey() {
+  const secret = getSessionSecret();
+  const sessionKey = new TextEncoder().encode(secret);
+  return sessionKey;
+}
+
+export async function encrypt(session: ISession) {
+  try {
+    const sessionKey = getSessionKey();
+    return new SignJWT(session)
+      .setProtectedHeader({ alg: 'HS256' })
+      .setIssuedAt()
+      .setExpirationTime('7d')
+      .sign(sessionKey);
+  } catch (error) {
+    console.log('encrypt.error', 'Failed to encrypt session');
+  }
+}
+
+export async function decrypt(session: string | undefined = '') {
+  try {
+    const sessionKey = getSessionKey();
+    const { payload } = await jwtVerify(session, sessionKey, {
+      algorithms: ['HS256'],
+    });
+    return payload;
+  } catch (error) {
+    console.log('decrypt.error', 'Failed to decrypt session');
+  }
+}
+
+export async function createSession(token: string) {
+  const expiresAt = new Date(Date.now() + 7 * 24 * 60 * 60 * 1000);
+  const session = await encrypt({ token, expiresAt });
+  if (session) {
+    const cookies = await getCookies();
+    cookies.set('session', session, {
+      httpOnly: true,
+      secure: true,
+      expires: expiresAt,
+      sameSite: 'lax',
+      path: '/',
+    });
+  }
+}
+
+export const getSession = cache(async () => {
+  const cookies = await getCookies();
+  const encriptedSession = cookies.get('session')?.value;
+  const session = await decrypt(encriptedSession);
+  return session as ISession | undefined;
+});
+
+export const hasValidSession = cache(async () => {
+  const session = await getSession();
+  return session?.token && new Date(session?.expiresAt) > new Date();
+});
+
+export async function updateSession() {
+  const cookies = await getCookies();
+  const session = cookies.get('session')?.value;
+  if (!session) {
+    return null;
+  }
+  const payload = await decrypt(session);
+  if (!payload) {
+    return null;
+  }
+  const expires = new Date(Date.now() + 7 * 24 * 60 * 60 * 1000);
+  cookies.set('session', session, {
+    httpOnly: true,
+    secure: true,
+    expires: expires,
+    sameSite: 'lax',
+    path: '/',
+  });
+}
+
+export async function deleteSession() {
+  const cookies = await getCookies();
+  cookies.delete('session');
+}

package/src/server/utils.ts

@@ -0,0 +1,23 @@
+import { getHost, IRoute } from '@websolutespa/bom-core';
+import { NextRequest } from 'next/server';
+import { resolveRoute } from '../lib/route';
+
+export function getNextUrl(request: NextRequest, route: IRoute) {
+  const nextUrl = request.nextUrl.clone();
+  const resolvedPathname = resolveRoute(route);
+  // console.log('getNextUrl.resolvedPathname', resolvedPathname);
+  nextUrl.pathname = resolvedPathname;
+  return nextUrl;
+}
+
+export function getHrefBeforeRedirect(request: NextRequest): string | null {
+  let hrefBeforeRedirect: string | null = null;
+  const urlBeforeRedirect = request.nextUrl.clone();
+  const host = getHost(request.headers);
+  if (host) {
+    urlBeforeRedirect.host = host;
+    urlBeforeRedirect.port = host.split(':')[1] || '';
+    hrefBeforeRedirect = urlBeforeRedirect.href;
+  }
+  return hrefBeforeRedirect;
+}

package/src/server/utmz.ts

@@ -0,0 +1,11 @@
+import { NextApiRequest } from 'next';
+
+export function getUtmz(request: NextApiRequest): string {
+  let utmz = 'N/A';
+  if (typeof request.cookies.__utmz === 'string') {
+    utmz = request.cookies.__utmz;
+    const i = utmz.indexOf('utmcsr');
+    utmz = utmz.substring(i === -1 ? 0 : i);
+  }
+  return utmz;
+}

package/src/types.ts

@@ -0,0 +1,211 @@
+import type { ICategorized, IComponent, ILayout, ILocale, IMarket, IPage, IPrettify, IRoute, PageProps } from '@websolutespa/bom-core';
+import type { Category, EndUser, User } from '@websolutespa/payload-plugin-bowl';
+import type { DynamicOptions, Loader } from 'next/dynamic';
+import type { BasePayload, CollectionSlug, DataFromCollectionSlug, SanitizedConfig, TypedFallbackLocale, TypedLocale } from 'payload';
+import type { ComponentType, ReactNode } from 'react';
+import type { BowlDecorator, MixerPayload } from './server/mixer-payload';
+
+export * from './instrumentation/types';
+
+export type ReadonlyHeaders = Headers & {
+  /** @deprecated Method unavailable on `ReadonlyHeaders`. Read more: https://nextjs.org/docs/app/api-reference/functions/headers */
+  append(...args: any[]): void;
+  /** @deprecated Method unavailable on `ReadonlyHeaders`. Read more: https://nextjs.org/docs/app/api-reference/functions/headers */
+  set(...args: any[]): void;
+  /** @deprecated Method unavailable on `ReadonlyHeaders`. Read more: https://nextjs.org/docs/app/api-reference/functions/headers */
+  delete(...args: any[]): void;
+};
+
+export type BaseOptions = {
+  currentDepth?: number;
+  depth?: number;
+  disableErrors?: boolean;
+  fallbackLocale?: TypedFallbackLocale;
+  includeLockStatus?: boolean;
+  limit?: number;
+  locale?: 'all' | TypedLocale;
+  overrideAccess?: boolean;
+  page?: number;
+  pagination?: boolean;
+  showHiddenFields?: boolean;
+  trash?: boolean;
+  user?: any;
+  draft?: boolean;
+};
+
+export type LocalProvider = {
+  config: Promise<SanitizedConfig> | undefined;
+  sanitizedConfig: SanitizedConfig | undefined;
+  payload: BasePayload | undefined;
+};
+
+export type SearchParams = {
+  [key: string]: string | string[] | undefined;
+}
+
+export type MarketLocaleParams = {
+  market: string;
+  locale: string;
+}
+
+export type NotFoundParams = IPrettify<MarketLocaleParams & {
+  slug: string;
+}>;
+
+export type NotFoundContext = Readonly<{
+  params: Promise<NotFoundParams>;
+}>;
+
+export type LayoutContext = Readonly<{
+  children: ReactNode;
+  params: Promise<MarketLocaleParams>;
+}>;
+
+export type PageParams = IPrettify<MarketLocaleParams & {
+  id: string;
+}>;
+
+export type PageContext = Readonly<{
+  params: Promise<PageParams>;
+  searchParams?: Promise<SearchParams>;
+}>;
+
+export type PageLayoutContext = Readonly<{
+  params: Promise<PageParams>;
+  children: ReactNode;
+}>;
+
+export type PartialPageProps<T extends ICategorized, B> = Omit<PageProps<T>, 'page'> & Partial<Pick<PageProps<T>, 'page'>> & B;
+
+export type ComponentProps<T extends Record<string, any> = Record<string, any>> = { item: IComponent & T };
+
+export type ComponentContext<T extends Record<string, any> = Record<string, any>> = PageContext & { page: IPage } & ComponentProps<T>;
+
+export type IUser = User;
+
+export type IEndUser = EndUser;
+
+/*
+export type IUser = {
+  id: number;
+  firstName: string;
+  lastName: string;
+  email: string;
+};
+*/
+
+// export type ILocale = (Locale['items'][number] & { title: string });
+
+export type MixerContext = {
+  market: string;
+  marketIds: string[];
+  markets: IMarket[];
+  locale: string;
+  localeIds: string[];
+  locales: ILocale[];
+  routes: IRoute[];
+  currentRoutes: IRoute[];
+  categories: Category[];
+  richText: boolean;
+};
+
+export type IContext = {
+  payload: MixerPayload;
+  context: MixerContext;
+}
+
+export type PageDocument<TSlug extends CollectionSlug> = DataFromCollectionSlug<TSlug>;
+
+/** A generated page collection document enriched with Bowl's page envelope. */
+export type TypedPage<TSlug extends CollectionSlug> = BowlDecorator<PageDocument<TSlug>> & IPage<ICategorized>;
+
+export type TypedPageContext<TSlug extends CollectionSlug = CollectionSlug> = {
+  layout: ILayout;
+  page: TypedPage<TSlug> | undefined;
+  user: IUser | IEndUser | null;
+  label: (key: string, params?: Record<string, any>) => string;
+  link: (category: string) => string | undefined;
+};
+
+/** Broad page context used where the page collection is only known at runtime. */
+export type IPageContext = TypedPageContext;
+
+export type ILazyComponent = IComponent;
+
+export type ILazyProps<T> = {
+  item: T & ILazyComponent;
+  index: number;
+  children?: ReactNode;
+};
+
+export type ILazyableProps<T> = {
+  item: T & Partial<ILazyComponent>;
+  index?: number;
+  children?: ReactNode;
+};
+
+export type INullableLazyableProps<T> = {
+  item?: T & Partial<ILazyComponent>;
+  index?: number;
+  children?: ReactNode;
+};
+
+export type ILazyedProps<T> = Omit<ILazyProps<T>, 'children'>;
+
+export type ILazyComponentProps = {
+  item: ILazyComponent;
+  index: number;
+};
+
+export type ILazyModules = Record<string, ComponentType<ILazyProps<any>>>;
+
+export type ILazyComponentFunc<P = {}> = DynamicOptions<P> | Loader<P>;
+
+export type ILazyFuncProps<T> = IContext & IPageContext & {
+  component: T & ILazyComponent;
+};
+
+export type ILazyStaticPropsFunc<T = any> = (props: ILazyFuncProps<T>) => Promise<T & ILazyComponent>;
+
+export type ILazyStaticProps = Record<string, ILazyStaticPropsFunc>;
+
+/*
+export const LAZY_MODULES: ILazyModules = {};
+
+export function withLazyModule<T>(key: string, callback: ILazyComponentFunc<ILazyProps<T>>) {
+  const module = dynamic<ILazyProps<T>>(callback);
+  LAZY_MODULES[key] = module;
+  return module;
+}
+
+export function withLazyModules(modules: Record<string, ILazyComponentFunc<ILazyProps<any>>>) {
+  Object.entries(modules).forEach(([key, callback]) => {
+    withLazyModule(key, callback);
+  });
+  return LAZY_MODULES;
+}
+*/
+
+
+
+
+
+/*
+
+export type NextAppPage<T = undefined> = T extends undefined
+    ? FC<{
+          searchParams?: Promise<SearchParams>;
+      }>
+    : FC<{
+          params: Promise<T>;
+          searchParams?: Promise<SearchParams>;
+      }>;
+
+export type NextAppLayout<T = undefined> = T extends undefined
+    ? FC<PropsWithChildren>
+    : FC<
+          PropsWithChildren<{
+              params: Promise<T>;
+          }>
+      >;
+*/