@phystack/products 4.3.40-dev

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

@@ -0,0 +1,105 @@
+import HttpService from './http-service';
+import {
+  ProductDetailsByCodeQueryParameters,
+  ProductDetailsQueryParameters,
+  ProductFiltersQueryParameters,
+  ProductGroupStoresInventoryParam,
+  ProductGroupStoresInventoryResponse,
+  ProductQueryParameters,
+  ProductRecommendationsQueryParameters,
+  ProductTypesListQueryParameters,
+  RequestTypeEnum,
+  SearchQueryParameters,
+} from '../types/parameters';
+import {
+  FacetsType,
+  FilterByGroup,
+  FilterByLanguage,
+  GetCartPromotionsParams,
+  GetCartPromotionsResponse,
+  GetVariantActivePriceParams,
+  GetVariantActivePriceResponse,
+  GridProduct,
+  InventoryItem,
+  ProductRecommendationResponse,
+  ProductType,
+  SortOptionsResponse,
+  VariantInfo,
+  VariantInventory,
+} from '../types/grid-product';
+import { IsoLanguageIds } from '../types/iso-language-ids';
+
+interface GridProductServiceInterface {
+  readonly httpService: HttpService;
+  locale: IsoLanguageIds | '*';
+  getProductById: (
+    id: string,
+    params: ProductDetailsQueryParameters,
+  ) => Promise<Partial<GridProduct>>;
+  getProductByBarcode: (
+    code: string,
+    params: ProductDetailsByCodeQueryParameters,
+  ) => Promise<{
+    productDetails: Partial<GridProduct>;
+    productId: string;
+  }>;
+  getProductList: (
+    params?: ProductQueryParameters,
+    requestType?: RequestTypeEnum,
+  ) => Promise<{
+    list: Partial<GridProduct>[];
+    attributeFilters: FilterByLanguage;
+  }>;
+  search: (params: SearchQueryParameters) => Promise<{
+    products: Array<Partial<GridProduct>>;
+    productTypes: Array<ProductType>;
+  }>;
+  getProductTypesList: (
+    params?: ProductTypesListQueryParameters,
+  ) => Promise<ProductType[]>;
+  getProductType: (id: string) => Promise<ProductType>;
+  getProductFilters: (params: ProductFiltersQueryParameters) => Promise<FilterByGroup>;
+  getProductSortOptions: (isoLanguageId?: IsoLanguageIds) => Promise<SortOptionsResponse>;
+  getProductRecommendations: (id: string) => Promise<Partial<GridProduct>[]>;
+  getProductRecommendationsByProductId: (
+    id: string,
+    params: Partial<ProductRecommendationsQueryParameters>,
+  ) => Promise<ProductRecommendationResponse>;
+  getVariantsList: (productIds: string[]) => Promise<VariantInfo[]>;
+  getVariantDetails: (productId: string) => Promise<VariantInfo>;
+  getProductEanByEpc: (epc: string) => Promise<string>;
+  getProductByEpc: (
+    code: string,
+    params: ProductDetailsByCodeQueryParameters,
+  ) => Promise<{
+    productDetails: Partial<GridProduct>;
+    productId: string;
+  }>;
+  getProductInventory: ({
+    deviceId,
+    requestedQty,
+    skuId,
+  }: {
+    deviceId?: string;
+    requestedQty: number;
+    skuId: string;
+  }) => Promise<InventoryItem | null>;
+  getVariantInventory: ({
+    productId,
+    spaceId,
+  }: {
+    productId: string;
+    spaceId?: string;
+  }) => Promise<VariantInventory>;
+  getProductGroupStoresInventory: (
+    params: ProductGroupStoresInventoryParam,
+  ) => Promise<ProductGroupStoresInventoryResponse | null>;
+  getCartPromotions: (
+    params: GetCartPromotionsParams,
+  ) => Promise<GetCartPromotionsResponse | null>;
+  getVariantActivePrice: (
+    params: GetVariantActivePriceParams,
+  ) => Promise<GetVariantActivePriceResponse | null>;
+}
+
+export default GridProductServiceInterface;

package/src/services/http-service.ts

@@ -0,0 +1,50 @@
+import axios, { AxiosInstance, AxiosRequestConfig } from 'axios';
+
+type Options = {
+  baseUrl?: string;
+  accessToken?: string;
+};
+class HttpService {
+  private readonly client: AxiosInstance;
+
+  constructor({ baseUrl, accessToken }: Options) {
+    this.client = axios.create({
+      baseURL: baseUrl ?? '',
+      headers: accessToken
+        ? {
+            'x-api-key': accessToken,
+          }
+        : {},
+    });
+  }
+
+  get = async <T = any>(path: string, config: AxiosRequestConfig): Promise<T> => {
+    const { data } = await this.client.get<T>(path, config);
+    return data;
+  };
+
+  post = async <T = any>(
+    path: string,
+    data?: any,
+    config?: AxiosRequestConfig,
+  ): Promise<T> => {
+    const response = await this.client.post<T>(path, data, config);
+    return response.data;
+  };
+
+  patch = async <T = any>(
+    path: string,
+    data?: any,
+    config?: AxiosRequestConfig,
+  ): Promise<T> => {
+    const response = await this.client.patch<T>(path, data, config);
+    return response.data;
+  };
+
+  delete = async <T = any>(path: string, config?: AxiosRequestConfig): Promise<T> => {
+    const response = await this.client.delete<T>(path, config);
+    return response.data;
+  };
+}
+
+export default HttpService;

package/src/types/grid-product.ts

@@ -0,0 +1,548 @@
+import { IsoLanguageIds } from './iso-language-ids';
+
+export enum DataResidencyEnum {
+  'EU' = "EU",
+  'US' = "US",
+  'UAE' = "UAE",
+  'AU' = "AU",
+  'IN' = "IN",
+  'QA' = "QA",
+  'DEV' = "DEV"
+}
+
+export type FacetsType =
+  | {
+      [propertyName: string]: {
+        [property: string]: any;
+        readonly count?: number;
+      };
+    }
+  | undefined;
+
+export type FilterByLanguage = {
+  [key: string]: {
+    [language: string]: string[];
+  };
+};
+
+export type FilterByGroup = {
+  [key: string]: {
+    [group: string]:
+      | string[]
+      | {
+          min: number;
+          max: number;
+          isoCurrencyCode: string;
+        };
+  };
+};
+
+export type SortOptionsResponse = {
+  sortOptions: {
+    [isoLanguageId: string]: string[];
+  };
+  sortOptionsEnum: {
+    [isoLanguageId: string]: string[];
+  };
+};
+
+export enum PriceListTypeEnum {
+  Standard = 'Standard',
+  Promotional = 'Promotional',
+  StandardConditional = 'StandardConditional',
+}
+
+export enum ProductStatusEnum {
+  Active = 'Active',
+  Inactive = 'Inactive',
+  Discontinued = 'Discontinued',
+  Dormant = 'Dormant',
+  Frozen = 'Frozen',
+  Replaced = 'Replaced',
+  Obsolete = 'Obsolete',
+  Abandoned = 'Abandoned',
+  Blocked = 'Blocked',
+}
+
+export enum ProductRelationshipTypes {
+  Recommended = 'Recommended',
+  StyleWith = 'StyleWith',
+  Similar = 'Similar',
+  // Other ProductRelationshipType to support in future
+}
+
+export interface ProductShortDescription {
+  isoLanguageId: IsoLanguageIds;
+  productShortDescription: string;
+}
+
+export interface ProductInternalName {
+  isoLanguageId: IsoLanguageIds;
+  productInternalName: string;
+}
+
+export interface ProductStorageInstructions {
+  isoLanguageId: IsoLanguageIds;
+  storageInstructions: string;
+}
+
+export interface ProductConsumerStorageInstruction {
+  isoLanguageId: IsoLanguageIds;
+  consumerStorageInstruction: string;
+}
+
+export interface ProductShippingInstruction {
+  isoLanguageId: IsoLanguageIds;
+  productShippingInstruction: string;
+}
+
+export interface ProductName {
+  isoLanguageId: IsoLanguageIds;
+  productName: string;
+}
+
+export interface ProductDescription {
+  isoLanguageId: IsoLanguageIds;
+  productDescription: string;
+}
+
+export interface RelatedProductGroup {
+  relatedProductGroupId: string;
+  productRelationshipType: ProductRelationshipTypes;
+}
+
+export interface VariantProductName {
+  isoLanguageId: IsoLanguageIds;
+  productName: string;
+}
+
+export interface Variant {
+  productId: string;
+  productGroupId: string;
+  globalTradeItemNumber?: string[];
+  gtinName?: string[];
+  europeanArticleNumber?: string[];
+  universalProductCode?: string[];
+  productName?: VariantProductName[];
+  periodStartDate?: string;
+  periodEndDate?: string;
+  color?: string;
+  colorImageUrl?: string;
+  colorRgb?: string;
+  style?: string;
+  size?: string;
+  productLink?: string;
+}
+
+export interface ProductBrand {
+  isoLanguageId: IsoLanguageIds;
+  brandName: string;
+  brandDescription?: string;
+  brandMark?: string;
+  brandTrademark?: string;
+  brandLogo?: string; // URL
+}
+
+export interface ProductStatus {
+  productStatus: ProductStatusEnum;
+  spaceId: string;
+  isoLanguageId?: IsoLanguageIds;
+  periodStartDate?: string;
+  periodEndDate?: string;
+  productStatusNote?: string;
+}
+
+export interface ProductFeature {
+  productId: string;
+  isoLanguageId: IsoLanguageIds;
+  productFeatureType: string;
+  productFeatureValue: string;
+}
+
+export interface ProductPriceList {
+  productId: string;
+  spaceId: string;
+  priceListType: PriceListTypeEnum;
+  isoLanguageId?: IsoLanguageIds;
+  pricingUomId?: string;
+  periodStartTimestamp?: string;
+  periodEndTimestamp?: string;
+  isoCurrencyCode: string;
+  suggestedRetailPrice?: number;
+  listPrice: number;
+}
+
+export interface CatalogPageLocationProduct {
+  productId: string;
+  productGroupId: string;
+  catalogType: string;
+  catalogPage?: string;
+  catalogPageLocation?: string;
+  catalogPageLocationProduct: string;
+  defaultImage?: boolean;
+}
+
+export interface ProductLabel {
+  isoLanguageId: IsoLanguageIds;
+  spaceId: string;
+  productLabel: string;
+}
+
+export interface ProductItemQuantity {
+  productId: string;
+  spaceId: string;
+  productItemQuantityStartDate?: string;
+  productItemQuantityEndDate?: string;
+  productItemQuantity: number;
+}
+
+export interface ProductVendor {
+  vendorId: string;
+  productVendor: string;
+  periodStartDate?: string;
+  periodEndDate?: string;
+}
+
+export type ProductTags = {
+  isoLanguageId: IsoLanguageIds;
+  productTags: string[];
+};
+
+export type CustomProperties = {
+  key: string;
+  spaceId: string;
+  value: string;
+  productId?: string;
+};
+
+// ❌ - property has not been used yet anywhere
+// ✅ - selector implemented
+
+export type GridProduct = {
+  productGroupId: string;
+  tenantId?: string; // Pre-filled during push. tenantId from console
+  tenantIndex?: string; // Pre-filled during push. Formatted to {tenant-id}_{data_residency}
+  spaceIds: string[];
+  productShortDescription?: ProductShortDescription[]; // selector: ✅, result - single
+  productInternalName?: ProductInternalName[]; // selector: ❌, result - single
+  introductionDate?: string;
+  plannedAbandonmentDate?: string;
+  storageInstructions?: ProductStorageInstructions[]; // selector ❌, result - unknown
+  shellLifeDays?: number;
+  consumerStorageInstruction?: ProductConsumerStorageInstruction[]; // selector ❌, result - unknown
+  productShippingInstruction?: ProductShippingInstruction[]; // selector ❌, result - unknown
+  productName: ProductName[]; // selector ✅, result - single
+  productDescription: ProductDescription[]; // selector ✅, result - single
+  relatedProductGroups?: RelatedProductGroup[]; // selector ❌, result - unknown
+  variants: Variant[]; // selector ✅, result - multiple
+  brand?: ProductBrand[]; // selector ✅, result - single (brandName)
+  productStatus: ProductStatus[]; // selector ❌, result - single
+  productFeature?: ProductFeature[]; // selector ✅, result - multiple,
+  productPriceList: ProductPriceList[]; // selector: ✅, result - multiple
+  catalogPageLocationProduct: CatalogPageLocationProduct[]; // selector ✅, result - multiple (catalogPageLocationProduct)
+  productType: Array<string>; //productTypeId value in ProductTypes DB and supports multiple ProductType
+  productLabel?: ProductLabel[]; // selector: ✅, result - multiple
+  productTags?: ProductTags[]; // selector ❌, result - multiple
+  productItemQuantity?: ProductItemQuantity[]; // selector ✅, result - single (productItemQuantity)
+  productVendor?: ProductVendor[]; // selector ❌, result - unknown
+  isDeleted?: boolean;
+  variantsGroupId?: string; //used as option to group together variants from different products
+  customProperties?: CustomProperties[]; // selector ❌, result - unknown
+
+  // Sort keys
+  sortName?: string;
+  sortPrice?: number;
+  sortQuantity?: number;
+  ranking?: number;
+};
+
+interface Price {
+  amount: number;
+  currencyCode: string;
+}
+
+export interface BaseSelectorProps {
+  locale?: IsoLanguageIds | '*';
+}
+
+export type SingleLocalizedResult<
+  T extends BaseSelectorProps,
+  U,
+  V,
+> = T['locale'] extends '*' ? U[] : V;
+
+interface FilterProps<T> {
+  filter?: (item: T) => boolean;
+}
+
+export interface GetProductLabelProps
+  extends BaseSelectorProps,
+    FilterProps<ProductLabel> {}
+
+export interface GetProductLabelBySpaceProps extends BaseSelectorProps {
+  spaceId: string;
+}
+
+export interface GetProductPriceListProps extends FilterProps<ProductPriceList> {}
+
+export interface GetProductPriceProps {
+  spaceId: string;
+}
+
+export interface GetVariantPriceProps {
+  variantId: string;
+  spaceId: string;
+}
+
+export interface GetProductItemQuantityProps extends FilterProps<ProductItemQuantity> {}
+
+export interface GetProductQuantityProps {
+  variantId: string;
+  spaceId?: string;
+}
+
+export interface GetCatalogPageLocationProductProps
+  extends FilterProps<CatalogPageLocationProduct> {}
+
+export interface GetProductFeatureProps
+  extends BaseSelectorProps,
+    FilterProps<ProductFeature> {}
+
+export interface GetVariantFeatureProps extends BaseSelectorProps {
+  productId: string;
+}
+
+export interface GetProductVariantsProps extends FilterProps<Variant> {}
+
+export interface GetProductVariantsByProductIdProps {
+  productId: string;
+}
+
+export interface GetVariantImagesProps {
+  variantId: string;
+}
+
+export interface GridProductSelectors {
+  getShortDescription: <T extends BaseSelectorProps>(
+    input?: T,
+  ) => SingleLocalizedResult<T, ProductShortDescription, string>;
+  getLabel: (input?: GetProductLabelProps) => ProductLabel['productLabel'][];
+  getLabelBySpace: (input: GetProductLabelBySpaceProps) => ProductLabel['productLabel'][];
+  getPriceList: (input?: GetProductPriceListProps) => ProductPriceList[];
+  getStandardPrice: (input: GetProductPriceProps) => Price | undefined;
+  getPromotionalPrice: (input: GetProductPriceProps) => Price | undefined;
+  getName: <T extends BaseSelectorProps>(
+    input?: T,
+  ) => SingleLocalizedResult<T, ProductName, string>;
+  getDescription: <T extends BaseSelectorProps>(
+    input?: T,
+  ) => SingleLocalizedResult<T, ProductDescription, string>;
+  getBrandName: <T extends BaseSelectorProps>(
+    input?: T,
+  ) => SingleLocalizedResult<T, ProductBrand, string>;
+  getItemQuantity: (input?: GetProductItemQuantityProps) => ProductItemQuantity[];
+  getVariantQuantity: (input: GetProductQuantityProps) => number;
+  getCatalogPageLocationProduct: (
+    input?: GetCatalogPageLocationProductProps,
+  ) => CatalogPageLocationProduct[];
+  getImages: () => string[];
+  getImage: () => string;
+  getFeature: (input?: GetProductFeatureProps) => ProductFeature[];
+  getVariants: (input?: GetProductVariantsProps) => Variant[];
+  getFirstVariant: () => Variant;
+  getVariantsByProductId: (input: GetProductVariantsByProductIdProps) => Variant[];
+  getVariantImages: (input: GetVariantImagesProps) => string[];
+  getVariantStandardPrice: (input: GetVariantPriceProps) => Price | undefined;
+  getVariantPromotionalPrice: (input: GetVariantPriceProps) => Price | undefined;
+  getVariantFeature: (input: GetVariantFeatureProps) => ProductFeature[];
+}
+
+export type SelectablePartialProduct = GridProductSelectors & Partial<GridProduct>;
+
+export interface CategoryResult {
+  id: string;
+  title: string;
+  parent: string;
+  isoLanguageId: IsoLanguageIds;
+}
+
+export interface ProductTypeTitle {
+  isoLanguageId: IsoLanguageIds;
+  label: string;
+  path?: string;
+}
+
+export type ProductType = {
+  isRoot: boolean;
+  parentId: string;
+  productTypeId: string;
+  title: ProductTypeTitle[];
+};
+
+export type ProductFeatureModel = {
+  id: string;
+  partitionKey: string; // price or feature
+  tenantId: string;
+  environment: string;
+  tenantIndex: string;
+  productId: string;
+  productGroupId: string;
+  productFeatureType: string;
+  productFeatureValue: string;
+  isoLanguageId: IsoLanguageIds;
+  productType: string[];
+  spaceId?: string; // Used for Price filters
+};
+
+export type ProductRecommendationResponse = {
+  default: Partial<GridProduct>[];
+  similar: Partial<GridProduct>[];
+  styleWith: Partial<GridProduct>[];
+  similarItems: Partial<GridProduct>[];
+  completeTheLook: Partial<GridProduct>[];
+};
+
+export interface ProductRecommendationLibraryResponse
+  extends ProductRecommendationResponse {
+  default: SelectablePartialProduct[];
+  similar: SelectablePartialProduct[];
+  styleWith: SelectablePartialProduct[];
+  similarItems: SelectablePartialProduct[];
+  completeTheLook: SelectablePartialProduct[];
+}
+
+export type VariantInfo = Variant & {
+  spaceIds: string[];
+  productName: ProductName[];
+  productDescription: ProductDescription[];
+  catalogPageLocationProduct: CatalogPageLocationProduct[];
+  productLabel: ProductLabel[];
+  productPriceList: ProductPriceList[];
+  productItemQuantity: ProductItemQuantity[];
+};
+
+export interface InventoryItem {
+  requestedQty: number;
+  skuId: string;
+  productId: string;
+  name: string;
+  brandDesc: string;
+  category: string;
+  color: string;
+  styleCode: string;
+  size: string;
+  imageUrl: string | null;
+  zones: InventoryZone[];
+}
+
+export interface VariantInventory {
+  productItemQuantity: ProductItemQuantity[];
+}
+
+export interface InventoryZone {
+  zoneId: string;
+  availableQty: number;
+  zoneName: string;
+  zoneType: string;
+}
+
+export interface CartItem {
+  sequenceId: number;
+  productId: string;
+  barcode: string;
+  price: number;
+  quantity: number;
+}
+
+export interface GetCartPromotionsParams {
+  storeId: string;
+  transactionId: string;
+  transactionTotal: number;
+  dateTime: string;
+  items: CartItem[];
+  posId?: string;
+}
+
+export interface CartItemPromotionList {
+  promoId: string;
+  promoAmount: number;
+  promoDescription: string;
+}
+
+export interface CartItemPromotion {
+  productId: string;
+  originalPrice: number;
+  discountValue: number;
+  newPrice: number;
+  promoList: CartItemPromotionList[];
+}
+
+export interface GetCartPromotionsResponse {
+  totalPrice: number;
+  items: CartItemPromotion[];
+}
+
+export interface UploadExcelDataResponse {
+  message: string;
+  isError: boolean;
+  count: {
+    productGroups: number;
+    products: number;
+    productTypes: number;
+  } | null;
+}
+
+export interface GetVariantActivePriceParams {
+  spaceId: string;
+  storeId: string;
+  productId: string;
+  dateTime?: string;
+  posId?: string;
+}
+
+export interface GetVariantActivePriceResponse {
+  productId: string;
+  productGroupId: string;
+  spaceId: string;
+  price: ProductPriceList;
+}
+
+export type VariantUpdateFields = Variant & {
+  productGroupId?: string; // convert productGroupId as optional
+  productPriceList?: ProductPriceList[];
+  productFeature?: ProductFeature[];
+  productItemQuantity?: ProductItemQuantity[];
+};
+
+export interface UpdateVariantsParams {
+  data: (Partial<VariantUpdateFields> & { productId: string })[];
+  upsertSpaceIds: boolean;
+}
+
+export type GridProductPushPayload = {
+  productGroupId: string;
+  productShortDescription?: ProductShortDescription[];
+  productInternalName?: ProductInternalName[];
+  introductionDate?: string;
+  plannedAbandonmentDate?: string;
+  storageInstructions?: ProductStorageInstructions[];
+  shellLifeDays?: number;
+  consumerStorageInstruction?: ProductConsumerStorageInstruction[];
+  productShippingInstruction?: ProductShippingInstruction[];
+  productName?: ProductName[];
+  productDescription?: ProductDescription[];
+  relatedProductGroups?: RelatedProductGroup[];
+  variants?: Variant[];
+  brand?: ProductBrand[];
+  productStatus?: ProductStatus[];
+  productFeature?: ProductFeature[];
+  productPriceList?: ProductPriceList[];
+  catalogPageLocationProduct?: CatalogPageLocationProduct[];
+  productType?: Array<string>;
+  productLabel?: ProductLabel[];
+  productTags?: ProductTags[];
+  productItemQuantity?: ProductItemQuantity[];
+  productVendor?: ProductVendor[];
+  variantsGroupId?: string;
+  customProperties?: CustomProperties[];
+};