Parallel requests strategy

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
import algoliasearch from 'algoliasearch';

// Constants
const RETAIL_MEDIA_TIMEOUT_MS = 500;
const RETAIL_MEDIA_API_ENDPOINT = 'https://api.retailmediaplaform.com/search/v1/products/';

const SPONSORED_PRODUCT_POSITIONS = [0, 1, 8, 12];

const ALGOLIA_INDEX_NAME = 'prod_products';
const ALGOLIA_APP_ID = '';
const ALGOLIA_API_KEY = '';

// Algolia setup
const client = algoliasearch(ALGOLIA_APP_ID, ALGOLIA_API_KEY);
const index = client.initIndex(ALGOLIA_INDEX_NAME);

/* -------------------------------------------------------------------------- */

/**
 * Fetches sponsored products from the Retail Media Platform with a timeout mechanism.
 * If the request takes longer than RETAIL_MEDIA_TIMEOUT_MS, it will be aborted.
 * @param {string} searchQuery - The search term to find sponsored products
 * @param {string} filters - Filtering criteria in Algolia format (for example 'size:10 AND color:"blue"')
 * @param {Array} organicObjectIds - Array of objectIDs from Algolia's organic hits (only for the Algolia first strategy)
 * @returns {Promise} Returns the JSON response from RMP if successful, null if the request times out or fails
 */
async function fetchRetailMediaWithTimeout(searchQuery, filters, organicObjectIds) {
    const controller = new AbortController();
    const timeout = setTimeout(() => controller.abort(), RETAIL_MEDIA_TIMEOUT_MS);
  
    try {
      const { statusCode, body } = await request(RETAIL_MEDIA_API_ENDPOINT, {
        method: 'POST',
        headers: { 'Content-Type': 'application/json' },
        signal: controller.signal,
        body: JSON.stringify({
          keyword: searchQuery,
          filters: filters,
          organicResults: organicObjectIds || [] // Pass regular results to RMP
        })
      });
  
      clearTimeout(timeout);
  
      if (statusCode === 200) {
        return await body.json();
      }
      throw new Error(`Request failed with status ${statusCode}`);
    } catch (error) {
      if (error.name === 'AbortError') {
        console.error('Retail Media Platform request timeout');
      } else {
        console.error('Retail Media Platform request failed:', error);
      }
      return null;
    }
  }

/**
 * Injects sponsored products into regular hits at specific positions defined by SPONSORED_PRODUCT_POSITIONS.
 * Removes any duplicate products that exist in both regular and sponsored hits.
 * @param {Array} regularHits - The array of regular product hits from Algolia
 * @param {Array} sponsoredHits - The array of sponsored product hits from RMP
 * @returns {Array} Combined array of regular and sponsored hits with sponsored products at specified positions
 */
function injectSponsoredProducts(regularHits, sponsoredHits) {
  if (!sponsoredHits?.length) return regularHits;

  // Remove duplicates
  const sponsoredIds = new Set(sponsoredHits.map(hit => hit.objectID));
  const finalHits = regularHits.filter(hit => !sponsoredIds.has(hit.objectID));

  // Insert sponsored products
  SPONSORED_PRODUCT_POSITIONS.forEach((position, index) => {
    if (index < sponsoredHits.length) {
      const sponsoredHit = { ...sponsoredHits[index], sponsored: true };
      const insertPosition = Math.min(position, finalHits.length);
      finalHits.splice(insertPosition, 0, sponsoredHit);
    }
  });

  return finalHits;
}

/**
 * Performs parallel search requests to Algolia and RMP
 * then combines the results with sponsored products injected at specific positions.
 * @param {string} searchQuery - The search term to find products
 * @param {Object|string} filters - Filtering criteria for both searches
 * @returns {Promise<Array>} Combined array of regular and sponsored hits
 */
async function searchProducts(searchQuery, filters) {
  const [algoliaResult, retailMediaResult] = await Promise.allSettled([
    index.search(searchQuery, {
      filters: filters,
      hitsPerPage: 48
    }),
    fetchRetailMediaWithTimeout(searchQuery, filters)
  ]);

  const algoliaHits = algoliaResult.status === 'fulfilled' ? algoliaResult.value.hits : [];
  const retailMediaHits = retailMediaResult.status === 'fulfilled' ? retailMediaResult.value?.hits : [];

  // Merge results by removing hits duplicates
  return injectSponsoredProducts(algoliaHits, retailMediaHits);
}

// Usage
const searchQuery = 'running shoes';
const filters = 'size:10 AND color:"blue"';

const results = await searchProducts(searchQuery, filters);
render(results);