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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nuskin/cs-product-lib",
-  "version": "1.0.24-cx12-8656.1",
+  "version": "1.0.24",
   "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,9 +132,6 @@ 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
                         })
                     }
@@ -471,7 +468,7 @@ const csProduct = (props) => {
         const translations = await getEntriesByQuery({
             contentType: 'strings_product_detail_page',
             locale,
-            includes: ['common_strings']
+            includes: ['common_strings', 'subscriptions.modal']
         })
         await parseSharedStrings(translations)
         return translations

package/src/formatKit.js

@@ -16,40 +16,52 @@ const parseStatus = (variant) => {
     let backorderedAvailableDate = null
     if (variant?.type === 'kit') {
         try {
-            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;
+            /* 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 = latestBODate
+                backorderedAvailableDate = moment(
+                    new Date(latestBODate)
+                ).format(dateFormat)
             }
         } catch {
             backorderedAvailableDate = null
         }
     } else if (variant?.type === 'bundle') {
         try {
-            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;
+            const latestBODate = Math.max(
+                ...variant?.requiredProducts?.flatMap(
+                    (a) =>
+                        Number(
+                            new Date(
+                                a?.product?.variants[0]?.status?.backorderedAvailableDate
+                            )
+                        ) || 0
+                )
+            )
             if (latestBODate) {
                 isBackordered = true
-                backorderedAvailableDate = latestBODate
+                backorderedAvailableDate = moment(
+                    new Date(latestBODate)
+                ).format(dateFormat)
             }
         } catch {
             backorderedAvailableDate = null
         }
     }
     return {
-        status: variant?.status?.status, 
-        isBackordered: isBackordered, 
+        // changed
+        status: variant?.status?.status,
+        isBackordered: isBackordered,
         backorderedAvailableDate: backorderedAvailableDate
     }
 }
@@ -142,85 +154,36 @@ const parsePrice = (product = []) => {
     return sumOfPriceAndPoints
 }
 
-const parseKitAvailableQuantity = (skuKit) => {
-    let quantities = [];
-    let prodQty = 0;
+const parseKitAvailableQuantity = (kit) => {
     try {
-        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;
+        return (
+            Math.min(
+                ...kit.flatMap((a) =>
+                    a?.sku?.map((s) => s?.inventoryProperties?.atpQty)
+                )
+            ) || 0
+        )
+    } catch {
+        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 {
-        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 { 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
     }
 }
 
 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
@@ -250,14 +213,13 @@ const parseKit = (product, market) => {
     kits.scanQualifiedCount = properties?.scanQualifiedCount
     kits.taxClass = properties?.taxClass
     // newVariant.slug = undefined
-    kits.status = status
-    if ((kits?.status || {})?.status === 'active') kits.status.status = 'sellable'
+    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)
-        kits.backorderQuantity = parseKitBackorderedQuantity(product.kit)
-        kits.backorderedAvailableDate = status?.backorderedAvailableDate
+        kits.availableQuantity = parseKitAvailableQuantity(product?.kit)
         for (const kit of product?.kit || []) {
             const kitProduct = formatKit(kit, market)
             kitProduct.id = kit?.identifier
@@ -273,8 +235,6 @@ 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,16 +25,18 @@ const formatVariant = (parent) => ({
     pricingJson: JSON.stringify(parent?.defaults?.status?.pricing) || null,
     price: helpers?.mapPrice(parent),
     points: helpers?.mapPoints(parent),
-    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),
+    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', null)
+        backorderedAvailableDate: _.get(
+            parent,
+            'defaults.status.backorderedAvailableDate',
+            ''
+        )
     },
     csStatus: helpers?.mapCsStatus(parent),
     purchaseTypes: helpers?.mapPurchaseTypes(parent),

package/src/productStatus.js

@@ -45,7 +45,6 @@ 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