Algolia first strategy

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);