@nuskin/cs-product-lib 1.7.1-order-first.1 → 1.7.2-status-key.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nuskin/cs-product-lib",
-  "version": "1.7.1-order-first.1",
+  "version": "1.7.2-status-key.1",
   "description": "Library for pulling and parsing product content (and applying business logic) retrieved from Contentstack",
   "main": "src/index.js",
   "scripts": {

package/src/formatKit.js

@@ -2,119 +2,104 @@ const { isNullOrEmpty, isTrue } = require('@nuskin/ns-common-lib');
 const { formatDiscounts } = require('./helpers/formatDiscounts');
 const moment = require('moment')
 
-const parsePrice = (product = [], status = {}) => {
-    const first = product[0] || {}
-    if (first?.type === 'kit') {
-        const kitStatus = status[first?.id]
-        if (kitStatus) {
-            return {
-                price: {
-                    retail: kitStatus?.pricing?.retail?.webOrder?.price || kitStatus?.pricing?.retail?.order?.price,
-                    retailSubscription: kitStatus?.pricing?.retail?.webAdr?.price,
-                    wholesale: kitStatus?.pricing?.wholesale?.webOrder?.price || kitStatus?.pricing?.wholesale?.order?.price,
-                    wholesaleSubscription: kitStatus?.pricing?.wholesale?.webAdr?.price
-                },
-                points: {
-                    subscription: {
-                        cv: kitStatus?.pricing?.wholesale?.webAdr?.cv || 0,
-                        pv: kitStatus?.pricing?.wholesale?.webAdr?.pv || 0,
-                        sb: kitStatus?.pricing?.wholesale?.webAdr?.sb || 0
-                    },
-                    wholesale: {
-                        cv: kitStatus?.pricing?.wholesale?.order?.cv || kitStatus?.pricing?.wholesale?.webOrder?.cv || 0,
-                        pv: kitStatus?.pricing?.wholesale?.order?.pv || kitStatus?.pricing?.wholesale?.webOrder?.pv || 0,
-                        sb: kitStatus?.pricing?.wholesale?.order?.sb || kitStatus?.pricing?.wholesale?.webOrder?.sb || 0
-                    }
-                }
-            }
-        }
-    }
+// Accumulate `base + value * quantity`, treating missing operands as 0.
+const addScaled = (base, value, quantity) =>
+    Number(base || 0) + Number((value || 0) * (quantity || 1))
 
+// Collapse a bundle's required products to their first variants (with quantity).
+const getComponentVariants = (product = []) => {
     const requiredProducts = !isNullOrEmpty(product)
         ? product?.map((p) => p?.requiredProducts).flat()
         : []
-
-    const variants = requiredProducts?.map((p) => {
+    return requiredProducts?.map((p) => {
         const [firstVariant] = p?.product?.variants || []
         return { ...firstVariant, quantity: p?.quantity }
     })
+}
 
+// sum of price and points from 1st variant of each required product in the bundle
+const computeComponentSum = (product = []) => {
+    const variants = getComponentVariants(product)
     const defaultValues = {
-        price: {
-            retail: 0,
-            retailSubscription: 0,
-            wholesale: 0,
-            wholesaleSubscription: 0
-        },
+        price: { retail: 0, retailSubscription: 0, wholesale: 0, wholesaleSubscription: 0 },
+        points: { subscription: { cv: 0, pv: 0, sb: 0 }, wholesale: { cv: 0, pv: 0, sb: 0 } }
+    }
+
+    return variants?.reduce((acc, curr) => {
+        const qty = curr?.quantity
+        const addPrice = (field) => addScaled(acc?.price?.[field], curr?.price?.[field], qty)
+        const addPoints = (group, field) =>
+            addScaled(acc?.points?.[group]?.[field], curr?.points?.[group]?.[field], qty)
+
+        return {
+            price: {
+                retail: addPrice('retail'),
+                retailSubscription: addPrice('retailSubscription'),
+                wholesale: addPrice('wholesale'),
+                wholesaleSubscription: addPrice('wholesaleSubscription'),
+                currencyCode: curr?.price?.currencyCode
+            },
+            points: {
+                subscription: {
+                    cv: addPoints('subscription', 'cv'),
+                    pv: addPoints('subscription', 'pv'),
+                    sb: addPoints('subscription', 'sb')
+                },
+                wholesale: {
+                    cv: addPoints('wholesale', 'cv'),
+                    pv: addPoints('wholesale', 'pv'),
+                    sb: addPoints('wholesale', 'sb')
+                }
+            }
+        }
+    }, defaultValues)
+}
+
+// The id a kit bundle is keyed by in product status, across pre/post-transform shapes.
+const getKitStatusKey = (first = {}) =>
+    first?.id || first?.bundle_id || first?.legacy_sku || first?.kit_id
+
+// Build the kit's price/points object from its product-status entry, exposing the
+// component sum as the original (pre-status) strike-through price when summable.
+const buildKitPriceFromStatus = (kitStatus, componentSum) => {
+    const retail = kitStatus?.pricing?.retail
+    const wholesale = kitStatus?.pricing?.wholesale
+    const price = {
+        retail: retail?.webOrder?.price || retail?.order?.price,
+        retailSubscription: retail?.webAdr?.price,
+        wholesale: wholesale?.webOrder?.price || wholesale?.order?.price,
+        wholesaleSubscription: wholesale?.webAdr?.price
+    }
+    // Only when components were actually summable -- never force 0.
+    if (componentSum?.price?.currencyCode !== undefined) {
+        price.retailOriginal = componentSum?.price?.retail
+        price.wholesaleOriginal = componentSum?.price?.wholesale
+    }
+    return {
+        price,
         points: {
             subscription: {
-                cv: 0,
-                pv: 0,
-                sb: 0
+                cv: wholesale?.webAdr?.cv || 0,
+                pv: wholesale?.webAdr?.pv || 0,
+                sb: wholesale?.webAdr?.sb || 0
             },
             wholesale: {
-                cv: 0,
-                pv: 0,
-                sb: 0
+                cv: wholesale?.order?.cv || wholesale?.webOrder?.cv || 0,
+                pv: wholesale?.order?.pv || wholesale?.webOrder?.pv || 0,
+                sb: wholesale?.order?.sb || wholesale?.webOrder?.sb || 0
             }
         }
     }
+}
 
-    // sum of price and points from 1st variant of product bundle
-    const sumOfPriceAndPoints = variants?.reduce((acc, curr) => {
-        const price = {}
-        const points = {
-            subscription: {},
-            wholesale: {}
-        }
-
-        price.retail =
-            Number(acc?.price?.retail || 0) +
-            Number((curr?.price?.retail || 0) * (curr?.quantity || 1))
-        price.retailSubscription =
-            Number(acc?.price?.retailSubscription || 0) +
-            Number(
-                (curr?.price?.retailSubscription || 0) * (curr?.quantity || 1)
-            )
-        price.wholesale =
-            Number(acc?.price?.wholesale || 0) +
-            Number((curr?.price?.wholesale || 0) * (curr?.quantity || 1))
-        price.wholesaleSubscription =
-            Number(acc?.price?.wholesaleSubscription || 0) +
-            Number(
-                (curr?.price?.wholesaleSubscription || 0) *
-                (curr?.quantity || 1)
-            )
-        price.currencyCode = curr?.price?.currencyCode
-
-        points.subscription.cv =
-            Number(acc?.points?.subscription?.cv || 0) +
-            Number(
-                (curr?.points?.subscription?.cv || 0) * (curr?.quantity || 1)
-            )
-        points.subscription.pv =
-            Number(acc?.points?.subscription?.pv || 0) +
-            Number(
-                (curr?.points?.subscription?.pv || 0) * (curr?.quantity || 1)
-            )
-        points.subscription.sb =
-            Number(acc?.points?.subscription?.sb || 0) +
-            Number(
-                (curr?.points?.subscription?.sb || 0) * (curr?.quantity || 1)
-            )
-        points.wholesale.cv =
-            Number(acc?.points?.wholesale?.cv || 0) +
-            Number((curr?.points?.wholesale?.cv || 0) * (curr?.quantity || 1))
-        points.wholesale.pv =
-            Number(acc?.points?.wholesale?.pv || 0) +
-            Number((curr?.points?.wholesale?.pv || 0) * (curr?.quantity || 1))
-        points.wholesale.sb =
-            Number(acc?.points?.wholesale?.sb || 0) +
-            Number((curr?.points?.wholesale?.sb || 0) * (curr?.quantity || 1))
-
-        return { price, points }
-    }, defaultValues)
-    return sumOfPriceAndPoints
+const parsePrice = (product = [], status = {}) => {
+    const first = product[0] || {}
+    const kitKey = getKitStatusKey(first)
+    const kitStatus = (first?.type === 'kit' || kitKey) ? status[kitKey] : undefined
+    if (kitStatus) {
+        return buildKitPriceFromStatus(kitStatus, computeComponentSum(product))
+    }
+    return computeComponentSum(product)
 }
 
 const parseKitAvailableQuantity = (kit) => {
@@ -289,5 +274,6 @@ const formatKit = (product, market, status) => {
 
 module.exports = {
     formatKit,
-    parseKit
+    parseKit,
+    parsePrice
 }