@websolutespa/bom-mixer-store 0.3.0 → 0.3.1

package/CHANGELOG.md

@@ -1,31 +1,37 @@
-# @websolutespa/bom-mixer-store
-
-## 0.3.0
-
-### Minor Changes
-
-- Added: splat routes.
-
-## 0.2.0
-
-### Minor Changes
-
-- Added: @websolutespa/bom-core.
-
-## 0.1.1
-
-### Patch Changes
-
-- Modified: store service.
-
-## 0.1.0
-
-### Minor Changes
-
-- mock refactor.
-
-## 0.0.2
-
-### Patch Changes
-
-- Added: first release.
+# @websolutespa/bom-mixer-store
+
+## 0.3.1
+
+### Patch Changes
+
+- Added: source files.
+
+## 0.3.0
+
+### Minor Changes
+
+- Added: splat routes.
+
+## 0.2.0
+
+### Minor Changes
+
+- Added: @websolutespa/bom-core.
+
+## 0.1.1
+
+### Patch Changes
+
+- Modified: store service.
+
+## 0.1.0
+
+### Minor Changes
+
+- mock refactor.
+
+## 0.0.2
+
+### Patch Changes
+
+- Added: first release.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@websolutespa/bom-mixer-store",
-  "version": "0.3.0",
+  "version": "0.3.1",
   "description": "Mixer Store module of the BOM Repository",
   "keywords": [
     "bom",
@@ -45,12 +45,14 @@
   "sideEffects": false,
   "prepack": {
     "types": "./dist/index.d.ts",
-    "main": "./dist/index.js"
+    "main": "./dist/index.js",
+    "source": "./src/index.ts"
   },
   "postpack": {
     "types": "./src/index.ts",
     "main": "./src/index.ts"
   },
   "types": "./dist/index.d.ts",
-  "main": "./dist/index.js"
+  "main": "./dist/index.js",
+  "source": "./src/index.ts"
 }

package/src/__tests/example.test.ts

@@ -0,0 +1,8 @@
+import '@testing-library/jest-dom';
+
+describe('Example', () => {
+  it('passes', async () => {
+    const value = 'test';
+    expect(value).toEqual(value);
+  });
+});

package/src/api/api.handler.ts

@@ -0,0 +1,43 @@
+import { NextApiRequest, NextApiResponse } from 'next';
+
+export type ICrudMethod = 'get' | 'post' | 'put' | 'patch' | 'delete' | string;
+
+export type IHandler = (request: NextApiRequest, response: NextApiResponse) => Promise<any>;
+
+export type IApiHandler = Record<ICrudMethod, IHandler>;
+
+export function apiHandler(handler: IApiHandler): any {
+  return async (request: NextApiRequest, response: NextApiResponse): Promise<any> => {
+    const method: ICrudMethod = (request.method || 'GET').toLowerCase() as ICrudMethod;
+    // check handler supports HTTP method
+    if (!handler[method]) {
+      return response.status(405).end(`Method ${method} Not Allowed`);
+    }
+    try {
+      // global middleware
+      // await jwtMiddleware(request, response);
+      // route handler
+      await handler[method](request, response);
+    } catch (error) {
+      // console.log('error', error);
+      // global error handler
+      return errorHandler(error, response);
+    }
+  };
+}
+
+export function errorHandler(error: any, response: NextApiResponse): Promise<any> | void {
+  if (typeof (error) === 'string') {
+    // custom application error
+    const is404 = error.toLowerCase().endsWith('not found');
+    const statusCode = is404 ? 404 : 400;
+    return response.status(statusCode).json({ message: error });
+  }
+  if (error.name === 'UnauthorizedError') {
+    // jwt authentication error
+    return response.status(401).json({ message: 'Invalid Token' });
+  }
+  // default to 500 server error
+  console.error(error);
+  return response.status(500).json({ message: error.message });
+}

package/src/api/api.service.ts

@@ -0,0 +1,52 @@
+import { FetchRequestOptions, httpFetch, merge } from '@websolutespa/bom-core';
+
+const defaultApiOptions: FetchRequestOptions = {
+  // mode: 'cors',
+  headers: {
+    // Authorization: `Bearer ${BEARER}`,
+  },
+};
+
+// typeof eval === 'function' ? defaultApiOptions.mode = 'cors' : null;
+// const BEARER = process.env.STORE_BEARER || '7584f15d12972fb1e7695e998dd5e4c754f46c74d06a08e8d76f556adcd045e48cd52bed6faac098784471ac273ee40243194b9cff7eba3c4a768f8f41d2d51959a7f767b943c7f0170f6e5f632db523803c357083bf7a7bf03ee8e0df2d8ce5cd52e0211283b34d7781313da775018a9e950433d2b6faf711c20e5a63b25243';
+
+export function getApiUrl(pathname: string): string {
+  const localUrl = process.env.NEXT_PUBLIC_URL === 'https://' ?
+    process.env.NEXT_PUBLIC_MOCK_FALLBACK_URL :
+    process.env.NEXT_PUBLIC_URL;
+  const apiBase = process.env.NEXT_PUBLIC_API || '/api';
+  const url = `${localUrl}${apiBase}${pathname}`;
+  return url;
+}
+
+export async function apiFetch<T = any>(pathname: string, options: FetchRequestOptions = {}, serviceOptions?: { locale: string, market: string }): Promise<T> {
+  const url = new URL(getApiUrl(pathname));
+  if (serviceOptions) {
+    url.searchParams.append('locale', serviceOptions.locale);
+    url.searchParams.append('market', serviceOptions.market);
+  }
+  const apiOptions = merge({ ...defaultApiOptions }, options);
+  // console.log('apiFetch', url.href, apiOptions);
+  const apiResponse = await httpFetch(url.href, apiOptions);
+  return apiResponse;
+}
+
+export async function apiGet<T = any>(url: string, options: FetchRequestOptions = {}, serviceOptions?: { locale: string, market: string }): Promise<T> {
+  return await apiFetch<T>(url, { ...options, method: 'GET' }, serviceOptions);
+}
+
+export async function apiPost<T = any>(url: string, payload?: unknown, options: FetchRequestOptions = {}, serviceOptions?: { locale: string, market: string }): Promise<T> {
+  return await apiFetch<T>(url, { ...options, method: 'POST', body: payload ? JSON.stringify(payload) : undefined }, serviceOptions);
+}
+
+export async function apiPut<T = any>(url: string, payload?: unknown, options: FetchRequestOptions = {}, serviceOptions?: { locale: string, market: string }): Promise<T> {
+  return await apiFetch<T>(url, { ...options, method: 'PUT', body: payload ? JSON.stringify(payload) : undefined }, serviceOptions);
+}
+
+export async function apiPatch<T = any>(url: string, payload?: unknown, options: FetchRequestOptions = {}, serviceOptions?: { locale: string, market: string }): Promise<T> {
+  return await apiFetch<T>(url, { ...options, method: 'PATCH', body: payload ? JSON.stringify(payload) : undefined }, serviceOptions);
+}
+
+export async function apiDelete<T = any>(url: string, options: FetchRequestOptions = {}, serviceOptions?: { locale: string, market: string }): Promise<T> {
+  return await apiFetch<T>(url, { ...options, method: 'DELETE' }, serviceOptions);
+}

package/src/fs/fs.service.ts

@@ -0,0 +1,127 @@
+/* eslint-disable @typescript-eslint/no-var-requires */
+const path = require('path');
+const fs = require('fs');
+
+export async function fsExists(pathname: string): Promise<boolean> {
+  try {
+    await fs.promises.access(pathname);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+export async function fsRead(pathname: string, encoding = 'utf8'): Promise<any> {
+  try {
+    const data = await fs.promises.readFile(pathname, encoding);
+    return data || null;
+  } catch (error) {
+    console.log('fsRead', error, pathname);
+    return null;
+  }
+}
+
+export async function fsReadJson(pathname: string): Promise<any> {
+  try {
+    const data = await fsRead(pathname);
+    if (data) {
+      return JSON.parse(data);
+    } else {
+      return null;
+    }
+  } catch (error) {
+    console.log('fsReadJson', error, pathname);
+    // throw (error);
+    return null;
+  }
+}
+
+export async function fsWrite(pathname: string, data: string, encoding = 'utf8'): Promise<void> {
+  try {
+    await fs.promises.mkdir(path.dirname(pathname), { recursive: true });
+    await fs.promises.writeFile(pathname, data, encoding);
+  } catch (error) {
+    console.log('fsWrite', error, pathname);
+  }
+}
+
+export async function fsWriteJson(pathname: string, data: any): Promise<void> {
+  try {
+    await fsWrite(pathname, JSON.stringify(data, null, 2));
+  } catch (error) {
+    console.log('fsWriteJson', error, pathname);
+  }
+}
+
+export async function fsExistOrCreateFolder(pathname: string): Promise<void> {
+  try {
+    const exists = fs.existsSync(pathname);
+    if (!exists) {
+      await fs.promises.mkdir(pathname);
+    }
+  } catch (error) {
+    console.log('fsExistOrCreateFolder', error, pathname);
+  }
+}
+
+export async function fsReadDirectory(pathname: string, extension?: string): Promise<{ name: string, data: string }[]> {
+  const files = await fs.promises.readdir(pathname);
+  const items = files.flatMap(async (file: string) => {
+    const filePath = path.join(pathname, file);
+    const stat = await fs.promises.stat(filePath);
+    if (stat.isDirectory()) {
+      return;
+    }
+    if (extension && path.parse(file).ext !== extension) {
+      return;
+    }
+    const data = await fs.promises.readFile(filePath);
+    if (!data) {
+      return;
+    }
+    return {
+      name: path.parse(file).name,
+      data: data.toString(),
+    };
+  }) as Promise<{ name: string, data: string }>[];
+  const items2 = (await Promise.all(items)).filter(Boolean);
+  return items2;
+}
+
+export async function fsReadJsonDirectory(pathname: string): Promise<{ name: string, data: any }[]> {
+  try {
+    const datas = await fsReadDirectory(pathname, '.json');
+    return datas.filter(Boolean).map(x => {
+      x.data = JSON.parse(x.data);
+      return x;
+    });
+  } catch (error) {
+    console.log('fsReadJsonDirectory', error, pathname);
+    // throw (error);
+    return [];
+  }
+}
+
+export function fsWatch(pathname: string, callback: (eventType: any, fileName: string) => void, options?: { interval: 2000 }): void {
+  const debounced = debounce(callback);
+  return fs.watch(pathname, options, debounced);
+}
+
+export function fsWatchFile(pathname: string, callback: (eventType: any, fileName: string) => void, options?: { interval: 2000 }): void {
+  const debounced = debounce(callback);
+  return fs.watchFile(pathname, options, debounced);
+}
+
+export function pathJoin(...paths: string[]): string {
+  return path.join(process.cwd(), ...paths);
+}
+
+export function debounce(callback: (...args: any[]) => void, timeout: number = 300) {
+  let timer: NodeJS.Timeout;
+  return (...args: any[]) => {
+    clearTimeout(timer);
+    timer = setTimeout(() => {
+      callback(...args);
+    }, timeout);
+  };
+}

package/src/index.ts

@@ -0,0 +1,15 @@
+export * from './api/api.handler';
+export * from './api/api.service';
+export * from './middleware/middleware.service';
+export * from './mock/mock.handler';
+export * from './mock/mock.service';
+export * from './mock/mock.store';
+// export * from './session/session.handler';
+export * from './static/static';
+export * from './static/static.service';
+export * from './store/store';
+export * from './store/store.handler';
+export * from './store/store.service';
+export * from './storeApi/storeApi.service';
+export * from './storeApi/storeApi.store';
+

package/src/middleware/middleware.service.ts

@@ -0,0 +1,79 @@
+import { NextRequest } from 'next/server';
+
+const API_BASE = process.env.NEXT_PUBLIC_API || '/api';
+
+export function isStaticRequest(request: NextRequest) {
+  const url = request.nextUrl;
+  const isStatic = url.pathname.indexOf('.') !== -1;
+  return isStatic;
+}
+
+export function isNextRequest(request: NextRequest) {
+  const url = request.nextUrl;
+  const isNext = url.pathname.indexOf('/_next/') === 0;
+  return isNext;
+}
+
+export function isApiRequest(request: NextRequest) {
+  const url = request.nextUrl;
+  const isApi = url.pathname.indexOf(API_BASE) === 0;
+  return isApi;
+}
+
+/*
+import { NextApiRequest, NextApiResponse } from 'next';
+
+export type RouteMiddleware = (request: NextRequest, event: NextFetchEvent) => Promise<Response | undefined> | Response | undefined;
+
+export type ApiMiddleware = (request: NextApiRequest, response: NextApiResponse) => unknown;
+
+// Helper method to wait for a middleware to execute before continuing
+// And to throw an error when an error happens in a middleware
+export default function useApiMiddleware(middleware) {
+  return (request, response) => new Promise((resolve, reject) => {
+    middleware(request, response, (result) => {
+      if (result instanceof Error) {
+        return reject(result);
+      }
+      return resolve(result);
+    });
+  })
+}
+
+ * @name withMiddleware
+ * @description combine multiple middleware before handling your API endpoint
+ * @param middlewares
+export function withApiMiddleware(...middlewares: ApiMiddleware[]) {
+
+  return async function withMiddlewareHandler(request: NextApiRequest, response: NextApiResponse) {
+
+    async function evaluateHandler(middleware: ApiMiddleware, innerMiddleware?: ApiMiddleware | undefined) {
+      // return early when the request has
+      // been ended by a previous middleware
+      if (response.headersSent) {
+        return;
+      }
+      if (typeof middleware === 'function') {
+        const handler = await middleware(request, response);
+        if (typeof handler === 'function') {
+          if (innerMiddleware) {
+            await handler(innerMiddleware);
+            const index = middlewares.indexOf(innerMiddleware);
+            // remove inner middleware
+            if (index >= 0) {
+              middlewares.splice(index, 1);
+            }
+          } else {
+            await handler();
+          }
+        }
+      }
+    }
+    for (let index = 0; index < middlewares.length; index++) {
+      const middleware = middlewares[index];
+      const nextMiddleware = middlewares[index + 1];
+      await evaluateHandler(middleware, nextMiddleware);
+    }
+  };
+}
+*/

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;
+}