@websolutespa/bom-mixer-store 0.3.0 → 0.3.2

package/CHANGELOG.md

@@ -1,5 +1,17 @@
 # @websolutespa/bom-mixer-store
 
+## 0.3.2
+
+### Patch Changes
+
+- Modified: MockMenuService.
+
+## 0.3.1
+
+### Patch Changes
+
+- Added: source files.
+
 ## 0.3.0
 
 ### Minor Changes

package/dist/index.js

@@ -573,6 +573,26 @@ var MockMenuService = class extends MockService {
     }
   }
 };
+async function collectPages(store, items) {
+  if (!items) {
+    return;
+  }
+  for (const item of items) {
+    if (item.type === "page" && typeof item.page.value === "number" && store[item.page.relationTo] !== void 0) {
+      const value = await store[item.page.relationTo].findOne(item.page.value);
+      if (value) {
+        item.page.value = value;
+      }
+    }
+    switch (item.type) {
+      case "group":
+      case "link":
+      case "page":
+        await collectPages(store, item.items);
+        break;
+    }
+  }
+}
 async function decorateMenu(store, item, market = "ww", locale = "en") {
   const items = item.items || [];
   const decoratedItem = {
@@ -590,27 +610,7 @@ async function decorateMenu(store, item, market = "ww", locale = "en") {
       }
     }
   });
-  async function collectPages(items2) {
-    if (!items2) {
-      return;
-    }
-    for (const item2 of items2) {
-      if (item2.type === "page" && typeof item2.page.value === "number" && store[item2.page.relationTo] !== void 0) {
-        const value = await store[item2.page.relationTo].findOne(item2.page.value);
-        if (value) {
-          item2.page.value = value;
-        }
-      }
-      switch (item2.type) {
-        case "group":
-        case "link":
-        case "page":
-          await collectPages(item2.items);
-          break;
-      }
-    }
-  }
-  await collectPages(items);
+  await collectPages(store, items);
   decoratedItem.items = items.filter((x) => hasMarket(x, market)).map((x) => decorateMenuItem(x, categories, routes, market));
   return decoratedItem;
 }
@@ -619,12 +619,14 @@ async function decorateMenus(store, items, market = "ww", locale = "en") {
 }
 function decorateMenuCategory(item, categories, routes, market, depth = 0) {
   const decoratedItem = {
-    id: item.id || "",
-    type: item.type,
-    title: "",
+    abstract: item.abstract,
     category: "",
+    customClass: item.customClass,
     href: "",
-    items: []
+    id: item.id || "",
+    items: [],
+    title: "",
+    type: item.type
   };
   const category = typeof item.category === "string" ? categories.find((x) => x.id === item.category) : item.category;
   if (category) {
@@ -680,9 +682,11 @@ function decorateMenuRoute(item) {
 function decorateMenuGroup(item, categories, routes, market) {
   const items = item.items || [];
   const decoratedItem = {
+    abstract: item.abstract,
+    customClass: item.customClass,
     id: item.id || "",
-    type: item.type,
     title: item.title,
+    type: item.type,
     items: items.filter((x) => hasMarket(x, market)).map((x) => decorateMenuItem(x, categories, routes, market))
   };
   return decoratedItem;
@@ -690,11 +694,13 @@ function decorateMenuGroup(item, categories, routes, market) {
 function decorateMenuLink(item, categories, routes, market) {
   const items = item.items || [];
   const decoratedItem = {
-    id: item.id || "",
-    type: item.type,
-    title: item.title,
+    abstract: item.abstract,
+    customClass: item.customClass,
     href: item.href,
+    id: item.id || "",
     target: item.target || "",
+    title: item.title,
+    type: item.type,
     items: items.filter((x) => hasMarket(x, market)).map((x) => decorateMenuItem(x, categories, routes, market))
   };
   return decoratedItem;
@@ -706,6 +712,8 @@ function decorateMenuPage(item, categories, routes, market) {
     id: item.id || "",
     type: item.type,
     title: item.title || item.page.value.title || "",
+    abstract: item.abstract || item.page.value.abstract || "",
+    customClass: item.customClass,
     href: route?.id || "",
     media: item.page.value.media,
     page: route?.page || "",

package/dist/index.mjs

@@ -523,6 +523,26 @@ var MockMenuService = class extends MockService {
     }
   }
 };
+async function collectPages(store, items) {
+  if (!items) {
+    return;
+  }
+  for (const item of items) {
+    if (item.type === "page" && typeof item.page.value === "number" && store[item.page.relationTo] !== void 0) {
+      const value = await store[item.page.relationTo].findOne(item.page.value);
+      if (value) {
+        item.page.value = value;
+      }
+    }
+    switch (item.type) {
+      case "group":
+      case "link":
+      case "page":
+        await collectPages(store, item.items);
+        break;
+    }
+  }
+}
 async function decorateMenu(store, item, market = "ww", locale = "en") {
   const items = item.items || [];
   const decoratedItem = {
@@ -540,27 +560,7 @@ async function decorateMenu(store, item, market = "ww", locale = "en") {
       }
     }
   });
-  async function collectPages(items2) {
-    if (!items2) {
-      return;
-    }
-    for (const item2 of items2) {
-      if (item2.type === "page" && typeof item2.page.value === "number" && store[item2.page.relationTo] !== void 0) {
-        const value = await store[item2.page.relationTo].findOne(item2.page.value);
-        if (value) {
-          item2.page.value = value;
-        }
-      }
-      switch (item2.type) {
-        case "group":
-        case "link":
-        case "page":
-          await collectPages(item2.items);
-          break;
-      }
-    }
-  }
-  await collectPages(items);
+  await collectPages(store, items);
   decoratedItem.items = items.filter((x) => hasMarket(x, market)).map((x) => decorateMenuItem(x, categories, routes, market));
   return decoratedItem;
 }
@@ -569,12 +569,14 @@ async function decorateMenus(store, items, market = "ww", locale = "en") {
 }
 function decorateMenuCategory(item, categories, routes, market, depth = 0) {
   const decoratedItem = {
-    id: item.id || "",
-    type: item.type,
-    title: "",
+    abstract: item.abstract,
     category: "",
+    customClass: item.customClass,
     href: "",
-    items: []
+    id: item.id || "",
+    items: [],
+    title: "",
+    type: item.type
   };
   const category = typeof item.category === "string" ? categories.find((x) => x.id === item.category) : item.category;
   if (category) {
@@ -630,9 +632,11 @@ function decorateMenuRoute(item) {
 function decorateMenuGroup(item, categories, routes, market) {
   const items = item.items || [];
   const decoratedItem = {
+    abstract: item.abstract,
+    customClass: item.customClass,
     id: item.id || "",
-    type: item.type,
     title: item.title,
+    type: item.type,
     items: items.filter((x) => hasMarket(x, market)).map((x) => decorateMenuItem(x, categories, routes, market))
   };
   return decoratedItem;
@@ -640,11 +644,13 @@ function decorateMenuGroup(item, categories, routes, market) {
 function decorateMenuLink(item, categories, routes, market) {
   const items = item.items || [];
   const decoratedItem = {
-    id: item.id || "",
-    type: item.type,
-    title: item.title,
+    abstract: item.abstract,
+    customClass: item.customClass,
     href: item.href,
+    id: item.id || "",
     target: item.target || "",
+    title: item.title,
+    type: item.type,
     items: items.filter((x) => hasMarket(x, market)).map((x) => decorateMenuItem(x, categories, routes, market))
   };
   return decoratedItem;
@@ -656,6 +662,8 @@ function decorateMenuPage(item, categories, routes, market) {
     id: item.id || "",
     type: item.type,
     title: item.title || item.page.value.title || "",
+    abstract: item.abstract || item.page.value.abstract || "",
+    customClass: item.customClass,
     href: route?.id || "",
     media: item.page.value.media,
     page: route?.page || "",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@websolutespa/bom-mixer-store",
-  "version": "0.3.0",
+  "version": "0.3.2",
   "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);
+    }
+  };
+}
+*/