@nuskin/cs-product-lib 1.0.0 → 1.0.1-cx12-6830.2

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nuskin/cs-product-lib",
-  "version": "1.0.0",
+  "version": "1.0.1-cx12-6830.2",
   "description": "Library for pulling and parsing product content (and applying business logic) retrieved from Contentstack",
   "main": "src/index.js",
   "scripts": {
@@ -40,6 +40,7 @@
     "@nuskin/ns-common-lib": "1.4.5",
     "axios": "1.3.0",
     "axios-retry": "3.4.0",
+    "config": "^3.3.6",
     "entities": "4.4.0",
     "lodash": "4.17.21",
     "turndown": "7.1.1"

package/src/axiosClient.js

@@ -0,0 +1,30 @@
+const axios = require("axios");
+const axiosRetry = require("axios-retry");
+
+const API_TIMEOUT = 3000;
+const CONTENT_STACK_DELIVERY_URL = "https://cdn.contentstack.io/v3/";
+
+
+const deliveryAxios = ({ apiKey, deliveryToken }) => {
+    const axiosClient = axios.create({
+        baseURL: CONTENT_STACK_DELIVERY_URL,
+        timeout: API_TIMEOUT,
+        headers: {
+            api_key: apiKey,
+            access_token: deliveryToken
+        }
+    });
+
+    /* istanbul ignore next */
+    axiosRetry(axiosClient, {
+        retries: 3,
+        shouldResetTimeout: true,
+        retryCondition: () => true
+    });
+
+    return axiosClient;
+};
+
+module.exports = {
+    deliveryAxios
+};

package/src/csProduct.js

@@ -1,187 +1,354 @@
-"use strict"
+'use strict'
 
-const axios = require('axios');
-const axiosRetry = require('axios-retry');
-const {arrayString} = require('./helpers')
+const helpers = require('./helpers')
+const { getProductStatus } = require('./status')
+const { deliveryAxios } = require('./axiosClient')
+const { formatTranslations } = require('./formatTranslations')
+const { formatVariant } = require('./formatVariant')
+const { formatProduct } = require('./formatProduct')
+const { transformBundle } = require('./transformBundle')
+
+const validateConfig = (config) => {
+    if (!config) {
+        throw new Error(
+            `This will not work without a valid configuration {apiKey, environment, deliveryToken}.`
+        )
+    }
+
+    const { apiKey, environment, deliveryToken } = config
+    if (!apiKey) throw new Error('apiKey missing in config.')
+    else if (!environment) throw new Error('environment missing in config.')
+    else if (!deliveryToken) throw new Error('deliveryToken missing in config.')
+}
 
 const csProduct = (config) => {
-    let apiKey = ''
-    let environment = ''
-    let deliveryToken = ''
-
-    // Query Constants (includes, etc.)
-    const DEV_ENVIRONMENT = 'public-dev';
-    const CONTENT_STACK_DELIVERY_URL = 'https://cdn.contentstack.io/v3/';
-    const VARIANTS = 'variants';
-    const KEY_INGREDIENTS = 'ingredients.key_ingredients';
-    const PRODUCT_HIGHLIGHTS = 'product_details.highlights';
-    const VARIANT_HIGHLIGHTS = 'variants.product_details.highlights';
-    const VARIANT_KEY_INGREDIENTS = 'variants.ingredients_override.key_ingredients';
-    const PRODUCT_FAQS = 'faqs';
-    const VARIANT_FAQS = 'variants.faqs';
-    const PRODUCT_RESOURCES = 'resources';
-    const VARIANT_RESOURCES = 'variants.resources';
-    const PRODUCT_CATEGORY = 'categories';
-    const PRODUCT_SUBCATEGORIES = 'categories.subcategories';
-    const DEFAULT_LOCALE = 'en';
-    const PRODUCT_TYPE = 'product';
+    const DEV_ENVIRONMENT = 'public-dev'
+    const VARIANTS = 'variants'
+    const KEY_INGREDIENTS = 'ingredients.key_ingredients'
+    const PRODUCT_HIGHLIGHTS = 'product_details.highlights'
+    const VARIANT_HIGHLIGHTS = 'variants.product_details.highlights'
+    const VARIANT_KEY_INGREDIENTS =
+        'variants.ingredients_override.key_ingredients'
+    const PRODUCT_FAQS = 'faqs'
+    const VARIANT_FAQS = 'variants.faqs'
+    const PRODUCT_RESOURCES = 'resources'
+    const VARIANT_RESOURCES = 'variants.resources'
+    const PRODUCT_CATEGORY = 'categories'
+    const PRODUCT_SUBCATEGORIES = 'categories.subcategories'
+    const DEFAULT_LOCALE = 'en'
+    const PRODUCT_TYPE = 'product'
+    const INCLUDE_FALLBACK = '&include_fallback=true'
+    const REQUIRED = 'required_products.product.'
+    const OPTIONAL = 'optional_products.product.'
+    const BUNDLE_TYPE = 'bundle'
 
     // eslint-disable-next-line max-len
-    const productIncludes = `&include[]=${VARIANTS}&include[]=${PRODUCT_FAQS}&include[]=${KEY_INGREDIENTS}&include[]=${PRODUCT_HIGHLIGHTS}&include[]=${PRODUCT_RESOURCES}&include[]=${VARIANT_KEY_INGREDIENTS}&include[]=${VARIANT_HIGHLIGHTS}&include[]=${VARIANT_FAQS}&include[]=${VARIANT_RESOURCES}&include[]=${PRODUCT_CATEGORY}&include[]=${PRODUCT_SUBCATEGORIES}`; 
+    const productIncludes = `&include[]=${VARIANTS}&include[]=${PRODUCT_FAQS}&include[]=${KEY_INGREDIENTS}&include[]=${PRODUCT_HIGHLIGHTS}&include[]=${PRODUCT_RESOURCES}&include[]=${VARIANT_KEY_INGREDIENTS}&include[]=${VARIANT_HIGHLIGHTS}&include[]=${VARIANT_FAQS}&include[]=${VARIANT_RESOURCES}&include[]=${PRODUCT_CATEGORY}&include[]=${PRODUCT_SUBCATEGORIES}`
+    const requiredIncludes = `&include[]=${REQUIRED}${VARIANTS}&include[]=${REQUIRED}${PRODUCT_FAQS}&include[]=${REQUIRED}${KEY_INGREDIENTS}&include[]=${REQUIRED}${PRODUCT_HIGHLIGHTS}&include[]=${REQUIRED}${PRODUCT_RESOURCES}&include[]=${REQUIRED}${VARIANT_KEY_INGREDIENTS}&include[]=${REQUIRED}${VARIANT_HIGHLIGHTS}&include[]=${REQUIRED}${VARIANT_FAQS}&include[]=${REQUIRED}${VARIANT_RESOURCES}&include[]=${REQUIRED}${PRODUCT_CATEGORY}&include[]=${REQUIRED}${PRODUCT_SUBCATEGORIES}`
+    const optionalIncludes = `&include[]=${OPTIONAL}${VARIANTS}&include[]=${OPTIONAL}${PRODUCT_FAQS}&include[]=${OPTIONAL}${KEY_INGREDIENTS}&include[]=${OPTIONAL}${PRODUCT_HIGHLIGHTS}&include[]=${OPTIONAL}${PRODUCT_RESOURCES}&include[]=${OPTIONAL}${VARIANT_KEY_INGREDIENTS}&include[]=${OPTIONAL}${VARIANT_HIGHLIGHTS}&include[]=${OPTIONAL}${VARIANT_FAQS}&include[]=${OPTIONAL}${VARIANT_RESOURCES}&include[]=${OPTIONAL}${PRODUCT_CATEGORY}&include[]=${OPTIONAL}${PRODUCT_SUBCATEGORIES}`
 
-    if (!config) {
-        throw new Error(`This will not work without a valid configuration {apiKey, environment, deliveryToken}.`)
-    } else {
-        apiKey = config.apiKey
-        environment = config.environment
-        deliveryToken = config.deliveryToken
-    }
-
-    const deliveryAxios = axios.create({
-        baseURL: CONTENT_STACK_DELIVERY_URL,
-        timeout: 3000,
-        headers: {
-            api_key: apiKey,
-            access_token: deliveryToken
-        }
-    });
-    axiosRetry(deliveryAxios, {
-        retries: 3,
-        shouldResetTimeout: true,
-        // eslint-disable-next-line no-unused-vars
-        retryCondition: (_error) => true
-    });
+    validateConfig(config)
+    const { apiKey, environment, deliveryToken } = config
+    const axios = deliveryAxios({ apiKey, deliveryToken })
 
     const asObject = () => {
-        return {apiKey, environment, deliveryToken}
+        return { apiKey, environment, deliveryToken }
     }
 
-    const getProductsBySlugs = async ({
-        slugs = [], locale = DEFAULT_LOCALE
-    }) => {
-        if (!Array.isArray(slugs) || slugs.length < 1) throw new Error(`Invalid Slugs: ${  slugs}`);
-        // eslint-disable-next-line max-len
-        let url = `content_types/${PRODUCT_TYPE}/entries?environment=${environment}&locale=${locale}&include_count=true&query={"seo_information.slug": {"$in": ${arrayString(slugs)}}}`;
-        url += productIncludes
-        if (environment === DEV_ENVIRONMENT){
-            url += '&include_fallback=true'
+    const removeInvalidVariants = async (products, locale, translations) => {
+        const validSkus = []
+        for (const product of products) {
+            for (const variant of product?.variants || []) {
+                const bestSkuData = helpers?.getBestSkuData(variant) || []
+                if (bestSkuData && Object.keys(bestSkuData)?.length > 0) {
+                    validSkus.push(bestSkuData.sku)
+                }
+            }
         }
-        try {
-            const res = await deliveryAxios.get(url);
-            return res && res.data && res.data.entries ? res.data.entries : res;
-        } catch (error) {
-            // log.error(error.response);
-            return error;
+        if (environment === 'public-dev' && validSkus?.length === 0) return
+
+        const localeData = helpers?.parseLocale(locale)
+        locale = helpers?.reorderLocale(locale)
+        let status = {}
+        let marketData = {}
+        if (validSkus?.length > 0) {
+            status = await getProductStatus(validSkus, locale)
+            const localeSplit = locale.split('_')
+            let market =
+                localeSplit?.length > 1 ? localeSplit[1].toUpperCase() : 'XX'
+            if (market === 'XX') {
+                const split2 = locale.split('-')
+                market = split2.length > 1 ? split2[0].toUpperCase() : ''
+            }
+            marketData = await getEntriesByQuery({
+                contentType: 'market',
+                query: `{"iso_code_2": "${market}"}`,
+                locale: 'en'
+            })
+            if (marketData?.length > 0) {
+                marketData = marketData[0]
+            }
+        }
+        for (const product of products) {
+            const validVariants = []
+            for (const variant of product?.variants || []) {
+                const bestSkuData = helpers?.getBestSkuData(variant)
+                if (bestSkuData.sku) {
+                    const varStatus = status[bestSkuData.sku]
+                    if (varStatus && varStatus.status.retail) {
+                        variant.sap_data.sku_data = [bestSkuData]
+                        validVariants.push({
+                            ...variant,
+                            status: varStatus,
+                            marketData
+                        })
+                    }
+                }
+            }
+            product.variants = validVariants
+            product.translations = Array.isArray(translations)
+                ? translations[0]
+                : translations
+            product.localeData = localeData
         }
     }
 
-    const getProductsByQuery = async ({
-        query, locale = DEFAULT_LOCALE
-    }) => {
-        if (!query) throw new Error(`Invalid Query: ${ query }`);
-        // eslint-disable-next-line max-len
-        let url = `content_types/${PRODUCT_TYPE}/entries?environment=${environment}&locale=${locale}&include_count=true&query=${query}`
-        url += productIncludes
-        if (environment === DEV_ENVIRONMENT){
-            url += '&include_fallback=true'
-        }
-        try {
-            const res = await deliveryAxios.get(url);
-            return res && res.data && res.data.entries ? res.data.entries : res;
-        } catch (error) {
-            // log.error(error.response);
-            return error;
+    const parseSharedStrings = async (translations) => {
+        if (helpers?.isIterable(translations)) {
+            for (const translation of translations) {
+                translation.common_strings = translation?.common_strings
+                    ?.map((obj) => {
+                        const commonStrings = { type: obj.key }
+                        // eslint-disable-next-line no-sequences
+                        commonStrings.strings = (
+                            (obj || {}).strings || []
+                        ).reduce(
+                            (result, { key, value }) => (
+                                (result[key] = value), result
+                            ),
+                            {}
+                        )
+                        return commonStrings
+                    })
+                    .reduce((result, { type, strings }) => {
+                        result[type] = strings
+                        return result
+                    }, {})
+            }
         }
     }
-      
+
+    const formatProductWithSchima = (products = []) => {
+        return products?.map((product) => {
+            const formatedProduct = formatProduct(product)
+            formatedProduct.variants = formatedProduct?.variants?.map(
+                (variant) => formatVariant(variant)
+            )
+            return formatedProduct
+        })
+    }
+
+    const formatBundleWithSchima = (products = []) => {
+        return products?.map((product) => {
+            const formatedProduct = transformBundle(product)
+            formatedProduct.variants = formatedProduct?.variants?.map(
+                (variant) => formatVariant(variant)
+            )
+            return formatedProduct
+        })
+    }
+
     // includes is an array of all the referenced types in the contentType you are requesting that should be resolved
     // and returned (Example: ['common_strings'])
     const getEntriesByQuery = async ({
-        contentType = PRODUCT_TYPE, query = '', locale = DEFAULT_LOCALE, includes, start = 0, limit=50, onlyEntries=true
+        contentType = PRODUCT_TYPE,
+        query = '',
+        locale = DEFAULT_LOCALE,
+        includes,
+        start = 0,
+        limit = 50
     }) => {
         // eslint-disable-next-line max-len
         let url = `content_types/${contentType}/entries?environment=${environment}&locale=${locale}&include_count=true&limit=${limit}&query=${query}`
         if (contentType === PRODUCT_TYPE) {
             url += productIncludes
         }
+        if (contentType === BUNDLE_TYPE) {
+            url += requiredIncludes
+            url += optionalIncludes
+        }
         if (includes) {
             for (const include of includes) {
                 url += `&include[]=${include}`
             }
         }
-        if (environment === DEV_ENVIRONMENT){
-            url += '&include_fallback=true'
+        if (environment === DEV_ENVIRONMENT) {
+            url += INCLUDE_FALLBACK
         }
         if (start > 0) {
             url += `&skip=${start}`
         }
         try {
-            const res = await deliveryAxios(url);
-            if (onlyEntries) {
-                return res && res.data && res.data.entries ? res.data.entries : res;
-            } 
-            return res && res.data && res.data.entries ? res.data : res;
+            const res = await axios(url)
+            return res?.data?.entries ? res.data.entries : res
         } catch (error) {
-            // log.error(error.response);
-            return error;
+            return error
         }
     }
 
-    const queryProducts = async(query, locale) => {
-        const products = await getEntriesByQuery({query, locale})
+    const queryProducts = async (query, locale) => {
+        const products = await getEntriesByQuery({ query, locale })
         return products
     }
 
+    const getBundle = async (id, locale) => {
+        const query = `{ "$or": [{ "bundle_id": { "$in": ["${id}"]}}, { "uid": { "$in": ["${id}"] }}] }`
+        const bundles = await getEntriesByQuery({
+            query,
+            locale,
+            contentType: BUNDLE_TYPE
+        })
+        const translations = await getTranslations(locale)
+
+        for (let b = 0; b < bundles.length; b++) {
+            for (
+                let i = 0;
+                i < (bundles[b].required_products || []).length;
+                i++
+            ) {
+                await removeInvalidVariants(
+                    bundles[b].required_products[i].product,
+                    locale,
+                    translations
+                )
+            }
+            for (
+                let i = 0;
+                i < (bundles[b].optional_products || []).length;
+                i++
+            ) {
+                await removeInvalidVariants(
+                    bundles[b].optional_products[i].product,
+                    locale,
+                    translations
+                )
+            }
+        }
+        return formatBundleWithSchima(bundles)
+    }
+
     const getProductsBySku = async (skus, locale) => {
         if (!Array.isArray(skus)) {
             skus = [skus]
         }
-        const query = `{"variants": {"$in_query":{"sap_data.skus": {"$in": ${arrayString([skus])}}}}}`
-        return await queryProducts(query, locale);
+        const query = `{"variants": {"$in_query":{"sap_data.skus": {"$in": ${helpers?.arrayString(
+            [skus]
+        )}}}}}`
+
+        let products = await queryProducts(query, locale)
+        const translations = await getTranslations(locale)
+        // await parseSharedStrings(translations);
+        await removeInvalidVariants(products, locale, translations)
+        return formatProductWithSchima(products)
     }
 
     const getProductsByGlobalId = async (ids, locale) => {
         if (!Array.isArray(ids)) {
             ids = [ids]
         }
-        const query = `{"variants": {"$in_query":{"sap_data.global_id": {"$in": ${arrayString([ids])}}}}}`
-        return await queryProducts(query, locale)
+        const query = `{"variants": {"$in_query":{"sap_data.global_id": {"$in": ${helpers?.arrayString(
+            [ids]
+        )}}}}}`
+
+        let products = await queryProducts(query, locale)
+        const translations = await getTranslations(locale)
+        // await parseSharedStrings(translations);
+        await removeInvalidVariants(products, locale, translations)
+        return formatProductWithSchima(products)
     }
 
     const getProductsBySlug = async (slugs, locale) => {
         if (!Array.isArray(slugs)) {
             slugs = [slugs]
         }
-        const query = `{"seo_information.slug": {"$in": ${arrayString(slugs)}}}`
-        return await queryProducts(query, locale)
+        const query = `{"seo_information.slug": {"$in": ${helpers?.arrayString(
+            slugs
+        )}}}`
+
+        const products = await queryProducts(query, locale)
+        const translations = await getTranslations(locale)
+        // await parseSharedStrings(translations);
+        await removeInvalidVariants(products, locale, translations)
+        return formatProductWithSchima(products)
     }
 
     const getProductsByUID = async (ids, locale) => {
         if (!Array.isArray(ids)) {
             ids = [ids]
         }
-        const query = `{"uid": {"$in": ${arrayString(ids)}}}`
-        return await queryProducts(query, locale)
+        const query = `{"uid": {"$in": ${helpers?.arrayString(ids)}}}`
+        let products = await queryProducts(query, locale)
+        const translations = await getTranslations(locale)
+        // await parseSharedStrings(translations);
+        await removeInvalidVariants(products, locale, translations)
+        return formatProductWithSchima(products)
     }
 
     const getTranslations = async (locale) => {
-        const translations = await getEntriesByQuery({contentType: 'strings_product_detail_page', locale, includes: ['common_strings'] })
+        const translations = await getEntriesByQuery({
+            contentType: 'strings_product_detail_page',
+            locale,
+            includes: ['common_strings', 'subscriptions.modal']
+        })
+        await parseSharedStrings(translations)
         return translations
     }
 
+    const getProductTranslations = async (locale) => {
+        const translations = await getTranslations(locale)
+        const formatedTranslations = translations.map((translate) =>
+            formatTranslations(translate)
+        )
+        return formatedTranslations
+    }
+
+    const publishedProducts = async ({ locale, skip = 0, limit = 50 } = {}) => {
+        let products =
+            (await getEntriesByQuery({
+                locale,
+                start: skip,
+                limit,
+                onlyEntries: false
+            })) || []
+        const count = products.count || 0
+        products = products.entries
+        const translations = await getTranslations(locale)
+        await parseSharedStrings(translations)
+        await removeInvalidVariants(products, locale, translations)
+        const transformProduct = formatProductWithSchima(products)
+        return {
+            products: transformProduct,
+            validCount: products.length,
+            totalCount: count,
+            skip
+        }
+    }
+
     return {
         asObject,
         getEntriesByQuery,
         getProductsBySku,
         getProductsByGlobalId,
         getProductsBySlug,
-        getProductsBySlugs,
-        getProductsByQuery,
         getProductsByUID,
-        getTranslations
+        getTranslations,
+        publishedProducts,
+        formatTranslations,
+        getProductTranslations,
+        getBundle
     }
 }
 
 module.exports = {
     csProduct
-}
+}

package/src/formatProduct.js

@@ -0,0 +1,81 @@
+const helpers = require('./helpers')
+const entities = require('entities')
+
+/* istanbul ignore next */
+const formatProduct = (parent) => ({
+    // 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) => 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),
+    results: helpers?.mapResults(parent),
+    sustainability: helpers?.mapSustainability(parent),
+    usage: helpers?.mapUsage(parent, parent.legacy_usage),
+    resources: helpers?.mapResources(parent),
+    faqs: parent.faqs?.map((faq) => ({
+        question: faq.question,
+        answers: faq.answer || []
+    })),
+    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),
+    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: (parent) => helpers?.mapWarranty(parent),
+    upSellProductIds: (parent) => helpers?.mapUpSellProductIds(parent),
+    crossProductIds: (parent) => helpers?.mapCrossProductIds(parent)
+})
+
+module.exports = {
+    formatProduct
+}