@nuskin/cs-product-lib 1.0.0-ian-001.1

package/README.md

@@ -0,0 +1,43 @@
+# @nuskin/cs-product-lib
+
+Library for pulling and parsing product content (and applying business logic) retrieved from Contentstack.
+
+## Installing
+
+Using npm:
+
+```bash
+npm add @nuskin/cs-product-lib
+```
+
+Usng yarn:
+
+```bash
+yarn add @nuskin/cs-product-lib
+```
+
+## Example usage
+
+```js
+const { tbd } = require('@nuskin/cs-product-lib')
+tbd.doSomething()
+
+```
+
+## Resources
+
+- Changelog could go here
+
+## License
+
+[MIT](https://opensource.org/licenses/MIT) 
+
+#### 7. Turning on your CI/CD pipeline
+
+Once you are ready for your project to start running the CI/CD pipeline, you should rename the `gitlab-ci.yml`
+to `.gitlab-ci.yml`.
+```bash
+git mv gitlab-ci.yml .gitlab-ci.yml
+git commit -am"Chore: renaming gitlab-ci.yml to .gitlab-ci.yml so my pipeline runs"
+git push
+```

package/package.json

@@ -0,0 +1,47 @@
+{
+  "name": "@nuskin/cs-product-lib",
+  "version": "1.0.0-ian-001.1",
+  "description": "Library for pulling and parsing product content (and applying business logic) retrieved from Contentstack",
+  "main": "src/index.js",
+  "scripts": {
+    "audit": "yarn audit --level high",
+    "jsdoc": "node_modules/.bin/jsdoc -a all -c jsdoc.json -r -d jsdocs",
+    "lint": "eslint src __tests__",
+    "test": "jest --coverage"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git@code.tls.nuskin.io:ns-am/product/js-libs/cs-product-lib.git"
+  },
+  "keywords": [],
+  "author": "Nuskin BFF Team",
+  "license": "MIT",
+  "homepage": "https://code.tls.nuskin.io/ns-am/product/js-libs/cs-product-lib/blob/master/README.md",
+  "devDependencies": {
+    "@nuskin/docdash": "1.0.1",
+    "eslint": "7.21.0",
+    "eslint-config-google": "0.14.0",
+    "eslint-config-prettier": "8.1.0",
+    "eslint-plugin-json": "2.1.2",
+    "eslint-plugin-prettier": "3.3.1",
+    "jest": "29.4.1",
+    "jest-sonar-reporter": "2.0.0",
+    "jsdoc": "3.6.6",
+    "prettier": "2.2.1"
+  },
+  "files": [
+    "src/"
+  ],
+  "dependencies": {
+    "@contentstack/json-rte-serializer": "2.0.1",
+    "@nuskin/ns-common-lib": "1.4.5",
+    "axios": "1.3.0",
+    "axios-retry": "3.4.0",
+    "entities": "4.4.0",
+    "lodash": "4.17.21",
+    "turndown": "7.1.1"
+  }
+}

package/src/csProduct.js

@@ -0,0 +1,187 @@
+"use strict"
+
+const axios = require('axios');
+const axiosRetry = require('axios-retry');
+const {arrayString} = require('./helpers')
+
+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';
+
+    // 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}`; 
+
+    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
+    });
+
+    const asObject = () => {
+        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'
+        }
+        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 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;
+        }
+    }
+      
+    // 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
+    }) => {
+        // 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 (includes) {
+            for (const include of includes) {
+                url += `&include[]=${include}`
+            }
+        }
+        if (environment === DEV_ENVIRONMENT){
+            url += '&include_fallback=true'
+        }
+        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;
+        } catch (error) {
+            // log.error(error.response);
+            return error;
+        }
+    }
+
+    const queryProducts = async(query, locale) => {
+        const products = await getEntriesByQuery({query, locale})
+        return products
+    }
+
+    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 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 getProductsBySlug = async (slugs, locale) => {
+        if (!Array.isArray(slugs)) {
+            slugs = [slugs]
+        }
+        const query = `{"seo_information.slug": {"$in": ${arrayString(slugs)}}}`
+        return await queryProducts(query, locale)
+    }
+
+    const getProductsByUID = async (ids, locale) => {
+        if (!Array.isArray(ids)) {
+            ids = [ids]
+        }
+        const query = `{"uid": {"$in": ${arrayString(ids)}}}`
+        return await queryProducts(query, locale)
+    }
+
+    const getTranslations = async (locale) => {
+        const translations = await getEntriesByQuery({contentType: 'strings_product_detail_page', locale, includes: ['common_strings'] })
+        return translations
+    }
+
+    return {
+        asObject,
+        getEntriesByQuery,
+        getProductsBySku,
+        getProductsByGlobalId,
+        getProductsBySlug,
+        getProductsBySlugs,
+        getProductsByQuery,
+        getProductsByUID,
+        getTranslations
+    }
+}
+
+module.exports = {
+    csProduct
+}

package/src/helpers.js

@@ -0,0 +1,558 @@
+'use strict';
+
+const { stripHtml } = require('@nuskin/ns-common-lib');
+const TurndownService = require('turndown')
+const {jsonToHtml} = require('@contentstack/json-rte-serializer')
+const entities = require('entities');
+const template = require('lodash/template')
+const templateSettings = require('lodash/templateSettings')
+
+function isIterable(obj) {
+    // checks for null and undefined
+    if (obj == null) {
+        return false;
+    }
+    return typeof obj[Symbol.iterator] === 'function';
+}
+
+function decodeHTML(decodeMe) {
+    if (Array.isArray(decodeMe)) {
+        for (const item of decodeMe) {
+            entities.decodeHTML(item);
+        }
+    } else if (typeof(decodeMe) === 'string') {
+        return entities.decodeHTML(decodeMe);
+    }
+    return decodeMe;
+}
+
+function rteHasContent(rteField) {
+    const markdown = createMarkdownFromRTE(rteField);
+    return !!markdown;
+}
+
+function mapSubscriptions(subscriptions) {
+    templateSettings.interpolate = /{([\s\S]+?)}/g;
+
+    const [{content = [], footer} = {}] = subscriptions?.modal || []
+    const parseContent = content.map(({_metadata : {uid}, ...props}) => ({
+        uid, ...props
+    }))
+
+    const buildLink = ({href = '#', title = ''} = {}) => `<a href='${href}' target='blank'>${title}</a>`
+
+    const footerTemplate = template(footer?.content_text)
+    const parseFooter = footerTemplate({
+        terms_conditions: buildLink(footer?.terms_conditions),
+        return_policy: buildLink(footer?.return_policy),
+        faq: buildLink(footer?.faq)
+    })
+
+    return {
+        message : subscriptions?.message,
+        triggerText: subscriptions?.trigger_text,
+        modal : {
+            content: parseContent,
+            footer: htmlToMarkdown(parseFooter)
+        }
+    }
+}
+
+function getBestSkuData(variant) {
+    if (variant.sap_data && variant.sap_data.sku_data && variant.sap_data.sku_data.length > 0) {
+        if (variant.sap_data.sku_data.length > 1) {
+            let bestSKUData = variant.sap_data.sku_data.find(s=>s.status === 10);
+            bestSKUData = variant.sap_data.sku_data.find(s=>(s.status_selections || {}).status === 'sellable') || bestSKUData;
+            if (!bestSKUData) {
+                bestSKUData = variant.sap_data.sku_data.find(s=>s.status === 9);
+                bestSKUData = variant.sap_data.sku_data.find(s=>(s.status_selections || {}).status === 'inactive') || bestSKUData;
+                if (!bestSKUData) {
+                    bestSKUData = variant.sap_data.sku_data.find(s=>s.status !== 2);
+                    bestSKUData = variant.sap_data.sku_data.find(s=>(s.status_selections || {}).status !== 'discontinued') || bestSKUData;
+                }
+                if (!bestSKUData) {
+                    bestSKUData = variant.sap_data.sku_data[0];
+                }
+            }
+            return bestSKUData;
+        } 
+        return variant.sap_data.sku_data[0] || {};
+    }
+    else if (variant.sap_data && Array.isArray(variant.sap_data.sku)) {
+        if (variant.sap_data.sku.length > 1) {
+            let bestSKUData = variant.sap_data.sku.find(s=>s.retail_status === 10);
+            if (!bestSKUData) {
+                bestSKUData = variant.sap_data.sku.find(s=>s.retail_status === 9);
+                if (!bestSKUData) {
+                    bestSKUData = variant.sap_data.sku.find(s=>s.retail_status !== 2);
+                }
+            }
+            bestSKUData.status = bestSKUData.retail_status;
+            return bestSKUData;
+        } 
+        if (variant.sap_data.sku[0]) {
+            variant.sap_data.sku[0].status = variant.sap_data.sku[0].retail_status;
+        }
+        return variant.sap_data.sku[0] || {};
+    } else if (variant.sap_data && variant.sap_data.sku) {
+        variant.sap_data.sku.status = variant.sap_data.sku.retail_status;
+        return variant.sap_data.sku;
+    }
+    return {};
+}
+
+function mapCsStatus(variant) {
+    const bestSKU = getBestSkuData(variant);
+    const status = {isBackordered: false, backorderedAvailableDate: null};
+  
+    if (bestSKU.status_selections) {
+        status.status = status.retail = status.wholesale = bestSKU.status_selections.status;
+        return status;
+    }
+
+    switch (bestSKU.status) {
+        case 10:
+            status.status = status.retail = status.wholesale = 'sellable';
+            break;
+        case 9:
+            status.status = status.retail = status.wholesale = 'inactive';
+            break;
+        case 5:
+            status.status = status.retail = status.wholesale = 'stopped';
+            break;
+        case 4:
+            status.status = status.retail = status.wholesale = 'bundleOnly';
+            break;
+        case 2:
+            status.status = status.retail = status.wholesale = 'discontinued';
+            break;
+        default:
+            status.status = status.retail = status.wholesale = 'inactive';
+            break;
+    }
+    return status;
+}
+
+function mapImage(image) {
+    if (Array.isArray(image)) {
+        image = image[0];
+    }
+    if ((image || {}).type) {
+        if (image.type === 'VIDEO') {
+            const derivatives = image.derivatives || {};
+            if ((image.previewUrls || []).length > 0) {
+                return {url: image.previewUrls[0], alt: image.description || image.name || '', thumbnail: derivatives.thumbnail};
+            }
+            return {url: derivatives.webImage, alt: image.description || image.name || '', thumbnail: derivatives.thumbnail};
+        }
+    }
+    if ((image || {}).derivatives) {
+        return {url: (image.derivatives || {}).webImage, alt: image.description || image.name || '', thumbnail: (image.derivatives || {}).thumbnail};
+    } else if ((image || {}).files) {
+        return {url: (image.files.webImage || {}).url, alt: image.description || image.name || '', thumbnail: (image.files.thumbnail || {}).url};
+    }
+    return (image || {}).url ? { url: image.url, alt: image.description || image.title || '', thumbnail: image.url } : null;
+}
+
+function mapLink(link) {
+    return (link || {}).href ? { url: link.href, text: link.title || '' } : null;
+}
+
+function mapProductDetails(productOrVariant) {
+    const productDetails = (productOrVariant || {}).product_details || {};
+    if ((productOrVariant.long_description_override || []).length > 0) {
+        productDetails.long_description = productOrVariant.long_description_override;
+    }
+    if ((productOrVariant.included_items_override || []).length > 0) {
+        productDetails.included_items = productOrVariant.included_items_override;
+    }
+    let description = productDetails.long_description;
+    if (!Array.isArray(description)) {
+        description = createMarkdown(description && description.type ? description : null, description);
+        description = description.type || description === '' || description === 'undefined' || description === null ? [] : [description]; 
+    }
+    const includedItems = productDetails.included_items;
+    const highlights = (productDetails.highlights || []).map(highlight => ({
+        iconUrl: (highlight.icon || {}).url,
+        label: highlight.text
+    }));
+    const originCountry = productDetails.origin_country;
+    const importer = productDetails.importer;
+    const warnings = productDetails.warnings;
+    return {
+        description: decodeHTML(description), 
+        includedItems: decodeHTML(includedItems), highlights, originCountry, importer, warnings
+    }
+}
+
+function featureImage(feature) {
+    let image = Array.isArray(feature.image) ? feature.image[0] : feature.image;
+    if(Array.isArray(feature.image_bynder) && feature.image_bynder.length > 0) {
+        image = feature.image_bynder;
+    }
+    return image;
+}
+
+function mapFeatures(productOrVariant) {
+    return ((productOrVariant || {}).features || []).map((feature = {}) => ({
+    // eslint-disable-next-line no-nested-ternary
+        image: mapImage(featureImage(feature)),
+        subtitle: feature.header,
+        features: feature.features,
+        backgroundColor: feature.background_color
+    }))
+}
+
+function benefitsToMarkdown(legacyBenefits, jsonBenefits) {
+    let benefits = '';
+    if (legacyBenefits.length > 0) {
+        const leg = legacyBenefits.map(benefit => ({
+            title: benefit.header,
+            benefits: benefit.benefits || []
+        }));
+        for (let i = 0; i < leg.length; i++) {
+            if (leg[i].title) {
+                benefits += `**${leg[i].title.trim().replace(/\*/g, '\\*')}**\n`;
+            }
+            for (const benefit of leg[i].benefits) {
+                benefits += `\n*   ${benefit.trim().replace(/\*/g, '\\*')}`;
+            }
+            if (i < leg.length-1) {
+                benefits += '\n\n';
+            }
+        }
+    }
+    if (jsonBenefits && rteHasContent(jsonBenefits)) {
+        benefits = createMarkdown(jsonBenefits);
+    }
+    return decodeHTML(benefits);
+}
+
+function mapBenefits(productOrVariant) {
+    let benefitsMedia = (productOrVariant || {}).benefits_media || {};
+    const legacyBenefits = Array.isArray((productOrVariant || {}).benefits) ? productOrVariant.benefits : [];
+    if ((productOrVariant || {}).benefits && (productOrVariant.benefits.image || productOrVariant.benefits.youtube_video_id)) {
+        benefitsMedia = {
+            image: Array.isArray(productOrVariant.benefits.image) ? productOrVariant.benefits.image[0] : productOrVariant.benefits.image,
+            youTubeVideoId: productOrVariant.benefits.youtube_video_id
+        }
+    }
+    // Account for new section in Product
+    if ((productOrVariant || {}).benefits_and_key_features && rteHasContent((productOrVariant || {}).benefits_and_key_features) && (productOrVariant.benefits_and_key_features.image || productOrVariant.benefits_and_key_features.youtube_video_id)) {
+        benefitsMedia = {
+            image: Array.isArray(productOrVariant.benefits_and_key_features.image) ? productOrVariant.benefits_and_key_features.image[0] : productOrVariant.benefits_and_key_features.image,
+            youTubeVideoId: productOrVariant.benefits_and_key_features.youtube_video_id
+        }
+    }
+    let jsonBenefits = (productOrVariant || {}).benefits && 
+    productOrVariant.benefits.benefits && 
+    productOrVariant.benefits.benefits.type ? productOrVariant.benefits.benefits : null;
+    // Account for new section in Product
+    jsonBenefits= (productOrVariant || {}).benefits_and_key_features && 
+  productOrVariant.benefits_and_key_features.benefits ? productOrVariant.benefits_and_key_features.benefits : jsonBenefits;
+  
+    return {
+        image: mapImage(benefitsMedia.image),
+        youTubeVideoId: benefitsMedia.youTubeVideoId,
+        benefits: benefitsToMarkdown(legacyBenefits, jsonBenefits)
+    }
+}
+
+function mapResults(productOrVariant) {
+    const results = (productOrVariant || {}).results || {};
+    const summary = results.summary ? [results.summary] : [];
+    return {
+        summary: Array.isArray(results.summary) ? results.summary : summary,
+        results: (results.results || []).map(result => ({
+            percentage: result.number,
+            text: decodeHTML(result.description)
+        })),
+        report: {
+            url: results.report_url,
+            text: results.report_text
+        },
+        image: mapImage((Array.isArray(results.image_or_video) && results.image_or_video.length > 0) || results.image),
+        youTubeVideoId: results.youtube_video_id
+    }
+}
+
+function mapSustainability(product) {
+    const sustainability = (product || {}).sustainability || {};
+    const youTubeVideoId = sustainability.youtube_video;
+    const image = mapImage(Array.isArray(sustainability.image) ? sustainability.image[0] : sustainability.image);
+    const richText = sustainability.description;
+    const description = hasRichTextContent(richText) ? createMarkdown(richText) : null;
+    const highlights = (sustainability.highlights || []).map(highlight => ({
+        image: mapImage((Array.isArray(highlight.image) ? highlight.image[0] : highlight.image)),
+        description: hasRichTextContent(highlight.description) ? createMarkdown(highlight.description) : null
+    }));
+    return {
+        youTubeVideoId,
+        image,
+        description,
+        highlights
+    }
+}
+
+function mapUsage(productOrVariant, legacyUsage) {
+    const usage = (productOrVariant || {}).usage || {};
+    return {
+        video: {
+            url: usage.video_url,
+            posterUrl: usage.video_thumbnail_url
+        },
+        steps: decodeHTML(usage.steps),
+        recommendations: decodeHTML(usage.recommendations),
+        warnings: decodeHTML(usage.warnings),
+        additionalText: usage.additional_text,
+        image: mapImage(usage.image_or_video || usage.image),
+        youTubeVideoId: usage.youtube_video_id,
+        markdown: legacyUsage ? htmlToMarkdown(legacyUsage) : null
+    }
+}
+
+function mapResource(resource) {
+    if (resource.bynder_document && resource.bynder_document.length > 0) {
+        const bynder = resource.bynder_document[0];
+        return {
+            title: bynder.name || bynder.description || '',
+            url: (bynder.derivatives || {}).original,
+            image: {
+                url: (bynder.derivatives || {}).thumbnail,
+                alt: (bynder.meta || {}).SEO_Tags || bynder.description || bynder.name || resource.title || ''
+            }
+        }
+    }
+  
+    return {
+        title: (resource.download_link || {}).title,
+        url: (resource.download_link || {}).href,
+        image: {
+            url: (resource.link_image || {}).url,
+            alt: (resource.link_image || {}).title
+        }
+    }
+}
+
+function mapResources(productOrVariant) {
+    if (productOrVariant.resources && Array.isArray(productOrVariant.resources) && productOrVariant.resources.length > 0) {
+        return productOrVariant.resources.map(resource => (
+            mapResource(resource)
+        ));
+    }
+    try {
+        const legacyResources = JSON.parse((productOrVariant.legacy_resources || '[]'));
+        return (legacyResources || []).map(resource => ({
+            title: resource.title,
+            url: resource.url,
+            image: {
+                url: (resource.link_image || {}).url,
+                alt: (resource.link_image || {}).title
+            }
+        }));
+    } catch(error) {
+        return [];
+    }
+}
+
+function mapIngredients(ings, legacyIngredients) {
+    if (Array.isArray(ings)) {
+        return ings.map(ingredients => ({
+            keyIngredients: ((ingredients || {}).key_ingredients || []).map(keyIngredient => ({
+                image: {url:(keyIngredient.icon || {}).url, alt:(keyIngredient.icon || {}).title},
+                name: keyIngredient.header,
+                description: keyIngredient.description
+            })),
+            nutritionInformationImage: (ingredients || {}).nutrition_information_image
+                ? { url: ingredients.nutrition_information_image.url, alt: ingredients.nutrition_information_image.title }
+                : null,
+            productName: (ingredients || {}).product_name,
+            allIngredients: decodeHTML((ingredients || {}).all_ingredients),
+            otherIngredients: (ingredients || {}).other_ingredients,
+            activeIngredients: (ingredients || {}).active_ingredients,
+            inactiveIngredients: (ingredients || {}).inactive_ingredients,
+            ingredientDisclaimers: (ingredients || {}).ingredient_disclaimers || [],
+            markdown: legacyIngredients ? htmlToMarkdown(legacyIngredients) : null
+        }))
+    }
+
+    const keyIngredients = (ings || {}).key_ingredients || [];
+    if (keyIngredients.length > 0) {
+        return [{
+            keyIngredients: keyIngredients.map(keyIngredient => ({
+                image: {url:(keyIngredient.icon || {}).url, alt:(keyIngredient.icon || {}).title},
+                name: keyIngredient.header,
+                description: keyIngredient.description
+            })),
+            nutritionInformationImage: (ings || {}).nutrition_information_image
+                ? { url: ings.nutrition_information_image.url, alt: ings.nutrition_information_image.title }
+                : null,
+            allIngredients: decodeHTML((ings || {}).all_ingredients),
+            otherIngredients: (ings || {}).other_ingredients,
+            activeIngredients: (ings || {}).active_ingredients,
+            inactiveIngredients: (ings || {}).inactive_ingredients,
+            ingredientDisclaimers: (ings || {}).ingredient_disclaimers || [],
+            markdown: legacyIngredients ? htmlToMarkdown(legacyIngredients) : null
+        }]
+    }
+    return [];
+}
+
+function mapSalesDisclaimer(salesDisclaimer) {
+    salesDisclaimer = salesDisclaimer || {};
+    const text = stripHtml(salesDisclaimer.text || '');
+    const richText = salesDisclaimer.rich_text;
+    if (!text && !hasRichTextContent(richText)) {
+        return null;
+    }
+    const boldText = salesDisclaimer.bold_text || '';
+    const link = mapLink(salesDisclaimer.link);
+    const markdownText = createMarkdown(richText, text, boldText, link);
+    return {
+        text,
+        boldText,
+        link,
+        markdownText
+    };
+}
+
+function mapDisclaimerWarnings(disclaimerWarnings) {
+    disclaimerWarnings = disclaimerWarnings || [];
+    return disclaimerWarnings
+        .map((disclaimerWarning) => {
+            const text = stripHtml(disclaimerWarning.text || '');
+            const richText = disclaimerWarning.rich_text;
+            if (!text && !hasRichTextContent(richText)) {
+                return null;
+            }
+            const icon = mapImage(disclaimerWarning.icon);
+            const boldText = disclaimerWarning.bold_text || '';
+            const link = mapLink(disclaimerWarning.link);
+            const markdownText = createMarkdown(richText, text, boldText, link);
+            return {
+                icon,
+                text,
+                boldText,
+                link,
+                markdownText
+            };
+        })
+        .filter((disclaimerWarning) => !!disclaimerWarning);
+}
+
+function hasRichTextContent(richText) {
+    // when cleared, the rich text json still contains children, this checks for any text or links
+    return ((richText || {}).children || []).some((line) =>
+        (line.children || []).some(
+            (block) => (!!block.text && block.text !=='This block is deleted,Remove this placeholder') || (block.children || []).some((part) => (!!part.text && part.text !== 'This block is deleted,Remove this placeholder'))
+        )
+    );
+}
+
+function createMarkdownWithModifiers(text, bold, italic) {
+    let modifier = '';
+    if(bold) {
+        modifier += '**';
+    }
+    if(italic){
+        modifier += '_';
+    }
+    return `${modifier}${text}${modifier}`;
+}
+
+function createMarkdownFromRichText(richText) {
+    let markdown = '';
+    for (const [index, line] of ((richText || {}).children || []).entries()) {
+        if (index > 0) {
+            markdown += '\n';
+        }
+        for (const block of line.children) {
+            if (block.type === 'a') {
+                const url = (block.attrs || {}).url || '';
+                for (const part of block.children) {
+                    const linkMarkdown = `[${part.text}](${url})`;
+                    markdown += createMarkdownWithModifiers(linkMarkdown, part.bold, part.italic);
+                }
+            } else if (block.text) {
+                markdown += createMarkdownWithModifiers(block.text, block.bold, block.italic);
+            }
+        }
+    }
+    return stripHtml(markdown);
+}
+
+function createMarkdownFromRTE(richText) {
+    if (!richText) {
+        return null;
+    }
+    const turndownService = new TurndownService();
+    const htmlVal = jsonToHtml(richText);
+    const markdown = turndownService.turndown(htmlVal);
+    if (markdown === 'This block is deleted,Remove this placeholder') {
+        return null
+    }
+    return stripHtml(markdown); 
+}
+
+function htmlToMarkdown(html) {
+    const turndownService = new TurndownService();
+    const markdown = turndownService.turndown(html);
+    return stripHtml(markdown); 
+}
+
+function createMarkdownFromReplacement(text, boldText, link) {
+    let markdown = text || '';
+    if (boldText) {
+        markdown = markdown.replace('%boldText%', `**${boldText}**`);
+    }
+    if (link && link.text && link.url) {
+        markdown = markdown.replace('%linkText%', `[${link.text}](${link.url})`);
+    }
+    return markdown;
+}
+
+function createMarkdown(richText, text, boldText, link) {
+    if (hasRichTextContent(richText)) {
+        return createMarkdownFromRTE(richText);
+    }
+
+    return createMarkdownFromReplacement(text, boldText, link);
+}
+
+const arrayString = (array) => {
+    let retString = '['
+    if (array[0]) {
+        retString += `"${  array[0]  }"`;
+    }
+    for (let index = 1; index < array.length; index++) {
+        retString += `, "${  array[index]  }"`;
+    }
+    retString += ']'
+    return retString
+}
+
+module.exports = {
+    getBestSkuData,
+    mapImage,
+    mapLink,
+    mapFeatures,
+    mapProductDetails,
+    mapSalesDisclaimer,
+    mapDisclaimerWarnings,
+    mapBenefits,
+    mapResults,
+    mapSustainability,
+    mapUsage,
+    mapResources,
+    mapIngredients,
+    mapCsStatus,
+    hasRichTextContent,
+    createMarkdownWithModifiers,
+    createMarkdownFromRichText,
+    createMarkdownFromReplacement,
+    createMarkdown,
+    isIterable,
+    rteHasContent,
+    mapSubscriptions,
+    arrayString
+};

package/src/index.js

@@ -0,0 +1,7 @@
+'use strict'
+
+const ContentStackProduct = require("./csProduct")
+
+module.exports = {
+    ContentStackProduct
+}

package/src/productStatus.js

@@ -0,0 +1,167 @@
+'use strict';
+
+// WARNING: Set to true if running locally to avoid Redis, don't forget to change back
+// const localDev = false;
+
+/**
+ * @typedef { import("aws-lambda") } AWSLambda
+ */
+
+const axios = require('axios');
+const axiosRetry = require('axios-retry');
+
+axiosRetry(axios, { retries: 1 });
+
+const config = require('config');
+
+const MarketRegionMappings = require('./resources/marketRegionMappings');
+
+const { isNullOrEmpty, getLocaleInfo } = require('@nuskin/ns-common-lib');
+
+/**
+ * Gets a list of skus.
+ * @param {string[]} skus the skus to be retrieved
+ * @param {string} locale the country code and language (ex: en_US)
+ */
+async function getProductStatus(skus, locale) {
+    validateRequest(skus, locale);
+
+    const localeInfo = getLocaleInfo(locale);
+
+    // get market configuration from AEM
+    const marketConfig = await getMarketConfig(localeInfo);
+
+    // if (products.length) {
+    // get product status data for each product
+    const productStatusResponse = await getProductStatusResponse(
+        marketConfig,
+        localeInfo,
+        skus
+    );
+    if (productStatusResponse && productStatusResponse.items) {
+        for (let i = 0; i < skus.length; i++) {
+            if (productStatusResponse.items[skus[i]]) {
+                const productStatus = productStatusResponse.items[skus[i]];
+                const overrideMaxQuantity = marketConfig.skuMaxQty ? marketConfig.skuMaxQty[skus[i]] : undefined;
+                const availableQuantity = productStatus.availableQuantity < 999 ? productStatus.availableQuantity : 999;
+                productStatus.maxQuantity = overrideMaxQuantity || availableQuantity;
+                productStatus.availableQuantity = availableQuantity;
+            }
+        }
+    }
+    return productStatusResponse && productStatusResponse.items || {};
+}
+
+/**
+ * Validates the post request paramaters are acceptible
+ * @param {string[]} skus
+ * @param {string} locale
+ */
+function validateRequest(skus, locale) {
+    const errorMessages = [];
+    if (!skus || !Array.isArray(skus) || skus.length === 0) {
+        errorMessages.push("Required parameter 'skus' is invalid.");
+    }
+    if (!locale || !locale.toString().match(/^[a-z]{2}_[A-Za-z]{2}$/)) {
+        errorMessages.push("Required parameter 'locale' is invalid.");
+    }
+    if (errorMessages.length) {
+    // eslint-disable-next-line no-throw-literal
+        throw {
+            status: 400,
+            message: `Bad Request. ${errorMessages.join(' ')}`
+        };
+    }
+}
+
+/**
+ * Get AEM market configuration
+ * @param {{language: string, countryCode: string}} localeInfo
+ */
+async function getMarketConfig(localeInfo) {
+    const siteHome = config.properties.home;
+    const region = MarketRegionMappings[localeInfo.countryCode];
+    const marketConfigUrl = `${siteHome}/content/configuration/global/markets/${region}.service.${localeInfo.countryCode}.json`;
+
+    let marketConfigResponse = null;
+    let marketConfig;
+    try {
+        if (isNullOrEmpty(marketConfigResponse)) {
+            marketConfigResponse = await axios.get(marketConfigUrl);
+            marketConfig = marketConfigResponse.data;
+        } else if (typeof marketConfigResponse === 'string') {
+            marketConfig = JSON.parse(marketConfigResponse);
+        } else {
+            marketConfig = marketConfigResponse;
+        }
+    } catch (error) {
+    // log.warn({ marketConfigFailed: error });
+    }
+
+    if (marketConfig && !isNullOrEmpty(marketConfig)) {
+        marketConfig.productStatusRequestedQuantity =
+      Number(marketConfig.productStatusRequestedQuantity) || 999;
+
+        if (Array.isArray(marketConfig.skuMaxQty)) {
+            const skuMaxQuantityMapping = {};
+            const skuMaxQuantities = marketConfig.skuMaxQty.map((smq) => JSON.parse(smq));
+            for (const skuMaxQuantity of skuMaxQuantities) {
+                skuMaxQuantityMapping[skuMaxQuantity.sku] = skuMaxQuantity.maxQty;
+            }
+            marketConfig.skuMaxQty = skuMaxQuantityMapping;
+        }
+
+        return marketConfig;
+    }
+    return {};
+}
+
+
+/**
+ * Get product status for each sku
+ * @param {object} marketConfig
+ * @param {{language: string, countryCode: string}} localeInfo
+ * @param {array} skus an array of all variant skus to get status for
+ */
+async function getProductStatusResponse(marketConfig, localeInfo, skus) {
+    const marketRequestedQuantity =  marketConfig.productStatusRequestedQuantity || 999;
+
+    const skusRequest = skus.reduce((result, sku) => {
+        result[sku] = {
+            requestedQuantity: marketRequestedQuantity
+        };
+        return result
+    }, {});
+
+    const productStatusUrl = `${config.properties.awsBase}/product/v2/status?country=${localeInfo.countryCode}`;
+    const productStatusPayload = JSON.stringify(skusRequest);
+
+    try {
+        const axiosInstance = axios.create({
+            baseURL: productStatusUrl,
+            timeout: 10000,
+            headers: {
+                client_id: config.properties.clientId
+                // 'x-correlation-id': correlate.retrieveCorrelationId(),
+            }
+        });
+        axiosRetry(axiosInstance, {
+            retries: 2,
+            shouldResetTimeout: true,
+            // eslint-disable-next-line no-unused-vars
+            retryCondition: (_error) => true
+        });
+
+        const productStatusResponse = await axiosInstance.post('', productStatusPayload);
+
+        return productStatusResponse.data;
+    } catch (error) {
+        console.log({ productStatusFailed: error });
+    }
+
+    return null;
+}
+
+module.exports = {
+    getProductStatus
+};