@mframework/layer-commerce 0.0.3

package/app/utils/Product/Product.type.ts

@@ -0,0 +1,260 @@
+/**
+ * M Framework - Flexible backend agnostic framework.
+ *
+ * Copyright © Meeovi, LTD. All rights reserved.
+ * See LICENSE for license details.
+ *
+ * @license OSL-3.0 (Open Software License ("OSL") v. 3.0)
+ * @package mframework/mframework-theme
+ * @link https://github.com/meeovi/mframework
+ */
+
+import { ImageType } from 'Component/ProductGallery/ProductGallery.config';
+import {
+    AttributeWithValue,
+    AttributeWithValueOption,
+    BundleItem,
+    BundleOption,
+    ConfigurableProductOptions,
+    CustomizableFieldValue,
+    CustomizableFileValue,
+    CustomizableProductFragmentOptions,
+    CustomizableSelectionValue,
+    GroupedProductItem,
+    PriceRange, ProductItem,
+    ProductReview,
+    ProductStockItem,
+    RatingsBreakdown,
+    SwatchData,
+} from '../../normalizers/ProductList.type';
+import { Product as DomainProduct } from '../../types/domain';
+import { WishlistProduct } from '../../stores/Wishlist/Wishlist.type';
+import { Merge } from '../../types/Common.type';
+import { GQLCurrencyEnum, GQLProductStockStatus } from '../../types/Graphql.type';
+import { DateRangeAttribute, YearRangeAttribute } from '../../utils/Form/Form.type';
+
+export enum QtyFields {
+    SALABLE_QTY = 'salable_qty',
+    MIN_SALE_QTY = 'min_sale_qty',
+    MAX_SALE_QTY = 'max_sale_qty',
+}
+
+export const DEFAULT_MIN_PRODUCTS = 1;
+
+export const DEFAULT_MAX_PRODUCTS = 999;
+
+export type IndexedConfigurableOption = Merge<
+Merge<ConfigurableProductOptions, IndexedAttributeWithValue>,
+{
+    attribute_values: string[];
+}
+>;
+
+export type IndexedConfigurableOptions = Record<string, IndexedConfigurableOption>;
+
+export type IndexedVariant = Merge<ProductItem | DomainProduct, {
+    attributes: Record<string, IndexedAttributeWithValue>;
+}>;
+
+export type CleanCustomizableProductFragmentOptions = Omit<
+CustomizableProductFragmentOptions,
+'CustomizableAreaOption' | 'CustomizableCheckboxOption' | 'CustomizableDateOption' | 'CustomizableDropDownOption'
+| 'CustomizableFieldOption' | 'CustomizableFileOption' | 'CustomizableMultipleOption' | 'CustomizableRadioOption'
+| 'checkboxValues' | 'dropdownValues' | 'fieldValues' | 'areaValues' | 'fileValues'
+>;
+
+export type IndexedCustomOptionValue = CustomizableSelectionValue
+| CustomizableFieldValue
+| CustomizableFileValue;
+
+export type IndexedCustomOption = Merge<
+CleanCustomizableProductFragmentOptions,
+{
+    value: IndexedCustomOptionValue[] | CleanCustomizableProductFragmentOptions;
+}
+>;
+
+export interface ReviewSummary {
+    rating_summary: number;
+    review_count: number;
+}
+
+export type IndexedBaseProduct<T> = Merge<T, {
+    configurable_options?: IndexedConfigurableOptions;
+    variants?: IndexedVariant[];
+    options?: IndexedCustomOption[];
+    attributes?: Record<string, IndexedAttributeWithValue>;
+    reviews?: IndexedReview[];
+    review_summary?: ReviewSummary;
+    items?: IndexedBundleItem[] | GroupedProductItem[];
+    // !FIXME: This prop is alway undefined. Added for compatibility with the legacy code.
+    productOptionsData?: Record<string, string | string[]>;
+}>;
+
+export type IndexedProduct = IndexedBaseProduct<Partial<ProductItem | DomainProduct>> & {
+    parent?: IndexedBaseProduct<Partial<ProductItem>>;
+};
+
+export type IndexedWishlistProduct = IndexedBaseProduct<Partial<WishlistProduct>>;
+
+export type IndexedBundleOption = Merge<BundleOption, {
+    regularOptionPrice: number;
+    regularOptionPriceExclTax: number;
+    finalOptionPrice: number;
+    finalOptionPriceExclTax: number;
+}>;
+
+export type IndexedBundleItem = Merge<BundleItem, {
+    options?: IndexedBundleOption[];
+}>;
+
+export type IndexedAttributeWithValue = Merge<AttributeWithValue, {
+    attribute_options: Record<string, IndexedAttributeWithValueOption>;
+}>;
+
+export type IndexedAttributeWithValueOption = Merge<AttributeWithValueOption, {
+    swatch_data: SwatchData | null;
+}>;
+
+export type IndexedReview = Merge<ProductReview, {
+    rating_votes: RatingVote[];
+}>;
+
+export interface BuyRequestBundleOptions {
+    bundle_option: Record<string, string | Record<string, string>>;
+    bundle_option_qty: Record<string, number>;
+}
+
+export interface BuyRequestCustomizableOptions {
+    options: Record<string, string | string[] | Record<string, string>>;
+}
+
+export interface BuyRequestDownloadableOptions {
+    links: string[];
+}
+
+export interface BuyRequestConfigurableOptions {
+    super_attribute: Record<string, string>;
+}
+
+export interface PriceLabels {
+    baseLabel?: string;
+    priceLabel: string;
+}
+
+export interface ProductTransformData {
+    sku: string;
+    quantity: number;
+    selected_options: string[];
+    entered_options: ProductOption[];
+}
+
+export interface FormattedMoney {
+    value: number;
+    currency: GQLCurrencyEnum;
+    valueFormatted: string;
+}
+
+export interface ProductExtractBasePrice {
+    finalPrice: FormattedMoney;
+    finalPriceExclTax: FormattedMoney;
+    originalPrice: FormattedMoney;
+    originalPriceExclTax: FormattedMoney;
+    discount: { percentOff: number };
+}
+
+export interface ProductExtractOriginalPrice {
+    minRegularPrice: FormattedMoney;
+    minFinalPrice: FormattedMoney;
+    minFinalPriceExclTax: FormattedMoney;
+    maxRegularPrice: FormattedMoney;
+    maxFinalPrice: FormattedMoney;
+    maxFinalPriceExclTax: FormattedMoney;
+}
+
+export interface ProductExtractPriceConfiguration {
+    containsOptions: boolean;
+    containsOptionsWithPrice: boolean;
+    containsRequiredOptions: boolean;
+    containsRequiredOptionsWithPrice: boolean;
+}
+
+export interface ProductExtractPrice {
+    price: ProductExtractBasePrice;
+    originalPrice: ProductExtractOriginalPrice;
+    configuration: ProductExtractPriceConfiguration;
+}
+
+export type ProductExtractImage = Record<ImageType, { url?: string } | undefined>;
+
+export interface TransformedBundleOption {
+    id: string;
+    name: string;
+    value: string;
+    label?: string;
+    subLabel: string;
+    sort_order: number;
+    isAvailable: boolean;
+    isDefault: boolean;
+}
+
+export type RatingVote = RatingsBreakdown & { percent: number };
+
+export interface NoneRadioOption {
+    title: string;
+    label: string;
+    uid: string;
+    price: number;
+    finalOptionPrice: number;
+    can_change_quantity: boolean;
+    priceInclTax: number;
+    is_default: boolean;
+}
+
+export interface TransformedCustomizableOptions {
+    id: string;
+    name: string;
+    value: string;
+    label?: string;
+    subLabel: string;
+    sort_order: number;
+}
+
+export type GetYearRangeAttributes<IsYear extends boolean = false> = IsYear extends true
+    ? YearRangeAttribute
+    : DateRangeAttribute;
+
+export interface StockCheckProduct {
+    type_id: string;
+    stock_status: GQLProductStockStatus;
+    stock_item?: ProductStockItem;
+    items?: Partial<StockCheckProduct>[];
+    variants?: Partial<StockCheckProduct>[];
+}
+
+export type ProductQuantity = number | Record<number, number>;
+
+export interface ProductOption {
+    uid: string;
+    value: string;
+}
+
+export interface AdjustedPrice {
+    exclTax: number;
+    inclTax: number;
+    requiresDiscountCalculations: boolean;
+    hasDiscountCalculated: boolean;
+}
+
+export interface AdjustedPriceMap {
+    downloadable: AdjustedPrice;
+    bundle: AdjustedPrice;
+    config: AdjustedPrice;
+}
+
+export interface ProductPrice {
+    minimum_price: Partial<PriceRange>;
+    maximum_price: Partial<PriceRange>;
+}
+
+export type ConfigurableProductSelectedVariantValue = string | number | boolean;

package/app/utils/Product/Transform.ts

@@ -0,0 +1,382 @@
+/* eslint-disable @typescript-eslint/default-param-last */
+/**
+ * M Framework - Flexible backend agnostic framework.
+ *
+ * Copyright © Meeovi, LTD. All rights reserved.
+ * See LICENSE for license details.
+ *
+ * @license OSL-3.0 (Open Software License ("OSL") v. 3.0)
+ * @package mframework/mframework
+ * @link https://github.com/meeovi/mframework
+ */
+
+import { FieldType } from 'Component/Field/Field.config';
+import { ProductType } from 'Component/Product/Product.config';
+import { NONE_RADIO_OPTION } from 'Component/ProductCustomizableOption/ProductCustomizableOption.config';
+import { CustomizableSelectionValue, GroupedProductItem } from '../../normalizers/ProductList.type';
+import { GQLCurrencyEnum } from '../../types/Graphql.type';
+import { decodeBase64, encodeBase64 } from '../../utils/Base64';
+import { formatPrice } from '../../utils/Price';
+import { ProductOption } from '../../utils/Product/Product.type';
+
+import { getProductInStock } from './Extract';
+import { ADD_TO_CART } from './Product';
+import {
+    BuyRequestBundleOptions,
+    BuyRequestCustomizableOptions,
+    BuyRequestDownloadableOptions,
+    IndexedAttributeWithValue,
+    IndexedBundleOption,
+    IndexedProduct,
+    NoneRadioOption,
+    PriceLabels,
+    ProductTransformData,
+    StockCheckProduct,
+    TransformedBundleOption,
+    TransformedCustomizableOptions,
+} from './Product.type';
+
+export const PRICE_TYPE_PERCENT = 'PERCENT';
+
+/**
+ * Generates correct UID for bundle with changed quantity
+ * UID is encoded in base64, original value is bundle/option_id/item_id/quantity
+ *
+ * @param uid
+ * @param quantity
+ * @namespace ../../utils/Product/Transform/getEncodedBundleUid
+ */
+export const getEncodedBundleUid = (uid: string, quantity: number): string => {
+    const decoded = decodeBase64(uid);
+    const parts = decoded.split('/');
+    // eslint-disable-next-line no-magic-numbers
+    const newUid = parts.length === 3
+        ? `bundle/${parts[1]}/${quantity}`
+        : `bundle/${parts[1]}/${parts[2]}/${quantity}`;
+
+    return encodeBase64(newUid);
+};
+
+/** @namespace ../../utils/Product/Transform/getBundleOptions */
+export const getBundleOptions = (buyRequest: string): string[] => {
+    const { bundle_option = {}, bundle_option_qty = {} }: BuyRequestBundleOptions = JSON.parse(buyRequest);
+
+    if (!bundle_option) {
+        return [];
+    }
+
+    return Object.entries(bundle_option).reduce((prev: string[], [option, variant]) => {
+        const qty = bundle_option_qty[option] || 1;
+
+        if (Array.isArray(variant) && variant.every((val) => typeof (val) === 'string')) {
+            return [...prev, ...variant.map((val) => encodeBase64(`bundle/${option}/${val}/${qty}`))];
+        }
+
+        return [...prev, ...Object.keys(variant).map((id) => encodeBase64(`bundle/${option}/${id}/${qty}`))];
+    }, []);
+};
+
+/** @namespace ../../utils/Product/Transform/getCustomizableOptions */
+export const getCustomizableOptions = (buyRequest: string): string[] => {
+    const { options = {} }: BuyRequestCustomizableOptions = JSON.parse(buyRequest);
+
+    // handle null
+    if (!options) {
+        return [];
+    }
+
+    return Object.entries(options).reduce<string[]>(
+        (prev, [option, variant]) => {
+            if (typeof variant === 'string') {
+                return [...prev, encodeBase64(`custom-option/${option}/${variant}`)];
+            }
+
+            if (Array.isArray(variant)) {
+                return [...prev, ...variant.map((id) => encodeBase64(`custom-option/${option}/${id}`))];
+            }
+
+            if (typeof variant === 'object' && (variant.date_internal || variant.date)) {
+                const { date_internal, date } = variant;
+
+                return [...prev, encodeBase64(`custom-option/${option}/${date_internal || date}`)];
+            }
+
+            // Handle case when we need to pass previously uploaded file as selected option
+            // Normally files are passed via entered_options, but when customer adds product with attachment from wishlist,
+            // we need to reference data of the already uploaded file
+            if (typeof variant === 'object' && variant.type === 'application/octet-stream') {
+                return [...prev, encodeBase64(`custom-option/${option}/file-${encodeBase64(JSON.stringify(variant))}`)];
+            }
+
+            return prev;
+        },
+        [],
+    );
+};
+
+/** @namespace ../../utils/Product/Transform/getDownloadableOptions */
+export const getDownloadableOptions = (buyRequest: string): string[] => {
+    const { links }: BuyRequestDownloadableOptions = JSON.parse(buyRequest);
+
+    if (!links) {
+        return [];
+    }
+
+    return links.map((link) => encodeBase64(`downloadable/${link}`));
+};
+
+/** @namespace ../../utils/Product/Transform/getConfigurableOptions */
+export const getConfigurableOptions = (buyRequest: string): string[] => {
+    const { super_attribute } = JSON.parse(buyRequest);
+
+    if (!super_attribute) {
+        return [];
+    }
+
+    return Object.entries(super_attribute).map(([attr, value]) => encodeBase64(`configurable/${attr}/${value}`));
+};
+
+/** @namespace ../../utils/Product/Transform/getSelectedOptions */
+export const getSelectedOptions = (buyRequest: string): string[] => [
+    ...getBundleOptions(buyRequest),
+    ...getCustomizableOptions(buyRequest),
+    ...getDownloadableOptions(buyRequest),
+    ...getConfigurableOptions(buyRequest),
+];
+
+/** @namespace ../../utils/Product/Transform/transformParameters */
+export const transformParameters = (
+    parameters: Record<string, string>,
+    attributes: Record<string, IndexedAttributeWithValue>,
+): string[] => Object.entries(parameters)
+    .map(([attrCode, selectedValue]) => {
+        const attrId = attributes[attrCode]?.attribute_id;
+
+        return encodeBase64(`configurable/${attrId}/${selectedValue}`);
+    });
+
+/**
+ * Generates label for bundle option
+ *
+ * @param option
+ * @param currencyCode
+ * @returns {{baseLabel: string, priceLabel: string}}
+ * @namespace ../../utils/Product/Transform/bundleOptionToLabel
+ */
+export const bundleOptionToLabel = (
+    option: Partial<IndexedBundleOption>,
+    currencyCode = GQLCurrencyEnum.USD,
+): PriceLabels => {
+    const {
+        price,
+        finalOptionPrice = 0,
+        price_type: priceType,
+        can_change_quantity: canChangeQuantity,
+        quantity = 0,
+        label,
+        product,
+    } = option || {};
+
+    const noPrice = price === 0 && finalOptionPrice === 0;
+    const priceLabel = noPrice ? '' : `+ ${ formatPrice(finalOptionPrice, currencyCode) }`;
+    const percentLabel = (noPrice || priceType !== PRICE_TYPE_PERCENT) ? '' : `(${ price }%)`;
+    // Accessing name here, because product may be passed as null - which prevents from assigning its
+    // default value, thus resulting in error
+    const fallbackLabel = product ? product.name : __('Option');
+    const renderLabel = label ?? fallbackLabel;
+
+    return {
+        baseLabel: !canChangeQuantity && quantity > 0 ? `${ quantity } x ${ renderLabel } ` : `${ renderLabel } `,
+        priceLabel: `${ priceLabel } ${ percentLabel }`,
+    };
+};
+
+/**
+ * Converts bundle products options into select field options,
+ * meaning into [uid:label] pair
+ *
+ * @param options
+ * @namespace ../../utils/Product/Transform/bundleOptionsToSelectTransform
+ */
+export const bundleOptionsToSelectTransform = (
+    options: IndexedBundleOption[],
+    currencyCode = GQLCurrencyEnum.USD,
+    quantity: Record<string, number> = {},
+): TransformedBundleOption[] => (
+    options.reduce((result: TransformedBundleOption[] = [], option) => {
+        const {
+            uid: sourceUid = '',
+            quantity: defaultQuantity = 1,
+            position,
+            product,
+            is_default,
+        } = option;
+
+        const isAvailable = getProductInStock(product);
+
+        const {
+            priceLabel,
+            baseLabel,
+        } = bundleOptionToLabel(option, currencyCode);
+
+        const { [sourceUid]: currentQty = defaultQuantity } = quantity;
+        const uid = getEncodedBundleUid(sourceUid, currentQty);
+
+        result.push({
+            id: sourceUid,
+            name: sourceUid,
+            value: uid,
+            label: baseLabel,
+            subLabel: priceLabel,
+            sort_order: position,
+            isAvailable,
+            isDefault: is_default,
+        });
+
+        return result;
+    }, [])
+);
+
+/**
+ * Generates label for customizable option
+ *
+ * @param option
+ * @param currencyCode
+ * @returns {{baseLabel: string, priceLabel: string}}
+ * @namespace ../../utils/Product/Transform/customizableOptionToLabel
+ */
+export const customizableOptionToLabel = (option: Partial<CustomizableSelectionValue>, currencyCode = GQLCurrencyEnum.USD): PriceLabels => {
+    const {
+        price,
+        priceInclTax = 0,
+        price_type,
+        title,
+    } = option || {};
+    const noPrice = price === 0 && priceInclTax === 0;
+    const priceLabel = noPrice ? '' : `+ ${ formatPrice(priceInclTax, currencyCode) }`;
+    const percentLabel = (noPrice || price_type !== PRICE_TYPE_PERCENT) ? '' : ` (${ price }%)`;
+
+    return {
+        baseLabel: title,
+        priceLabel: `${ priceLabel } ${ percentLabel }`,
+    };
+};
+
+/**
+ * Converts customizable products options into select field options,
+ * meaning into [uid:label] pair
+ *
+ * @param options
+ * @namespace ../../utils/Product/Transform/customizableOptionsToSelectTransform
+ */
+export const customizableOptionsToSelectTransform = (
+    options: CustomizableSelectionValue[],
+    currencyCode = GQLCurrencyEnum.USD,
+): TransformedCustomizableOptions[] => (
+    options.reduce((result: TransformedCustomizableOptions[] = [], option) => {
+        const {
+            uid,
+            title,
+            sort_order = 0,
+        } = option;
+
+        const {
+            priceLabel,
+            baseLabel,
+        } = customizableOptionToLabel(option, currencyCode);
+
+        result.push({
+            id: uid,
+            name: title,
+            value: uid,
+            label: baseLabel,
+            subLabel: priceLabel,
+            sort_order,
+        });
+
+        return result;
+    }, [])
+);
+
+/**
+ * Generates Magento type product interface for performing
+ * actions (add to cart, wishlist, exc.)
+ * @param product
+ * @param quantity
+ * @param enteredOptions
+ * @param selectedOptions
+ * @returns {*[]}
+ * @namespace ../../utils/Product/Transform/magentoProductTransform
+ */
+export const magentoProductTransform = (
+    action: string = ADD_TO_CART,
+    product: IndexedProduct,
+    quantity: number | Record<string, number> = 1,
+    enteredOptions: ProductOption[] = [],
+    selectedOptions: string[] = [],
+): ProductTransformData[] => {
+    const { sku = '', type_id: typeId } = product;
+
+    const productData: ProductTransformData[] = [];
+
+    if (typeId === ProductType.GROUPED && action === ADD_TO_CART) {
+        const { items = [] } = product;
+        const groupedProducts: string[] = [];
+
+        (items as GroupedProductItem[]).forEach(({ product: { id } }) => {
+            const { [String(id)]: groupedQuantity = 0 } = quantity as Record<string, number>;
+
+            groupedProducts.push(encodeBase64(`grouped/${id}/${groupedQuantity}`));
+        });
+
+        productData.push({
+            sku,
+            quantity: 1,
+            selected_options: [...selectedOptions, ...groupedProducts],
+            entered_options: enteredOptions,
+        });
+    } else {
+        const baseProductToAdd: ProductTransformData = {
+            sku,
+            quantity: quantity as number,
+            selected_options: selectedOptions,
+            entered_options: enteredOptions,
+        };
+
+        productData.push(baseProductToAdd);
+    }
+
+    return productData;
+};
+
+/**
+ *
+ * @param options
+ * @param isRequired
+ * @param type
+ * @returns {[{uid: string, price: number, priceInclTax: number, title: *, is_default: boolean},...*]|*}
+ * @namespace ../../utils/Product/Transform/nonRequiredRadioOptions
+ */
+export const nonRequiredRadioOptions = <T>(
+    options: T | T[],
+    isRequired = false,
+    type: string = FieldType.RADIO,
+): T | Array<T | NoneRadioOption> => {
+    if (isRequired || type !== FieldType.RADIO) {
+        return options;
+    }
+
+    const hasDefault = (options as unknown as Array<
+    { is_default?: boolean; product: StockCheckProduct }
+    >).find(({ is_default, product }) => is_default && getProductInStock(product));
+
+    return [
+        {
+            ...(NONE_RADIO_OPTION as any),
+            is_default: !hasDefault,
+        },
+        ...(options as T[]),
+    ];
+};
+
+export default bundleOptionsToSelectTransform;

package/app/utils/Product/index.ts

@@ -0,0 +1,12 @@
+/**
+ * M Framework - Flexible backend agnostic framework.
+ *
+ * Copyright © Meeovi, LTD. All rights reserved.
+ * See LICENSE for license details.
+ *
+ * @license OSL-3.0 (Open Software License ("OSL") v. 3.0)
+ * @package mframework/mframework
+ * @link https://github.com/meeovi/mframework
+ */
+
+export * from './Product';

package/app/utils/Promise/MakeCancelable.ts

@@ -0,0 +1,44 @@
+/**
+ * M Framework - Flexible backend agnostic framework.
+ *
+ * Copyright © Meeovi, LTD. All rights reserved.
+ * See LICENSE for license details.
+ *
+ * @license OSL-3.0 (Open Software License ("OSL") v. 3.0)
+ * @package mframework/mframework
+ * @link https://github.com/meeovi/mframework
+ */
+
+import { CancelablePromise } from './Promise.type';
+
+/* eslint-disable prefer-promise-reject-errors */
+// Disabled due promise being reject with custom error (isCanceled)
+
+/**
+ * Promise wrapper to make it cancelable
+ * @static
+ * @param  {Promise} promise promise which has to be cancelable
+ * @return {Promise} Cancelable promise
+ * @namespace ../../utils/Promise/MakeCancelable/makeCancelable */
+export const makeCancelable = <T>(promise: Promise<T>): CancelablePromise<T> => {
+    // eslint-disable-next-line fp/no-let
+    let hasCanceled = false;
+
+    const wrappedPromise: Promise<T> = new Promise((resolve, reject) => {
+        promise.then(
+            /** @namespace ../../utils/Promise/MakeCancelable/makeCancelable/wrappedPromise/promise/then */
+            (val) => (!hasCanceled && resolve(val)),
+            /** @namespace ../../utils/Promise/MakeCancelable/makeCancelable/wrappedPromise/promise/then/catch */
+            (error) => (!hasCanceled && reject(error)),
+        );
+    });
+
+    return {
+        promise: wrappedPromise,
+        cancel() {
+            hasCanceled = true;
+        },
+    };
+};
+
+export default makeCancelable;