@websolutespa/bom-mixer-store 0.3.0 → 0.3.2

package/src/storeApi/storeApi.service.ts

@@ -0,0 +1,191 @@
+import { FetchRequestOptions, httpFetch, IEntity, IEquatable, IQuerable, merge, Pagination, qsSerialize, QueryParams } from '@websolutespa/bom-core';
+import { StoreStrategy, storeStrategy } from '../store/store';
+
+const STORE_API_URL = process.env.STORE_URL;
+const STORE_API_BASE = process.env.STORE_API || '/api';
+const STORE_BEARER = process.env.STORE_BEARER;
+
+const MOCK_API_URL = process.env.NEXT_PUBLIC_URL;
+const MOCK_API_BASE = process.env.NEXT_PUBLIC_API || '/api';
+
+export type ApiRequestOptions = FetchRequestOptions;
+
+const defaultStoreOptions: ApiRequestOptions = {
+  // mode: 'cors',
+  headers: {
+    Authorization: `Bearer ${STORE_BEARER}`,
+  },
+};
+
+function getApiUrl(pathname: string): string {
+  let url: string;
+  if (storeStrategy === StoreStrategy.Api) {
+    url = `${STORE_API_URL}${STORE_API_BASE}${pathname}`;
+  } else {
+    url = `${MOCK_API_URL}${MOCK_API_BASE}/_mock${pathname}`;
+  }
+  return url;
+}
+
+export async function storeApiFetch(pathname: string, options: ApiRequestOptions = {}): Promise<any> {
+  const url = getApiUrl(pathname);
+  // console.log('ApiStore.apiFetch', url, options.method);
+  const apiOptions = merge({ ...defaultStoreOptions }, options);
+  const apiResponse = await httpFetch(url, apiOptions);
+  return apiResponse;
+}
+
+export async function storeApiGet(url: string, options: ApiRequestOptions = {}): Promise<any> {
+  return await storeApiFetch(url, { ...options, method: 'GET' });
+}
+
+export async function storeApiPost(url: string, payload: any, options: ApiRequestOptions = {}): Promise<any> {
+  return await storeApiFetch(url, { ...options, method: 'POST', body: JSON.stringify(payload) });
+}
+
+export async function storeApiPut(url: string, payload: any, options: ApiRequestOptions = {}): Promise<any> {
+  return await storeApiFetch(url, { ...options, method: 'PUT', body: JSON.stringify(payload) });
+}
+
+export async function storeApiPatch(url: string, payload: any, options: ApiRequestOptions = {}): Promise<any> {
+  return await storeApiFetch(url, { ...options, method: 'PATCH', body: JSON.stringify(payload) });
+}
+
+export async function storeApiDelete(url: string, options: ApiRequestOptions = {}): Promise<any> {
+  return await storeApiFetch(url, { ...options, method: 'DELETE' });
+}
+
+export class StoreApiService<T extends IEntity = IEntity> implements IQuerable<T> {
+  key: string;
+
+  constructor(key: string) {
+    if (!key) {
+      throw new Error('StoreApiService: key is required');
+    }
+    this.key = key;
+  }
+
+  /*
+  async findOne___<B extends T = T>(id: IEquatable, params: QueryParams = {}): Promise<B | undefined> {
+    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 storeApiGet(url);
+    const items: B[] = Array.isArray(response.docs) ? response.docs : response;
+    const item = items.length ? items[0] : undefined;
+    if (item) {
+      return this.decorator_(item, params);
+    }
+    return;
+  }
+  */
+
+  async findOne<B extends T = T>(id: IEquatable, params: QueryParams = {}): Promise<B | undefined> {
+    params.richText = String(params.richText) === 'true' ? true : false;
+    const query = qsSerialize(params);
+    const search = query ? `?${query}` : '';
+    const url = `/${this.key}/${encodeURIComponent(id)}${search}`;
+    const item: B = await storeApiGet(url);
+    if (item) {
+      return this.decorator_(item, params);
+    }
+    return;
+  }
+
+  async findMany<B extends T = T>(params: QueryParams = {}): Promise<B[]> {
+    params.richText = String(params.richText) === 'true' ? true : false;
+    params.pagination = false;
+    const query = qsSerialize(params);
+    const search = query ? `?${query}` : '';
+    const url = `/${this.key}${search}`;
+    const response = await storeApiGet(url);
+    const items: B[] = Array.isArray(response.docs) ? response.docs : response;
+    // console.log('StoreApiService.findMany', url);
+    // console.log('StoreApiService.findMany', url, items);
+    // items = this.where_(items, params);
+    return items.map(x => this.decorator_(x, params));
+  }
+
+  async findPaged<B extends T = T>(params: QueryParams = {}): Promise<{ docs: B[]; } & Pagination> {
+    params.richText = String(params.richText) === 'true' ? true : false;
+    params.pagination = true;
+    const query = qsSerialize(params);
+    const search = query ? `?${query}` : '';
+    const url = `/${this.key}${search}`;
+    const response = await storeApiGet(url);
+    let items: B[] = response.docs;
+    items = items.map(x => this.decorator_(x, params));
+    return { ...response, docs: items };
+  }
+
+  async create<B extends T = T>(payload: Omit<B, 'id'>): Promise<B> {
+    const url = `/${this.key}`;
+    // console.log('StoreApiService', this.key, 'create', url);
+    const item = await storeApiPost(url, payload);
+    return this.decorator_(item);
+  }
+
+  async update<B extends T = T>(payload: Partial<B>): Promise<B> {
+    const url = `/${this.key}`;
+    // console.log('StoreApiService', this.key, 'update', url);
+    const item = await storeApiPut(url, payload);
+    return this.decorator_(item);
+  }
+
+  async delete<B extends T = T>(id: IEquatable): Promise<B | undefined> {
+    // 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('StoreApiService', this.key, 'delete', url);
+    const item = await storeApiDelete(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_<B extends T = T>(item: B, params: QueryParams = {}): B {
+    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/storeApi/storeApi.store.ts

@@ -0,0 +1,66 @@
+import { IEntity, IQuerable, IStore, isDevelopment } from '@websolutespa/bom-core';
+import { MockService } from '../mock/mock.service';
+import { getMockStoreServer } from '../mock/mock.store';
+import { MOCK_COLLECTIONS } from '../store/store.service';
+import { StoreApiService, storeApiGet } from './storeApi.service';
+
+export async function getApiStore<T extends IStore>(collections: string[]): Promise<T> {
+  // console.count('ApiStore.getApiStore');
+  // console.log('ApiStore.getApiStore', collections);
+  // 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;
+  }
+  let mockStore: IStore = {};
+  if (MOCK_COLLECTIONS.length > 0) {
+    mockStore = await getMockStoreServer<T>();
+  }
+  const store: { [key: string]: IQuerable<IEntity> } = {};
+  collections.sort();
+  collections.forEach(key => {
+    if (MOCK_COLLECTIONS.includes(key)) {
+      store[key] = mockStore[key];
+    } else {
+      store[key] = new StoreApiService(key);
+    }
+  });
+  // console.count('ApiStore.getApiRuntimeStore');
+  // console.log('StoreApi.getApiRuntimeStore', Object.keys(store));
+  if (!isDevelopment) {
+    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: IStore = {};
+  const url = '/store?pagination=true&richText=false';
+  const json = await storeApiGet(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], store);
+      }
+    });
+  }
+  // console.count('ApiStore.getApiBuildStore');
+  // console.log('StoreApi.getApiBuildStore', Object.keys(store));
+  BUILD_STORE_ = store;
+  return store as T;
+}