@phystack/products 4.3.40-dev

package/src/services/grid-product-service-client.ts

@@ -0,0 +1,995 @@
+import HttpService from './http-service';
+import {
+  ProductDetailsByCodeQueryParameters,
+  ProductDetailsQueryParameters,
+  ProductFiltersQueryParameters,
+  ProductGroupStoresInventoryParam,
+  ProductGroupStoresInventoryResponse,
+  ProductQueryParameters,
+  ProductRecommendationsQueryParameters,
+  ProductTypesListQueryParameters,
+  ProductTypesListWithSpaceProductsQueryParameters,
+  RequestTypeEnum,
+  SearchQueryParameters,
+} from '../types/parameters';
+import {
+  BaseSelectorProps,
+  DataResidencyEnum,
+  FilterByGroup,
+  FilterByLanguage,
+  GetCartPromotionsParams,
+  GetCartPromotionsResponse,
+  GetVariantActivePriceParams,
+  GetVariantActivePriceResponse,
+  GridProduct,
+  GridProductSelectors,
+  InventoryItem,
+  PriceListTypeEnum,
+  ProductBrand,
+  ProductDescription,
+  ProductName,
+  ProductRecommendationLibraryResponse,
+  ProductRecommendationResponse,
+  ProductShortDescription,
+  ProductType,
+  SelectablePartialProduct,
+  SingleLocalizedResult,
+  SortOptionsResponse,
+  VariantInfo,
+  VariantInventory,
+} from '../types/grid-product';
+import { setApiEndpoint } from '../api';
+import { IsoLanguageIds } from '../types/iso-language-ids';
+import GridProductServiceInterface from './grid-product-service-interface';
+
+
+interface GetProductListResponse {
+  list: Partial<GridProduct>[];
+  attributeFilters: FilterByLanguage;
+}
+
+interface GetProductListLibraryResponse extends GetProductListResponse {
+  list: SelectablePartialProduct[];
+}
+
+type Options = {
+  tenantId: string;
+  environment: string;
+  dataResidency: DataResidencyEnum;
+  locale: IsoLanguageIds;
+  fallbackLocale?: IsoLanguageIds;
+};
+
+type JSONValue = string | number | boolean | null | JSONObject | JSONArray;
+
+interface JSONObject {
+  [key: string]: JSONValue;
+}
+
+type JSONArray = JSONValue[];
+
+export class GridProductServiceClient implements GridProductServiceInterface {
+  readonly httpService: HttpService;
+
+  locale: IsoLanguageIds;
+
+  fallbackLocale?: IsoLanguageIds;
+
+  apiEndpoint: string;
+
+  tenantId: string;
+
+  constructor({ tenantId, environment, dataResidency, locale, fallbackLocale }: Options) {
+    if (!tenantId) {
+      throw new Error('Error: tenantId is required');
+    }
+
+    if (!environment) {
+      throw new Error('Error: environment is required');
+    }
+
+    const apiEndpoint: string = setApiEndpoint(dataResidency);
+
+    this.httpService = new HttpService({
+      baseUrl: `${apiEndpoint}/tenants/${tenantId}/${environment}`,
+    });
+
+    this.apiEndpoint = apiEndpoint;
+
+    this.tenantId = tenantId;
+
+    this.locale = locale;
+
+    this.fallbackLocale = fallbackLocale;
+  }
+
+  getLocalizedValue = <T extends { isoLanguageId?: IsoLanguageIds | '*' }>(
+    list: T[],
+    locale: IsoLanguageIds | '*',
+  ): T | undefined => {
+    const fallbackLocale = this.fallbackLocale;
+
+    const filteredList = list.filter((item) => item.isoLanguageId === locale);
+
+    if (filteredList.length === 0 && fallbackLocale) {
+      const newFilteredList = list.filter(
+        (item) => item.isoLanguageId === fallbackLocale,
+      );
+
+      return newFilteredList[0];
+    }
+
+    return filteredList[0];
+  };
+
+  getLocalizedList = <T extends { isoLanguageId?: IsoLanguageIds | '*' }>(
+    list: T[],
+    locale: IsoLanguageIds | '*',
+  ): T[] => {
+    if (locale === '*') {
+      return list;
+    }
+
+    const filteredList = list.filter((item) => {
+      if (!item.isoLanguageId) {
+        return true;
+      }
+
+      return item.isoLanguageId === locale;
+    });
+
+    const fallbackLocale = this.fallbackLocale;
+
+    if (filteredList.length === 0 && fallbackLocale) {
+      const newFilteredList = list.filter(
+        (item) => item.isoLanguageId === fallbackLocale,
+      );
+
+      return newFilteredList;
+    }
+
+    return filteredList;
+  };
+
+  getFilteredList = <T>(list: T[], filterFn: ((item: T) => boolean) | undefined) => {
+    if (!filterFn) {
+      return list;
+    }
+
+    return list.filter(filterFn);
+  };
+
+  buildSelectableProduct = (product: Partial<GridProduct>): SelectablePartialProduct => {
+    const defaultLocale = this.locale;
+
+    const getShortDescription: GridProductSelectors['getShortDescription'] = <
+      T extends BaseSelectorProps,
+    >(
+      input?: T,
+    ) => {
+      const locale = input?.locale ?? defaultLocale;
+
+      const list = product.productShortDescription ?? [];
+
+      const localizedValue = this.getLocalizedValue(list, locale);
+
+      const value = localizedValue?.productShortDescription ?? '';
+
+      return input?.locale === '*'
+        ? <SingleLocalizedResult<T, ProductShortDescription, string>>list
+        : <SingleLocalizedResult<T, ProductShortDescription, string>>value;
+    };
+
+    const getLabel: GridProductSelectors['getLabel'] = (input) => {
+      const locale = input?.locale ?? defaultLocale;
+
+      const filterFn = input?.filter;
+
+      const list = product.productLabel ?? [];
+
+      const newList = this.getFilteredList(this.getLocalizedList(list, locale), filterFn);
+
+      return newList.map((item) => item.productLabel);
+    };
+
+    const getLabelBySpace: GridProductSelectors['getLabelBySpace'] = (input) =>
+      getLabel({
+        ...input,
+        filter: (item) => item.spaceId === input.spaceId,
+      });
+
+    const getPriceList: GridProductSelectors['getPriceList'] = (input?) => {
+      const filterFn = input?.filter;
+
+      const list = product.productPriceList ?? [];
+
+      const filteredList = this.getFilteredList(list, filterFn);
+
+      return filteredList;
+    };
+
+    const getStandardPrice: GridProductSelectors['getStandardPrice'] = ({ spaceId }) => {
+      const priceList = getPriceList({
+        filter: (item) =>
+          item.spaceId === spaceId && item.priceListType === PriceListTypeEnum.Standard,
+      });
+
+      const firstItem = priceList[0];
+
+      if (!firstItem) {
+        return undefined;
+      }
+
+      return { amount: firstItem.listPrice, currencyCode: firstItem.isoCurrencyCode };
+    };
+
+    const getPromotionalPrice: GridProductSelectors['getStandardPrice'] = ({
+      spaceId,
+    }) => {
+      const priceList = getPriceList({
+        filter: (item) =>
+          item.spaceId === spaceId &&
+          item.priceListType === PriceListTypeEnum.Promotional,
+      });
+
+      const firstItem = priceList[0];
+
+      if (!firstItem) {
+        return undefined;
+      }
+
+      return { amount: firstItem.listPrice, currencyCode: firstItem.isoCurrencyCode };
+    };
+
+    const getName: GridProductSelectors['getName'] = <T extends BaseSelectorProps>(
+      input?: T,
+    ) => {
+      const locale = input?.locale ?? defaultLocale;
+
+      const list = product.productName ?? [];
+
+      const localizedValue = this.getLocalizedValue(list, locale);
+
+      const value = localizedValue?.productName ?? '';
+
+      return input?.locale === '*'
+        ? <SingleLocalizedResult<T, ProductName, string>>list
+        : <SingleLocalizedResult<T, ProductName, string>>value;
+    };
+
+    const getDescription: GridProductSelectors['getDescription'] = <
+      T extends BaseSelectorProps,
+    >(
+      input?: T,
+    ) => {
+      const locale = input?.locale ?? defaultLocale;
+
+      const list = product.productDescription ?? [];
+
+      const localizedValue = this.getLocalizedValue(list, locale);
+
+      const value = localizedValue?.productDescription ?? '';
+
+      return input?.locale === '*'
+        ? <SingleLocalizedResult<T, ProductDescription, string>>list
+        : <SingleLocalizedResult<T, ProductDescription, string>>value;
+    };
+
+    const getBrandName: GridProductSelectors['getBrandName'] = <
+      T extends BaseSelectorProps,
+    >(
+      input?: T,
+    ) => {
+      const locale = input?.locale ?? defaultLocale;
+
+      const list = product.brand ?? [];
+
+      const localizedValue = this.getLocalizedValue(list, locale);
+
+      const value = localizedValue?.brandName ?? '';
+
+      return input?.locale === '*'
+        ? <SingleLocalizedResult<T, ProductBrand, string>>list
+        : <SingleLocalizedResult<T, ProductBrand, string>>value;
+    };
+
+    const getItemQuantity: GridProductSelectors['getItemQuantity'] = (input) => {
+      const filterFn = input?.filter;
+
+      const list = product.productItemQuantity ?? [];
+
+      const filteredList = this.getFilteredList(list, filterFn);
+
+      return filteredList;
+    };
+
+    const getVariantQuantity: GridProductSelectors['getVariantQuantity'] = ({
+      variantId,
+      spaceId,
+    }) => {
+      const filteredList = getItemQuantity({
+        filter: (item) => {
+          if (!spaceId) {
+            return item.productId === variantId;
+          }
+
+          return item.productId === variantId && item.spaceId === spaceId;
+        },
+      });
+
+      const sum = filteredList.reduce(
+        (accumulator, item) => accumulator + item.productItemQuantity,
+        0,
+      );
+
+      return sum;
+    };
+
+    const getCatalogPageLocationProduct: GridProductSelectors['getCatalogPageLocationProduct'] =
+      (input) => {
+        const filterFn = input?.filter;
+
+        const list = product.catalogPageLocationProduct ?? [];
+
+        const filteredList = this.getFilteredList(list, filterFn);
+
+        return filteredList;
+      };
+
+    const getImages: GridProductSelectors['getImages'] = () => {
+      const list = getCatalogPageLocationProduct();
+
+      const result = list.map((item) => item.catalogPageLocationProduct);
+
+      return result;
+    };
+
+    const getImage: GridProductSelectors['getImage'] = () => {
+      const list = getCatalogPageLocationProduct();
+
+      const images = list.map((item) => item.catalogPageLocationProduct);
+
+      const result = images[0] ?? '';
+
+      return result;
+    };
+
+    const getFeature: GridProductSelectors['getFeature'] = (input) => {
+      const locale = input?.locale ?? defaultLocale;
+
+      const filterFn = input?.filter;
+
+      const list = product.productFeature ?? [];
+
+      const filteredList = this.getFilteredList(
+        this.getLocalizedList(list, locale),
+        filterFn,
+      );
+
+      return filteredList;
+    };
+
+    const getVariantFeature: GridProductSelectors['getVariantFeature'] = (input) =>
+      getFeature({
+        ...input,
+        filter: (item) => item.productId === input.productId,
+      });
+
+    const getVariants: GridProductSelectors['getVariants'] = (input) => {
+      const filterFn = input?.filter;
+
+      const list = product.variants ?? [];
+
+      const filteredList = this.getFilteredList(list, filterFn);
+
+      return filteredList;
+    };
+
+    const getFirstVariant: GridProductSelectors['getFirstVariant'] = () => {
+      const variants = getVariants();
+
+      const result = variants[0];
+
+      return result;
+    };
+
+    const getVariantsByProductId: GridProductSelectors['getVariantsByProductId'] = ({
+      productId,
+    }) => getVariants({ filter: (item) => item.productId === productId });
+
+    const getVariantImages: GridProductSelectors['getVariantImages'] = ({
+      variantId,
+    }) => {
+      const filteredList = getCatalogPageLocationProduct({
+        filter: (item) => item.productId === variantId,
+      });
+
+      const result = filteredList.map((item) => item.catalogPageLocationProduct);
+
+      return result;
+    };
+
+    const getVariantStandardPrice: GridProductSelectors['getVariantStandardPrice'] = ({
+      variantId,
+      spaceId,
+    }) => {
+      const priceList = getPriceList({
+        filter: (item) =>
+          item.productId === variantId &&
+          item.spaceId === spaceId &&
+          item.priceListType === PriceListTypeEnum.Standard,
+      });
+
+      const firstItem = priceList[0];
+
+      if (!firstItem) {
+        return undefined;
+      }
+
+      return { amount: firstItem.listPrice, currencyCode: firstItem.isoCurrencyCode };
+    };
+
+    const getVariantPromotionalPrice: GridProductSelectors['getVariantPromotionalPrice'] =
+      ({ variantId, spaceId }) => {
+        const priceList = getPriceList({
+          filter: (item) =>
+            item.productId === variantId &&
+            item.spaceId === spaceId &&
+            item.priceListType === PriceListTypeEnum.Promotional,
+        });
+
+        const firstItem = priceList[0];
+
+        if (!firstItem) {
+          return undefined;
+        }
+
+        return { amount: firstItem.listPrice, currencyCode: firstItem.isoCurrencyCode };
+      };
+
+    const selectableProduct: SelectablePartialProduct = {
+      ...product,
+      getShortDescription,
+      getLabel,
+      getLabelBySpace,
+      getPriceList,
+      getStandardPrice,
+      getPromotionalPrice,
+      getName,
+      getDescription,
+      getBrandName,
+      getItemQuantity,
+      getCatalogPageLocationProduct,
+      getImages,
+      getImage,
+      getFeature,
+      getVariantFeature,
+      getVariants,
+      getFirstVariant,
+      getVariantsByProductId,
+      getVariantImages,
+      getVariantStandardPrice,
+      getVariantPromotionalPrice,
+      getVariantQuantity,
+    };
+
+    return selectableProduct;
+  };
+
+  getProductById = async (
+    id: string,
+    params: ProductDetailsQueryParameters,
+  ): Promise<SelectablePartialProduct> => {
+    try {
+      const result = await this.httpService.get(`/products/${id}`, {
+        params,
+      });
+
+      return this.buildSelectableProduct(result.data);
+    } catch (err) {
+      // @ts-ignore
+      throw new Error(err.response.data.message ?? err.message);
+    }
+  };
+
+  getProductByBarcode = async (
+    code: string,
+    params: ProductDetailsByCodeQueryParameters,
+  ): Promise<{
+    productDetails: SelectablePartialProduct;
+    productId: string;
+  }> => {
+    try {
+      const result = await this.httpService.get<{
+        data: { productDetails: Partial<GridProduct>; productId: string };
+      }>(`/products-barcode/${code}`, {
+        params,
+      });
+
+      return {
+        productDetails: this.buildSelectableProduct(result.data.productDetails),
+        productId: result.data.productId,
+      };
+    } catch (err) {
+      // @ts-ignore
+      throw new Error(err.response.data.message ?? err.message);
+    }
+  };
+
+  getProductList = async (
+    params?: ProductQueryParameters,
+  ): Promise<GetProductListLibraryResponse> => {
+    try {
+      const buildParams = (params?: ProductQueryParameters): Record<string, string> => {
+        const stringParams: Record<string, string> = {};
+
+        if (params) {
+          Object.keys(params).forEach((key) => {
+            stringParams[key] = params[
+              key as keyof ProductQueryParameters
+            ]?.toString() as string;
+          });
+        }
+
+        return stringParams;
+      };
+
+      const getRequestLength = (path: string, params: Record<string, string>): number => {
+        return (
+          path.length +
+          Object.entries(params).reduce((acc, [key, value]) => {
+            return (
+              acc + encodeURIComponent(key).length + encodeURIComponent(value).length + 2
+            );
+          }, 0)
+        );
+      };
+
+      const allowedGetRequestLength = 2048; // Replace with the allowed GET API request length
+      const requestPath = '/products';
+      const requestParams = buildParams(params);
+
+      const requestType =
+        getRequestLength(requestPath, requestParams) < allowedGetRequestLength
+          ? RequestTypeEnum.GET
+          : RequestTypeEnum.POST;
+
+      const result =
+        requestType === RequestTypeEnum.POST
+          ? await this.httpService.post<{ data: GetProductListResponse }>(requestPath, {
+              ...params,
+            })
+          : await this.httpService.get<{ data: GetProductListResponse }>(requestPath, {
+              params: requestParams,
+            });
+
+      const response = {
+        ...result.data,
+        list: result.data.list.map(this.buildSelectableProduct),
+      };
+
+      return response;
+    } catch (err) {
+      // @ts-ignore
+      throw new Error(err.response.data.message ?? err.message);
+    }
+  };
+
+  // TODO: Remove
+  // Temporary - for testing purposes only on v2 product list connected to cosmos
+  getProductListV2 = async (
+    params?: ProductQueryParameters,
+  ): Promise<GetProductListLibraryResponse> => {
+    try {
+      const buildParams = (params?: ProductQueryParameters): Record<string, string> => {
+        const stringParams: Record<string, string> = {};
+
+        if (params) {
+          Object.keys(params).forEach((key) => {
+            stringParams[key] = params[
+              key as keyof ProductQueryParameters
+            ]?.toString() as string;
+          });
+        }
+
+        return stringParams;
+      };
+
+      const getRequestLength = (path: string, params: Record<string, string>): number => {
+        return (
+          path.length +
+          Object.entries(params).reduce((acc, [key, value]) => {
+            return (
+              acc + encodeURIComponent(key).length + encodeURIComponent(value).length + 2
+            );
+          }, 0)
+        );
+      };
+
+      const allowedGetRequestLength = 2048; // Replace with the allowed GET API request length
+      const requestPath = '/products-v2';
+      const requestParams = buildParams(params);
+
+      const requestType =
+        getRequestLength(requestPath, requestParams) < allowedGetRequestLength
+          ? RequestTypeEnum.GET
+          : RequestTypeEnum.POST;
+
+      const result =
+        requestType === RequestTypeEnum.POST
+          ? await this.httpService.post<{ data: GetProductListResponse }>(requestPath, {
+              ...params,
+            })
+          : await this.httpService.get<{ data: GetProductListResponse }>(requestPath, {
+              params: requestParams,
+            });
+
+      const response = {
+        ...result.data,
+        list: result.data.list.map(this.buildSelectableProduct),
+      };
+
+      return response;
+    } catch (err) {
+      // @ts-ignore
+      throw new Error(err.response.data.message ?? err.message);
+    }
+  };
+
+  search = async (
+    params: SearchQueryParameters,
+  ): Promise<{
+    products: SelectablePartialProduct[];
+    productTypes: Array<ProductType>;
+  }> => {
+    try {
+      const result = await this.httpService.get<{
+        data: {
+          products: Array<Partial<GridProduct>>;
+          productTypes: Array<ProductType>;
+        };
+      }>('/search', {
+        params,
+      });
+
+      const response = {
+        ...result.data,
+        products: result.data.products.map(this.buildSelectableProduct),
+      };
+
+      return response;
+    } catch (err) {
+      // @ts-ignore
+      throw new Error(err.response.data.message ?? err.message);
+    }
+  };
+
+  getProductTypesList = async (
+    params?: ProductTypesListQueryParameters,
+  ): Promise<ProductType[]> => {
+    try {
+      const result = await this.httpService.get('/product-types', {
+        params: {
+          ...params,
+          ids: params?.ids?.join(',') ?? '',
+        },
+      });
+      return result.data;
+    } catch (err) {
+      // @ts-ignore
+      throw new Error(err.response.data.message ?? err.message);
+    }
+  };
+
+  getProductTypesListWithSpaceProducts = async (
+    params: ProductTypesListWithSpaceProductsQueryParameters,
+  ): Promise<ProductType[]> => {
+    try {
+      const result = await this.httpService.get('/product-types-with-space-products', {
+        params: {
+          spaceIds: params.spaceIds.join(','),
+        },
+      });
+      return result.data;
+    } catch (err) {
+      // @ts-ignore
+      throw new Error(err.response.data.message ?? err.message);
+    }
+  };
+
+  getProductType = async (id: string): Promise<ProductType> => {
+    try {
+      const result = await this.httpService.get(`/product-types/${id}`, {});
+      return result.data;
+    } catch (err) {
+      // @ts-ignore
+      throw new Error(err.response.data.message ?? err.message);
+    }
+  };
+
+  getProductFilters = async (
+    params: ProductFiltersQueryParameters,
+  ): Promise<FilterByGroup> => {
+    try {
+      const result = await this.httpService.get(`/products-filters`, {
+        // Join by ";" to handle productTypes with ","
+        params: {
+          ...params,
+          productTypes: params.productTypes?.join(';') ?? [],
+          filterKeys: params.filterKeys?.join(';') ?? [],
+        },
+      });
+      return result.data;
+    } catch (err) {
+      // @ts-ignore
+      throw new Error(err.response.data.message ?? err.message);
+    }
+  };
+
+  getProductSortOptions = async (
+    isoLanguageId?: IsoLanguageIds,
+  ): Promise<SortOptionsResponse> => {
+    try {
+      const result = await this.httpService.get(`/product-sort-options`, {
+        params: { isoLanguageId },
+      });
+      return result.data;
+    } catch (err) {
+      // @ts-ignore
+      throw new Error(err.response.data.message ?? err.message);
+    }
+  };
+
+  getProductRecommendations = async (id: string): Promise<SelectablePartialProduct[]> => {
+    try {
+      const result = await this.httpService.get<{ data: Partial<GridProduct>[] }>(
+        `/product-recommendations/${id}`,
+        {},
+      );
+
+      const response = result.data.map(this.buildSelectableProduct);
+
+      return response;
+    } catch (err) {
+      // @ts-ignore
+      throw new Error(err.response.data.message ?? err.message);
+    }
+  };
+
+  getProductRecommendationsByProductId = async (
+    id: string,
+    params: Partial<ProductRecommendationsQueryParameters>,
+  ): Promise<ProductRecommendationLibraryResponse> => {
+    try {
+      const result = await this.httpService.get<{ data: ProductRecommendationResponse }>(
+        `/product-recommendations-by-productId/${id}`,
+        {
+          params,
+        },
+      );
+
+      const response = {
+        default: result?.data?.default?.map(this.buildSelectableProduct),
+        similar: result?.data?.similar?.map(this.buildSelectableProduct),
+        styleWith: result?.data?.styleWith?.map(this.buildSelectableProduct),
+        similarItems: result?.data?.similarItems?.map(this.buildSelectableProduct),
+        completeTheLook: result?.data?.completeTheLook?.map(this.buildSelectableProduct),
+      };
+
+      return response;
+    } catch (err) {
+      // @ts-ignore
+      throw new Error(err.response.data.message ?? err.message);
+    }
+  };
+
+  getProductRecommendationsByProductIdV2 = async (
+    id: string,
+    payload: JSONValue,
+  ): Promise<SelectablePartialProduct[]> => {
+    try {
+      const result = await this.httpService.get<{ data: Partial<GridProduct>[] }>(
+        `/products/${id}/recommendations`,
+        {
+          params: {
+            payload: JSON.stringify(payload),
+          },
+        },
+      );
+
+      const response = result.data.map(this.buildSelectableProduct);
+
+      return response;
+    } catch (err) {
+      // @ts-ignore
+      throw new Error(err.response.data.message ?? err.message);
+    }
+  };
+
+  getVariantsList = async (productIds: string[]): Promise<VariantInfo[]> => {
+    try {
+      const result = await this.httpService.get(`/variants`, {
+        params: {
+          productIds: productIds.join(','),
+        },
+      });
+      return result.data;
+    } catch (err) {
+      // @ts-ignore
+      throw new Error(err.response.data.message ?? err.message);
+    }
+  };
+
+  getVariantsListByIds = async (productIds: string[]): Promise<VariantInfo[]> => {
+    try {
+      const result = await this.httpService.get(`/variants`, {
+        baseURL: `${this.apiEndpoint}/tenants/${this.tenantId}`,
+        params: {
+          productIds: productIds.join(','),
+        },
+      });
+      return result.data;
+    } catch (err) {
+      // @ts-ignore
+      throw new Error(err.response.data.message ?? err.message);
+    }
+  };
+
+  getVariantDetails = async (productId: string): Promise<VariantInfo> => {
+    try {
+      const result = await this.httpService.get(`/variants/${productId}`, {});
+      return result.data;
+    } catch (err) {
+      // @ts-ignore
+      throw new Error(err.response.data.message ?? err.message);
+    }
+  };
+
+  getProductEanByEpc = async (epc: string): Promise<string> => {
+    try {
+      const result = await this.httpService.get(`/product-ean-by-epc/${epc}`, {});
+      return result.data;
+    } catch (err) {
+      // @ts-ignore
+      throw new Error(err.response.data.message ?? err.message);
+    }
+  };
+
+  getProductByEpc = async (
+    code: string,
+    params: ProductDetailsByCodeQueryParameters,
+  ): Promise<{
+    productDetails: SelectablePartialProduct;
+    productId: string;
+  }> => {
+    try {
+      const result = await this.httpService.get<{
+        data: {
+          productDetails: Partial<GridProduct>;
+          productId: string;
+        };
+      }>(`/products-by-epc/${code}`, {
+        params,
+      });
+
+      const response = {
+        ...result.data,
+        productDetails: this.buildSelectableProduct(result.data.productDetails),
+      };
+
+      return response;
+    } catch (err) {
+      // @ts-ignore
+      throw new Error(err.response.data.message ?? err.message);
+    }
+  };
+
+  getProductInventory = async ({
+    deviceId,
+    requestedQty,
+    skuId,
+  }: {
+    deviceId?: string;
+    requestedQty: number;
+    skuId: string;
+  }): Promise<InventoryItem | null> => {
+    try {
+      const result = await this.httpService.get<{ data: InventoryItem | null }>(
+        `/products-inventory`,
+        {
+          params: { deviceId, requestedQty, skuId },
+        },
+      );
+      return result.data;
+    } catch (err) {
+      // @ts-ignore
+      throw new Error(err.response.data.message ?? err.message);
+    }
+  };
+
+  getVariantInventory = async ({
+    productId,
+    spaceId,
+  }: {
+    productId: string;
+    spaceId?: string;
+  }): Promise<VariantInventory> => {
+    try {
+      const result = await this.httpService.get<{ data: VariantInventory }>(
+        `/variants/${productId}/inventory`,
+        {
+          params: { spaceId },
+        },
+      );
+      return result.data;
+    } catch (err) {
+      // @ts-ignore
+      throw new Error(err.response.data.message ?? err.message);
+    }
+  };
+
+  getProductGroupStoresInventory = async (
+    params: ProductGroupStoresInventoryParam,
+  ): Promise<ProductGroupStoresInventoryResponse | null> => {
+    try {
+      const result = await this.httpService.get<{
+        data: ProductGroupStoresInventoryResponse | null;
+      }>(`/product-group-stores-inventory`, {
+        params,
+      });
+      return result.data;
+    } catch (err) {
+      // @ts-ignore
+      throw new Error(err.response.data.message ?? err.message);
+    }
+  };
+
+  getCartPromotions = async (
+    params: GetCartPromotionsParams,
+  ): Promise<GetCartPromotionsResponse | null> => {
+    try {
+      const { transactionTotal, items } = params;
+
+      const result = await this.httpService.get<{
+        data: GetCartPromotionsResponse | null;
+      }>(`/cart/promotions`, {
+        params: {
+          ...params,
+          transactionTotal: transactionTotal.toFixed(2),
+          items: JSON.stringify(
+            items.map((item) => ({
+              ...item,
+              sequenceId: item.sequenceId.toString(),
+              price: item.price.toFixed(2),
+              quantity: item.quantity.toString(),
+            })),
+          ),
+        },
+      });
+
+      return result.data;
+    } catch (err) {
+      // @ts-ignore
+      throw new Error(err.response.data.message ?? err.message);
+    }
+  };
+
+  getVariantActivePrice = async (
+    params: GetVariantActivePriceParams,
+  ): Promise<GetVariantActivePriceResponse | null> => {
+    try {
+      const result = await this.httpService.get(
+        `/variant-active-price/${params.productId}`,
+        {
+          params,
+        },
+      );
+      return result.data;
+    } catch (err) {
+      // @ts-ignore
+      throw new Error(err.response.data.message ?? err.message);
+    }
+  };
+}
+
+export default GridProductServiceClient;