@websolutespa/bom-mixer-models 0.0.1

package/src/layout/layout.service.ts

@@ -0,0 +1,51 @@
+import { ILabel } from '../label/label';
+import { getLabels } from '../label/label.service';
+import { ILocale } from '../locale/locale';
+import { getLocales } from '../locale/locale.service';
+import { IMarket } from '../market/market';
+import { getMarkets } from '../market/market.service';
+import { IRouteLink } from '../route/route';
+import { getRouteLinkTree } from '../route/route.service';
+import { ILayout } from './layout';
+
+export async function getLayout(market: string, locale: string): Promise<ILayout> {
+  // const store = await getStore<IModelStore>();
+  const markets: IMarket[] = await getMarkets({ locale });
+  const locales: ILocale[] = await getLocales({ locale });
+  const labels: ILabel[] = await getLabels({ locale });
+  const tree = await getRouteLinkTree(market, locale);
+  const firstLevelRoutes = tree?.items || [];
+  const flatTopLevelRoutes = tree ? [tree, ...firstLevelRoutes] : [];
+  const topLevelRoutes = flatTopLevelRoutes.reduce((object, route: IRouteLink) => {
+    object[route.id] = route;
+    return object;
+  }, {} as { [key: string]: IRouteLink });
+  const topLevelHrefs = flatTopLevelRoutes.reduce((object, route: IRouteLink) => {
+    if (route.href) {
+      object[route.id] = route.href;
+    }
+    return object;
+  }, {} as { [key: string]: string });
+  const navs = {
+    primary: (tree && tree.items ? tree.items : []),
+    secondary: [],
+    footer: [],
+  };
+  /*
+  // get known routes eg 'reserved_area', 'login', 'homepage';
+  const knownRoutes = await getRoutesForSchemas(['homepage', 'login', 'reserved_area'], market, locale);
+  // console.log('knownRoutes', knownRoutes);
+  */
+  // console.log('getLayout', market, locale);
+  return {
+    markets,
+    market,
+    locales,
+    locale,
+    labels,
+    tree,
+    navs,
+    topLevelRoutes,
+    topLevelHrefs,
+  };
+}

package/src/layout/layout.ts

@@ -0,0 +1,27 @@
+import { ILabel } from '../label/label';
+import { ILocale } from '../locale/locale';
+import { IMarket } from '../market/market';
+import { IRouteLink } from '../route/route';
+
+export type ILayout = {
+  market: string;
+  locale: string;
+  markets: IMarket[];
+  locales: ILocale[];
+  labels: ILabel[];
+  tree?: IRouteLink;
+  navs: {
+    [key: string]: IRouteLink[],
+  };
+  topLevelRoutes: {
+    [key: string]: IRouteLink;
+  };
+  topLevelHrefs: {
+    [key: string]: string;
+  };
+  /*
+  knownRoutes?: {
+    [key: string]: string;
+  };
+  */
+};

package/src/link/link.ts

@@ -0,0 +1,7 @@
+
+export type ILink = {
+  href: string;
+  title: string;
+  type?: string;
+  secure?: boolean;
+};

package/src/list/list.service.ts

@@ -0,0 +1,19 @@
+import { getStore } from '@websolutespa/bom-mixer-store';
+import { IModelStore } from '../store/store';
+import { IKeyedList, IList } from './list';
+
+export async function getLists(locale?: string): Promise<IList[]> {
+  const store = await getStore<IModelStore>();
+  const items = await store.list.findMany({ locale });
+  return items;
+}
+
+export async function getListByKeys(keys: string[], locale?: string): Promise<{ [key: string]: IList[] }> {
+  const store = await getStore<IModelStore>();
+  const items = await store.list.findMany({ locale });
+  const lists: { [key: string]: IList[] } = {};
+  (items.filter((x: IList) => x.key && keys.includes(x.key)) as IKeyedList[]).forEach(x => {
+    lists[x.key] = items.filter((i: any) => i.listId === x.id);
+  });
+  return lists;
+}

package/src/list/list.ts

@@ -0,0 +1,11 @@
+import { IEquatable, INamedEntity } from '@websolutespa/bom-mixer-core';
+
+export type IList = INamedEntity & {
+  key?: string;
+  listId?: IEquatable;
+  items?: IList[];
+};
+
+export type IKeyedList = IList & {
+  key: string;
+};

package/src/locale/locale.service.ts

@@ -0,0 +1,11 @@
+import { QueryParams } from '@websolutespa/bom-mixer-core';
+import { getStore } from '@websolutespa/bom-mixer-store';
+import { IModelStore } from '../store/store';
+import { ILocale } from './locale';
+
+export async function getLocales(params: QueryParams = {}): Promise<ILocale[]> {
+  const store = await getStore<IModelStore>();
+  const items = await store.locale.findMany(params);
+  return items;
+}
+

package/src/locale/locale.ts

@@ -0,0 +1,9 @@
+import { IEntity } from '@websolutespa/bom-mixer-core';
+
+export type ILocale = IEntity & {
+  id: string;
+  // schema?: string;
+  title?: string;
+  isActive?: boolean;
+  isDefault?: boolean;
+};

package/src/market/market.service.ts

@@ -0,0 +1,10 @@
+import { QueryParams } from '@websolutespa/bom-mixer-core';
+import { getStore } from '@websolutespa/bom-mixer-store';
+import { IModelStore } from '../store/store';
+import { IMarket } from './market';
+
+export async function getMarkets(params: QueryParams = {}): Promise<IMarket[]> {
+  const store = await getStore<IModelStore>();
+  const items = await store.market.findMany(params);
+  return items;
+}

package/src/market/market.ts

@@ -0,0 +1,11 @@
+import { IEntity } from '@websolutespa/bom-mixer-core';
+
+export type IMarket = IEntity & {
+  id: string;
+  title?: string;
+  isActive?: boolean;
+  isDefault?: boolean;
+  countries?: string[];
+  languages?: string[];
+  defaultLanguage?: string;
+};

package/src/media/media.ts

@@ -0,0 +1,14 @@
+
+export type IMediaType = 'image' | 'video' | string;
+
+export type IMedia = {
+  src: string;
+  type: IMediaType;
+  alt?: string;
+  title?: string;
+  abstract?: string;
+  width?: number;
+  height?: number;
+  url?: string; // !!! todo remap payloadcms media
+  media?: IMedia; // !!! todo remap payloadcms media
+};

package/src/menu/menu.service.ts

@@ -0,0 +1,22 @@
+import { IEquatable } from '@websolutespa/bom-mixer-core';
+import { getStore } from '@websolutespa/bom-mixer-store';
+import { IModelStore } from '../store/store';
+import { IMenu } from './menu';
+
+export async function getMenu(id: IEquatable): Promise<IMenu | undefined> {
+  const store = await getStore<IModelStore>();
+  const item = await store.menu.findOne({
+    where: {
+      id: {
+        equals: id,
+      }
+    },
+  });
+  return item;
+}
+
+export async function getMenus(): Promise<IMenu[]> {
+  const store = await getStore<IModelStore>();
+  const items = await store.menu.findMany();
+  return items;
+}

package/src/menu/menu.ts

@@ -0,0 +1,11 @@
+import { IEntity, IEquatable } from '@websolutespa/bom-mixer-core';
+
+export type IMenu = IEntity & {
+  id: IEquatable;
+  items: IMenuItem[];
+};
+
+export type IMenuItem = {
+  name: string;
+  href: string;
+};

package/src/order/order.service.ts

@@ -0,0 +1,29 @@
+import { IEquatable } from '@websolutespa/bom-mixer-core';
+import { OrderDefaults } from '@websolutespa/bom-mixer-mock';
+import { getRoutesForTemplates } from '../route/route.service';
+import { IOrderDetail } from './order';
+
+export async function getOrders(market: string, locale: string): Promise<IOrderDetail[]> {
+  const knownRoutes = await getRoutesForTemplates(['reserved_area_order_detail'], market, locale);
+  return OrderDefaults.items.map(x => {
+    const orderDetail: IOrderDetail = {
+      ...x,
+      href: `${knownRoutes.reserved_area_order_detail}?orderId=${x.id}`,
+    };
+    return orderDetail;
+  });
+}
+
+export async function getOrder(id: IEquatable, market: string, locale: string): Promise<IOrderDetail | null> {
+  const knownRoutes = await getRoutesForTemplates(['reserved_area_order_detail'], market, locale);
+  const order = OrderDefaults.items.find(x => String(x.id) === String(id)) || null;
+  if (order) {
+    const orderDetail: IOrderDetail = {
+      ...order,
+      href: `${knownRoutes.reserved_area_order_detail}?orderId=${order.id}`,
+    };
+    return orderDetail;
+  }
+  return order;
+}
+

package/src/order/order.ts

@@ -0,0 +1,31 @@
+import { IEquatable, ValueOf } from '@websolutespa/bom-mixer-core';
+import { ICheckout } from '../checkout/checkout';
+
+export const IOrderStatus = {
+  Pending: 'pending', // Customer started the checkout process but did not complete it. Incomplete orders are assigned a "Pending" status and can be found under the More tab in the View Orders screen.
+  AwaitingPayment: 'awaitingPayment', // Customer has completed the checkout process, but payment has yet to be confirmed. Authorize only transactions that are not yet captured have this status.
+  AwaitingFulfillment: 'awaitingFulfillment', // Customer has completed the checkout process and payment has been confirmed.
+  AwaitingShipment: 'awaitingShipment', // Order has been pulled and packaged and is awaiting collection from a shipping provider.
+  AwaitingPickup: 'awaitingPickup', // Order has been packaged and is awaiting customer pickup from a seller-specified location.
+  PartiallyShipped: 'partiallyShipped', // Only some items in the order have been shipped.
+  Completed: 'completed', // Order has been shipped/picked up, and receipt is confirmed; client has paid for their digital product, and their file(s) are available for download.
+  Shipped: 'shipped', // Order has been shipped, but receipt has not been confirmed; seller has used the Ship Items action. A listing of all orders with a "Shipped" status can be found under the More tab of the View Orders screen.
+  Cancelled: 'cancelled', // Seller has cancelled an order, due to a stock inconsistency or other reasons. Stock levels will automatically update depending on your Inventory Settings. Cancelling an order will not refund the order. This status is triggered automatically when an order using an authorize-only payment gateway is voided in the control panel before capturing payment.
+  Declined: 'declined', // Seller has marked the order as declined.
+  Refunded: 'refunded', // Seller has used the Refund action to refund the whole order. A listing of all orders with a "Refunded" status can be found under the More tab of the View Orders screen.
+  Disputed: 'disputed', // Customer has initiated a dispute resolution process for the PayPal transaction that paid for the order or the seller has marked the order as a fraudulent order.
+  ManualVerificationRequired: 'manualVerificationRequired', // Order on hold while some aspect, such as tax-exempt documentation, is manually confirmed. Orders with this status must be updated manually. Capturing funds or other order actions will not automatically update the status of an order marked Manual Verification Required.
+  PartiallyRefunded: 'partiallyRefunded', // Seller has partially refunded the order.
+};
+
+export type IOrderStatusValue = ValueOf<typeof IOrderStatus>;
+
+export type IOrder = ICheckout & {
+  id: IEquatable;
+  date: Date | string;
+  status: IOrderStatusValue;
+};
+
+export type IOrderDetail = IOrder & {
+  href: string;
+};

package/src/page/page.service.ts

@@ -0,0 +1,132 @@
+import { IEquatable, QueryParams } from '@websolutespa/bom-mixer-core';
+import { getStore } from '@websolutespa/bom-mixer-store';
+import { ICategory } from '../category/category';
+import { getSegments } from '../category/category.service';
+import { resolveLabel } from '../label/label.service';
+import { ILayout } from '../layout/layout';
+import { getLayout } from '../layout/layout.service';
+import { IRouteLink, SchemaType } from '../route/route';
+import { getBreadcrumbFromSegments } from '../route/route.service';
+import { IModelStore } from '../store/store';
+import { IPage } from './page';
+
+export async function findPage<T extends IPage>(schema: string, params?: QueryParams): Promise<T | undefined> {
+  const store = await getStore<IModelStore>();
+  const collection = store[schema];
+  if (!collection) {
+    throw `PageService.findPage: Collection not found [${schema}]`;
+  }
+  const page = await collection.findOne(params) as T;
+  if (page) {
+    return page;
+  } else {
+    console.log('PageService.getPage.notfound', schema, params);
+    return;
+  }
+}
+
+export async function getPage<T extends IPage>(schema: string, id: IEquatable, market?: string, locale?: string): Promise<T | undefined> {
+  const store = await getStore<IModelStore>();
+  const page = await findPage(schema, {
+    where: {
+      id: {
+        equals: id,
+      },
+    }, market, locale
+  }) as T;
+  // console.log(page, market, locale);
+  if (page) {
+    const routes = await store.route.findMany({
+      where: {
+        page: {
+          equals: id,
+        },
+        schema: {
+          equals: schema,
+        },
+      }
+    });
+    const currentRoute = routes.find((x: any) => x.market === market && x.locale === locale);
+    if (!currentRoute) {
+      throw ('No route found for page ' + schema + ':' + id + ' in market ' + market + ' and locale ' + locale);
+    }
+    const alternates = routes.filter((x: any) => x.market !== market || x.locale !== locale);
+    const segments: ICategory[] = await getSegments(page);
+    const breadcrumb: IRouteLink[] = await getBreadcrumbFromSegments(segments, market, locale);
+    const parentRoute: IRouteLink | undefined = breadcrumb.length > 1 ? breadcrumb[breadcrumb.length - 2] : undefined;
+    return {
+      ...page,
+      href: currentRoute.id, // !!! route?
+      alternates,
+      breadcrumb,
+      parentRoute,
+    } as T;
+  } else {
+    console.log('PageService.getPage.notfound', schema, id, locale);
+    return;
+  }
+}
+
+export async function getPageCategory<T extends IPage>(schema: string, page?: IPage, market?: string, locale?: string): Promise<T | undefined> {
+  if (!page) {
+    return;
+  }
+  const store = await getStore<IModelStore>();
+  const category = await findPage(schema, {
+    where: {
+      category: {
+        equals: typeof page.category === 'object' ? page.category.id : page.category,
+      }
+    }, market, locale
+  }) as T;
+  // console.log(page, market, locale);
+  if (category) {
+    const routes = await store.route.findMany({
+      where: {
+        schema: {
+          equals: schema,
+        },
+        page: {
+          equals: category.id,
+        },
+      }
+    });
+    const currentRoute = routes.find((x: any) => x.market === market && x.locale === locale);
+    if (!currentRoute) {
+      throw ('No route found for page ' + schema + ':' + category.id + ' in market ' + market + ' and locale ' + locale);
+    }
+    return {
+      ...category,
+      href: currentRoute.id,
+    } as T;
+  } else {
+    console.log('PageService.getPageCategory.notfound', schema, locale);
+    return;
+  }
+}
+
+export async function getErrorPageLayout(): Promise<{ layout: ILayout, page: IPage }> {
+  const defaultMarket = 'ww';
+  const defaultLocale = 'en';
+  const layout = await getLayout(defaultMarket, defaultLocale);
+  const title = resolveLabel(layout.labels, 'notfound.title');
+  const abstract = resolveLabel(layout.labels, 'notfound.abstract');
+  const page = {
+    id: 'notfound',
+    schema: 'notfound' as SchemaType,
+    href: '',
+    alternates: [],
+    breadcrumb: [],
+    title,
+    abstract,
+    category: 'homepage',
+    meta: {
+      title,
+      description: abstract,
+      keywords: '',
+      robots: 'all',
+    },
+  };
+  return { layout, page };
+}
+

package/src/page/page.ts

@@ -0,0 +1,53 @@
+import { IEntity } from '@websolutespa/bom-mixer-core';
+import { ICategory } from '../category/category';
+import { ILayout } from '../layout/layout';
+import { IMedia } from '../media/media';
+import { IRoute, IRouteLink, IRouteParams } from '../route/route';
+
+export type IMeta = {
+  title?: string;
+  description?: string;
+  keywords?: string;
+  robots?: string;
+};
+
+export type IImage = {
+  url: string;
+  type?: string;
+  alt?: string;
+  title?: string;
+  caption?: string;
+  width?: number;
+  height?: number;
+};
+
+export type IPage = IEntity & {
+  category: string | number | ICategory;
+  slug?: string;
+  href: string;
+  alternates: IRoute[];
+  breadcrumb: IRouteLink[];
+  parentRoute?: IRouteLink;
+  title?: string;
+  abstract?: string;
+  description?: string;
+  content?: string;
+  createdAt?: Date;
+  updatedAt?: Date;
+  meta?: IMeta;
+  media?: IMedia;
+  [key: string]: any;
+};
+
+export type PageProps<T extends IPage = IPage> = {
+  layout: ILayout;
+  page: T;
+  params: IRouteParams;
+  locales?: string[];
+  locale?: string;
+  defaultLocale?: string;
+};
+
+/*
+export type IPageLayout = IPage & ILayout & { }
+*/

package/src/province/province.service.ts

@@ -0,0 +1,9 @@
+import { INamedEntity } from '@websolutespa/bom-mixer-core';
+import { getStore } from '@websolutespa/bom-mixer-store';
+import { IModelStore } from '../store/store';
+
+export async function getProvinces(locale?: string): Promise<INamedEntity[]> {
+  const store = await getStore<IModelStore>();
+  const items = await store.i18n_province.findMany({ locale });
+  return items;
+}

package/src/region/region.service.ts

@@ -0,0 +1,9 @@
+import { INamedEntity } from '@websolutespa/bom-mixer-core';
+import { getStore } from '@websolutespa/bom-mixer-store';
+import { IModelStore } from '../store/store';
+
+export async function getRegions(locale?: string): Promise<INamedEntity[]> {
+  const store = await getStore<IModelStore>();
+  const items = await store.i18n_region.findMany({ locale });
+  return items;
+}

package/src/route/route.interceptor.ts

@@ -0,0 +1,30 @@
+import { apiPost } from '@websolutespa/bom-mixer-core';
+import { NextFetchEvent, NextRequest, NextResponse } from 'next/server';
+import { IRoute } from './route';
+import { resolveRoute } from './route.service';
+
+export async function routeInterceptor(request: NextRequest, next: NextFetchEvent) {
+  let url = request.nextUrl;
+  let route: IRoute;
+  // console.log('routeInterceptor.url', url.pathname);
+  try {
+    route = await apiPost('/route', { pathname: url.pathname });
+    // console.log('route', route);
+    if (!route) {
+      console.log('routeInterceptor.route.notfound', url.pathname);
+      return;
+    }
+  } catch (error: any) {
+    console.log('routeInterceptor.error', url.pathname, error, error.url, error.status, error.statusText);
+    return;
+  }
+  // console.log('routeInterceptor.route.found', url.pathname, '->', route);
+  url = request.nextUrl.clone();
+  const resolvedPathname = resolveRoute(route);
+  // console.log('resolvedPathname', resolvedPathname);
+  url.pathname = resolvedPathname;
+  // console.log('routeInterceptor.route', route.schema, route.page, route.market, route.locale);
+  const response = NextResponse.rewrite(url);
+  // const response = NextResponse.redirect(url);
+  return response;
+}