Algolia first 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
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
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 RMP with a timeout mechanism.
 * If the request takes longer than RETAIL_MEDIA_TIMEOUT_MS, it will be stopped.
 * @param {string} searchQuery - The search term to find sponsored products
 * @param {string} filters - Filtering criteria in Algolia format (e.g. 'size:10 AND color:"blue"')
 * @param {Array} organicObjectIds - Array of objectIDs from Algolia's regular hits
 * @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 organic 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 sequential search requests, first to Algolia, then to RMP
 * Passes Algolia regular results to RMP to inform sponsored product selection,
 * then combines both results maintaining the specified positioning.
 * @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, empty if the search fails
 */
async function searchProducts(searchQuery, filters) {
    try {
      // Get regular results from Algolia
      const { hits: organicHits } = await index.search(searchQuery, {
        filters: filters,
        hitsPerPage: 48
      });
  
      // Extract objectIDs from regular results
      const organicObjectIds = organicHits.map(hit => hit.objectID);
  
      // Get sponsored products from RMP, passing regular results
      const retailMediaResult = await fetchRetailMediaWithTimeout(
        searchQuery, 
        filters,
        organicObjectIds
      );
  
        // Merge results by removing hits duplicates
      return injectSponsoredProducts(
        organicHits,
        retailMediaResult?.hits || []
      );
  
    } catch (error) {
      console.error('Search failed:', error);
      return [];
    }
  }

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

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