@websolutespa/bom-mixer-store 0.2.0 → 0.3.1

package/CHANGELOG.md

@@ -1,25 +1,37 @@
-# @websolutespa/bom-mixer-store
-
-## 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/dist/index.js

@@ -1194,6 +1194,26 @@ function storeHandler(storePromise = async () => await getStore()) {
                 }
               }
             });
+            if (routes.length === 0) {
+              const splatRoutes = await store.route.findMany({
+                where: {
+                  useSplat: {
+                    equals: true
+                  }
+                }
+              });
+              const route = splatRoutes.reduce((p, c) => {
+                const match = pathname.indexOf(c.id) === 0;
+                if (match && (!p || p.id.length < c.id.length)) {
+                  return { ...c, splat: pathname.substring(c.id.length, pathname.length) };
+                } else {
+                  return p;
+                }
+              }, void 0);
+              if (route) {
+                return response.status(200).json(route);
+              }
+            }
             if (routes.length > 0) {
               return response.status(200).json(routes[0]);
             } else {

package/dist/index.mjs

@@ -1146,6 +1146,26 @@ function storeHandler(storePromise = async () => await getStore()) {
                 }
               }
             });
+            if (routes.length === 0) {
+              const splatRoutes = await store.route.findMany({
+                where: {
+                  useSplat: {
+                    equals: true
+                  }
+                }
+              });
+              const route = splatRoutes.reduce((p, c) => {
+                const match = pathname.indexOf(c.id) === 0;
+                if (match && (!p || p.id.length < c.id.length)) {
+                  return { ...c, splat: pathname.substring(c.id.length, pathname.length) };
+                } else {
+                  return p;
+                }
+              }, void 0);
+              if (route) {
+                return response.status(200).json(route);
+              }
+            }
             if (routes.length > 0) {
               return response.status(200).json(routes[0]);
             } else {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@websolutespa/bom-mixer-store",
-  "version": "0.2.0",
+  "version": "0.3.1",
   "description": "Mixer Store module of the BOM Repository",
   "keywords": [
     "bom",
@@ -22,11 +22,10 @@
     "prepack": "bom prepack",
     "postpack": "bom postpack"
   },
-  "dependencies": {
-    "@websolutespa/bom-core": "*",
-    "iron-session": "^6.2.1"
-  },
+  "dependencies": {},
   "peerDependencies": {
+    "@websolutespa/bom-core": "*",
+    "iron-session": ">= 6.2.1",
     "next": ">= 12.3.2"
   },
   "devDependencies": {
@@ -46,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);
+    }
+  };
+}
+*/