@nuskin/cs-product-lib 1.1.2 → 1.1.3-cx12-8656.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nuskin/cs-product-lib",
-  "version": "1.1.2",
+  "version": "1.1.3-cx12-8656.1",
   "description": "Library for pulling and parsing product content (and applying business logic) retrieved from Contentstack",
   "main": "src/index.js",
   "scripts": {

package/src/csProduct.js

@@ -134,6 +134,9 @@ const csProduct = (props) => {
                         validVariants.push({
                             ...variant,
                             status: varStatus,
+                            backorderQuantity: varStatus?.backordered ? varStatus?.availableQuantity : 0,
+                            availableQuantity: varStatus?.backordered ? 0 : varStatus?.availableQuantity,
+                            backorderedAvailableDate: varStatus?.backorderedAvailableDate || null,
                             marketData
                         })
                     }
@@ -564,7 +567,8 @@ const csProduct = (props) => {
         getProductTranslations,
         getBundle,
         getBundles,
-        getCategoryPageTranslations
+        getCategoryPageTranslations,
+        formatProductWithSchema
     }
 }
 

package/src/formatKit.js

@@ -2,71 +2,6 @@ const { isNullOrEmpty, isTrue } = require('@nuskin/ns-common-lib');
 const { formatDiscounts } = require('./helpers/formatDiscounts');
 const moment = require('moment')
 
-const parseStatus = (variant) => {
-    const dateFormat = 'YYYY-MM-DD'
-
-    if (variant?.type !== 'bundle' && variant?.type !== 'kit') {
-        return {
-            status: variant?.status?.status,
-            isBackordered: variant?.status?.isBackordered,
-            backorderedAvailableDate: variant?.status?.backorderedAvailableDate
-        }
-    }
-
-    let isBackordered = false
-    let backorderedAvailableDate = null
-    if (variant?.type === 'kit') {
-        try {
-            /* eslint-disable no-unsafe-optional-chaining */
-            const latestBODate = Math.max(
-                ...variant?.requiredProducts?.flatMap((a) =>
-                    a?.product?.variants?.map(
-                        (s) =>
-                            Number(
-                                new Date(s?.status?.backorderedAvailableDate)
-                            ) || 0
-                    )
-                )
-            )
-            if (latestBODate) {
-                isBackordered = true
-                backorderedAvailableDate = moment(
-                    new Date(latestBODate)
-                ).format(dateFormat)
-            }
-        } catch {
-            backorderedAvailableDate = null
-        }
-    } else if (variant?.type === 'bundle') {
-        try {
-            const latestBODate = Math.max(
-                ...variant?.requiredProducts?.flatMap(
-                    (a) =>
-                        Number(
-                            new Date(
-                                a?.product?.variants[0]?.status?.backorderedAvailableDate
-                            )
-                        ) || 0
-                )
-            )
-            if (latestBODate) {
-                isBackordered = true
-                backorderedAvailableDate = moment(
-                    new Date(latestBODate)
-                ).format(dateFormat)
-            }
-        } catch {
-            backorderedAvailableDate = null
-        }
-    }
-    return {
-        // changed
-        status: variant?.status?.status,
-        isBackordered: isBackordered,
-        backorderedAvailableDate: backorderedAvailableDate
-    }
-}
-
 const parsePrice = (product = []) => {
     const requiredProducts = !isNullOrEmpty(product)
         ? product?.map((p) => p?.requiredProducts).flat()
@@ -155,36 +90,49 @@ const parsePrice = (product = []) => {
     return sumOfPriceAndPoints
 }
 
-const parseKitAvailableQuantity = (kit) => {
-    try {
-        return (
-            Math.min(
-                ...kit.flatMap((a) =>
-                    a?.sku?.map((s) => s?.inventoryProperties?.atpQty)
-                )
-            ) || 0
-        )
-    } catch {
-        return 0
-    }
-}
-
-const parseBundleAvailableQuantity = (product) => {
+const getKitOrBundleDetails = (bundle) => {
+    const dateFormat = 'YYYY-MM-DD'
+    let maxQty = null;
+    let backOrderedQty = null;
+    let availableQty = null;
+    let quantities = [];
+    let availableQuantities = [];
+    let prodQty = 0;
+    let dates = [];
+    let latestBackOrderedDate = null;
     try {
-        const { requiredProducts = [] } = !isNullOrEmpty(product) ? product : {}
-        const quantities = requiredProducts?.map((p) =>
-            p?.product?.variants?.map((a) => a?.availableQuantity)
-        )
-        return Math.min(...quantities) || 0
-    } catch {
-        console.log('some error in availableQuantity')
-        return 0
+        bundle?.requiredProducts?.flatMap(a => {
+            prodQty = Number(a?.quantity || 1);
+            a?.product?.variants?.map(s => {
+                const backorderQty = s?.backorderQuantity || 0;
+                const availableQty = s?.availableQuantity || 0;
+                const backorderDate = s?.status?.backorderedAvailableDate || null;
+                dates.push(moment(backorderDate))
+                quantities.push({maxPurchasable: (backorderQty + availableQty)/prodQty});
+                availableQuantities.push({availableQty});
+            })
+        })
+        const maxQtyPurchasable = quantities && quantities.length > 0 ? Math.min(...quantities.map(obj=>obj.maxPurchasable)) : 0;
+        const maxAvailableQty = availableQuantities && availableQuantities.length > 0 ? Math.min(...availableQuantities.map(obj=>obj.availableQty)) : 0;
+        maxQty = Math.floor(maxQtyPurchasable);
+        const checkIfNegative = (maxQty - maxAvailableQty) < 0;
+        backOrderedQty = checkIfNegative ? 0 : maxQty - maxAvailableQty;
+        availableQty = maxAvailableQty;
+        dates = dates.filter(date => date.isValid());
+        latestBackOrderedDate = dates && dates.length > 0 && backOrderedQty !== 0  ? moment.max(dates).format(dateFormat) : null;
+    } catch (error) {
+        console.error('getKitOrBundleDetails() - back order qty, available qty, max qty, latest back order date or status error', error);
+        maxQty = 0;
+        backOrderedQty = 0;
+        availableQty = 0;
+        latestBackOrderedDate = null;
     }
+    return {status: bundle?.status?.status, maxQty, backOrderedQty, availableQty, latestBackOrderedDate}
 }
 
-const parseKit = (product, market) => {
+const parseKit = (bundle, market) => {
     const kits = {}
-    const [properties] = !isNullOrEmpty(product) ? product : []
+    const [properties] = !isNullOrEmpty(bundle) ? bundle : []
     kits.id = properties?.id
     if (properties?.type === 'kit' && properties?.legacy_sku) {
         kits.id = properties?.legacy_sku
@@ -199,8 +147,7 @@ const parseKit = (product, market) => {
     kits.excludeFromSearch = isTrue(properties?.excludeFromSearch)
     kits.isExclusive = isTrue(properties?.isExclusive)
     kits.marketAttributes = properties?.marketAttributes
-    kits.maxQuantity = (product?.inventoryProperties || {}).atpQty
-    const priceData = parsePrice(product)
+    const priceData = parsePrice(bundle)
     kits.points = priceData?.points
     kits.price = priceData?.price
     kits.purchaseTypes = {
@@ -218,35 +165,20 @@ const parseKit = (product, market) => {
     kits.scanQualifiedCount = properties?.scanQualifiedCount
     kits.foreignOrderLimit = properties?.foreignOrderLimit || properties?.foreign_limit
     kits.taxClass = properties?.taxClass
-    // newVariant.slug = undefined
-    kits.status = parseStatus(properties)
-    if ((kits?.status || {})?.status === 'active')
-        kits.status.status = 'sellable'
     const kitProducts = []
-    if (properties?.type === 'kit' && product?.kit) {
-        kits.type = 'kit'
-        kits.availableQuantity = parseKitAvailableQuantity(product?.kit)
-        for (const kit of product?.kit || []) {
-            const kitProduct = formatKit(kit, market)
-            kitProduct.id = kit?.identifier
-            kitProducts.push({
-                product: kitProduct,
-                quantity: (kit?.properties || {})?.quantity || 0,
-                isMandatory: true
-            })
-        }
-    } else if (
-        properties?.type === 'bundle' ||
-        (properties?.type === 'kit' && properties?.requiredProducts)
-    ) {
-        kits.type = properties?.type
-        kits.availableQuantity = parseBundleAvailableQuantity(properties)
+    const type = properties?.type === 'bundle' ? 'bundle' : 'kit'
+    kits.type = type
+    const details = getKitOrBundleDetails(properties)
+    kits.status = { status: details.status, isBackordered: !!(details.backOrderedQty !== 0 && details.latestBackOrderedDate !== null), backorderedAvailableDate: details.latestBackOrderedDate }
+    kits.maxQuantity = details.maxQty
+    kits.availableQuantity = details.availableQty
+    kits.backorderQuantity = details.backOrderedQty
+    kits.backorderedAvailableDate = details.latestBackOrderedDate
+    if (type === 'bundle') {
         for (const kit of properties?.requiredProducts || []) {
             if (kit?.product) {
-                const kitProduct = formatKit(kit?.product, market)
-                kitProduct.id = kit?.product?.id
                 kitProducts?.push({
-                    product: kitProduct,
+                    product: formatKit(kit?.product, market),
                     quantity: kit?.quantity || 0,
                     isMandatory: true
                 })
@@ -254,17 +186,24 @@ const parseKit = (product, market) => {
         }
         for (const kit of properties?.optionalProducts || []) {
             if (kit?.product) {
-                const kitProduct = formatKit(kit?.product, market)
-                kitProduct.id = kit?.product?.id
                 kitProducts?.push({
-                    product: kitProduct,
+                    product: formatKit(kit?.product, market),
                     quantity: kit?.quantity || 0,
                     isMandatory: false
                 })
             }
         }
+    } else if (type === 'kit') {
+        for (const kit of properties?.requiredProducts || []) {
+            kitProducts.push({
+                product: formatKit(kit?.product, market),
+                quantity: kit?.quantity || 0,
+                isMandatory: true
+            })
+        }
     }
     kits.kitProducts = kitProducts
+    if ((kits?.status || {})?.status === 'active') kits.status.status = 'sellable'
     return kits
 }
 
@@ -277,6 +216,7 @@ const formatKit = (product, market) => {
     if (['kit', 'bundle'].includes(product?.type)) {
         kit = parseKit(product?.bundle, market)
     }
+
     return {
         ...product,
         bundle: kit
@@ -285,9 +225,5 @@ const formatKit = (product, market) => {
 
 module.exports = {
     formatKit,
-    parseKit,
-    parseBundleAvailableQuantity,
-    parseKitAvailableQuantity,
-    parsePrice,
-    parseStatus
+    parseKit
 }

package/src/formatVariant.js

@@ -2,110 +2,114 @@ const helpers = require('./helpers')
 const _ = require('lodash')
 const entities = require('entities')
 
-const formatVariant = (parent) => ({
+const formatVariant = (parent) => {
+    const isBackOrdered = _.get(parent, 'defaults.status.backordered', null);
+    const backOrderedDate = _.get(parent, 'defaults.status.backorderedAvailableDate', null);
+    const preliminaryAvailableQty  = _.get(parent, 'defaults.status.availableQuantity', 0);
+    const availableQty = isBackOrdered ? 0 : preliminaryAvailableQty;
+    const backOrderedQty = isBackOrdered ? availableQty : 0;
+
     // Each value is a function with a parameter 'parent' that is the current instance of a Variant
     // ContentStack references need to be queried separately
-    id: parent?.uid,
-    globalId: parent?.sap_data?.global_id,
-    sku: helpers?.getBestSkuData(parent)?.sku,
-    slug: parent?.slug,
-    size: parent?.size,
-    variantLabel: parent?.select_label,
-    variantColor: parent?.select_color,
-    title: parent?.name || parent?.defaults?.name,
-    salesLabel: parent?.sales_label,
-    salesText: parent?.sales_text,
-    activeEventDisclaimer: helpers?.mapActiveEventDisclaimer(parent?.active_event_disclaimer),
-    description: entities?.decodeHTML(
-        parent?.short_description_override || parent?.defaults?.description || ''
-    ),
-    salesDisclaimer: helpers?.mapSalesDisclaimer(parent?.sales_disclaimer),
-    nettoWeight: parent?.netto_weight,
-    productImages: helpers?.mapProductImages(parent),
-    isExclusive: parent?.is_exclusive,
-    pricingJson: JSON.stringify(parent?.defaults?.status?.pricing) || null,
-    price: helpers?.mapPrice(parent),
-    points: helpers?.mapPoints(parent),
-    availableQuantity: _.get(parent, 'defaults.status.availableQuantity', 0),
-    maxQuantity: _.get(parent, 'defaults.status.maxQuantity', 0),
-    status: {
-        status: _.get(parent, 'defaults.status.status.retail', null),
-        retail: _.get(parent, 'defaults.status.status.retail', null),
-        wholesale: _.get(parent, 'defaults.status.status.wholesale', null),
-        isBackordered: _.get(parent, 'defaults.status.backordered', null),
-        backorderedAvailableDate: _.get(
-            parent,
-            'defaults.status.backorderedAvailableDate',
-            ''
-        )
-    },
-    csStatus: helpers?.mapCsStatus(parent),
-    purchaseTypes: helpers?.mapPurchaseTypes(parent),
-    features: helpers?.mapFeatures(parent),
-    productDetails: helpers?.mapProductDetails(parent),
-    ingredients: helpers?.mapIngredients(
-        parent.ingredients_override,
-        parent.legacy_ingredients
-    ),
-    benefitsAndFeatures: helpers?.mapBenefitsAndFeatures(parent),
-    results: helpers?.mapResults(parent),
-    usage: helpers?.mapUsage(parent, parent.legacy_usage),
-    resources: helpers?.mapResources(parent),
-    faqs: helpers?.mapFaqs(parent),
-    disclaimers: parent?.disclaimers || [],
-    disclaimerWarnings: helpers?.mapDisclaimerWarnings(
-        parent.disclaimer_warnings
-    ),
-    matchingVariant:
-        parent.sap_data?.sku_data?.findIndex((s) =>
-            parent.searchedSkus.includes(s.sku)
-        ) > -1,
-    shadeable: parent?.shadeable || false,
-    restrictedMarkets: parent?.restricted_markets || [],
-    productType: parent?.sap_data?.product_type,
-    primaryBrand: parent.sap_data?.primary_brand,
-    brandFamily: parent?.sap_data?.brand_family,
-    marketAttributes: {
-        discount: _.get(
-            parent,
-            'defaults.status.marketAttributes.discount',
-            null
+    return {
+        id: parent?.uid,
+        globalId: parent?.sap_data?.global_id,
+        sku: helpers?.getBestSkuData(parent)?.sku,
+        slug: parent?.slug,
+        size: parent?.size,
+        variantLabel: parent?.select_label,
+        variantColor: parent?.select_color,
+        title: parent?.name || parent?.defaults?.name,
+        salesLabel: parent?.sales_label,
+        salesText: parent?.sales_text,
+        activeEventDisclaimer: helpers?.mapActiveEventDisclaimer(parent?.active_event_disclaimer),
+        description: entities?.decodeHTML(
+            parent?.short_description_override || parent?.defaults?.description || ''
+        ),
+        salesDisclaimer: helpers?.mapSalesDisclaimer(parent?.sales_disclaimer),
+        nettoWeight: parent?.netto_weight,
+        productImages: helpers?.mapProductImages(parent),
+        isExclusive: parent?.is_exclusive,
+        pricingJson: JSON.stringify(parent?.defaults?.status?.pricing) || null,
+        price: helpers?.mapPrice(parent),
+        points: helpers?.mapPoints(parent),
+        backorderedAvailableDate: backOrderedDate,
+        backorderQuantity: backOrderedQty,
+        availableQuantity: availableQty,
+        maxQuantity: _.get(parent, 'defaults.status.maxQuantity', 0), // will be product status overrideMaxQty else its availableQty
+        status: {
+            status: _.get(parent, 'defaults.status.status.retail', null),
+            retail: _.get(parent, 'defaults.status.status.retail', null),
+            wholesale: _.get(parent, 'defaults.status.status.wholesale', null)
+        },
+        csStatus: helpers?.mapCsStatus(parent),
+        purchaseTypes: helpers?.mapPurchaseTypes(parent),
+        features: helpers?.mapFeatures(parent),
+        productDetails: helpers?.mapProductDetails(parent),
+        ingredients: helpers?.mapIngredients(
+            parent.ingredients_override,
+            parent.legacy_ingredients
         ),
-        redeem: _.get(parent, 'defaults.status.marketAttributes.redeem', null),
-        earn: _.get(parent, 'defaults.status.marketAttributes.earn', null)
-    },
-    legacyBenefits: parent.legacy_benefits,
-    legacyLongDescription: parent.legacy_long_description,
-    legacyResources: parent.legacy_resources,
-    legacyUsage: parent.legacy_usage,
-    legacyIngredients: parent.legacy_ingredients,
-    legacyImages: parent.legacy_images || [],
-    legacyYouTube: parent.legacy_youtube_video,
-    csAtts: {
-        version: parent._version || 0,
-        updatedAt: parent.updated_at || '',
-        updatedBy: parent.updated_by || '',
-        createdAt: parent.created_at || '',
-        createdBy: parent.created_by || '',
-        locale: parent.locale || ''
-    },
-    searchKeywords: parent?.search_keywords,
-    excludeFromSearch: parent?.exclude_from_search || helpers?.mapCsStatus(parent).status === 'discontinued' || _.get(parent, 'defaults.status.status.retail', null) === 'DISCONTINUED',
-    customerTypes: helpers?.getBestSkuData(parent)?.status_selections
-        ?.customer_types,
-    availableChannels: helpers?.getBestSkuData(parent)?.status_selections
-        ?.display_channels,
-    displayChannels: helpers?.getBestSkuData(parent)?.status_selections
-        ?.display_channels,
-    scanQualifiedCount: helpers?.getBestSkuData(parent)?.scan_qualify_count,
-    scanQualifyCount: helpers?.getBestSkuData(parent)?.scan_qualify_count,
-    chargeShipping: helpers?.getBestSkuData(parent)?.charge_shipping,
-    dangerousGoods: helpers?.getBestSkuData(parent)?.dangerous_goods,
-    channels: helpers?.getBestSkuData(parent)?.channels,
-    foreignLimit: helpers?.getBestSkuData(parent)?.foreign_limit,
-    foreignOrderLimit: helpers?.getBestSkuData(parent)?.foreign_limit,
-    orderType: parent.sap_data?.order_type
-})
+        benefitsAndFeatures: helpers?.mapBenefitsAndFeatures(parent),
+        results: helpers?.mapResults(parent),
+        usage: helpers?.mapUsage(parent, parent.legacy_usage),
+        resources: helpers?.mapResources(parent),
+        faqs: helpers?.mapFaqs(parent),
+        disclaimers: parent?.disclaimers || [],
+        disclaimerWarnings: helpers?.mapDisclaimerWarnings(
+            parent.disclaimer_warnings
+        ),
+        matchingVariant: 
+            parent.sap_data?.sku_data?.findIndex((s) =>
+                parent.searchedSkus.includes(s.sku)
+            ) > -1,
+        shadeable: parent?.shadeable || false,
+        restrictedMarkets: parent?.restricted_markets || [],
+        productType: parent?.sap_data?.product_type,
+        primaryBrand: parent.sap_data?.primary_brand,
+        brandFamily: parent?.sap_data?.brand_family,
+        marketAttributes: {
+            discount: _.get(
+                parent,
+                'defaults.status.marketAttributes.discount',
+                null
+            ),
+            redeem: _.get(parent, 'defaults.status.marketAttributes.redeem', null),
+            earn: _.get(parent, 'defaults.status.marketAttributes.earn', null)
+        },
+        legacyBenefits: parent.legacy_benefits,
+        legacyLongDescription: parent.legacy_long_description,
+        legacyResources: parent.legacy_resources,
+        legacyUsage: parent.legacy_usage,
+        legacyIngredients: parent.legacy_ingredients,
+        legacyImages: parent.legacy_images || [],
+        legacyYouTube: parent.legacy_youtube_video,
+        csAtts: {
+            version: parent._version || 0,
+            updatedAt: parent.updated_at || '',
+            updatedBy: parent.updated_by || '',
+            createdAt: parent.created_at || '',
+            createdBy: parent.created_by || '',
+            locale: parent.locale || ''
+        },
+        searchKeywords: parent?.search_keywords,
+        excludeFromSearch: parent?.exclude_from_search || helpers?.mapCsStatus(parent).status === 'discontinued' || _.get(parent, 'defaults.status.status.retail', null) === 'DISCONTINUED',
+        customerTypes: helpers?.getBestSkuData(parent)?.status_selections
+            ?.customer_types,
+        availableChannels: helpers?.getBestSkuData(parent)?.status_selections
+            ?.display_channels,
+        displayChannels: helpers?.getBestSkuData(parent)?.status_selections
+            ?.display_channels,
+        scanQualifiedCount: helpers?.getBestSkuData(parent)?.scan_qualify_count,
+        scanQualifyCount: helpers?.getBestSkuData(parent)?.scan_qualify_count,
+        chargeShipping: helpers?.getBestSkuData(parent)?.charge_shipping,
+        dangerousGoods: helpers?.getBestSkuData(parent)?.dangerous_goods,
+        channels: helpers?.getBestSkuData(parent)?.channels,
+        foreignLimit: helpers?.getBestSkuData(parent)?.foreign_limit,
+        foreignOrderLimit: helpers?.getBestSkuData(parent)?.foreign_limit,
+        orderType: parent.sap_data?.order_type
+    }
+}
 
 module.exports = {
     formatVariant

package/src/productStatus.js

@@ -45,6 +45,7 @@ async function getProductStatus(skus, locale, homeUrl, awsBase, clientId) {
                 const overrideMaxQuantity = marketConfig.skuMaxQty
                     ? marketConfig.skuMaxQty[skus[i]]
                     : undefined
+                // @TODO - Update this code when we update our config for minimum availableQuantity in CS
                 const availableQuantity =
                     productStatus.availableQuantity < 999
                         ? productStatus.availableQuantity