@nuskin/ns-shop 7.2.1-mdigi-2049.2 → 7.3.0-mdigi-897.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nuskin/ns-shop",
-  "version": "7.2.1-mdigi-2049.2",
+  "version": "7.3.0-mdigi-897.1",
   "description": "The description that will amaze and astound your audience when they read it",
   "main": "src/shop.js",
   "scripts": {

package/src/order/orderAdapter.js

@@ -137,7 +137,7 @@ const populateItem = (order, salesOrder, shipImmediate, includeSapItems) => {
 };
 
 const populateAttribution = (salesOrder) => {
-    const sponsorId = util.getSponsorId();
+    const sponsorId = util.getSponsorId(); 
     const enableGuestCheckout = getCachedConfigField('enableGuestCheckout');
 
     if (sponsorId) {
@@ -164,22 +164,10 @@ const populateAttribution = (salesOrder) => {
     }
 }
 
-const getDefaultShipCode = () => {
-    let defaultCode = '';
-    const useShipMethodsApi = getCachedConfigField('useShipMethodsApi')
-    if (useShipMethodsApi) {
-        const csDefaultCode = getCachedConfigField('defaultShipMethod');
-        const shipMethods = PickupUtil.getStoredShipMethods();
-        const firstSm = shipMethods.length > 0 ? shipMethods[0].Code : '';
-        defaultCode = shipMethods.find((sm) => sm.Code === csDefaultCode) ? csDefaultCode : firstSm;
-    }
-
-    return defaultCode;
-};
-
 const populateShipping = (order, salesOrder) => {
     const user = UserService.getUser();
-    const defaultCode = getDefaultShipCode();
+    const useShipMethodsApi = getCachedConfigField('useShipMethodsApi')
+    const defaultCode = useShipMethodsApi ? getCachedConfigField('defaultShipMethod') : '';
     const method = order.selectedShippingMethod;
     const code = method ? method.Code : defaultCode;
 

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 {productSearchAPI} from "./productSearchAPIQueryService.js"
 
 /**
  *
@@ -436,119 +437,136 @@ 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;
-            }
+            productSearchAPI(deferred, {
+                searchTerm,
+                rows,
+                language,
+                market,
+                groupByVariant: true,
+                page: 1
+            })
 
-            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 +591,132 @@ 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 !== '') {
+
+            productSearchAPI(deferred, {
+                searchTerm,
+                rows: 50,
+                language,
+                market,
+                page: 1
+            })
+
+        } 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,389 @@
+import $ from '@nuskin/nuskinjquery';
+import { getCachedConfiguration } from '@nuskin/configuration-sdk';
+import { SolrProductAdaptor } from './solrProductAdaptor';
+import { CustomerTypes } from '@nuskin/ns-product-lib';
+
+/**
+ * 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);
+}
+
+/**
+ * Performs a search in the Equinox catalog based on the provided options.
+ * @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 productSearchAPI(deferred, options) {
+
+    let allProducts = [];
+    let currentPage = 1;
+    let baseScore = 5;
+    const { MySite_search_API_Base_URLs } = getCachedConfiguration('Equinox_Markets');
+    
+    /**
+     * Sends a query to the Equinox catalog API.
+     * @returns {Promise} A promise that resolves with the query response.
+     */
+    function sendQuery(page) {
+
+        const query = `
+            query ProductSearch(
+                $sizeOpt: Int
+                $language: String!
+                $market: String!
+                $storeId: String
+                $searchTerm: String
+                $filterOpt: String
+                $sortOpt: String
+                $pageOpt: Int
+            ) {
+                productSearch(
+                    sizeOpt: $sizeOpt
+                    language: $language
+                    market: $market
+                    store_Id: $storeId
+                    searchTerm: $searchTerm
+                    filterOpt: $filterOpt
+                    sortOpt: $sortOpt
+                    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 variables = {
+            "language": options.language,
+            "market": options.market,
+            "sizeOpt": options.rows,
+            "pageOpt": page,
+            "searchTerm": options.searchTerm,
+            "filterOpt": null,
+            "sortOpt": null
+        };
+    
+        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 response.
+     * @param {Object} response - The response from the Equinox catalog API.
+     * @returns {Object} An object containing products and total number found.
+     */
+    function processResponse(response) {
+        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;
+    
+            if (options.groupByVariant) {
+                products = processGroupByVariant(products);
+            } else {
+                products = processGroupByParent(products);
+            }
+    
+            retValue = {
+                products,
+                totalNumFound: result.pageableInfo.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) {
+        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) {
+
+        //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
+        })
+
+        let groupedProducts = products.map((v) => {
+            return v.variants && v.variants.length > 0 ? v.variants : [{ ...v, sku: v.id }];
+        }).flat();
+    
+        groupedProducts = groupedProducts.filter((v) => v !== undefined).map((product) => {
+            return {
+                sku: [product.sku],
+                fullImage: (product.productImages && product.productImages.length > 0) ? product.productImages[0].url : '',
+                name: product.title || '',
+                _root_: `product/${product.sku}`,
+                isExclusive: product.isExclusive || "false"
+            };
+        });
+    
+        let exactSkuResult = groupedProducts.filter((product) => product.sku[0].toLowerCase() === options.searchTerm.toLowerCase());
+        
+        if (isSkuFormat(options.searchTerm) && exactSkuResult.length > 0) {
+            groupedProducts = exactSkuResult
+        }
+    
+        return groupedProducts;
+    }
+
+
+    /**
+     * 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;
+    }
+
+    
+    function fetchNextPage() {
+        sendQuery(currentPage)
+            .then(processResponse)
+            .then((result) => {
+                allProducts = allProducts.concat(result.products);
+                if ((currentPage * options.rows) < result.totalNumFound && !options.groupByVariant) {
+                    currentPage++;
+                    fetchNextPage();
+                } else {
+                    deferred.resolve({
+                        products: allProducts,
+                        totalNumFound: result.totalNumFound
+                    });
+                }
+            })
+            .catch((error) => {
+                console.error(error);
+                deferred.reject(error);
+            });
+    }
+
+    fetchNextPage();
+}
+
+export {
+    productSearchAPI,
+    isSkuFormat
+};

package/src/product/productSearchService.js

@@ -1,7 +1,7 @@
 import {ProductSearchFieldsEnum, ProductSortOrderEnum, ProductSortTypeEnum} from "./productSearchFieldsEnum.js";
 import {ProductResultsEnum} from "./productResultsEnum.js";
 import {util, BrowserDetection, UrlService} from '@nuskin/ns-util';
-import {getCachedConfigField} from "@nuskin/configuration-sdk";
+import {getCachedConfigField, getCachedConfiguration} from "@nuskin/configuration-sdk";
 import {AccountManager} from '@nuskin/ns-account';
 import SolrQueryService from "./SolrQueryService.js";
 import SynonymService from "./synonymService";
@@ -604,6 +604,7 @@ let productSearchService = function() {
     const createProductFromBasicProduct = function(basicProduct) {
         let siteUrl = UrlService.getSiteUrl();
         let productData = {};
+        const {active, MySite_search_API_Base_URLs} = getCachedConfiguration('Equinox_Markets');
         if (basicProduct.sku) {
             if (typeof(basicProduct.sku) === 'object') {
                 productData.sku = basicProduct.sku[0];
@@ -612,6 +613,11 @@ let productSearchService = function() {
             }
             // eslint-disable-next-line
             productData.thumbnail = siteUrl + "/content/products/" + productData.sku.substring(0,2) +"/" + productData.sku.substring(2,4) + "/" + productData.sku.substring(4,6) +"/" + productData.sku +"/_jcr_content/fullImage.img.160.160.png"
+            //use equinox image when using product-search-api and market is active
+            if(MySite_search_API_Base_URLs !== '' && active) {
+                productData.thumbnail = basicProduct.fullImage
+            }
+
         }
         if (basicProduct.name) {
             if (typeof(basicProduct.name) === 'object') {

package/src/shipping/pickupUtil.js

@@ -201,16 +201,10 @@ let PickupUtil = function() {
         }
     }
 
-    // if the calling code knows that loadShipMethods has finished then this
-    // function can be called directly if the calling function is not async.
-    function getStoredShipMethods() {
-        return JSON.parse((sessionStorage.getItem(SHIP_METHODS) || '[]'));
-    }
-
     async function getShipMethods() {
         await promise;
 
-        return getStoredShipMethods();
+        return JSON.parse((sessionStorage.getItem(SHIP_METHODS) || []));
     }
 
     async function getPickupPoints() {
@@ -227,7 +221,6 @@ let PickupUtil = function() {
         markers: generateMarkers,
         loadShipMethods,
         getShipMethods,
-        getStoredShipMethods,
         getPickupPoints
     }
 }();