@websolutespa/bom-mixer-store 0.2.0 → 0.3.1

package/src/mock/mock-menu.service.ts

@@ -0,0 +1,276 @@
+import {
+  ICategorized, ICategory, IEntity, IEquatable, IMenu, IMenuCategory, IMenuGroup, IMenuItem,
+  IMenuLink, IMenuPage, IMenuRoute, IRoute, IStore,
+  IUndecoratedMenu, IUndecoratedMenuCategory, IUndecoratedMenuGroup, IUndecoratedMenuItem,
+  IUndecoratedMenuLink, IUndecoratedMenuPage, Pagination, QueryParams, localizeItem
+} from '@websolutespa/bom-core';
+import { MockService } from './mock.service';
+
+export const MAX_INT = 1000000000000; // 9007199254740991
+
+let UID = 0;
+
+export class MockMenuService<T extends IEntity = IEntity> extends MockService<T> {
+
+  async findOne<B extends T = T>(id: IEquatable, params: QueryParams = {}): Promise<B | undefined> {
+    // console.log('MockMenuService.findOne', id, params);
+    let item = await super.findOne<B>(id, params);
+    if (item && params.market && params.locale) {
+      item = await decorateMenu(this.store, (item as any), params.market, params.locale) as any;
+    }
+    return item;
+  }
+
+  async findMany<B extends T = T>(params: QueryParams = {}): Promise<B[]> {
+    // console.log('MockMenuService.findMany', params);
+    let items = await super.findMany<B>(params);
+    if (params.market && params.locale) {
+      items = await decorateMenus(this.store, (items as any[]), params.market, params.locale) as any[];
+    }
+    return items;
+  }
+
+  async findPaged<B extends T = T>(params: QueryParams = {}): Promise<{ docs: B[]; } & Pagination> {
+    // console.log('MockMenuService.findPaged', params);
+    const pagination = await super.findPaged<B>(params);
+    if (params.market && params.locale) {
+      pagination.docs = await decorateMenus(this.store, (pagination.docs as any[]), params.market, params.locale) as any[];
+    }
+    return pagination;
+  }
+
+  protected override decorator_<B extends T = T>(item: B, params: QueryParams = {}): B {
+    if (params.locale) {
+      return localizeItem(item, params.locale);
+    } else {
+      return item;
+    }
+  }
+}
+
+export async function decorateMenu(store: IStore, item: IUndecoratedMenu, market: string = 'ww', locale: string = 'en'): Promise<IMenu> {
+  const items = item.items || [];
+  const decoratedItem: IMenu = {
+    id: item.id,
+    items: [],
+  };
+  const categories = await store.category.findMany<ICategory>({ market, locale });
+  const routes = await store.route.findMany<IRoute>({
+    where: {
+      market: {
+        equals: market,
+      },
+      locale: {
+        equals: locale,
+      }
+    }
+  });
+  async function collectPages(items?: IUndecoratedMenuItem[]) {
+    if (!items) {
+      return;
+    }
+    for (const item of items) {
+      if (
+        item.type === 'page' &&
+        typeof item.page.value === 'number' &&
+        store[item.page.relationTo] !== undefined
+      ) {
+        const value = await store[item.page.relationTo].findOne<ICategorized>(item.page.value);
+        if (value) {
+          item.page.value = value;
+        }
+      }
+      switch (item.type) {
+        case 'group':
+        case 'link':
+        case 'page':
+          await collectPages(item.items);
+          break;
+      }
+    }
+  }
+  await collectPages(items);
+  decoratedItem.items = items.filter(x => hasMarket(x, market)).map(x => decorateMenuItem(x, categories, routes, market));
+  return decoratedItem;
+}
+
+export async function decorateMenus(store: IStore, items: IUndecoratedMenu[], market: string = 'ww', locale: string = 'en'): Promise<IMenu[]> {
+  return await Promise.all(items.map(x => decorateMenu(store, x, market, locale)));
+}
+
+export function decorateMenuCategory(
+  item: IUndecoratedMenuCategory,
+  categories: ICategory[],
+  routes: IRoute[],
+  market: string,
+  depth: number = 0,
+): IMenuItem {
+  const decoratedItem: IMenuCategory = {
+    id: item.id || '',
+    type: item.type,
+    title: '',
+    category: '',
+    href: '',
+    items: [],
+  };
+  const category = (typeof item.category === 'string' ? categories.find(x => x.id === item.category) : item.category) as ICategory;
+  if (category) {
+    // assigning category id
+    decoratedItem.category = category.id;
+    // assigning category title
+    decoratedItem.title = item.title || category.title || '';
+    // assigning current or category media
+    decoratedItem.media = decoratedItem.media || category.media;
+    // find category's index page route
+    const route = routes.find(x => x.isDefault && x.category === category.id);
+    if (route) {
+      // hasLink
+      decoratedItem.href = route.id;
+    } else {
+      // isGroup
+    }
+    // checking for max depth recursion
+    let maxDepth = item.maxDepth;
+    if (typeof maxDepth === 'number') {
+      if (depth > maxDepth) {
+        return decoratedItem;
+      }
+      maxDepth--;
+    }
+    // search child categories
+    const childCategories = categories.filter(x => (
+      x.category && (typeof x.category === 'object' ?
+        x.category.id === category.id :
+        x.category === category.id)
+    ));
+    if (childCategories.length) {
+      // sort child categories
+      childCategories.sort((a, b) => {
+        return (a.order || MAX_INT) - (b.order || MAX_INT);
+      });
+      decoratedItem.items = childCategories.map(c => decorateMenuCategory({
+        id: c.id,
+        type: 'category',
+        category: c.id,
+        maxDepth,
+        items: [],
+      } as IUndecoratedMenuCategory, categories, routes, market, depth + 1));
+    } else {
+      // find child routes
+      const childRoutes = routes.filter(x => !x.isDefault && x.category === category.id);
+      // sort child routes
+      childRoutes.sort((a, b) => {
+        return (a.order || MAX_INT) - (b.order || MAX_INT);
+      });
+      decoratedItem.items = childRoutes.map(x => decorateMenuRoute(x));
+    }
+  }
+  return decoratedItem;
+}
+
+export function decorateMenuRoute(
+  item: IRoute,
+): IMenuItem {
+  const decoratedItem: IMenuRoute = {
+    id: item.page,
+    type: 'route',
+    title: item.title,
+    href: item.id,
+    page: item.page,
+    schema: item.schema,
+    items: [],
+  };
+  return decoratedItem;
+}
+
+export function decorateMenuGroup(
+  item: IUndecoratedMenuGroup,
+  categories: ICategory[],
+  routes: IRoute[],
+  market: string,
+): IMenuItem {
+  const items = item.items || [];
+  const decoratedItem: IMenuGroup = {
+    id: item.id || '',
+    type: item.type,
+    title: item.title,
+    items: items.filter(x => hasMarket(x, market)).map(x => decorateMenuItem(x, categories, routes, market)),
+  };
+  return decoratedItem;
+}
+
+export function decorateMenuLink(
+  item: IUndecoratedMenuLink,
+  categories: ICategory[],
+  routes: IRoute[],
+  market: string,
+): IMenuItem {
+  const items = item.items || [];
+  const decoratedItem: IMenuLink = {
+    id: item.id || '',
+    type: item.type,
+    title: item.title,
+    href: item.href,
+    target: item.target || '',
+    items: items.filter(x => hasMarket(x, market)).map(x => decorateMenuItem(x, categories, routes, market)),
+  };
+  return decoratedItem;
+}
+
+export function decorateMenuPage(
+  item: IUndecoratedMenuPage,
+  categories: ICategory[],
+  routes: IRoute[],
+  market: string,
+): IMenuItem {
+  const items = item.items || [];
+  const route = routes.find(x => x.schema === item.page.relationTo && x.page === item.page.value.id);
+  const decoratedItem: IMenuPage = {
+    id: item.id || '',
+    type: item.type,
+    title: item.title || item.page.value.title || '',
+    href: route?.id || '',
+    media: item.page.value.media,
+    page: route?.page || '',
+    schema: route?.schema || '',
+    items: items.filter(x => hasMarket(x, market)).map(x => decorateMenuItem(x, categories, routes, market)),
+  };
+  return decoratedItem;
+}
+
+export function decorateMenuItem(
+  item: IUndecoratedMenuItem,
+  categories: ICategory[],
+  routes: IRoute[],
+  market: string,
+  depth: number = 0,
+): IMenuItem {
+  let decoratedItem: IMenuItem;
+  switch (item.type) {
+    case 'category':
+      decoratedItem = decorateMenuCategory(item, categories, routes, market, depth);
+      break;
+    case 'group':
+      decoratedItem = decorateMenuGroup(item, categories, routes, market);
+      break;
+    case 'link':
+      decoratedItem = decorateMenuLink(item, categories, routes, market);
+      break;
+    case 'page':
+      decoratedItem = decorateMenuPage(item, categories, routes, market);
+      break;
+    default:
+      // eslint-disable-next-line no-case-declarations
+      const { blockType, ...rest } = item;
+      decoratedItem = {
+        ...rest,
+        type: blockType,
+      } as any;
+  }
+  decoratedItem.id = ++UID;
+  return decoratedItem;
+}
+
+export function hasMarket(item: IUndecoratedMenuItem, market: string): boolean {
+  return Array.isArray(item.markets) ? item.markets.includes(market) : true;
+}

package/src/mock/mock-page.service.ts

@@ -0,0 +1,79 @@
+import {
+  IEntity, IEquatable,
+  IRoute, ISchema, IStore, Pagination,
+  QueryParams, localizeItem
+} from '@websolutespa/bom-core';
+import { MockService } from './mock.service';
+
+export class MockPageService<T extends IEntity = IEntity> extends MockService<T> {
+
+  async findOne<B extends T = T>(id: IEquatable, params: QueryParams = {}): Promise<B | undefined> {
+    // console.log('MockPageService.findOne', id, params);
+    let item = await super.findOne<B>(id, params);
+    if (item && params.market && params.locale) {
+      item = await decorateHref<B>(this.store, item, params.market, params.locale);
+    }
+    return item;
+  }
+
+  async findMany<B extends T = T>(params: QueryParams = {}): Promise<B[]> {
+    // console.log('MockPageService.findMany', params);
+    let items = await super.findMany<B>(params);
+    if (params.market && params.locale) {
+      items = await decorateHrefs<B>(this.store, items, params.market, params.locale);
+    }
+    return items;
+  }
+
+  async findPaged<B extends T = T>(params: QueryParams = {}): Promise<{ docs: B[]; } & Pagination> {
+    // console.log('MockPageService.findPaged', params);
+    const pagination = await super.findPaged<B>(params);
+    if (params.market && params.locale) {
+      pagination.docs = await decorateHrefs<B>(this.store, pagination.docs, params.market, params.locale);
+    }
+    return pagination;
+  }
+
+  protected override decorator_<B extends T = T>(item: B, params: QueryParams = {}): B {
+    if (params.locale) {
+      return localizeItem(item, params.locale);
+    } else {
+      return item;
+    }
+  }
+}
+
+export async function decorateHref<T extends ISchema = ISchema>(store: IStore, item: T, market: string = 'ww', locale: string = 'en'): Promise<T & { href: string | null }> {
+  const routes = await store.route.findMany<IRoute>({
+    where: {
+      schema: {
+        equals: item.schema
+      },
+      page: {
+        equals: item.id
+      },
+      market: {
+        equals: market
+      },
+      locale: {
+        equals: locale
+      },
+    }
+  });
+  const href = routes.length ? routes[0].id : null;
+  return { ...item, href };
+}
+
+export async function decorateHrefs<T extends ISchema = ISchema>(store: IStore, items: T[], market: string = 'ww', locale: string = 'en'): Promise<(T & { href: string | null })[]> {
+  const routes = await store.route.findMany<IRoute>();
+  return items.map(item => {
+    const route = routes.find(x =>
+      x.schema === item.schema &&
+      x.page === item.id &&
+      x.market === market &&
+      x.locale === locale
+    );
+    const href = route ? route.id : null;
+    return { ...item, href };
+  });
+}

package/src/mock/mock.handler.ts

@@ -0,0 +1,6 @@
+import { storeHandler } from '../store/store.handler';
+import { getMockStore } from './mock.store';
+
+export function mockHandler(getJson: () => Promise<string>) {
+  return storeHandler(async () => await getMockStore(getJson));
+}

package/src/mock/mock.service.ts

@@ -0,0 +1,73 @@
+import { IEntity, IPageRelation, IStore, JsonService, localizeItem, QueryParams } from '@websolutespa/bom-core';
+
+export class MockService<T extends IEntity = IEntity> extends JsonService<T> {
+  store: IStore;
+
+  constructor(items: T[], store: IStore) {
+    super(items);
+    this.store = store;
+  }
+
+  // !!! todo handle relations
+
+  /*
+  override async findOne<B extends T = T>(id: IEquatable, params: QueryParams = {}): Promise<B | undefined> {
+    console.log('MockService.findOne', id, params);
+    let item = await super.findOne<B>(id, params);
+    // relations
+    if (item) {
+      if (params.depth !== 0) {
+        item = await this.relatedItems_(item);
+      }
+    }
+    return item;
+  }
+
+  override async findMany<B extends T = T>(params: QueryParams = {}): Promise<B[]> {
+    // console.log('MockService.findMany', params);
+    let items = await super.findMany<B>(params);
+    // relations
+    if (params.depth !== 0) {
+      items = await Promise.all(items.map(x => this.relatedItems_(x)));
+    }
+    return items;
+  }
+
+  override async findPaged<B extends T = T>(params: QueryParams = {}): Promise<{ docs: B[]; } & Pagination> {
+    // console.log('MockService.findPaged', params);
+    const pagination = await super.findPaged<B>(params);
+    // relations
+    if (params.depth !== 0) {
+      pagination.docs = await Promise.all(pagination.docs.map(x => this.relatedItems_(x)));
+    }
+    return pagination;
+  }
+
+  protected async relatedItems_<B extends T = T>(item: B): Promise<B> {
+    const x = { ...item };
+    Object.entries(item).forEach(([k, v]) => {
+      if (isRelation(v)) {
+        console.log(k, v);
+      }
+    });
+    return x;
+  }
+  */
+
+  protected override decorator_<B extends T = T>(item: B, params: QueryParams = {}): B {
+    if (params.locale) {
+      return localizeItem(item, params.locale);
+    } else {
+      return item;
+    }
+  }
+
+}
+
+export function isObject(item: unknown): item is Record<string, unknown> {
+  return item !== null && (typeof item === 'object');
+}
+
+export function isRelation(item: unknown): item is IPageRelation {
+  return isObject(item) && typeof item.relationTo === 'string' && item.value !== undefined;
+}

package/src/mock/mock.store.ts

@@ -0,0 +1,80 @@
+import { IMemoryStore, isDevelopment, IStore } from '@websolutespa/bom-core';
+import { fsReadJson } from '../fs/fs.service';
+import { staticCollections } from '../static/static';
+import { StaticService } from '../static/static.service';
+import { MockMenuService } from './mock-menu.service';
+import { MockPageService } from './mock-page.service';
+import { MockService } from './mock.service';
+
+// eslint-disable-next-line @typescript-eslint/no-var-requires
+const path = require('path');
+
+const PAGES: string[] = process.env.PAGES ? process.env.PAGES.split(',') : [];
+
+let STORE_: IStore;
+
+export async function getMockStoreServer<T extends IStore>(): Promise<T> {
+  // console.log('getMockStore', STORE_ ? Object.keys(STORE_) : null);
+  // console.log('getMockStore.process.cwd', process.cwd());
+  if (STORE_) {
+    return STORE_ as T;
+  }
+  const pathname = path.join(process.cwd(), '.mixer', 'store.json');
+  // console.log('getMockStore.pathname', pathname);
+  const data: IMemoryStore = await fsReadJson(pathname);
+  const store = getMockStoreFromData(data);
+  if (!isDevelopment) {
+    STORE_ = store;
+  }
+  return store as T;
+}
+
+export async function getMockStore<T extends IStore>(getJson: () => Promise<string>): Promise<T> {
+  // console.log('getMockStore', STORE_ ? Object.keys(STORE_) : null);
+  // console.log('getMockStore.process.cwd', process.cwd());
+  if (STORE_) {
+    return STORE_ as T;
+  }
+  const json = await getJson();
+  const data: IMemoryStore = JSON.parse(json);
+  const store = getMockStoreFromData(data);
+  if (!isDevelopment) {
+    STORE_ = store;
+  }
+  return store as T;
+}
+
+export function getMockStoreFromData<T extends IStore>(data: IMemoryStore): T {
+  const store: IStore = {};
+  for (const key in data) {
+    if (!PAGES.includes(key)) {
+      // new collection
+      const service = new MockService(data[key], store);
+      store[key] = service;
+    }
+  }
+  const category = store.category;
+  const route = store.route;
+  const menu = data.menu;
+  if (category && route && menu) {
+    store.menu = new MockMenuService(menu, store);
+  }
+  for (const key in data) {
+    if (PAGES.includes(key)) {
+      let service;
+      if (route) {
+        // new page
+        service = new MockPageService(data[key], store);
+      } else {
+        // !!! new collection should throw
+        service = new MockService(data[key], store);
+      }
+      store[key] = service;
+    }
+  }
+  staticCollections.forEach(config => {
+    store[config.slug] = new StaticService(config, store);
+  });
+  return store as T;
+}
+

package/src/session/session.handler.ts

@@ -0,0 +1,82 @@
+import { httpDelete, httpGet, httpPost } from '@websolutespa/bom-core';
+import { apiHandler } from '@websolutespa/bom-mixer-store';
+import { IronSessionOptions } from 'iron-session/edge';
+import { withIronSessionApiRoute } from 'iron-session/next';
+import { NextApiRequest, NextApiResponse } from 'next';
+import { StateStorage } from 'zustand/middleware';
+
+function sessionGet(request: NextApiRequest, response: NextApiResponse<string | null>) {
+  const { key } = request.query;
+  const session: { [key: string]: string | null } = request.session as any;
+  if (session[key as string]) {
+    response.status(200).json(session[key as string]);
+  } else {
+    response.status(200).json(null);
+  }
+}
+
+async function sessionPost(request: NextApiRequest, response: NextApiResponse<null>) {
+  const { key } = request.query;
+  const body = request.body;
+  const session: { [key: string]: string | null } = request.session as any;
+  // console.log('body', body);
+  session[key as string] = body.value;
+  // console.log('session', session);
+  await request.session.save();
+  response.status(200).json(null);
+}
+
+async function sessionDelete(request: NextApiRequest, response: NextApiResponse<null>) {
+  const { key } = request.query;
+  const session: { [key: string]: string | null } = request.session as any;
+  session[key as string] = null;
+  await request.session.save();
+  response.status(200).json(null);
+}
+
+export type ISessionHandler = (request: NextApiRequest, response: NextApiResponse) => Promise<void>;
+
+export function sessionHandler<T extends {}>(sessionOptions: IronSessionOptions) {
+  return apiHandler({
+    get: withIronSessionApiRoute(sessionGet, sessionOptions) as ISessionHandler,
+    post: withIronSessionApiRoute(sessionPost, sessionOptions) as ISessionHandler,
+    delete: withIronSessionApiRoute(sessionDelete, sessionOptions) as ISessionHandler,
+  });
+}
+
+export const IronSessionStorage: StateStorage = {
+  getItem: async (name: string) => {
+    const value = await httpGet(`/api/__session/${name}`);
+    // console.log('IronSessionStorage.getItem', name, value);
+    return value;
+  },
+  setItem: async (name: string, value: string) => {
+    // console.log('IronSessionStorage.setItem', name, { cart: value });
+    await httpPost(`/api/__session/${name}`, { value });
+  },
+  removeItem: async (name: string) => {
+    // console.log('IronSessionStorage.removeItem', name);
+    await httpDelete(`/api/__session/${name}`);
+  },
+};
+
+/*
+import { withIronSessionSsr } from 'iron-session/next';
+
+type IronSessionCallback<P> = (context: GetServerSidePropsContext) => GetServerSidePropsResult<P> | Promise<GetServerSidePropsResult<P>>
+type IronSessionHandlerResult<P> = (context: GetServerSidePropsContext) => Promise<GetServerSidePropsResult<P>>;
+
+export function withIronSession<P extends { [key: string]: unknown; } = { [key: string]: unknown; }>(
+  callback: IronSessionCallback<P>,
+  options: IronSessionOptions,
+): IronSessionHandlerResult<P> {
+  return withIronSessionSsr(async function (context) {
+    // !!! hack for vercel lambdas
+    if (storeStrategy === StoreStrategy.Mock) {
+      const pathname = path.join(process.cwd(), '.mixer', 'store.json');
+      const data = await fs.readFile(pathname, 'utf8');
+    }
+    return callback(context);
+  }, options);
+}
+*/

package/src/static/static.service.ts

@@ -0,0 +1,102 @@
+import {
+  IEntity, IEquatable, IStore, JsonService, QueryParams,
+  httpGet, localizeItem
+} from '@websolutespa/bom-core';
+import { IField, MapTo, StaticServiceConfig } from './static';
+
+export class StaticService<T extends IEntity = IEntity> extends JsonService<T> {
+  loaded: boolean = false;
+  config: StaticServiceConfig<T>;
+  store: IStore;
+
+  constructor(config: StaticServiceConfig<T>, store: IStore) {
+    super([]);
+    this.config = config;
+    this.store = store;
+  }
+
+  async getItems<B extends T = T>(): Promise<B[]> {
+    let items = this.items;
+    if (this.loaded && items) {
+      return items as B[];
+    } else {
+      const config = this.config;
+      const src = config.src;
+      if (typeof src === 'string') {
+        const response = await httpGet(src, {});
+        items = response.items;
+      } else if (typeof src === 'function') {
+        if (src instanceof Promise) {
+          items = await src(config);
+        } else {
+          items = src(config) as T[];
+        }
+      } else {
+        items = src;
+      }
+      items = this.mapItems_(items, config.map);
+      this.items = items;
+      this.loaded = true;
+      return items as B[];
+    }
+  }
+
+  override async findOne<B extends T = T>(id: IEquatable, params: QueryParams = {}): Promise<B | undefined> {
+    let items = await this.getItems<B>();
+    params.where = params.where || {};
+    params.where.id = params.where.id || { equals: id };
+    items = this.whereItems_<B>(items, params.where);
+    if (items.length > 0) {
+      let item = items[0];
+      // relations
+      if (params.depth !== 0) {
+        item = await this.relatedItems_(item, this.config.fields);
+      }
+      return this.decorator_<B>(item, params);
+    } else {
+      console.log('StaticService.findOne.notfound', id, params);
+      return undefined;
+    }
+  }
+
+  protected mapItems_<B extends T = T>(items: B[], map?: MapTo): B[] {
+    if (typeof map === 'object') {
+      items = items.map(x => {
+        const item: Partial<B> = {};
+        Object.entries(x).forEach(([k, v]) => {
+          const key = map[k] || k;
+          (item as any)[key] = v;
+        });
+        return item as B;
+      });
+    }
+    return items;
+  }
+
+  // !!! todo make recursive by depth with traverse
+  protected async relatedItems_<B extends T = T>(item: B, fields: IField[], locale: string = 'en'): Promise<B> {
+    const x = { ...item };
+    for (const field of fields) {
+      if (field.type === 'relationship' && typeof field.relationTo === 'string') {
+        const name = field.name as keyof typeof item;
+        const items = await this.store[field.relationTo].findMany();
+        if (field.hasMany) {
+          const ids = x[name] as IEquatable[];
+          x[name] = items.filter(x => ids.indexOf(x.id) !== -1) as any;
+        } else {
+          const id = x[name];
+          x[name] = (items.find(x => x.id === id) || id) as any;
+        }
+      }
+    }
+    return x;
+  }
+
+  protected override decorator_<B extends T = T>(item: B, params: QueryParams = {}): B {
+    if (params.locale) {
+      item = localizeItem(item, params.locale);
+    }
+    return item;
+  }
+
+}