@websolutespa/bom-mixer-store 0.3.0 → 0.3.2

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

package/src/static/static.ts

@@ -0,0 +1,223 @@
+import { IEntity } from '@websolutespa/bom-core';
+
+export type IField = {
+  name: string,
+  type: 'text' | 'number' | 'relationship',
+  localized?: boolean,
+  relationTo?: string,
+  hasMany?: boolean,
+  required?: boolean
+};
+
+export type MapTo = Record<string, string>;
+
+export type StaticServiceSrc<T extends IEntity = IEntity> = string | T[] | ((config: StaticServiceConfig<T>) => T[]) | ((config: StaticServiceConfig<T>) => Promise<T[]>);
+
+export type StaticServiceConfig<T extends IEntity = IEntity> = {
+  src: StaticServiceSrc<T>;
+  slug: string;
+  fields: IField[];
+  map?: MapTo;
+};
+
+export const staticCollections: StaticServiceConfig[] = [{
+  src: 'https://actarian.github.io/cms-i18n-react/api/continent.json',
+  slug: 'i18n_continent',
+  fields: [
+    {
+      name: 'id',
+      type: 'text',
+    },
+    {
+      name: 'name',
+      type: 'text',
+    },
+  ],
+}, {
+  src: 'https://actarian.github.io/cms-i18n-react/api/country.json',
+  slug: 'i18n_country',
+  fields: [
+    {
+      name: 'id',
+      type: 'text',
+    },
+    {
+      name: 'name',
+      type: 'text',
+      localized: true,
+    },
+    {
+      name: 'englishName',
+      type: 'text',
+    },
+    {
+      name: 'nativeName',
+      type: 'text',
+    },
+    {
+      name: 'alpha2Code',
+      type: 'text',
+    },
+    {
+      name: 'alpha3Code',
+      type: 'text',
+    },
+    {
+      name: 'continent',
+      type: 'relationship',
+      relationTo: 'i18n_continent',
+      hasMany: false,
+      required: true,
+    },
+    {
+      name: 'subContinent',
+      type: 'relationship',
+      relationTo: 'i18n_sub_continent',
+      hasMany: false,
+      required: true,
+    },
+  ],
+}, {
+  src: 'https://actarian.github.io/cms-i18n-react/api/countryZone.json',
+  slug: 'i18n_country_zone',
+  fields: [
+    {
+      name: 'id',
+      type: 'text',
+    },
+    {
+      name: 'name',
+      type: 'text',
+    },
+  ],
+}, {
+  src: 'https://actarian.github.io/cms-i18n-react/api/municipality.json',
+  slug: 'i18n_municipality',
+  fields: [
+    {
+      name: 'id',
+      type: 'text',
+    },
+    {
+      name: 'name',
+      type: 'text',
+    },
+    {
+      name: 'code',
+      type: 'text',
+    },
+    {
+      name: 'country',
+      type: 'relationship',
+      relationTo: 'i18n_country',
+      hasMany: false,
+      required: true,
+    },
+    {
+      name: 'countryZone',
+      type: 'relationship',
+      relationTo: 'i18n_country_zone',
+      hasMany: false,
+      required: true,
+    },
+    {
+      name: 'region',
+      type: 'relationship',
+      relationTo: 'i18n_region',
+      hasMany: false,
+      required: true,
+    },
+    {
+      name: 'province',
+      type: 'relationship',
+      relationTo: 'i18n_province',
+      hasMany: false,
+      required: true,
+    },
+  ],
+}, {
+  src: 'https://actarian.github.io/cms-i18n-react/api/province.json',
+  slug: 'i18n_province',
+  fields: [
+    {
+      name: 'id',
+      type: 'text',
+    },
+    {
+      name: 'name',
+      type: 'text',
+    },
+    {
+      name: 'code',
+      type: 'text',
+    },
+    {
+      name: 'country',
+      type: 'relationship',
+      relationTo: 'i18n_country',
+      hasMany: false,
+      required: true,
+    },
+    {
+      name: 'countryZone',
+      type: 'relationship',
+      relationTo: 'i18n_country_zone',
+      hasMany: false,
+      required: true,
+    },
+    {
+      name: 'region',
+      type: 'relationship',
+      relationTo: 'i18n_region',
+      hasMany: false,
+      required: true,
+    },
+  ],
+}, {
+  src: 'https://actarian.github.io/cms-i18n-react/api/region.json',
+  slug: 'i18n_region',
+  fields: [
+    {
+      name: 'id',
+      type: 'text',
+    },
+    {
+      name: 'name',
+      type: 'text',
+    },
+    {
+      name: 'country',
+      type: 'relationship',
+      relationTo: 'i18n_country',
+      hasMany: false,
+      required: true,
+    },
+    {
+      name: 'countryZone',
+      type: 'relationship',
+      relationTo: 'i18n_country_zone',
+      hasMany: false,
+      required: true,
+    },
+  ],
+}, {
+  src: 'https://actarian.github.io/cms-i18n-react/api/subContinent.json',
+  slug: 'i18n_sub_continent',
+  fields: [
+    {
+      name: 'id',
+      type: 'text',
+    },
+    {
+      name: 'name',
+      type: 'text',
+    },
+    {
+      name: 'continent',
+      type: 'relationship',
+      relationTo: 'i18n_continent',
+      hasMany: false,
+      required: true,
+    },
+  ],
+}];

package/src/store/store.handler.ts

@@ -0,0 +1,176 @@
+import { IRoute, IStore, asEquatable, qsDeserialize } from '@websolutespa/bom-core';
+import { apiHandler } from '@websolutespa/bom-mixer-store';
+import { NextApiRequest, NextApiResponse } from 'next';
+import { COLLECTIONS, getStore } from './store.service';
+
+export function storeHandler<T extends IStore>(storePromise: () => Promise<T> = async () => await getStore<T>()) {
+  return apiHandler({
+    // find a specific document by id or
+    // find paginated documents
+    get: async (request: NextApiRequest, response: NextApiResponse) => {
+      try {
+        const { collections, ...query } = request.query;
+        // console.log('query', query);
+        if (!Array.isArray(collections) || collections?.length === 0) {
+          console.error('method not allowed', collections);
+          return response.status(405).send('method not allowed');
+        }
+        const collection: string = collections[0];
+        const id: string = collections[1];
+        const qs = Object.entries(query).map(kv => kv.join('=')).join('&');
+        const params = qsDeserialize(qs);
+        // console.log('params', params);
+        if (!COLLECTIONS.includes(collection)) {
+          console.error('method not allowed', collection);
+          return response.status(405).send('method not allowed');
+        }
+        const store = await storePromise();
+        const service = store[collection];
+        if (!service) {
+          console.error('method not allowed', collection);
+          return response.status(405).send('method not allowed');
+        }
+        // find a specific document by id
+        if (id) {
+          // console.log('getStoreDetail', collection, id, params);
+          const item = await service.findOne(asEquatable(id), params);
+          if (item) {
+            return response.status(200).json(item);
+          } else {
+            return response.status(404).send('not found');
+          }
+          // find paginated documents
+        } else if (String(params.pagination) === 'true') {
+          // console.log('getStoreIndex', collection, params);
+          const pagination = await service.findPaged(params);
+          return response.status(200).json(pagination);
+        } else {
+          // console.log('getStoreIndex', collection, params);
+          const items = await service.findMany(params);
+          return response.status(200).json(items);
+        }
+      } catch (error: any) {
+        console.error('storeHandler.error.500', error);
+        throw error;
+      }
+    },
+    // create a new document
+    post: async (request: NextApiRequest, response: NextApiResponse) => {
+      try {
+        const { collections, ...query } = request.query;
+        if (!Array.isArray(collections) || collections.length !== 1) {
+          console.error('method not allowed', collections);
+          return response.status(405).send('method not allowed');
+        }
+        const collection: string = collections[0];
+        const store = await storePromise();
+        const service = store[collection];
+        if (!service) {
+          console.error('method not allowed', collection);
+          return response.status(405).send('method not allowed');
+        }
+        // api post route pathname
+        if (collection === 'route' && request.body.pathname) {
+          try {
+            const { pathname } = request.body;
+            // here we use findMany because route id would break api url
+            const routes = await store.route.findMany<IRoute>({
+              where: {
+                id: {
+                  equals: pathname,
+                }
+              }
+            });
+            // let's try if match splat routes
+            if (routes.length === 0) {
+              const splatRoutes = await store.route.findMany<IRoute>({
+                where: {
+                  useSplat: {
+                    equals: true,
+                  }
+                }
+              });
+              // console.log('splatRoutes', splatRoutes);
+              // find best match splat route
+              const route = splatRoutes.reduce((p: (IRoute & { splat: string }) | undefined, c: IRoute) => {
+                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;
+                }
+              }, undefined);
+              if (route) {
+                return response.status(200).json(route);
+              }
+            }
+            // console.log('pathname', pathname);
+            if (routes.length > 0) {
+              return response.status(200).json(routes[0]);
+            } else {
+              // console.error('not found', collection);
+              return response.status(404).send('not found');
+            }
+          } catch (error: any) {
+            if (error.status === 404) {
+              // console.error('not found', collection);
+              return response.status(404).send('not found');
+            } else {
+              console.error('storeHandler.error.500', error);
+              throw error;
+            }
+          }
+        }
+      } catch (error: any) {
+        console.error('storeHandler.error.500', error);
+        throw error;
+      }
+    },
+    // update a document by id
+    patch: async (request: NextApiRequest, response: NextApiResponse) => {
+      try {
+        const params = request.query;
+        const { collections, ...query } = params;
+        if (!Array.isArray(collections) || collections.length !== 2) {
+          console.error('method not allowed', collections);
+          return response.status(405).send('method not allowed');
+        }
+        const collection: string = collections[0];
+        const id: string = collections[1];
+        const store = await storePromise();
+        const service = store[collection];
+        if (!service) {
+          console.error('method not allowed', collection);
+          return response.status(405).send('method not allowed');
+        }
+        // !!! todo patch
+      } catch (error: any) {
+        console.error('storeHandler.error.500', error);
+        throw error;
+      }
+    },
+    // delete an existing document by id
+    delete: async (request: NextApiRequest, response: NextApiResponse) => {
+      try {
+        const params = request.query;
+        const { collections, ...query } = params;
+        if (!Array.isArray(collections) || collections.length !== 2) {
+          console.error('method not allowed', collections);
+          return response.status(405).send('method not allowed');
+        }
+        const collection: string = collections[0];
+        const id: string = collections[1];
+        const store = await storePromise();
+        const service = store[collection];
+        if (!service) {
+          console.error('method not allowed', collection);
+          return response.status(405).send('method not allowed');
+        }
+        // !!! todo delete
+      } catch (error: any) {
+        console.error('storeHandler.error.500', error);
+        throw error;
+      }
+    },
+  });
+}

package/src/store/store.service.ts

@@ -0,0 +1,34 @@
+import { IStore } from '@websolutespa/bom-core';
+import { getMockStoreServer } from '../mock/mock.store';
+import { staticCollections } from '../static/static';
+import { getApiStore } from '../storeApi/storeApi.store';
+import { StoreStrategy, storeStrategy } from './store';
+
+const ENV_COLLECTIONS: string[] = process.env.COLLECTIONS ? process.env.COLLECTIONS.split(',') : [];
+export const MOCK_COLLECTIONS: string[] = process.env.MOCKS ? process.env.MOCKS.split(',') : [];
+export const STATIC_COLLECTIONS: string[] = staticCollections.map(x => x.slug);
+export const KNOWN_COLLECTIONS: string[] = [
+  'category',
+  'label',
+  'locale',
+  'market',
+  'menu',
+  'template',
+  'page',
+  'route',
+  ...STATIC_COLLECTIONS,
+];
+export const COLLECTIONS = [...ENV_COLLECTIONS, ...KNOWN_COLLECTIONS];
+
+export async function getStore<T extends IStore>(): Promise<T> {
+  switch (storeStrategy) {
+    case StoreStrategy.Api:
+      if (COLLECTIONS.length === 0) {
+        console.error('StoreService.getStore no collections');
+        throw ('StoreService.getStore no collections');
+      }
+      return await getApiStore<T>(COLLECTIONS);
+    default:
+      return await getMockStoreServer<T>();
+  }
+}

package/src/store/store.ts

@@ -0,0 +1,15 @@
+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();