@nuskin/ns-shop 7.5.6-mdigi-4997.1 → 7.6.0-brw-988.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nuskin/ns-shop",
-  "version": "7.5.6-mdigi-4997.1",
+  "version": "7.6.0-brw-988.1",
   "description": "The description that will amaze and astound your audience when they read it",
   "main": "src/shop.js",
   "scripts": {

package/src/cart/equinoxCartService.js

@@ -395,7 +395,7 @@ function _assembleChildSkus(requestData, options) {
     if (personalOffer !== null) {
         personalOffer = JSON.parse(personalOffer);
         productWithVariant = personalOffer.products.filter((sku) =>
-            sku.type.toLowerCase() === 'bundle' && sku.variantSelected !== null && sku.sku === productSku
+            sku.type === 'bundle' && sku.variantSelected !== null && sku.sku === productSku
         )
     }
 
@@ -411,17 +411,18 @@ function _assembleChildSkus(requestData, options) {
             }
             if (personalOffer != null && selectedVariants && cs.skuId != selectedVariants[cs.productId] && (cs.type !== "BUNDLE" && cs.type !== "OPTIONAL")) return null
             const childSku =
-    (personalOffer != null && selectedVariants && selectedVariants[cs.productId] && config?.MySite_graphql_active)                ? {
-        productId: cs.productId,
-        skuId: selectedVariants[cs.productId],
-        type: cs.type,
-        availableChannels: cs.availableChannels
-    } : {
-        productId: cs.productId,
-        skuId: cs.skuId,
-        type: cs.type,
-        availableChannels: cs.availableChannels
-    }
+            (personalOffer != null && selectedVariants && selectedVariants[cs.productId] && config.MySite_graphql_active)
+                ? {
+                    productId: cs.productId,
+                    skuId: selectedVariants[cs.productId],
+                    type: cs.type,
+                    availableChannels: cs.availableChannels
+                } : {
+                    productId: cs.productId,
+                    skuId: cs.skuId,
+                    type: cs.type,
+                    availableChannels: cs.availableChannels
+                }
             if (cs.inventory) {
                 childSku.skuQuantity = cs.skuQuantity;
                 childSku.backOrdered = cs.inventory.backOrdered;

package/src/product/SolrQueryService.js

@@ -4,7 +4,8 @@ import {ProductResultsEnum} from "./productResultsEnum.js";
 import OrderType from "./orderType.js";
 import {SolrProductAdaptor} from "./solrProductAdaptor.js";
 import {SolrQueryUrlService} from "./solrQueryUrlService.js";
-import {getCachedConfigField} from '@nuskin/configuration-sdk';
+import {getCachedConfigField, getCachedConfiguration} from '@nuskin/configuration-sdk';
+import {allPredictiveSearch, predictiveSearch} from "./productSearchAPIQueryService.js"
 
 /**
  *
@@ -436,120 +437,134 @@ let SolrQueryService = function() {
             productResultType, searchTerm, productSearchFields, language, market, searchByOrderType ? rows*5 : rows, start
         );
 
-        // Search for language nodes for the given market that match the search term.
-        let queryResponsePromise = $.ajax({
-            url: solrUrl,
-            type: "GET",
-            contentType: 'application/json; charset=utf-8',
-            headers: {
-                "client_id": getCachedConfigField('solrClientId'),
-                "client_secret": getCachedConfigField('solrClientSecret')
-            },
-            timeout: SolrTimeout,
-            success: function () {
-                //console.log("Search success!");
-            },
-            error: function (xmlHttpRequest, textStatus) {
-                deferred.reject(textStatus);
-                //console.log('Search failed!');
-            }
-        });
+        const {active, MySite_search_API_Base_URLs} = getCachedConfiguration('Equinox_Markets');
 
-        queryResponsePromise.then(function(responseData) {
-            let retValue;
-            let docs, totalNumFound/*, responseHeader*/;
+        if(active && MySite_search_API_Base_URLs !== '') {
 
-            if (typeof(responseData) === "string") {
-                docs = $.parseJSON(responseData).response.docs;
-                totalNumFound = $.parseJSON(responseData).response.numFound;
-                // responseHeader = $.parseJSON(responseData).responseHeader;
-            } else {
-                docs = responseData.response.docs;
-                totalNumFound = responseData.response.numFound;
-                // responseHeader = responseData.responseHeader;
-            }
+            predictiveSearch(deferred, {
+                searchTerm,
+                rows,
+                language,
+                market,
+                page: start/rows
+            })
 
-            if (searchByOrderType) {
-                solrUrl = SolrQueryUrlService.getProductsByRoots(docs, language, market, rows, 0, orderTypes);
-                let _orderTypes = orderTypes;
-                if (solrUrl.url) {
-                    let productDocuments = [];
-                    queryResponsePromise = $.ajax({
-                        url: solrUrl.url,
-                        type: "POST",
-                        contentType: 'application/json; charset=utf-8',
-                        headers: {
-                            "client_id": getCachedConfigField('solrClientId'),
-                            "client_secret":getCachedConfigField('solrClientSecret')
-                        },
-                        timeout: SolrTimeout,
-                        data: JSON.stringify(solrUrl.postData),
-                        success: function (responseData) {
-                            if (typeof(responseData) === "string") {
-                                docs = $.parseJSON(responseData).response.docs;
-                                totalNumFound = $.parseJSON(responseData).response.numFound;
-                            }
-                            else {
-                                docs = responseData.response.docs;
-                                totalNumFound = responseData.response.numFound;
-                            }
+        } else {
+            // Search for language nodes for the given market that match the search term.
+            let queryResponsePromise = $.ajax({
+                url: solrUrl,
+                type: "GET",
+                contentType: 'application/json; charset=utf-8',
+                headers: {
+                    "client_id": getCachedConfigField('solrClientId'),
+                    "client_secret": getCachedConfigField('solrClientSecret')
+                },
+                timeout: SolrTimeout,
+                success: function () {
+                    //console.log("Search success!");
+                },
+                error: function (xmlHttpRequest, textStatus) {
+                    deferred.reject(textStatus);
+                    //console.log('Search failed!');
+                }
+            });
 
-                            // Wrap the products in an adaptor for ease of use.
-                            for (let i = 0; i < docs.length; i++) {
-                                //ONLY RETURN PRODUCTS THAT HAVE A MARKET
-                                if (docs[i]._childDocuments_) {
-                                    for (let m = 0; m < docs[i]._childDocuments_.length; m++) {
-                                        if ((docs[i]._childDocuments_[m].path_exact === "product/" + docs[i].sku + '/' + market.toUpperCase()) &&
-                                            !docs[i]._childDocuments_[m].excludeFromSearch) {
+            queryResponsePromise.then(function(responseData) {
+                let retValue;
+                let docs, totalNumFound/*, responseHeader*/;
 
-                                            if (!skuExistsInProductArray(productDocuments, docs[i].sku.toString())) {
-                                                let prodAdaptor = new SolrProductAdaptor(docs[i]);
-                                                let marketChild = prodAdaptor.getMarketChild(market);
-                                                let languageChild = prodAdaptor.getLanguageChild(language);
-                                                if (existsInArray(marketChild.getOrderType(), _orderTypes)) {
-                                                    productDocuments.push({
-                                                        sku: docs[i].sku,
-                                                        fullImage: marketChild.getFullImageUrl(),
-                                                        name: languageChild.getTitle(),
-                                                        _root_: "product/" + docs[i].sku,
-                                                        isExclusive: languageChild.getIsExclusive()
-                                                    });
+                if (typeof(responseData) === "string") {
+                    docs = $.parseJSON(responseData).response.docs;
+                    totalNumFound = $.parseJSON(responseData).response.numFound;
+                    // responseHeader = $.parseJSON(responseData).responseHeader;
+                } else {
+                    docs = responseData.response.docs;
+                    totalNumFound = responseData.response.numFound;
+                    // responseHeader = responseData.responseHeader;
+                }
+
+                if (searchByOrderType) {
+                    solrUrl = SolrQueryUrlService.getProductsByRoots(docs, language, market, rows, 0, orderTypes);
+                    let _orderTypes = orderTypes;
+                    if (solrUrl.url) {
+                        let productDocuments = [];
+                        queryResponsePromise = $.ajax({
+                            url: solrUrl.url,
+                            type: "POST",
+                            contentType: 'application/json; charset=utf-8',
+                            headers: {
+                                "client_id": getCachedConfigField('solrClientId'),
+                                "client_secret":getCachedConfigField('solrClientSecret')
+                            },
+                            timeout: SolrTimeout,
+                            data: JSON.stringify(solrUrl.postData),
+                            success: function (responseData) {
+                                if (typeof(responseData) === "string") {
+                                    docs = $.parseJSON(responseData).response.docs;
+                                    totalNumFound = $.parseJSON(responseData).response.numFound;
+                                }
+                                else {
+                                    docs = responseData.response.docs;
+                                    totalNumFound = responseData.response.numFound;
+                                }
+
+                                // Wrap the products in an adaptor for ease of use.
+                                for (let i = 0; i < docs.length; i++) {
+                                    //ONLY RETURN PRODUCTS THAT HAVE A MARKET
+                                    if (docs[i]._childDocuments_) {
+                                        for (let m = 0; m < docs[i]._childDocuments_.length; m++) {
+                                            if ((docs[i]._childDocuments_[m].path_exact === "product/" + docs[i].sku + '/' + market.toUpperCase()) &&
+                                                !docs[i]._childDocuments_[m].excludeFromSearch) {
+
+                                                if (!skuExistsInProductArray(productDocuments, docs[i].sku.toString())) {
+                                                    let prodAdaptor = new SolrProductAdaptor(docs[i]);
+                                                    let marketChild = prodAdaptor.getMarketChild(market);
+                                                    let languageChild = prodAdaptor.getLanguageChild(language);
+                                                    if (existsInArray(marketChild.getOrderType(), _orderTypes)) {
+                                                        productDocuments.push({
+                                                            sku: docs[i].sku,
+                                                            fullImage: marketChild.getFullImageUrl(),
+                                                            name: languageChild.getTitle(),
+                                                            _root_: "product/" + docs[i].sku,
+                                                            isExclusive: languageChild.getIsExclusive()
+                                                        });
+                                                    }
                                                 }
                                             }
                                         }
                                     }
                                 }
-                            }
 
-                            let retValue = {
-                                products: productDocuments,
-                                totalNumFound: totalNumFound
-                            };
+                                let retValue = {
+                                    products: productDocuments,
+                                    totalNumFound: totalNumFound
+                                };
 
-                            deferred.resolve(retValue);
-                        },
-                        error: function (xmlHttpRequest, textStatus) {
-                            deferred.reject(textStatus);
-                            //console.log('Search failed!');
-                        }
-                    });
+                                deferred.resolve(retValue);
+                            },
+                            error: function (xmlHttpRequest, textStatus) {
+                                deferred.reject(textStatus);
+                                //console.log('Search failed!');
+                            }
+                        });
+                    } else {
+                        retValue = {
+                            products: docs,
+                            totalNumFound: totalNumFound
+                        };
+                        deferred.resolve(retValue);
+                    }
                 } else {
                     retValue = {
                         products: docs,
                         totalNumFound: totalNumFound
                     };
+
                     deferred.resolve(retValue);
                 }
-            } else {
-                retValue = {
-                    products: docs,
-                    totalNumFound: totalNumFound
-                };
-
-                deferred.resolve(retValue);
-            }
-        });
-
+            });
+        }
+        
         return deferred;
     }
 
@@ -573,113 +588,127 @@ let SolrQueryService = function() {
             productResultType, searchTerm, productSearchFields, language, market, rows, start
         );
 
-        // Search for language nodes for the given market that match the search term.
-        let queryResponsePromise = $.ajax({
-            url: solrUrl,
-            type: "GET",
-            contentType: 'application/json; charset=utf-8',
-            headers: {
-                "client_id": getCachedConfigField('solrClientId'),
-                "client_secret": getCachedConfigField('solrClientSecret')
-            },
-            timeout: SolrTimeout,
-            success: function () {
+        const {active, MySite_search_API_Base_URLs} = getCachedConfiguration('Equinox_Markets');
+
+        if(active && MySite_search_API_Base_URLs !== '') {
+
+            allPredictiveSearch(deferred, {
+                searchTerm,
+                language,
+                market
+            })
+
+        } else {
+
+            // Search for language nodes for the given market that match the search term.
+            let queryResponsePromise = $.ajax({
+                url: solrUrl,
+                type: "GET",
+                contentType: 'application/json; charset=utf-8',
+                headers: {
+                    "client_id": getCachedConfigField('solrClientId'),
+                    "client_secret": getCachedConfigField('solrClientSecret')
+                },
+                timeout: SolrTimeout,
+                success: function () {
                 //console.log("Search success!");
-            },
-            error: function (xmlHttpRequest, textStatus) {
-                deferred.reject(textStatus);
+                },
+                error: function (xmlHttpRequest, textStatus) {
+                    deferred.reject(textStatus);
                 //console.log('Search failed!');
-            }
-        });
+                }
+            });
 
-        queryResponsePromise.then(function(responseData){
-            let matchingRootProducts, totalNumFound, responseHeader;
+            queryResponsePromise.then(function(responseData){
+                let matchingRootProducts, totalNumFound, responseHeader;
 
-            if (typeof(responseData) === "string") {
-                matchingRootProducts = $.parseJSON(responseData).response.docs;
-                totalNumFound = $.parseJSON(responseData).response.numFound;
-                responseHeader = $.parseJSON(responseData).responseHeader;
-            } else {
-                matchingRootProducts = responseData.response.docs;
-                totalNumFound = responseData.response.numFound;
-                responseHeader = responseData.responseHeader;
-            }
+                if (typeof(responseData) === "string") {
+                    matchingRootProducts = $.parseJSON(responseData).response.docs;
+                    totalNumFound = $.parseJSON(responseData).response.numFound;
+                    responseHeader = $.parseJSON(responseData).responseHeader;
+                } else {
+                    matchingRootProducts = responseData.response.docs;
+                    totalNumFound = responseData.response.numFound;
+                    responseHeader = responseData.responseHeader;
+                }
 
-            // If the zkConnected header is true, we count on the data returned from the query being accurate.
-            // If it's false, we will re-try the Solr query so that we are sure we have the most up-to-date information
-            // (We only try again once, which is what sets the retrySolrRequest variable)
-            if (responseHeader.zkConnected || !retrySolrRequest) {
+                // If the zkConnected header is true, we count on the data returned from the query being accurate.
+                // If it's false, we will re-try the Solr query so that we are sure we have the most up-to-date information
+                // (We only try again once, which is what sets the retrySolrRequest variable)
+                if (responseHeader.zkConnected || !retrySolrRequest) {
                 // eslint-disable-next-line
                 // Example solrUrl: http://dev-gateway-mulesoft-21:8080/mec/solr/oak/select?fl=*,[child%20parentFilter=path_exact:product/????????%20childFilter=path_exact:product/????????/en],[child%20parentFilter=path_exact:product/????????%20childFilter=path_exact:product/????????/US]&q=path_exact:product/01003611&rows=5&wt=json
                 // Always start at 0 so we get all the rows we are asking for.
-                solrUrl = SolrQueryUrlService.getProductsByRoots(matchingRootProducts, language, market, rows, 0, orderTypes);
-
-                if (solrUrl.url) {
-                    let productDocuments = [];
-
-                    // Return the complete records for the given matches
-                    queryResponsePromise = $.ajax({
-                        url: solrUrl.url,
-                        type: "POST",
-                        contentType: 'application/json; charset=utf-8',
-                        headers: {
-                            "client_id": getCachedConfigField('solrClientId'),
-                            "client_secret": getCachedConfigField('solrClientSecret')
-                        },
-                        data: JSON.stringify(solrUrl.postData),
-                        timeout: SolrTimeout,
-                        success: function (responseData) {
-                            let docs;
-
-                            if (typeof(responseData) === "string") {
-                                docs = $.parseJSON(responseData).response.docs;
-                            }
-                            else {
-                                docs = responseData.response.docs;
-                            }
+                    solrUrl = SolrQueryUrlService.getProductsByRoots(matchingRootProducts, language, market, rows, 0, orderTypes);
+
+                    if (solrUrl.url) {
+                        let productDocuments = [];
+
+                        // Return the complete records for the given matches
+                        queryResponsePromise = $.ajax({
+                            url: solrUrl.url,
+                            type: "POST",
+                            contentType: 'application/json; charset=utf-8',
+                            headers: {
+                                "client_id": getCachedConfigField('solrClientId'),
+                                "client_secret": getCachedConfigField('solrClientSecret')
+                            },
+                            data: JSON.stringify(solrUrl.postData),
+                            timeout: SolrTimeout,
+                            success: function (responseData) {
+                                let docs;
+
+                                if (typeof(responseData) === "string") {
+                                    docs = $.parseJSON(responseData).response.docs;
+                                }
+                                else {
+                                    docs = responseData.response.docs;
+                                }
 
-                            for (let i = 0; i < matchingRootProducts.length; i++) {
-                                matchingRootProducts[i].path_exact = matchingRootProducts[i]._root_[0];
-                            }
+                                for (let i = 0; i < matchingRootProducts.length; i++) {
+                                    matchingRootProducts[i].path_exact = matchingRootProducts[i]._root_[0];
+                                }
 
-                            // Wrap the products in an adaptor for ease of use.
-                            for (let i = 0; i < docs.length; i++) {
+                                // Wrap the products in an adaptor for ease of use.
+                                for (let i = 0; i < docs.length; i++) {
                                 //ONLY RETURN PRODUCTS THAT HAVE A MARKET
-                                if (docs[i]._childDocuments_) {
-                                    for (let m = 0; m < docs[i]._childDocuments_.length; m++) {
-                                        if ((docs[i]._childDocuments_[m].path_exact === "product/" + docs[i].sku + '/' + market.toUpperCase()) &&
+                                    if (docs[i]._childDocuments_) {
+                                        for (let m = 0; m < docs[i]._childDocuments_.length; m++) {
+                                            if ((docs[i]._childDocuments_[m].path_exact === "product/" + docs[i].sku + '/' + market.toUpperCase()) &&
                                             !docs[i]._childDocuments_[m].excludeFromSearch) {
 
-                                            if (!skuExistsInSolrProductAdaptorArray(productDocuments, docs[i].sku.toString())) {
-                                                const match = matchingRootProducts.find(root => root.path_exact === docs[i].path_exact) || null;
-                                                const score = match ? match.score : 0;
-                                                productDocuments.push(new SolrProductAdaptor(docs[i], score));
+                                                if (!skuExistsInSolrProductAdaptorArray(productDocuments, docs[i].sku.toString())) {
+                                                    const match = matchingRootProducts.find(root => root.path_exact === docs[i].path_exact) || null;
+                                                    const score = match ? match.score : 0;
+                                                    productDocuments.push(new SolrProductAdaptor(docs[i], score));
+                                                }
                                             }
                                         }
                                     }
                                 }
-                            }
 
-                            let retValue = {
-                                products: productDocuments,
-                                totalNumFound: totalNumFound
-                            };
+                                let retValue = {
+                                    products: productDocuments,
+                                    totalNumFound: totalNumFound
+                                };
 
-                            deferred.resolve(retValue);
-                        },
-                        error: function (xmlHttpRequest, textStatus) {
-                            deferred.reject(textStatus);
+                                deferred.resolve(retValue);
+                            },
+                            error: function (xmlHttpRequest, textStatus) {
+                                deferred.reject(textStatus);
                             //console.log('Search failed!');
-                        }
-                    });
-                }
-                else {
-                    deferred.resolve(undefined);
+                            }
+                        });
+                    }
+                    else {
+                        deferred.resolve(undefined);
+                    }
+                } else {
+                    getProductsBySearchFields(productResultType, searchTerm, productSearchFields, language, market, rows, start, orderTypes, deferred)
                 }
-            } else {
-                getProductsBySearchFields(productResultType, searchTerm, productSearchFields, language, market, rows, start, orderTypes, deferred)
-            }
-        });
+            });
+
+        }
 
         return deferred;
     }

package/src/product/productSearchAPIQueryService.js

@@ -0,0 +1,521 @@
+import $ from '@nuskin/nuskinjquery';
+import { getCachedConfiguration } from '@nuskin/configuration-sdk';
+import { SolrProductAdaptor } from './solrProductAdaptor';
+import { CustomerTypes } from '@nuskin/ns-product-lib';
+
+// const {$} = require('@nuskin/nuskinjquery');
+// const { getCachedConfiguration } = require('@nuskin/configuration-sdk');
+// const { SolrProductAdaptor } = require('./solrProductAdaptor');
+// const { CustomerTypes } = require('@nuskin/ns-product-lib');
+
+let baseScore = 5;
+const searchQuery = `
+query ProductSearch(
+    $market: String!
+    $language: String!
+    $searchTerm: String
+    $sizeOpt: Int
+    $pageOpt: Int
+) {
+    productSearch(
+        sizeOpt: $sizeOpt
+        language: $language
+        market: $market
+        searchTerm: $searchTerm
+        pageOpt: $pageOpt
+    ) {
+        ProductContent {
+            products {
+                error {
+                    errors
+                }
+                title
+                productImages {
+                    url
+                }
+                variants {
+                    title
+                    sku
+                    productImages {
+                        url
+                        alt
+                        thumbnail
+                    }
+                    isExclusive
+                    availableChannels
+                    customerTypes
+                    description
+                    searchKeywords
+                }
+                bundle {
+                    purchaseTypes {
+                        buyOnce
+                        subscription
+                    }
+                    customerTypes
+                }
+                id
+            }
+        }
+        pageableInfo {
+            page
+            size
+            count
+            totalCount
+        }
+    }
+}`;
+const predictiveQuery = `
+query PredictiveSearch($language: String, $market: String, $page: Int, $searchTerm: String, $size: Int) {
+    predictiveSearch(
+        language: $language
+        market: $market
+        page: $page
+        searchTerm: $searchTerm
+        size: $size
+    ) {
+        didYouMean
+        pagination {
+            count
+            page
+            size
+            totalCount
+        }
+        products {
+            id
+            isExclusive
+            sku
+            slug
+            title
+            price {
+                retail
+                retailSales
+                wholesale
+                wholesaleSales
+            }
+            productImages {
+                url
+                thumbnail
+                alt
+            }
+            status {
+                status
+                inventory
+                isBackordered
+            }
+        }
+    }
+}`;
+
+/**
+ * Checks if the input string follows a specific SKU format.
+ * @param {string} str - The input string to be checked.
+ * @returns {boolean} Returns true if the input string is a valid SKU format, otherwise false.
+ */
+function isSkuFormat(str) {
+    return typeof str === 'string' && str.length === 8 && /^[a-zA-Z0-9]+$/.test(str);
+}
+
+/**
+     * Sends a query to the product-search graphql
+     * @returns {Promise} A promise that resolves with the query response.
+     */
+function sendQuery(query, variables, page) {    
+    if (page) {
+        variables.pageOpt = page;
+    }
+
+    const { MySite_search_API_Base_URLs } = getCachedConfiguration('Equinox_Markets');
+
+    const data = JSON.stringify({
+        query: query,
+        variables: variables
+    });
+    
+    return $.ajax({
+        url: MySite_search_API_Base_URLs,
+        type: "POST",
+        contentType: 'application/json; charset=utf-8',
+        data: data
+    });
+}
+
+/**
+     * Extracts relevant information from the product search response.
+     * @param {Object} response - The response from the product-search graphql.
+     * @returns {Object} An object containing products and total number found.
+     */
+function processSearchResponse(response, options) {
+    let retValue = {
+        products: [],
+        totalNumFound: 0
+    };
+    
+    const result = response.data.productSearch || {};
+    
+    if (result.ProductContent && result.ProductContent.products && result.ProductContent.products.length > 0) {
+        let products = result.ProductContent.products;
+        products = processGroupByParent(products, options);
+    
+        retValue = {
+            products,
+            totalNumFound: result.pageableInfo.totalCount
+        };
+    }
+    
+    return retValue;
+}
+
+/**
+     * Extracts relevant information from the predictive search response.
+     * @param {Object} response - The response from the product-search graphql.
+     * @returns {Object} An object containing products and total number found.
+     */
+function processPredictiveResponse(response, options) {
+    let retValue = {
+        products: [],
+        totalNumFound: 0
+    };
+    
+    const result = response.data.predictiveSearch || {};
+    
+    if (result.products && result.products.length > 0) {
+        let products = result.products;
+        const unfilteredProductCount = products.length;
+        products = processGroupByVariant(products, options);
+    
+        retValue = {
+            products,
+            totalNumFound: unfilteredProductCount === result.pagination.totalCount ? products.length : result.pagination.totalCount
+        };
+    }
+    
+    return retValue;
+}
+
+/**
+     * Processes a list of products to be grouped by parent, generating a mapped product structure.
+     *
+     * @param {Array} products - The list of products to process.
+     * @returns {Array} An array of mapped products with child documents for each variant.
+     */
+function processGroupByParent(products, options) {
+    let mappedProducts = [];
+
+    //clean up null data (a lot exists in test environment)
+    products = products.filter((product) => {
+        if(product.error) {
+            console.log('Removed Products with error' , product.error)
+        }
+
+        return !product.error
+    })
+    
+    products.forEach((parentProduct) => {
+        let mappedParentProduct = parentProduct;
+    
+        if (!isSkuFormat(parentProduct.id) && parentProduct.variants && parentProduct.variants.length > 0) {
+            mappedParentProduct = parentProduct.variants[0];
+        } else {
+            mappedParentProduct.sku = parentProduct.id;
+            mappedParentProduct.variants = [];
+            mappedParentProduct.variants.push({ ...mappedParentProduct, sku: parentProduct.id });
+        }
+
+        let indexDocuments = parentProduct.variants.map((variant) => {
+
+            let orderTypes = mapOrderTypes(variant.availableChannels, variant.bundle ? variant.bundle.purchaseTypes : undefined);
+
+            return {
+                path_exact: `product/${variant.sku}/${options.language}`,
+                sku: [`${variant.sku}`],
+                markets: [`${options.market}`],
+                variantType: [""],
+                name: [`${variant.title}`],
+                shortDescription: variant.description,
+                longDescription: variant.description,
+                searchTerms: variant.searchKeywords,
+                isExclusive: mappedParentProduct.isExclusive || "false",
+                custType: mapCustomerTypes(variant.bundle ? variant.bundle.customerTypes : variant.customerTypes),
+                statusCode: ["10"],
+                orderType: Object.keys(orderTypes).filter(key => orderTypes[key]),
+                _root_: [`product/${mappedParentProduct.sku}`]
+            };
+        });
+    
+        let mySiteIndexDocuments = parentProduct.variants.map((variant) => {
+
+            let orderTypes = mapOrderTypes(variant.availableChannels, variant.bundle ? variant.bundle.purchaseTypes : undefined);
+                
+            return {
+                path_exact: `product/${variant.sku}/${options.market.toUpperCase()}`,
+                sku: [`${variant.sku}`],
+                searchTerms: variant.searchKeywords,
+                orderType: Object.keys(orderTypes).filter(key => orderTypes[key]),
+                custType: mapCustomerTypes(variant.bundle ? variant.bundle.customerTypes : variant.customerTypes),
+                statusCode: ["10"],
+                webEnabled: ["true"],
+                _root_: [`product/${mappedParentProduct.sku}`]
+            };
+        });
+    
+        indexDocuments = indexDocuments.concat(mySiteIndexDocuments);
+    
+        if (indexDocuments.length > 0) {
+            mappedProducts.push({
+                path_exact: `product/${mappedParentProduct.sku}`,
+                languages: [`${options.language.toLowerCase()}`],
+                markets: [`${options.market.toLowerCase()}`],
+                sku: [`${mappedParentProduct.sku}`],
+                _childDocuments_: indexDocuments
+            });
+        } else {
+            console.log('Invalid Product', mappedParentProduct);
+        }
+    });
+
+    console.log('Products' , mappedProducts)
+    
+    return mappedProducts.map((product) => { 
+        baseScore -= 0.01;
+        return new SolrProductAdaptor(product, baseScore)
+    });
+}
+    
+/**
+     * Processes a list of products to be grouped by variant, generating a mapped product structure.
+     *
+     * @param {Array} products - The list of products to process.
+     * @returns {Array} An array of mapped products with a flattened structure.
+     */
+function processGroupByVariant(products, options) {
+    let sellableProducts = products.filter((v) => {
+        return v.status && v.status.status && (v.status.status !== 'inactive' && v.status.status !== 'discontinued');
+    });
+    
+    sellableProducts = sellableProducts.filter((v) => v !== undefined).map((product) => {
+        return {
+            sku: [product.sku],
+            fullImage: (product.productImages && product.productImages.length > 0) ? product.productImages[0].thumbnail ? product.productImages[0].thumbnail : product.productImages[0].url : '',
+            name: product.title || '',
+            _root_: `product/${product.sku}`,
+            isExclusive: product.isExclusive || "false",
+            price: product.price,
+            status: product.status
+        };
+    });
+    
+    let exactSkuResult = sellableProducts.filter((product) => product.sku[0].toLowerCase() === options.searchTerm.toLowerCase());
+        
+    if (isSkuFormat(options.searchTerm) && exactSkuResult.length > 0) {
+        sellableProducts = exactSkuResult
+    }
+    
+    return sellableProducts;
+}
+
+
+/**
+     * map EQ customer types to supported product card customer types
+     * @param {Array<string>} eqCustomerTypes
+     * @returns{string} customer types
+     */
+function mapCustomerTypes(eqCustomerTypes) {
+    if (!eqCustomerTypes) {
+        return "";
+    }
+    
+    const custTypes = eqCustomerTypes.map(str => str.toLowerCase());
+    
+    let newCustType = [];
+    if (custTypes.includes(CustomerTypes.BrandAffiliate)) {
+        newCustType.push(CustomerTypes.properties.BRAND_AFFILIATE.code);
+    }
+    
+    if (custTypes.includes(CustomerTypes.Retail)) {
+        newCustType.push(CustomerTypes.properties.RETAIL.code);
+    }
+    
+    if (custTypes.includes(CustomerTypes.Preferred) || custTypes.includes(CustomerTypes.PreferredCustomer)) {
+        newCustType.push(CustomerTypes.properties.PREFERRED.code);
+    }
+    
+    return newCustType.toString().split(",")
+}
+
+/**
+     * Map Order Types
+     * @param {Array<string>} availableChannels
+     * @param {object} purchaseTypes
+     * @returns {object} orderTypes
+     */
+function mapOrderTypes(availableChannels, purchaseTypes) {
+
+    let orderTypes = {
+        "adr": false,
+        "order": false,
+        "zpfc": false,
+        "zadp": false,
+        "ars": false,
+        "kiosk": false,
+        "mobile": false,
+        "preferred customer": false,
+        "retail": false,
+        "web": false,
+        "web display": false
+    };
+  
+    if (availableChannels) {
+        let availableChannelsArr = Array.isArray(availableChannels) ? availableChannels : availableChannels.split(',');
+  
+        availableChannelsArr.forEach(channel => {
+            if (channel == 'arsPhone')
+                orderTypes.ars = true
+            if (channel == 'web') {
+                orderTypes.order = true
+                orderTypes.web = true
+            }
+            if (channel == 'kiosk')
+                orderTypes.kiosk = true
+            if (channel == 'mobile')
+                orderTypes.mobile = true
+            if (channel == 'subscription')
+                orderTypes.adr = true
+        });
+    }
+  
+    if (purchaseTypes && purchaseTypes.buyOnce) {
+        orderTypes.web = true
+        orderTypes.order = true
+    }
+    if (purchaseTypes && purchaseTypes.subscription) {
+        orderTypes.adr = true
+    }
+  
+    return orderTypes;
+}
+
+
+/**
+ * Performs a product search to the product-search graphql
+ * @param {Promise} deferred - A promise object that resolves when the search is complete.
+ * @param {Object} options - The search options including searchTerm, rows, language, market.
+ */
+function productSearch(deferred, options) {
+
+    let allProducts = [];
+    let currentPage = 1;
+    const variables = {
+        "language": options.language,
+        "market": options.market,
+        "sizeOpt": options.rows,
+        "pageOpt": currentPage,
+        "searchTerm": options.searchTerm
+    };
+    
+    function fetchNextPage() {
+        sendQuery(searchQuery, variables, currentPage)
+            .then((qresp) => processSearchResponse(qresp, options))
+            .then((result) => {
+                allProducts = allProducts.concat(result.products);
+                if ((currentPage * options.rows) < result.totalNumFound) {
+                    currentPage++;
+                    fetchNextPage();
+                } else {
+                    baseScore = 5;
+                    deferred.resolve({
+                        products: allProducts,
+                        totalNumFound: result.totalNumFound
+                    });
+                }
+            })
+            .catch((error) => {
+                console.error(error);
+                deferred.reject(error);
+            });
+    }
+
+    fetchNextPage();
+}
+
+/**
+ * Performs a product search to the product-search graphql
+ * @param {Promise} deferred - A promise object that resolves when the search is complete.
+ * @param {Object} options - The search options including searchTerm, rows, language, market.
+ */
+function predictiveSearch(deferred, options, page) {
+    const variables = {
+        "language": options.language,
+        "market": options.market,
+        "searchTerm": options.searchTerm,
+        "page": page ? page : options.page ? options.page : 1,
+        "size": options.rows || 6
+    }
+    
+    sendQuery(predictiveQuery, variables)
+        .then((qresult) => processPredictiveResponse(qresult, options))
+        .then((result) => {
+            deferred.resolve({
+                products: result.products,
+                totalNumFound: result.totalNumFound
+            });
+        })
+        .catch((error) => {
+            console.error(error);
+            deferred.reject(error);
+        });
+}
+
+/**
+ * Performs multiple predictive searches to the product-search graphql to retrieve all results for the term
+ * @param {Promise} deferred - A promise object that resolves when the search is complete.
+ * @param {Object} options - The search options including searchTerm, rows, language, market.
+ */
+function allPredictiveSearch(deferred, options) {
+
+    let allProducts = [];
+    let currentPage = 1;
+    let variables = {
+        "language": options.language,
+        "market": options.market,
+        "searchTerm": options.searchTerm,
+        "page": currentPage,
+        "size": 50
+    };
+    
+    function fetchNextPage() {
+        sendQuery(predictiveQuery, variables)
+            .then((qresp) => processPredictiveResponse(qresp, options))
+            .then((result) => {
+                result.products.map((product) => { 
+                    baseScore -= 0.01;
+                    product.searchScore = baseScore
+                });
+                allProducts = allProducts.concat(result.products);
+                if ((currentPage * 6) < result.totalNumFound) {
+                    currentPage++;
+                    variables.page = currentPage
+                    fetchNextPage();
+                } else {
+                    baseScore = 5;
+                    deferred.resolve({
+                        products: allProducts,
+                        totalNumFound: result.totalNumFound
+                    });
+                }
+            })
+            .catch((error) => {
+                console.error(error);
+                deferred.reject(error);
+            });
+    }
+
+    fetchNextPage();
+}
+
+export {
+    allPredictiveSearch,
+    predictiveSearch,
+    productSearch,
+    isSkuFormat
+};

package/src/product/productSearchService.js

@@ -44,7 +44,7 @@ let productSearchService = function() {
                 productFields.push(ProductSearchFieldsEnum.USAGE);
                 productFields.push(ProductSearchFieldsEnum.KEY_INGREDIENTS);
             }
-            if (typeof(limit) === "undefined"|| limit === null)
+            if (typeof(limit) === "undefined" || limit === null)
                 limit = 6;
             if (typeof(market) === "undefined" || market === null) {
                 market = util.countryCode;
@@ -255,46 +255,60 @@ let productSearchService = function() {
                 let skuArray = [];
 
                 for (let i = 0; i < products.length; i++) {
-                    skuArray.push(products[i].getSku());
+                    if (products[i].sku && products[i].sku.length > 0) {
+                        skuArray.push(products[i].sku[0]);
+                    } else {
+                        skuArray.push(products[i].getSku());
+                    }
                 }
 
                 if (skuArray.length > 0) {
                     let productResults = [];
                     let marketChild;
+                    const addProductData = (productData) => {
+                        if (productData.sku && Array.isArray(productData.sku)) {
+                            productData.sku = productData.sku[0]
+                        }
+                        let addProduct = new Product(productData);
+
+                        const siteUrl = UrlService.getSiteUrl();
+                        const isEdge = BrowserDetection.isEdge();
+                        const isFirefox = BrowserDetection.isFirefox();
+
+                        // set the base url for images, etc
+                        addProduct.setBaseUrl(siteUrl);
+
+                        // fix image paths for non-edge/firefox
+                        if (!isEdge && !isFirefox) {
+                            if (addProduct.fullImage && !addProduct.fullImage.includes("media.nuskin.com/transform")) {
+                                addProduct.fullImage = addProduct.fullImage
+                                    ? `${addProduct.fullImage.split("?")[0]}?format=pjpg`
+                                    : undefined;
+                                addProduct.thumbnail = addProduct.thumbnail
+                                    ? `${addProduct.thumbnail.split("?")[0]}?format=pjpg`
+                                    : undefined;
+                            }
+                        }
+
+                        // set price type
+                        const priceType = getCachedConfigField('showWholeSalePricing') && !AccountManager.isLoggedIn()
+                            ? PriceType.WWHL
+                            : PriceType.RTL;
+                        addProduct.setPriceAndPvFromType(priceType);
+                        productResults.push(addProduct);
+                    }
                     for (let i = 0; i < products.length; i++) {
-                        marketChild = products[i].getMarketChild(market);
-                        if (searchedProductIsBase(products[i], productResultTypes) || (marketChild.getPurchasable() &&
-                            existsInArray(marketChild.getOrderType(), orderTypes))) {
-                            let productData = createDataFromSolrSearch(products[i], market, language);
-                            if (productData) {
-                                let addProduct = new Product(productData);
-
-                                const siteUrl = UrlService.getSiteUrl();
-                                const isEdge = BrowserDetection.isEdge();
-                                const isFirefox = BrowserDetection.isFirefox();
-
-                                // set the base url for images, etc
-                                addProduct.setBaseUrl(siteUrl);
-
-                                // fix image paths for non-edge/firefox
-                                if (!isEdge && !isFirefox) {
-                                    if (addProduct.fullImage && !addProduct.fullImage.includes("media.nuskin.com/transform")) {
-                                        addProduct.fullImage = addProduct.fullImage
-                                            ? `${addProduct.fullImage.split("?")[0]}?format=pjpg`
-                                            : undefined;
-                                        addProduct.thumbnail = addProduct.thumbnail
-                                            ? `${addProduct.thumbnail.split("?")[0]}?format=pjpg`
-                                            : undefined;
-                                    }
+                        if (products[i].getMarketChild) {
+                            marketChild = products[i].getMarketChild(market);
+                            if (searchedProductIsBase(products[i], productResultTypes) || (marketChild.getPurchasable() &&
+                                existsInArray(marketChild.getOrderType(), orderTypes))) {
+                                let productData = createDataFromSolrSearch(products[i], market, language);
+                                if (productData) {
+                                    addProductData(productData)
                                 }
-
-                                // set price type
-                                const priceType = getCachedConfigField('showWholeSalePricing') && !AccountManager.isLoggedIn()
-                                    ? PriceType.WWHL
-                                    : PriceType.RTL;
-                                addProduct.setPriceAndPvFromType(priceType);
-                                productResults.push(addProduct);
                             }
+                        } else {
+                            addProductData(products[i])
                         }
                     }
                     productResults = sortProducts(productResults, sortOrder, productFieldAsText(sortField));
@@ -636,6 +650,28 @@ let productSearchService = function() {
             }
         }
 
+        if (basicProduct.price) {
+            productData.priceMap = {
+                RTL: basicProduct.price.retail,
+                WRTL: basicProduct.price.retail,
+                WHL: basicProduct.price.wholesale,
+                WWHL: basicProduct.price.wholesale
+            }
+        }
+
+        if (basicProduct.status) {
+            switch (basicProduct.status) {
+                case "discontinued":
+                case "inactive":
+                case "bundleOnly":
+                    productData.status = "NOT_RELEASED_FOR_SALE"
+                    break;
+                default:
+                    productData.status = "RELEASED_FOR_SALE"
+                    break;
+            }
+        }
+
         return new Product(productData);
     }