@nuskin/cs-product-lib 1.0.23 → 1.0.24-cx12-8656.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nuskin/cs-product-lib",
-  "version": "1.0.23",
+  "version": "1.0.24-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

@@ -132,6 +132,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
                         })
                     }

package/src/formatKit.js

@@ -16,52 +16,40 @@ const parseStatus = (variant) => {
     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
-                    )
-                )
-            )
+            let dates = [];
+            variant?.requiredProducts?.flatMap(a => a?.product?.variants?.map(s => {
+                const backorderDate = s?.status?.backorderedAvailableDate || null;
+                dates.push(moment(backorderDate))
+            }))
+            dates = dates.filter(date => date.isValid());
+            const latestBODate = dates && dates.length > 0 ? moment.max(dates).format(dateFormat) : null;
             if (latestBODate) {
                 isBackordered = true
-                backorderedAvailableDate = moment(
-                    new Date(latestBODate)
-                ).format(dateFormat)
+                backorderedAvailableDate = latestBODate
             }
         } 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
-                )
-            )
+            let dates = [];
+            variant?.requiredProducts?.flatMap(a => a?.product?.variants?.map(s => {
+                const backorderDate = s?.status?.backorderedAvailableDate || null;
+                dates.push(moment(backorderDate))
+            }))
+            dates = dates.filter(date => date.isValid());
+            const latestBODate = dates && dates.length > 0 ? moment.max(dates).format(dateFormat) : null;
             if (latestBODate) {
                 isBackordered = true
-                backorderedAvailableDate = moment(
-                    new Date(latestBODate)
-                ).format(dateFormat)
+                backorderedAvailableDate = latestBODate
             }
         } catch {
             backorderedAvailableDate = null
         }
     }
     return {
-        // changed
-        status: variant?.status?.status,
-        isBackordered: isBackordered,
+        status: variant?.status?.status, 
+        isBackordered: isBackordered, 
         backorderedAvailableDate: backorderedAvailableDate
     }
 }
@@ -154,36 +142,85 @@ const parsePrice = (product = []) => {
     return sumOfPriceAndPoints
 }
 
-const parseKitAvailableQuantity = (kit) => {
+const parseKitAvailableQuantity = (skuKit) => {
+    let quantities = [];
+    let prodQty = 0;
     try {
-        return (
-            Math.min(
-                ...kit.flatMap((a) =>
-                    a?.sku?.map((s) => s?.inventoryProperties?.atpQty)
-                )
-            ) || 0
-        )
-    } catch {
-        return 0
+        skuKit.flatMap(a => {
+            prodQty = Number(a.properties.quantity)
+            a.sku.map(s => {
+                const backorderQty = s?.inventoryProperties?.backOrderedQty/prodQty || 0;
+                const availableQty = s?.inventoryProperties?.atpQty/prodQty || 0;
+                quantities.push({backorderQty, availableQty, canSellUpTo: Math.max(backorderQty, availableQty)})
+            })
+        })
+        const maxAvailableQty = quantities && quantities.length > 0 ? Math.min(...quantities.map(obj=>obj.canSellUpTo)) : 0;
+        return Math.floor(maxAvailableQty);
+    } catch (error) {
+        return 0;
     }
 }
 
 const parseBundleAvailableQuantity = (product) => {
+    let quantities = [];
+    let prodQty = 0;
+    try {
+        product?.requiredProducts?.flatMap(a => {
+            prodQty = Number(a.quantity)
+            a?.product?.variants?.map(s => {
+                const backorderQty = s?.backorderQuantity/prodQty || 0;
+                const availableQty = s?.availableQuantity/prodQty || 0;
+                quantities.push({backorderQty, availableQty, canSellUpTo: Math.max(backorderQty, availableQty)})
+            })
+        })
+        const maxAvailableQty = quantities && quantities.length > 0 ? Math.min(...quantities.map(obj=>obj.canSellUpTo)) : 0;
+        return Math.floor(maxAvailableQty);
+    } catch (error) {
+        return 0;
+    }
+}
+
+
+const parseKitBackorderedQuantity = (skuKit) => {
+    let quantities = [];
+    let prodQty = 0;
     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
+        skuKit?.flatMap(a => {
+            prodQty = Number(a?.properties?.quantity)
+            a.sku.map(s => {
+                const backorderQty = s?.inventoryProperties?.backOrderedQty/prodQty || 0;
+                quantities.push(backorderQty)
+            })
+        })
+        const maxBackorderedQty = quantities && quantities.length > 0 ? Math.min(...quantities) : 0;
+        return Math.floor(maxBackorderedQty);
+    } catch (error) {
+        return 0;
+    }
+}
+  
+const parseBundleBackorderedQuantity = (product) => {
+    let quantities = [];
+    let prodQty = 0;
+    try {
+        product?.requiredProducts?.flatMap(a => {
+            prodQty = Number(a?.quantity)
+            a?.product?.variants?.map(s => {
+                const backorderQty = s?.backorderQuantity/prodQty || 0;
+                quantities.push(backorderQty)
+            })
+        })
+        const maxBackorderedQty = quantities && quantities.length > 0 ? Math.min(...quantities) : 0;
+        return Math.floor(maxBackorderedQty);
+    } catch (error) {
+        return 0;
     }
 }
 
 const parseKit = (product, market) => {
     const kits = {}
     const [properties] = !isNullOrEmpty(product) ? product : []
+    const status = parseStatus(properties)
     kits.id = properties?.id
     kits.uid = properties?.uid
     kits.title = properties?.title
@@ -213,13 +250,14 @@ const parseKit = (product, market) => {
     kits.scanQualifiedCount = properties?.scanQualifiedCount
     kits.taxClass = properties?.taxClass
     // newVariant.slug = undefined
-    kits.status = parseStatus(properties)
-    if ((kits?.status || {})?.status === 'active')
-        kits.status.status = 'sellable'
+    kits.status = status
+    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)
+        kits.availableQuantity = parseKitAvailableQuantity(product.kit)
+        kits.backorderQuantity = parseKitBackorderedQuantity(product.kit)
+        kits.backorderedAvailableDate = status?.backorderedAvailableDate
         for (const kit of product?.kit || []) {
             const kitProduct = formatKit(kit, market)
             kitProduct.id = kit?.identifier
@@ -235,6 +273,8 @@ const parseKit = (product, market) => {
     ) {
         kits.type = properties?.type
         kits.availableQuantity = parseBundleAvailableQuantity(properties)
+        kits.backorderQuantity = parseBundleBackorderedQuantity(properties)
+        kits.backorderedAvailableDate = status?.backorderedAvailableDate
         for (const kit of properties?.requiredProducts || []) {
             if (kit?.product) {
                 const kitProduct = formatKit(kit?.product, market)

package/src/formatVariant.js

@@ -25,18 +25,16 @@ const formatVariant = (parent) => ({
     pricingJson: JSON.stringify(parent?.defaults?.status?.pricing) || null,
     price: helpers?.mapPrice(parent),
     points: helpers?.mapPoints(parent),
-    availableQuantity: _.get(parent, 'defaults.status.availableQuantity', 0),
+    backorderedAvailableDate: _.get(parent, 'defaults.status.backorderedAvailableDate', null),
+    backorderQuantity: _.get(parent, 'defaults.status.backordered', null) ? _.get(parent, 'defaults.status.availableQuantity', 0) : 0,
+    availableQuantity: _.get(parent, 'defaults.status.backordered', null) ? 0 : _.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',
-            ''
-        )
+        backorderedAvailableDate: _.get(parent, 'defaults.status.backorderedAvailableDate', null)
     },
     csStatus: helpers?.mapCsStatus(parent),
     purchaseTypes: helpers?.mapPurchaseTypes(parent),

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