@phystack/products 4.3.40-dev

package/dist/services/grid-product-service-interface.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/services/http-service.d.ts

@@ -0,0 +1,14 @@
+import { AxiosRequestConfig } from 'axios';
+type Options = {
+    baseUrl?: string;
+    accessToken?: string;
+};
+declare class HttpService {
+    private readonly client;
+    constructor({ baseUrl, accessToken }: Options);
+    get: <T = any>(path: string, config: AxiosRequestConfig) => Promise<T>;
+    post: <T = any>(path: string, data?: any, config?: AxiosRequestConfig) => Promise<T>;
+    patch: <T = any>(path: string, data?: any, config?: AxiosRequestConfig) => Promise<T>;
+    delete: <T = any>(path: string, config?: AxiosRequestConfig) => Promise<T>;
+}
+export default HttpService;

package/dist/services/http-service.js

@@ -0,0 +1,44 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const axios_1 = __importDefault(require("axios"));
+class HttpService {
+    constructor({ baseUrl, accessToken }) {
+        this.get = (path, config) => __awaiter(this, void 0, void 0, function* () {
+            const { data } = yield this.client.get(path, config);
+            return data;
+        });
+        this.post = (path, data, config) => __awaiter(this, void 0, void 0, function* () {
+            const response = yield this.client.post(path, data, config);
+            return response.data;
+        });
+        this.patch = (path, data, config) => __awaiter(this, void 0, void 0, function* () {
+            const response = yield this.client.patch(path, data, config);
+            return response.data;
+        });
+        this.delete = (path, config) => __awaiter(this, void 0, void 0, function* () {
+            const response = yield this.client.delete(path, config);
+            return response.data;
+        });
+        this.client = axios_1.default.create({
+            baseURL: baseUrl !== null && baseUrl !== void 0 ? baseUrl : '',
+            headers: accessToken
+                ? {
+                    'x-api-key': accessToken,
+                }
+                : {},
+        });
+    }
+}
+exports.default = HttpService;

package/dist/types/grid-product.d.ts

@@ -0,0 +1,458 @@
+import { IsoLanguageIds } from './iso-language-ids';
+export declare 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 declare enum PriceListTypeEnum {
+    Standard = "Standard",
+    Promotional = "Promotional",
+    StandardConditional = "StandardConditional"
+}
+export declare enum ProductStatusEnum {
+    Active = "Active",
+    Inactive = "Inactive",
+    Discontinued = "Discontinued",
+    Dormant = "Dormant",
+    Frozen = "Frozen",
+    Replaced = "Replaced",
+    Obsolete = "Obsolete",
+    Abandoned = "Abandoned",
+    Blocked = "Blocked"
+}
+export declare enum ProductRelationshipTypes {
+    Recommended = "Recommended",
+    StyleWith = "StyleWith",
+    Similar = "Similar"
+}
+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;
+}
+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;
+};
+export type GridProduct = {
+    productGroupId: string;
+    tenantId?: string;
+    tenantIndex?: string;
+    spaceIds: 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[];
+    isDeleted?: boolean;
+    variantsGroupId?: string;
+    customProperties?: CustomProperties[];
+    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;
+    tenantId: string;
+    environment: string;
+    tenantIndex: string;
+    productId: string;
+    productGroupId: string;
+    productFeatureType: string;
+    productFeatureValue: string;
+    isoLanguageId: IsoLanguageIds;
+    productType: string[];
+    spaceId?: string;
+};
+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;
+    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[];
+};
+export {};

package/dist/types/grid-product.js

@@ -0,0 +1,38 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ProductRelationshipTypes = exports.ProductStatusEnum = exports.PriceListTypeEnum = exports.DataResidencyEnum = void 0;
+var DataResidencyEnum;
+(function (DataResidencyEnum) {
+    DataResidencyEnum["EU"] = "EU";
+    DataResidencyEnum["US"] = "US";
+    DataResidencyEnum["UAE"] = "UAE";
+    DataResidencyEnum["AU"] = "AU";
+    DataResidencyEnum["IN"] = "IN";
+    DataResidencyEnum["QA"] = "QA";
+    DataResidencyEnum["DEV"] = "DEV";
+})(DataResidencyEnum || (exports.DataResidencyEnum = DataResidencyEnum = {}));
+var PriceListTypeEnum;
+(function (PriceListTypeEnum) {
+    PriceListTypeEnum["Standard"] = "Standard";
+    PriceListTypeEnum["Promotional"] = "Promotional";
+    PriceListTypeEnum["StandardConditional"] = "StandardConditional";
+})(PriceListTypeEnum || (exports.PriceListTypeEnum = PriceListTypeEnum = {}));
+var ProductStatusEnum;
+(function (ProductStatusEnum) {
+    ProductStatusEnum["Active"] = "Active";
+    ProductStatusEnum["Inactive"] = "Inactive";
+    ProductStatusEnum["Discontinued"] = "Discontinued";
+    ProductStatusEnum["Dormant"] = "Dormant";
+    ProductStatusEnum["Frozen"] = "Frozen";
+    ProductStatusEnum["Replaced"] = "Replaced";
+    ProductStatusEnum["Obsolete"] = "Obsolete";
+    ProductStatusEnum["Abandoned"] = "Abandoned";
+    ProductStatusEnum["Blocked"] = "Blocked";
+})(ProductStatusEnum || (exports.ProductStatusEnum = ProductStatusEnum = {}));
+var ProductRelationshipTypes;
+(function (ProductRelationshipTypes) {
+    ProductRelationshipTypes["Recommended"] = "Recommended";
+    ProductRelationshipTypes["StyleWith"] = "StyleWith";
+    ProductRelationshipTypes["Similar"] = "Similar";
+    // Other ProductRelationshipType to support in future
+})(ProductRelationshipTypes || (exports.ProductRelationshipTypes = ProductRelationshipTypes = {}));