@algolia/client-common 5.0.0-alpha.1 → 5.0.0-alpha.100

package/dist/client-common.esm.node.js

@@ -7,11 +7,9 @@ function createAuth(appId, apiKey, authMode = 'WithinHeaders') {
     headers() {
       return authMode === 'WithinHeaders' ? credentials : {};
     },
-
     queryParameters() {
       return authMode === 'WithinQueryParameters' ? credentials : {};
     }
-
   };
 }
 
@@ -22,15 +20,12 @@ function getUrlParams({
 }) {
   const algoliaAgent = urlSearchParams.get('x-algolia-agent') || '';
   const searchParams = {};
-
   for (const [k, v] of urlSearchParams) {
     if (k === 'x-algolia-agent') {
       continue;
     }
-
     searchParams[k] = v;
   }
-
   return {
     host,
     algoliaAgent,
@@ -38,7 +33,6 @@ function getUrlParams({
     path: pathname
   };
 }
-
 function createEchoRequester({
   getURL,
   status = 200
@@ -50,11 +44,12 @@ function createEchoRequester({
       algoliaAgent,
       path
     } = getUrlParams(getURL(request.url));
-    const content = { ...request,
+    const content = {
+      ...request,
       data: request.data ? JSON.parse(request.data) : undefined,
       path,
       host,
-      algoliaAgent: encodeURI(algoliaAgent),
+      algoliaAgent: encodeURIComponent(algoliaAgent),
       searchParams
     };
     return Promise.resolve({
@@ -63,95 +58,108 @@ function createEchoRequester({
       status
     });
   }
-
   return {
     send
   };
 }
 
-const DEFAULT_MAX_RETRIES = 50;
-const DEFAULT_TIMEOUT = retryCount => Math.min(retryCount * 200, 5000);
-/**
- * Return a promise that retry a task until it meets the condition.
- *
- * @param createRetryablePromiseOptions - The createRetryablePromise options.
- * @param createRetryablePromiseOptions.func - The function to run, which returns a promise.
- * @param createRetryablePromiseOptions.validate - The validator function. It receives the resolved return of `func`.
- * @param createRetryablePromiseOptions.maxRetries - The maximum number of retries. 50 by default.
- * @param createRetryablePromiseOptions.timeout - The function to decide how long to wait between retries.
+/**
+ * Helper: Returns the promise of a given `func` to iterate on, based on a given `validate` condition.
+ *
+ * @param createIterator - The createIterator options.
+ * @param createIterator.func - The function to run, which returns a promise.
+ * @param createIterator.validate - The validator function. It receives the resolved return of `func`.
+ * @param createIterator.aggregator - The function that runs right after the `func` method has been executed, allows you to do anything with the response before `validate`.
+ * @param createIterator.error - The `validate` condition to throw an error, and its message.
+ * @param createIterator.timeout - The function to decide how long to wait between iterations.
  */
-
-function createRetryablePromise({
+function createIterablePromise({
   func,
   validate,
-  maxRetries = DEFAULT_MAX_RETRIES,
-  timeout = DEFAULT_TIMEOUT
+  aggregator,
+  error,
+  timeout = () => 0
 }) {
-  let retryCount = 0;
-
-  const retry = () => {
+  const retry = previousResponse => {
     return new Promise((resolve, reject) => {
-      func().then(response => {
-        const isValid = validate(response);
-
-        if (isValid) {
-          resolve(response);
-        } else if (retryCount + 1 >= maxRetries) {
-          reject(new Error(`The maximum number of retries exceeded. (${retryCount + 1}/${maxRetries})`));
-        } else {
-          retryCount += 1;
-          setTimeout(() => {
-            retry().then(resolve).catch(reject);
-          }, timeout(retryCount));
+      func(previousResponse).then(response => {
+        if (aggregator) {
+          aggregator(response);
+        }
+        if (validate(response)) {
+          return resolve(response);
         }
-      }).catch(error => {
-        reject(error);
+        if (error && error.validate(response)) {
+          return reject(new Error(error.message(response)));
+        }
+        return setTimeout(() => {
+          retry(response).then(resolve).catch(reject);
+        }, timeout());
+      }).catch(err => {
+        reject(err);
       });
     });
   };
-
   return retry();
 }
 
 function createBrowserLocalStorageCache(options) {
-  let storage; // We've changed the namespace to avoid conflicts with v4, as this version is a huge breaking change
-
+  let storage;
+  // We've changed the namespace to avoid conflicts with v4, as this version is a huge breaking change
   const namespaceKey = `algolia-client-js-${options.key}`;
-
   function getStorage() {
     if (storage === undefined) {
       storage = options.localStorage || window.localStorage;
     }
-
     return storage;
   }
-
   function getNamespace() {
     return JSON.parse(getStorage().getItem(namespaceKey) || '{}');
   }
-
+  function setNamespace(namespace) {
+    getStorage().setItem(namespaceKey, JSON.stringify(namespace));
+  }
+  function removeOutdatedCacheItems() {
+    const timeToLive = options.timeToLive ? options.timeToLive * 1000 : null;
+    const namespace = getNamespace();
+    const filteredNamespaceWithoutOldFormattedCacheItems = Object.fromEntries(Object.entries(namespace).filter(([, cacheItem]) => {
+      return cacheItem.timestamp !== undefined;
+    }));
+    setNamespace(filteredNamespaceWithoutOldFormattedCacheItems);
+    if (!timeToLive) {
+      return;
+    }
+    const filteredNamespaceWithoutExpiredItems = Object.fromEntries(Object.entries(filteredNamespaceWithoutOldFormattedCacheItems).filter(([, cacheItem]) => {
+      const currentTimestamp = new Date().getTime();
+      const isExpired = cacheItem.timestamp + timeToLive < currentTimestamp;
+      return !isExpired;
+    }));
+    setNamespace(filteredNamespaceWithoutExpiredItems);
+  }
   return {
     get(key, defaultValue, events = {
       miss: () => Promise.resolve()
     }) {
       return Promise.resolve().then(() => {
-        const keyAsString = JSON.stringify(key);
-        const value = getNamespace()[keyAsString];
-        return Promise.all([value || defaultValue(), value !== undefined]);
+        removeOutdatedCacheItems();
+        return getNamespace()[JSON.stringify(key)];
+      }).then(value => {
+        return Promise.all([value ? value.value : defaultValue(), value !== undefined]);
       }).then(([value, exists]) => {
         return Promise.all([value, exists || events.miss(value)]);
       }).then(([value]) => value);
     },
-
     set(key, value) {
       return Promise.resolve().then(() => {
         const namespace = getNamespace();
-        namespace[JSON.stringify(key)] = value;
+        namespace[JSON.stringify(key)] = {
+          timestamp: new Date().getTime(),
+          value
+        };
         getStorage().setItem(namespaceKey, JSON.stringify(namespace));
         return value;
       });
     },
-
     delete(key) {
       return Promise.resolve().then(() => {
         const namespace = getNamespace();
@@ -159,13 +167,11 @@ function createBrowserLocalStorageCache(options) {
         getStorage().setItem(namespaceKey, JSON.stringify(namespace));
       });
     },
-
     clear() {
       return Promise.resolve().then(() => {
         getStorage().removeItem(namespaceKey);
       });
     }
-
   };
 }
 
@@ -177,30 +183,24 @@ function createNullCache() {
       const value = defaultValue();
       return value.then(result => Promise.all([result, events.miss(result)])).then(([result]) => result);
     },
-
     set(_key, value) {
       return Promise.resolve(value);
     },
-
     delete(_key) {
       return Promise.resolve();
     },
-
     clear() {
       return Promise.resolve();
     }
-
   };
 }
 
 function createFallbackableCache(options) {
   const caches = [...options.caches];
   const current = caches.shift();
-
   if (current === undefined) {
     return createNullCache();
   }
-
   return {
     get(key, defaultValue, events = {
       miss: () => Promise.resolve()
@@ -211,7 +211,6 @@ function createFallbackableCache(options) {
         }).get(key, defaultValue, events);
       });
     },
-
     set(key, value) {
       return current.set(key, value).catch(() => {
         return createFallbackableCache({
@@ -219,7 +218,6 @@ function createFallbackableCache(options) {
         }).set(key, value);
       });
     },
-
     delete(key) {
       return current.delete(key).catch(() => {
         return createFallbackableCache({
@@ -227,7 +225,6 @@ function createFallbackableCache(options) {
         }).delete(key);
       });
     },
-
     clear() {
       return current.clear().catch(() => {
         return createFallbackableCache({
@@ -235,7 +232,6 @@ function createFallbackableCache(options) {
         }).clear();
       });
     }
-
   };
 }
 
@@ -248,30 +244,24 @@ function createMemoryCache(options = {
       miss: () => Promise.resolve()
     }) {
       const keyAsString = JSON.stringify(key);
-
       if (keyAsString in cache) {
         return Promise.resolve(options.serializable ? JSON.parse(cache[keyAsString]) : cache[keyAsString]);
       }
-
       const promise = defaultValue();
       return promise.then(value => events.miss(value)).then(() => promise);
     },
-
     set(key, value) {
       cache[JSON.stringify(key)] = options.serializable ? JSON.stringify(value) : value;
       return Promise.resolve(value);
     },
-
     delete(key) {
       delete cache[JSON.stringify(key)];
       return Promise.resolve();
     },
-
     clear() {
       cache = {};
       return Promise.resolve();
     }
-
   };
 }
 
@@ -280,16 +270,14 @@ function createMemoryCache(options = {
 const EXPIRATION_DELAY = 2 * 60 * 1000;
 function createStatefulHost(host, status = 'up') {
   const lastUpdate = Date.now();
-
   function isUp() {
     return status === 'up' || Date.now() - lastUpdate > EXPIRATION_DELAY;
   }
-
   function isTimedOut() {
     return status === 'timed out' && Date.now() - lastUpdate <= EXPIRATION_DELAY;
   }
-
-  return { ...host,
+  return {
+    ...host,
     status,
     lastUpdate,
     isUp,
@@ -297,7 +285,22 @@ function createStatefulHost(host, status = 'up') {
   };
 }
 
+function _toPrimitive(t, r) {
+  if ("object" != typeof t || !t) return t;
+  var e = t[Symbol.toPrimitive];
+  if (void 0 !== e) {
+    var i = e.call(t, r || "default");
+    if ("object" != typeof i) return i;
+    throw new TypeError("@@toPrimitive must return a primitive value.");
+  }
+  return ("string" === r ? String : Number)(t);
+}
+function _toPropertyKey(t) {
+  var i = _toPrimitive(t, "string");
+  return "symbol" == typeof i ? i : String(i);
+}
 function _defineProperty(obj, key, value) {
+  key = _toPropertyKey(key);
   if (key in obj) {
     Object.defineProperty(obj, key, {
       value: value,
@@ -308,92 +311,82 @@ function _defineProperty(obj, key, value) {
   } else {
     obj[key] = value;
   }
-
   return obj;
 }
 
 class AlgoliaError extends Error {
   constructor(message, name) {
     super(message);
-
     _defineProperty(this, "name", 'AlgoliaError');
-
     if (name) {
       this.name = name;
     }
   }
-
 }
 class ErrorWithStackTrace extends AlgoliaError {
   constructor(message, stackTrace, name) {
-    super(message, name); // the array and object should be frozen to reflect the stackTrace at the time of the error
-
+    super(message, name);
+    // the array and object should be frozen to reflect the stackTrace at the time of the error
     _defineProperty(this, "stackTrace", void 0);
-
     this.stackTrace = stackTrace;
   }
-
 }
 class RetryError extends ErrorWithStackTrace {
   constructor(stackTrace) {
-    super('Unreachable hosts - your application id may be incorrect. If the error persists, contact support@algolia.com.', stackTrace, 'RetryError');
+    super('Unreachable hosts - your application id may be incorrect. If the error persists, please create a ticket at https://support.algolia.com/ sharing steps we can use to reproduce the issue.', stackTrace, 'RetryError');
   }
-
 }
 class ApiError extends ErrorWithStackTrace {
-  constructor(message, status, stackTrace) {
-    super(message, stackTrace, 'ApiError');
-
+  constructor(message, status, stackTrace, name = 'ApiError') {
+    super(message, stackTrace, name);
     _defineProperty(this, "status", void 0);
-
     this.status = status;
   }
-
 }
 class DeserializationError extends AlgoliaError {
   constructor(message, response) {
     super(message, 'DeserializationError');
-
     _defineProperty(this, "response", void 0);
-
     this.response = response;
   }
-
+}
+// DetailedApiError is only used by the ingestion client to return more informative error, other clients will use ApiClient.
+class DetailedApiError extends ApiError {
+  constructor(message, status, error, stackTrace) {
+    super(message, status, stackTrace, 'DetailedApiError');
+    _defineProperty(this, "error", void 0);
+    this.error = error;
+  }
 }
 
 function shuffle(array) {
   const shuffledArray = array;
-
   for (let c = array.length - 1; c > 0; c--) {
     const b = Math.floor(Math.random() * (c + 1));
     const a = array[c];
     shuffledArray[c] = array[b];
     shuffledArray[b] = a;
   }
-
   return shuffledArray;
 }
 function serializeUrl(host, path, queryParameters) {
   const queryParametersAsString = serializeQueryParameters(queryParameters);
   let url = `${host.protocol}://${host.url}/${path.charAt(0) === '/' ? path.substr(1) : path}`;
-
   if (queryParametersAsString.length) {
     url += `?${queryParametersAsString}`;
   }
-
   return url;
 }
 function serializeQueryParameters(parameters) {
   const isObjectOrArray = value => Object.prototype.toString.call(value) === '[object Object]' || Object.prototype.toString.call(value) === '[object Array]';
-
-  return Object.keys(parameters).map(key => `${key}=${isObjectOrArray(parameters[key]) ? JSON.stringify(parameters[key]) : parameters[key]}`).join('&');
+  return Object.keys(parameters).map(key => `${key}=${encodeURIComponent(isObjectOrArray(parameters[key]) ? JSON.stringify(parameters[key]) : parameters[key])}`).join('&');
 }
 function serializeData(request, requestOptions) {
   if (request.method === 'GET' || request.data === undefined && requestOptions.data === undefined) {
     return undefined;
   }
-
-  const data = Array.isArray(request.data) ? request.data : { ...request.data,
+  const data = Array.isArray(request.data) ? request.data : {
+    ...request.data,
     ...requestOptions.data
   };
   return JSON.stringify(data);
@@ -423,14 +416,16 @@ function deserializeFailure({
   content,
   status
 }, stackFrame) {
-  let message = content;
-
   try {
-    message = JSON.parse(content).message;
-  } catch (e) {// ..
+    const parsed = JSON.parse(content);
+    if ('error' in parsed) {
+      return new DetailedApiError(parsed.message, status, parsed.error, stackFrame);
+    }
+    return new ApiError(parsed.message, status, stackFrame);
+  } catch (e) {
+    // ..
   }
-
-  return new ApiError(message, status, stackFrame);
+  return new ApiError(content, status, stackFrame);
 }
 
 function isNetworkError({
@@ -461,9 +456,12 @@ function stackFrameWithoutCredentials(stackFrame) {
   const modifiedHeaders = stackFrame.request.headers['x-algolia-api-key'] ? {
     'x-algolia-api-key': '*****'
   } : {};
-  return { ...stackFrame,
-    request: { ...stackFrame.request,
-      headers: { ...stackFrame.request.headers,
+  return {
+    ...stackFrame,
+    request: {
+      ...stackFrame.request,
+      headers: {
+        ...stackFrame.request.headers,
         ...modifiedHeaders
       }
     }
@@ -488,51 +486,49 @@ function createTransporter({
       });
     }));
     const hostsUp = statefulHosts.filter(host => host.isUp());
-    const hostsTimedOut = statefulHosts.filter(host => host.isTimedOut()); // Note, we put the hosts that previously timed out on the end of the list.
-
+    const hostsTimedOut = statefulHosts.filter(host => host.isTimedOut());
+    // Note, we put the hosts that previously timed out on the end of the list.
     const hostsAvailable = [...hostsUp, ...hostsTimedOut];
     const compatibleHostsAvailable = hostsAvailable.length > 0 ? hostsAvailable : compatibleHosts;
     return {
       hosts: compatibleHostsAvailable,
-
       getTimeout(timeoutsCount, baseTimeout) {
-        /**
-         * Imagine that you have 4 hosts, if timeouts will increase
-         * on the following way: 1 (timed out) > 4 (timed out) > 5 (200).
-         *
-         * Note that, the very next request, we start from the previous timeout.
-         *
-         *  5 (timed out) > 6 (timed out) > 7 ...
-         *
-         * This strategy may need to be reviewed, but is the strategy on the our
-         * current v3 version.
+        /**
+         * Imagine that you have 4 hosts, if timeouts will increase
+         * on the following way: 1 (timed out) > 4 (timed out) > 5 (200).
+         *
+         * Note that, the very next request, we start from the previous timeout.
+         *
+         *  5 (timed out) > 6 (timed out) > 7 ...
+         *
+         * This strategy may need to be reviewed, but is the strategy on the our
+         * current v3 version.
          */
         const timeoutMultiplier = hostsTimedOut.length === 0 && timeoutsCount === 0 ? 1 : hostsTimedOut.length + 3 + timeoutsCount;
         return timeoutMultiplier * baseTimeout;
       }
-
     };
   }
-
   async function retryableRequest(request, requestOptions, isRead = true) {
     const stackTrace = [];
-    /**
-     * First we prepare the payload that do not depend from hosts.
+    /**
+     * First we prepare the payload that do not depend from hosts.
      */
-
     const data = serializeData(request, requestOptions);
-    const headers = serializeHeaders(baseHeaders, request.headers, requestOptions.headers); // On `GET`, the data is proxied to query parameters.
-
-    const dataQueryParameters = request.method === 'GET' ? { ...request.data,
+    const headers = serializeHeaders(baseHeaders, request.headers, requestOptions.headers);
+    // On `GET`, the data is proxied to query parameters.
+    const dataQueryParameters = request.method === 'GET' ? {
+      ...request.data,
       ...requestOptions.data
     } : {};
     const queryParameters = {
-      'x-algolia-agent': algoliaAgent.value,
       ...baseQueryParameters,
       ...request.queryParameters,
       ...dataQueryParameters
     };
-
+    if (algoliaAgent.value) {
+      queryParameters['x-algolia-agent'] = algoliaAgent.value;
+    }
     if (requestOptions && requestOptions.queryParameters) {
       for (const key of Object.keys(requestOptions.queryParameters)) {
         // We want to keep `undefined` and `null` values,
@@ -545,25 +541,19 @@ function createTransporter({
         }
       }
     }
-
     let timeoutsCount = 0;
-
     const retry = async (retryableHosts, getTimeout) => {
-      /**
-       * We iterate on each host, until there is no host left.
+      /**
+       * We iterate on each host, until there is no host left.
        */
       const host = retryableHosts.pop();
-
       if (host === undefined) {
         throw new RetryError(stackTraceWithoutCredentials(stackTrace));
       }
-
       let responseTimeout = requestOptions.timeout;
-
       if (responseTimeout === undefined) {
         responseTimeout = isRead ? timeouts.read : timeouts.write;
       }
-
       const payload = {
         data,
         headers,
@@ -572,12 +562,11 @@ function createTransporter({
         connectTimeout: getTimeout(timeoutsCount, timeouts.connect),
         responseTimeout: getTimeout(timeoutsCount, responseTimeout)
       };
-      /**
-       * The stackFrame is pushed to the stackTrace so we
-       * can have information about onRetry and onFailure
-       * decisions.
+      /**
+       * The stackFrame is pushed to the stackTrace so we
+       * can have information about onRetry and onFailure
+       * decisions.
        */
-
       const pushToStackTrace = response => {
         const stackFrame = {
           request: payload,
@@ -588,102 +577,85 @@ function createTransporter({
         stackTrace.push(stackFrame);
         return stackFrame;
       };
-
       const response = await requester.send(payload);
-
       if (isRetryable(response)) {
-        const stackFrame = pushToStackTrace(response); // If response is a timeout, we increase the number of timeouts so we can increase the timeout later.
-
+        const stackFrame = pushToStackTrace(response);
+        // If response is a timeout, we increase the number of timeouts so we can increase the timeout later.
         if (response.isTimedOut) {
           timeoutsCount++;
         }
-        /**
-         * Failures are individually sent to the logger, allowing
-         * the end user to debug / store stack frames even
-         * when a retry error does not happen.
+        /**
+         * Failures are individually sent to the logger, allowing
+         * the end user to debug / store stack frames even
+         * when a retry error does not happen.
          */
         // eslint-disable-next-line no-console -- this will be fixed by exposing a `logger` to the transporter
-
-
         console.log('Retryable failure', stackFrameWithoutCredentials(stackFrame));
-        /**
-         * We also store the state of the host in failure cases. If the host, is
-         * down it will remain down for the next 2 minutes. In a timeout situation,
-         * this host will be added end of the list of hosts on the next request.
+        /**
+         * We also store the state of the host in failure cases. If the host, is
+         * down it will remain down for the next 2 minutes. In a timeout situation,
+         * this host will be added end of the list of hosts on the next request.
          */
-
         await hostsCache.set(host, createStatefulHost(host, response.isTimedOut ? 'timed out' : 'down'));
         return retry(retryableHosts, getTimeout);
       }
-
       if (isSuccess(response)) {
         return deserializeSuccess(response);
       }
-
       pushToStackTrace(response);
       throw deserializeFailure(response, stackTrace);
     };
-    /**
-     * Finally, for each retryable host perform request until we got a non
-     * retryable response. Some notes here:
-     *
-     * 1. The reverse here is applied so we can apply a `pop` later on => more performant.
-     * 2. We also get from the retryable options a timeout multiplier that is tailored
-     * for the current context.
+    /**
+     * Finally, for each retryable host perform request until we got a non
+     * retryable response. Some notes here:
+     *
+     * 1. The reverse here is applied so we can apply a `pop` later on => more performant.
+     * 2. We also get from the retryable options a timeout multiplier that is tailored
+     * for the current context.
      */
-
-
     const compatibleHosts = hosts.filter(host => host.accept === 'readWrite' || (isRead ? host.accept === 'read' : host.accept === 'write'));
     const options = await createRetryableOptions(compatibleHosts);
     return retry([...options.hosts].reverse(), options.getTimeout);
   }
-
   function createRequest(request, requestOptions = {}) {
-    /**
-     * A read request is either a `GET` request, or a request that we make
-     * via the `read` transporter (e.g. `search`).
+    /**
+     * A read request is either a `GET` request, or a request that we make
+     * via the `read` transporter (e.g. `search`).
      */
     const isRead = request.useReadTransporter || request.method === 'GET';
-
     if (!isRead) {
-      /**
-       * On write requests, no cache mechanisms are applied, and we
-       * proxy the request immediately to the requester.
+      /**
+       * On write requests, no cache mechanisms are applied, and we
+       * proxy the request immediately to the requester.
        */
       return retryableRequest(request, requestOptions, isRead);
     }
-
     const createRetryableRequest = () => {
-      /**
-       * Then, we prepare a function factory that contains the construction of
-       * the retryable request. At this point, we may *not* perform the actual
-       * request. But we want to have the function factory ready.
+      /**
+       * Then, we prepare a function factory that contains the construction of
+       * the retryable request. At this point, we may *not* perform the actual
+       * request. But we want to have the function factory ready.
        */
       return retryableRequest(request, requestOptions);
     };
-    /**
-     * Once we have the function factory ready, we need to determine of the
-     * request is "cacheable" - should be cached. Note that, once again,
-     * the user can force this option.
+    /**
+     * Once we have the function factory ready, we need to determine of the
+     * request is "cacheable" - should be cached. Note that, once again,
+     * the user can force this option.
      */
-
-
     const cacheable = requestOptions.cacheable || request.cacheable;
-    /**
-     * If is not "cacheable", we immediately trigger the retryable request, no
-     * need to check cache implementations.
+    /**
+     * If is not "cacheable", we immediately trigger the retryable request, no
+     * need to check cache implementations.
      */
-
     if (cacheable !== true) {
       return createRetryableRequest();
     }
-    /**
-     * If the request is "cacheable", we need to first compute the key to ask
-     * the cache implementations if this request is on progress or if the
-     * response already exists on the cache.
+    /**
+     * If the request is "cacheable", we need to first compute the key to ask
+     * the cache implementations if this request is on progress or if the
+     * response already exists on the cache.
      */
-
-
     const key = {
       request,
       requestOptions,
@@ -692,33 +664,31 @@ function createTransporter({
         headers: baseHeaders
       }
     };
-    /**
-     * With the computed key, we first ask the responses cache
-     * implementation if this request was been resolved before.
+    /**
+     * With the computed key, we first ask the responses cache
+     * implementation if this request was been resolved before.
      */
-
     return responsesCache.get(key, () => {
-      /**
-       * If the request has never resolved before, we actually ask if there
-       * is a current request with the same key on progress.
+      /**
+       * If the request has never resolved before, we actually ask if there
+       * is a current request with the same key on progress.
        */
       return requestsCache.get(key, () =>
-      /**
-       * Finally, if there is no request in progress with the same key,
-       * this `createRetryableRequest()` will actually trigger the
-       * retryable request.
+      /**
+       * Finally, if there is no request in progress with the same key,
+       * this `createRetryableRequest()` will actually trigger the
+       * retryable request.
        */
       requestsCache.set(key, createRetryableRequest()).then(response => Promise.all([requestsCache.delete(key), response]), err => Promise.all([requestsCache.delete(key), Promise.reject(err)])).then(([_, response]) => response));
     }, {
-      /**
-       * Of course, once we get this response back from the server, we
-       * tell response cache to actually store the received response
-       * to be used later.
+      /**
+       * Of course, once we get this response back from the server, we
+       * tell response cache to actually store the received response
+       * to be used later.
        */
       miss: response => responsesCache.set(key, response)
     });
   }
-
   return {
     hostsCache,
     requester,
@@ -736,17 +706,13 @@ function createTransporter({
 function createAlgoliaAgent(version) {
   const algoliaAgent = {
     value: `Algolia for JavaScript (${version})`,
-
     add(options) {
       const addedAlgoliaAgent = `; ${options.segment}${options.version !== undefined ? ` (${options.version})` : ''}`;
-
       if (algoliaAgent.value.indexOf(addedAlgoliaAgent) === -1) {
         algoliaAgent.value = `${algoliaAgent.value}${addedAlgoliaAgent}`;
       }
-
       return algoliaAgent;
     }
-
   };
   return algoliaAgent;
 }
@@ -771,4 +737,4 @@ const DEFAULT_CONNECT_TIMEOUT_NODE = 2000;
 const DEFAULT_READ_TIMEOUT_NODE = 5000;
 const DEFAULT_WRITE_TIMEOUT_NODE = 30000;
 
-export { AlgoliaError, ApiError, DEFAULT_CONNECT_TIMEOUT_BROWSER, DEFAULT_CONNECT_TIMEOUT_NODE, DEFAULT_MAX_RETRIES, DEFAULT_READ_TIMEOUT_BROWSER, DEFAULT_READ_TIMEOUT_NODE, DEFAULT_TIMEOUT, DEFAULT_WRITE_TIMEOUT_BROWSER, DEFAULT_WRITE_TIMEOUT_NODE, DeserializationError, ErrorWithStackTrace, RetryError, createAlgoliaAgent, createAuth, createBrowserLocalStorageCache, createEchoRequester, createFallbackableCache, createMemoryCache, createNullCache, createRetryablePromise, createStatefulHost, createTransporter, deserializeFailure, deserializeSuccess, getAlgoliaAgent, isNetworkError, isRetryable, isSuccess, serializeData, serializeHeaders, serializeQueryParameters, serializeUrl, shuffle, stackFrameWithoutCredentials, stackTraceWithoutCredentials };
+export { AlgoliaError, ApiError, DEFAULT_CONNECT_TIMEOUT_BROWSER, DEFAULT_CONNECT_TIMEOUT_NODE, DEFAULT_READ_TIMEOUT_BROWSER, DEFAULT_READ_TIMEOUT_NODE, DEFAULT_WRITE_TIMEOUT_BROWSER, DEFAULT_WRITE_TIMEOUT_NODE, DeserializationError, DetailedApiError, ErrorWithStackTrace, RetryError, createAlgoliaAgent, createAuth, createBrowserLocalStorageCache, createEchoRequester, createFallbackableCache, createIterablePromise, createMemoryCache, createNullCache, createStatefulHost, createTransporter, deserializeFailure, deserializeSuccess, getAlgoliaAgent, isNetworkError, isRetryable, isSuccess, serializeData, serializeHeaders, serializeQueryParameters, serializeUrl, shuffle, stackFrameWithoutCredentials, stackTraceWithoutCredentials };