AI solution for JavaScript Coding Question on BFE.dev
101. merge identical API calls

One possible solution could be to keep a cache of previous API calls and their responses, and check if a new API call is identical to a previous one. If it is, we return the cached response instead of making a new API call. If it is not, we make a new API call and cache the result.

To ensure that the cache doesn't bloat and that we only keep the responses from the last 1000ms, we can store each entry as an object with a timestamp property. We can then use a Queue data structure to keep track of the order in which the cache entries were added, so that we can remove the oldest entry when the cache has reached the maximum size of 5.

Here's a possible implementation of the createGetAPIWithMerging function:

function createGetAPIWithMerging(getAPI) {
  // Define the maximum size of the cache and the maximum age of entries in ms
  const MAX_CACHE_SIZE = 5;
  const MAX_CACHE_AGE = 1000;

  // Define the queue data structure to keep track of cache entries
  const cacheQueue = [];

  // Define the cache object to store API responses
  const cache = {};

  // Define a utility function to check if two objects are deeply equal
  const isEqual = (a, b) => JSON.stringify(a) === JSON.stringify(b);

  // Define the main function that merges identical API calls
  async function getAPIWithMerging(path, config) {
    const cacheKey = JSON.stringify({ path, config });

    // Check if the request is identical to a previous one within the cache age limit
    const matchingCache = cacheQueue.find((entry) => {
      return (
        isEqual(entry.request, { path, config }) &&
        Date.now() - entry.timestamp < MAX_CACHE_AGE
      );
    });

    if (matchingCache) {
      // If there is a cache match, return the cached response
      return matchingCache.response;
    } else {
      // Otherwise, make a new API call and cache the result
      const response = await getAPI(path, config);

      const cacheEntry = { request: { path, config }, response, timestamp: Date.now() };
      cache[cacheKey] = cacheEntry;
      cacheQueue.push(cacheEntry);

      // If the cache has reached the maximum size, remove the oldest entry
      if (cacheQueue.length > MAX_CACHE_SIZE) {
        const oldestCache = cacheQueue.shift();
        delete cache[JSON.stringify(oldestCache.request)];
      }

      return response;
    }
  }

  // Define a method to clear the cache
  getAPIWithMerging.clearCache = function() {
    cacheQueue.length = 0;
    for (const key in cache) {
      delete cache[key];
    }
  };

  return getAPIWithMerging;
}