@websolutespa/bom-mixer-store 0.0.1

package/jest.config.ts

@@ -0,0 +1,3 @@
+import { getPackageConfig } from '@websolutespa/test';
+
+export default getPackageConfig();

package/package.json

@@ -0,0 +1,56 @@
+{
+  "name": "@websolutespa/bom-mixer-store",
+  "version": "0.0.1",
+  "description": "",
+  "keywords": [
+    "bom",
+    "mixer",
+    "store"
+  ],
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git://github.com/websolutespa/bom.git"
+  },
+  "prepack": {
+    "types": "./dist/index.d.ts",
+    "main": "./dist/index.js",
+    "module": "./dist/index.mjs"
+  },
+  "postpack": {
+    "types": "./src/index.ts",
+    "main": "./src/index.ts"
+  },
+  "sideEffects": false,
+  "publishConfig": {
+    "access": "public"
+  },
+  "scripts": {
+    "build": "tsup ./src/index.ts --format esm,cjs --dts --external react",
+    "lint": "eslint *.ts*",
+    "test": "jest",
+    "test-watch": "npm test -- --watch",
+    "coverage:integration": "npm run test -- --coverage",
+    "coverage": "run-s -c --silent coverage:*",
+    "coverage-open": "open-cli coverage/lcov-report/index.html",
+    "prepack": "bom prepack",
+    "postpack": "bom postpack"
+  },
+  "dependencies": {},
+  "devDependencies": {
+    "@types/react": "^18.0.18",
+    "@types/react-dom": "^18.0.6",
+    "@websolutespa/bom-cli": "*",
+    "@websolutespa/test": "*",
+    "@websolutespa/tsconfig": "*",
+    "eslint": "^8.23.0",
+    "eslint-config-websolute": "*",
+    "npm-run-all": "^4.1.5",
+    "react": "^18.2.0",
+    "ts-node": "^10.9.1",
+    "typescript": "^4.8.2"
+  },
+  "types": "./dist/index.d.ts",
+  "main": "./dist/index.js",
+  "module": "./dist/index.mjs"
+}

package/src/api/api.service.ts

@@ -0,0 +1,158 @@
+import { FetchRequestOptions, httpFetch, IEntity, IEquatable, IQuerable, merge, qsSerialize, QueryParams } from '@websolutespa/bom-mixer-core';
+
+// !!! these keys are server-side only
+const STORE_API_URL = process.env.STORE_URL;
+const STORE_API_BASE = process.env.STORE_API;
+const STORE_BEARER = process.env.STORE_BEARER;
+
+const defaultStoreOptions: FetchRequestOptions = {
+  // mode: 'cors',
+  headers: {
+    Authorization: `Bearer ${STORE_BEARER}`,
+  },
+};
+
+export async function apiFetch(pathname: string, options: FetchRequestOptions = {}): Promise<any> {
+  const url = `${STORE_API_URL}${STORE_API_BASE}${pathname}`;
+  // console.log('ApiStore.apiFetch', url, options.method);
+  const apiOptions = merge({ ...defaultStoreOptions }, options);
+  const apiResponse = await httpFetch(url, apiOptions);
+  return apiResponse;
+}
+
+export async function apiGet(url: string, options: FetchRequestOptions = {}): Promise<any> {
+  return await apiFetch(url, { ...options, method: 'GET' });
+}
+
+export async function apiPost(url: string, payload: any, options: FetchRequestOptions = {}): Promise<any> {
+  return await apiFetch(url, { ...options, method: 'POST', body: JSON.stringify(payload) });
+}
+
+export async function apiPut(url: string, payload: any, options: FetchRequestOptions = {}): Promise<any> {
+  return await apiFetch(url, { ...options, method: 'PUT', body: JSON.stringify(payload) });
+}
+
+export async function apiPatch(url: string, payload: any, options: FetchRequestOptions = {}): Promise<any> {
+  return await apiFetch(url, { ...options, method: 'PATCH', body: JSON.stringify(payload) });
+}
+
+export async function apiDelete(url: string, options: FetchRequestOptions = {}): Promise<any> {
+  return await apiFetch(url, { ...options, method: 'DELETE' });
+}
+
+export class ApiService<T extends IEntity> implements IQuerable<IEntity> {
+  key: string;
+
+  constructor(key: string) {
+    if (!key) {
+      throw new Error('ApiService: key is required');
+    }
+    this.key = key;
+  }
+
+  async findOne(params: QueryParams = {}): Promise<T | undefined> {
+    // const params = toFindParams(idOrParams);
+    // const search = this.search_(params);
+    params.pagination = params.pagination || false;
+    params.richText = params.richText || false;
+    const query = qsSerialize(params);
+    const search = query ? `?${query}` : '';
+    // const id = params.where.id as string | number;
+    // const url = `/${this.key}${id ? `/${encodeURIComponent(id)}` : ''}${search}`;
+    const url = `/${this.key}${search}`;
+    // console.log('ApiService', this.key, 'findOne', url);
+    const response = await apiGet(url);
+    const items: T[] = Array.isArray(response.docs) ? response.docs : response;
+    const item = items.length ? items[0] : undefined;
+    // console.log('ApiService.findOne', url);
+    // console.log('ApiService.findOne', url, item);
+    if (item) {
+      return this.decorator_(item, params);
+    }
+    return;
+  }
+
+  async findMany(params: QueryParams = {}): Promise<T[]> {
+    // const search = this.search_(params);
+    params.pagination = params.pagination || false;
+    params.richText = params.richText || false;
+    const query = qsSerialize(params);
+    const search = query ? `?${query}` : '';
+    const url = `/${this.key}${search}`;
+    const response = await apiGet(url);
+    const items: T[] = Array.isArray(response.docs) ? response.docs : response;
+    // console.log('ApiService.findMany', url);
+    // console.log('ApiService.findMany', url, items);
+    // items = this.where_(items, params);
+    return items.map(x => this.decorator_(x, params));
+  }
+
+  async create(payload: any): Promise<T> {
+    const url = `/${this.key}`;
+    // console.log('ApiService', this.key, 'create', url);
+    const item = await apiPost(url, payload);
+    return this.decorator_(item);
+  }
+
+  async update(payload: T): Promise<T> {
+    const url = `/${this.key}`;
+    // console.log('ApiService', this.key, 'update', url);
+    const item = await apiPut(url, payload);
+    return this.decorator_(item);
+  }
+
+  async delete(id: IEquatable) {
+    // const params = toFindParams(id);
+    const params = {
+      where: {
+        id: {
+          equals: id,
+        }
+      },
+    };
+    const query = qsSerialize(params);
+    const search = query ? `?${query}` : '';
+    // const search = this.search_(params);
+    const url = `/${this.key}${search}`;
+    // const url = `/${this.key}/${encodeURIComponent(id.toString())}`;
+    // console.log('ApiService', this.key, 'delete', url);
+    const item = await apiDelete(url);
+    return this.decorator_(item);
+  }
+
+  /*
+  protected where_(items: any[], params: FindParams): any[] {
+    const where = params.where;
+    if (where) {
+      const keys = Object.keys(where);
+      items = items.filter(x => {
+        return keys.reduce<boolean>((p, c) => {
+          return p && (x[c] === where[c]);
+        }, true);
+      });
+    }
+    return items;
+  }
+  */
+
+  protected decorator_(item: any, params: QueryParams = {}): any {
+    return item;
+  }
+
+  /*
+  protected search_(params: QueryParams): string {
+    const search: { [key: string]: string; } = {};
+    Object.entries(params).forEach(([key, value]) => {
+      if (typeof value !== 'object') {
+        search[key] = value.toString();
+      } else {
+        switch (key) {
+          case 'where':
+            search[key] = JSON.stringify(value);
+        }
+      }
+    });
+    return Object.keys(search).length ? '?' + new URLSearchParams(search).toString() : '';
+  }
+  */
+}

package/src/api/api.store.ts

@@ -0,0 +1,56 @@
+import { IEntity, IQuerable } from '@websolutespa/bom-mixer-core';
+import { MockService } from '../mock/mock.service';
+import { IStore } from '../store/store';
+import { apiGet, ApiService } from './api.service';
+
+export async function getApiStore<T extends IStore>(collections: string[]): Promise<T> {
+  // console.count('ApiStore.getApiStore');
+  // console.log('ApiStore.getApiStore', collections);
+  // console.log(process.env);
+  // console.log('NODE_ENV', process.env.NODE_ENV, 'NEXT_RUNTIME', process.env.NEXT_RUNTIME, 'NEXT_PHASE', process.env.NEXT_PHASE);
+  if (process.env.NEXT_PHASE === 'phase-production-build') {
+    return await getApiBuildStore();
+  } else {
+    return await getApiRuntimeStore(collections);
+  }
+}
+
+let RUNTIME_STORE_: IStore;
+export async function getApiRuntimeStore<T extends IStore>(collections: string[]): Promise<T> {
+  if (RUNTIME_STORE_) {
+    return RUNTIME_STORE_ as T;
+  }
+  const store: { [key: string]: IQuerable<IEntity> } = {};
+  collections.sort();
+  collections.forEach(key => {
+    store[key] = new ApiService<any>(key);
+  });
+  // console.count('ApiStore.getApiRuntimeStore');
+  // console.log('StoreApi.getApiRuntimeStore', Object.keys(store));
+  RUNTIME_STORE_ = store;
+  return store as T;
+}
+
+let BUILD_STORE_: IStore;
+export async function getApiBuildStore<T extends IStore>(): Promise<T> {
+  if (BUILD_STORE_) {
+    return BUILD_STORE_ as T;
+  }
+  const store: { [key: string]: IQuerable<IEntity> } = {};
+  const url = '/store?pagination=true&richText=false';
+  const json = await apiGet(url);
+  // const json: { [key: string]: { items: any[] } } = {};
+  if (json != null) {
+    const collections = Object.keys(json);
+    collections.sort();
+    collections.forEach(key => {
+      if (json[key]) {
+        store[key] = new MockService(json[key]);
+      }
+    });
+  }
+  // console.count('ApiStore.getApiBuildStore');
+  // console.log('StoreApi.getApiBuildStore', Object.keys(store));
+  BUILD_STORE_ = store;
+  return store as T;
+}

package/src/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/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,9 @@
+export * from './api/api.service';
+export * from './api/api.store';
+export * from './middleware/middleware.service';
+export * from './mock/mock.api';
+export * from './mock/mock.interceptor';
+export * from './mock/mock.service';
+export * from './mock/mock.store';
+export * from './store/store';
+export * from './store/store.service';

package/src/middleware/middleware.service.ts

@@ -0,0 +1,85 @@
+import { NextRequest } from 'next/server';
+
+/*
+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);
+    }
+  };
+}
+*/
+
+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') === 0;
+  return isApi;
+}
+
+export function isExistingApiRoute(request: NextRequest) {
+  const rx = /^\/api\/(route|product|(product\/(.+))|(menu\/(.+)))\/?$/gm;
+  const url = request.nextUrl;
+  const isApi = url.pathname.indexOf('/api') === 0;
+  const isExisting = isApi && rx.test(url.pathname);
+  return isExisting;
+}

package/src/mock/mock.api.ts

@@ -0,0 +1,11 @@
+import { fsRead, fsReadJson, pathJoin } from '../fs/fs.service';
+
+export async function resolveMockApi(api: string): Promise<any> {
+  const pathname = pathJoin(`${api}.json`);
+  return await fsRead(pathname);
+}
+
+export async function parseMockApi(api: string): Promise<any> {
+  const pathname = pathJoin(`${api}.json`);
+  return await fsReadJson(pathname);
+}

package/src/mock/mock.interceptor.ts

@@ -0,0 +1,16 @@
+import { NextFetchEvent, NextRequest, NextResponse } from 'next/server';
+import { isExistingApiRoute } from '../middleware/middleware.service';
+import { StoreStrategy, storeStrategy } from '../store/store';
+
+export async function mockInterceptor(request: NextRequest, next: NextFetchEvent) {
+  if (storeStrategy !== StoreStrategy.Mock) {
+    return;
+  }
+  if (!isExistingApiRoute(request)) {
+    const url = request.nextUrl.clone();
+    url.pathname = `/api/_mock/${encodeURIComponent(url.pathname)}`;
+    const response = NextResponse.rewrite(url);
+    return response;
+  }
+  return;
+}

package/src/mock/mock.service.ts

@@ -0,0 +1,31 @@
+import { IEntity, JsonService, localizeItem, QueryParams } from '@websolutespa/bom-mixer-core';
+
+export class MockService<T extends IEntity = any> extends JsonService<T> {
+
+  /*
+  findOne(params: QueryParams): Promise<T | undefined> {
+    const query = qsSerialize(params);
+    console.log('MockService.findOne', query);
+    const deserialized = qsDeserialize(query);
+    console.log('MockService.findOne', deserialized);
+    return super.findOne(params);
+  }
+
+  findMany(params: QueryParams = {}): Promise<T[]> {
+    const query = qsSerialize(params);
+    console.log('MockService.findMany', query);
+    const deserialized = qsDeserialize(query);
+    console.log('MockService.findMany', deserialized);
+    return super.findMany(params);
+  }
+  */
+
+  protected override decorator_(item: any, params: QueryParams = {}): any {
+    if (params.locale) {
+      return localizeItem(item, params.locale);
+    } else {
+      return item;
+    }
+  }
+
+}

package/src/mock/mock.store.ts

@@ -0,0 +1,30 @@
+import { IEntity, IQuerable } from '@websolutespa/bom-mixer-core';
+import { fsReadJson } from '../fs/fs.service';
+import { IStore } from '../store/store';
+import { MockService } from './mock.service';
+
+// eslint-disable-next-line @typescript-eslint/no-var-requires
+const path = require('path');
+
+let STORE_: IStore;
+
+export async function getMockStore<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 json = await fsReadJson(pathname);
+  const store: { [key: string]: IQuerable<IEntity> } = {};
+  if (json != null) {
+    Object.keys(json).forEach(key => {
+      store[key] = new MockService(json[key]);
+    });
+  }
+  // console.count('MockStore.getMockStore');
+  // console.log('MockStore.getMockStore', Object.keys(store));
+  STORE_ = store;
+  return STORE_ as T;
+}

package/src/store/store.service.ts

@@ -0,0 +1,24 @@
+import { getApiStore } from '../api/api.store';
+import { getMockStore } from '../mock/mock.store';
+import { IStore, StoreStrategy, storeStrategy } from './store';
+
+const CONFIG_: {
+  COLLECTIONS: string[],
+} = {
+  COLLECTIONS: []
+};
+
+export function registerCollections(collections: string[] = []): void {
+  CONFIG_.COLLECTIONS = collections;
+  // console.log('registerCollections', collections);
+}
+
+export async function getStore<T extends IStore>(): Promise<T> {
+  // console.count('Store.getStore'); // !!! > 11000
+  switch (storeStrategy) {
+    case StoreStrategy.Api:
+      return await getApiStore<T>(CONFIG_.COLLECTIONS);
+    default:
+      return await getMockStore<T>();
+  }
+}

package/src/store/store.ts

@@ -0,0 +1,29 @@
+import { IEntity, IQuerable } from '@websolutespa/bom-mixer-core';
+
+export type Store = {
+  [key: string]: IQuerable<IEntity>;
+};
+
+export type MockStore = {
+  [key: string]: any[];
+};
+
+export enum StoreStrategy {
+  Api = 'api',
+  Data = 'data',
+  Mock = 'mock',
+}
+
+function getStoreStrategy(): StoreStrategy {
+  let storeStrategy = StoreStrategy.Mock;
+  if (process && process.env.STORE_STRATEGY) {
+    storeStrategy = process.env.STORE_STRATEGY as StoreStrategy;
+  }
+  return storeStrategy;
+}
+
+export const storeStrategy: StoreStrategy = getStoreStrategy();
+
+export type IStore = {
+  [key: string]: IQuerable<IEntity>;
+};

package/tsconfig.json

@@ -0,0 +1,16 @@
+{
+  "extends": "@websolutespa/tsconfig/tsnode.json",
+  "include": [
+    "."
+  ],
+  "exclude": [
+    "node_modules",
+    "dist",
+    "build",
+    "coverage"
+  ],
+  "compilerOptions": {
+    "baseUrl": ".",
+    "rootDir": "."
+  }
+}