@nuskin/cs-product-lib 1.0.6-cx12-6632.1 → 1.0.6

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nuskin/cs-product-lib",
-  "version": "1.0.6-cx12-6632.1",
+  "version": "1.0.6",
   "description": "Library for pulling and parsing product content (and applying business logic) retrieved from Contentstack",
   "main": "src/index.js",
   "scripts": {
@@ -43,6 +43,7 @@
     "config": "^3.3.6",
     "entities": "4.4.0",
     "lodash": "4.17.21",
+    "moment": "^2.29.4",
     "turndown": "7.1.1"
   }
 }

package/src/formatKit.js

@@ -0,0 +1,169 @@
+const moment = require('moment')
+
+const parseStatus = (variant) => {
+    const dateFormat = 'YYYY-MM-DD'
+    const properties = variant.properties || {}
+    if (
+        variant.inventoryProperties && 
+    variant.inventoryProperties.backOrdered && 
+    variant.inventoryProperties.expectedBackOrderAvailabilityDate) {
+        return {
+
+            // changed
+            status: 'inactive', 
+            isBackordered: variant.inventoryProperties.backOrdered, 
+            backorderedAvailableDate: moment(variant.inventoryProperties.expectedBackOrderAvailabilityDate).format(dateFormat)
+        }
+    } else if(properties.productStatus) {
+        let isBackordered = false
+        let backorderedAvailableDate = null
+        if (variant.skuKit) {
+            try {
+                const latestBODate = Math.min(...variant.skuKit.flatMap(a=>a.sku.map(s=>s.inventoryProperties.expectedBackOrderAvailabilityDate))) || 0
+                if (latestBODate) {
+                    isBackordered = true
+                    backorderedAvailableDate = moment(Date(latestBODate)).format(dateFormat)
+                }
+            } catch {
+                backorderedAvailableDate = null
+            }
+      
+        } else if (variant.bundle) {
+            try {
+                const latestBODate = Math.min(...variant.bundleMandatoryProducts.flatMap(a=>a.sku.map(s=>s.inventoryProperties.expectedBackOrderAvailabilityDate))) || 0
+                if (latestBODate) {
+                    isBackordered = true
+                    backorderedAvailableDate = moment(Date(latestBODate)).format(dateFormat)
+                }
+            } catch {
+                backorderedAvailableDate = null
+            }
+        }
+        return {
+            // changed
+            status: 'active',
+            isBackordered,
+            backorderedAvailableDate
+        }
+    } 
+    return {
+        // changed
+        status: 'active',
+        isBackordered: false,
+        backorderedAvailableDate: null
+    }
+};
+
+const parsePrice = (variant) => {
+    const price = {}
+    const points = {}
+    price.currencyCode = (variant.prices || [])?.[0]?.currencyCode || (variant?.prices || [])?.[0]?.currencySymbol
+    const priceFacets = variant?.priceFacets || {}
+    price.retail = priceFacets['Regular Price'] || ((variant?.prices || [])[0] || {}).price
+    price.wholesale = priceFacets['Wholesale Price'] || ((variant?.prices || [])[0] || {}).price
+    price.retailSubscription = priceFacets['Regular Price'] || ((variant?.prices || [])[0] || {}).price
+    price.wholesaleSubscription = priceFacets['Wholesale Price'] || ((variant?.prices || [])[0] || {}).price
+    points.wholesale = {cv: priceFacets.CV, pv: priceFacets.PV, sb: priceFacets.SB}
+    // Where do we pull subscription price/points from?
+    points.subscription = {cv: priceFacets.CV, pv: priceFacets.PV, sb: priceFacets.SB}
+    return {price, points}
+}
+
+const parseKitAvailableQuantity = (skuKit) => {
+    try {
+        return Math.min(...skuKit.flatMap(a=>a.sku.map(s=>s.inventoryProperties.atpQty))) || 0
+    } catch {
+        return 0
+    }
+}
+
+const parseBundleAvailableQuantity = (product) => {
+    try {
+        const {requiredProducts = []} = product|| {}
+        const quantities = requiredProducts?.map(p => p?.quantity || 0)
+        return Math.min(...quantities) || 0
+    } catch {
+        console.log("some error in availableQuantity")
+        return 0
+    }
+}
+
+const parseKit = (product, market) => {
+    const kits = {}
+    const [properties] = product || []
+    kits.description = properties?.description
+    kits.availableChannels = properties.availableChannels
+    kits.chargeShipping = properties.chargeShipping === 'true'
+    kits.customerTypes = properties.customerTypes
+    kits.dangerousGoods = properties.dangerousGoods === 'true'
+    // missing
+    kits.excludeFromSearch = properties.excludeFromSearch === 'true'
+    kits.isExclusive = properties.isExclusive === 'true'
+    kits.marketAttributes = properties?.marketAttributes
+    kits.maxQuantity = (product.inventoryProperties || {}).atpQty
+    const priceData = parsePrice(product)
+    kits.points = priceData?.points
+    kits.price = priceData?.price
+    kits.purchaseTypes = {
+        buyOnce: kits?.availableChannels?.includes('web'), 
+        subscription: kits?.availableChannels?.includes('subscription')
+    }
+    kits.retailDiscount= properties?.retailDiscount
+    kits.wholesaleDiscount = properties?.wholesaleDiscount
+    kits.pvDiscount = properties?.pvDiscount
+    kits.cvDiscount = properties?.cvDiscount
+    kits.sbDiscount = properties?.sbDiscount
+    kits.grpDiscount = properties?.grpDiscount
+    kits.scanQualifiedCount = properties?.scanQualifiedCount
+    // newVariant.slug = undefined
+    kits.status = parseStatus(product)
+    if ((kits.status || {}).status === 'active') kits.status.status = 'sellable'
+    const kitProducts = []
+    if (properties.type === 'kit') {
+        kits.type = 'skuKit'
+        kits.availableQuantity = parseKitAvailableQuantity(product.skuKit)
+        for (const kit of product.skuKit) {
+            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') {
+        kits.type = 'bundle'
+        kits.availableQuantity = parseBundleAvailableQuantity(properties)
+        for (const kit of properties?.requiredProducts || []) {
+            const kitProduct = formatKit(kit?.product, market)
+            kitProduct.id = kit.product.id
+            kitProducts.push({product: kitProduct, quantity: kit?.quantity || 0, isMandatory:true})
+        }
+        for (const kit of properties?.optionalProducts || []) {
+            const kitProduct = formatKit(kit?.product, market)
+            kitProduct.id = kit.product.id
+            kitProducts.push({product: kitProduct, quantity: kit?.quantity || 0, isMandatory:false})
+        }
+    }
+    kits.kitProducts = kitProducts
+    return kits
+}
+
+const formatKit = (product, market) => {
+
+    if (!product) {
+        return {}
+    }
+
+    let kit = null
+    if(['kit', 'bundle'].includes(product.type)) {
+        kit = parseKit(product.bundle, market)
+    }
+    return {
+        ...product,
+        bundle: kit 
+   
+    }
+}
+
+
+module.exports = {
+    formatKit
+}
+

package/src/formatProduct.js

@@ -1,79 +1,83 @@
 const helpers = require('./helpers')
 const entities = require('entities')
+const { formatKit } = require('./formatKit')
 
 /* istanbul ignore next */
-const formatProduct = (parent, homeUrl) => ({
-    // Each value is a function with a parameter 'parent' that is the current instance of a Product
-    // ContentStack references need to be queried separately (ie: variants)
-    id: parent.uid,
-    slug: parent?.seo_information?.slug,
-    variantSelectLabel: parent.variant_select_label,
-    secondaryTitle: parent.secondary_title,
-    title: parent.name,
-    productImages: helpers?.getProductImages(parent),
-    salesLabel: parent.sales_label,
-    salesText: parent.sales_text,
-    description: entities.decodeHTML(parent.short_description || ''),
-    salesDisclaimer: helpers?.mapSalesDisclaimer(parent.sales_disclaimer),
-    features: helpers?.mapFeatures(parent),
-    productDetails: helpers?.mapProductDetails(parent),
-    benefitsMedia: {
-        image: helpers?.mapImage(parent.benefits_media?.image),
-        youTubeVideoId: parent.benefits_media?.youtube_video_id
-    },
-    benefits: helpers?.mapBenefits(parent),
-    benefitsAndFeatures: helpers?.mapBenefitsAndFeatures(parent),
-    bundle: parent?.bundle,
-    type: parent?.type,
-    results: helpers?.mapResults(parent),
-    sustainability: helpers?.mapSustainability(parent),
-    usage: helpers?.mapUsage(parent, parent.legacy_usage),
-    resources: helpers?.mapResources(parent),
-    faqs: helpers?.mapFaqs(parent),
-    categories: parent.categories?.map((category) => ({
-        displayName: category.display_name,
-        id: category.category_id,
-        subcategories: category.subcategories?.map((subcategory) => ({
-            displayName: subcategory.display_name,
-            id: subcategory.category_id
-        }))
-    })),
-    ingredients: helpers?.mapIngredients(
-        parent.ingredients,
-        parent.legacy_ingredients
-    ),
-    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,
-    disclaimers: parent.disclaimers || [],
-    disclaimerWarnings: helpers?.mapDisclaimerWarnings(
-        parent.disclaimer_warnings
-    ),
-    seoInformation: helpers?.mapSeoInformation(parent, homeUrl),
-    variants: helpers?.mapVariants(parent),
-    refund: helpers?.mapRefund(parent),
-    shipping: helpers?.mapShipping(parent),
-    generalDisclaimer: parent.translations?.general_disclaimer_text,
-    thirdPartyScripts: parent.third_party_scripts
-        ?.filter((tps) => tps.enabled && !!tps.script)
-        ?.map((tps) => tps.script),
-    csAtts: {
-        version: parent._version || 0,
-        updatedAt: parent.updated_at || '',
-        updatedBy: parent.updated_by || '',
-        createdAt: parent.created_at || '',
-        createdBy: parent.created_by || '',
-        locale: parent.locale || ''
-    },
-    relevancyRank: parent.relevancy_rank || null,
-    warranty:  helpers?.mapWarranty(parent),
-    upSellProductIds:  helpers?.mapUpSellProductIds(parent),
-    crossProductIds:  helpers?.mapCrossProductIds(parent)
-})
+const formatProduct = (parent, homeUrl) => {
+    const formatedProduct = {
+        // Each value is a function with a parameter 'parent' that is the current instance of a Product
+        // ContentStack references need to be queried separately (ie: variants)
+        id: parent.uid,
+        slug: parent?.seo_information?.slug,
+        variantSelectLabel: parent.variant_select_label,
+        secondaryTitle: parent.secondary_title,
+        title: parent.name,
+        productImages: helpers?.getProductImages(parent),
+        salesLabel: parent.sales_label,
+        salesText: parent.sales_text,
+        description: entities.decodeHTML(parent.short_description || ''),
+        salesDisclaimer: helpers?.mapSalesDisclaimer(parent.sales_disclaimer),
+        features: helpers?.mapFeatures(parent),
+        productDetails: helpers?.mapProductDetails(parent),
+        benefitsMedia: {
+            image: helpers?.mapImage(parent.benefits_media?.image),
+            youTubeVideoId: parent.benefits_media?.youtube_video_id
+        },
+        benefits: helpers?.mapBenefits(parent),
+        benefitsAndFeatures: helpers?.mapBenefitsAndFeatures(parent),
+        bundle: parent?.bundle,
+        type: parent?.type,
+        results: helpers?.mapResults(parent),
+        sustainability: helpers?.mapSustainability(parent),
+        usage: helpers?.mapUsage(parent, parent.legacy_usage),
+        resources: helpers?.mapResources(parent),
+        faqs: helpers?.mapFaqs(parent),
+        categories: parent.categories?.map((category) => ({
+            displayName: category.display_name,
+            id: category.category_id,
+            subcategories: category.subcategories?.map((subcategory) => ({
+                displayName: subcategory.display_name,
+                id: subcategory.category_id
+            }))
+        })),
+        ingredients: helpers?.mapIngredients(
+            parent.ingredients,
+            parent.legacy_ingredients
+        ),
+        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,
+        disclaimers: parent.disclaimers || [],
+        disclaimerWarnings: helpers?.mapDisclaimerWarnings(
+            parent.disclaimer_warnings
+        ),
+        seoInformation: helpers?.mapSeoInformation(parent, homeUrl),
+        variants: helpers?.mapVariants(parent),
+        refund: helpers?.mapRefund(parent),
+        shipping: helpers?.mapShipping(parent),
+        generalDisclaimer: parent.translations?.general_disclaimer_text,
+        thirdPartyScripts: parent.third_party_scripts
+            ?.filter((tps) => tps.enabled && !!tps.script)
+            ?.map((tps) => tps.script),
+        csAtts: {
+            version: parent._version || 0,
+            updatedAt: parent.updated_at || '',
+            updatedBy: parent.updated_by || '',
+            createdAt: parent.created_at || '',
+            createdBy: parent.created_by || '',
+            locale: parent.locale || ''
+        },
+        relevancyRank: parent.relevancy_rank || null,
+        warranty: helpers?.mapWarranty(parent),
+        upSellProductIds: helpers?.mapUpSellProductIds(parent),
+        crossProductIds: helpers?.mapCrossProductIds(parent)
+    }
+    return formatKit(formatedProduct)
+}
 
 module.exports = {
     formatProduct