@algolia/client-common 5.0.0-alpha.9 → 5.0.0-alpha.90

package/dist/{client-common.cjs.js → client-common.cjs}

@@ -1,7 +1,5 @@
 'use strict';
 
-Object.defineProperty(exports, '__esModule', { value: true });
-
 function createAuth(appId, apiKey, authMode = 'WithinHeaders') {
   const credentials = {
     'x-algolia-api-key': apiKey,
@@ -11,11 +9,9 @@ function createAuth(appId, apiKey, authMode = 'WithinHeaders') {
     headers() {
       return authMode === 'WithinHeaders' ? credentials : {};
     },
-
     queryParameters() {
       return authMode === 'WithinQueryParameters' ? credentials : {};
     }
-
   };
 }
 
@@ -26,15 +22,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,
@@ -42,7 +35,6 @@ function getUrlParams({
     path: pathname
   };
 }
-
 function createEchoRequester({
   getURL,
   status = 200
@@ -54,11 +46,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({
@@ -67,21 +60,20 @@ function createEchoRequester({
       status
     });
   }
-
   return {
     send
   };
 }
 
-/**
- * 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.
+/**
+ * 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 createIterablePromise({
   func,
@@ -96,15 +88,12 @@ function createIterablePromise({
         if (aggregator) {
           aggregator(response);
         }
-
         if (validate(response)) {
           return resolve(response);
         }
-
         if (error && error.validate(response)) {
           return reject(new Error(error.message(response)));
         }
-
         return setTimeout(() => {
           retry(response).then(resolve).catch(reject);
         }, timeout());
@@ -113,27 +102,22 @@ function createIterablePromise({
       });
     });
   };
-
   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) || '{}');
   }
-
   return {
     get(key, defaultValue, events = {
       miss: () => Promise.resolve()
@@ -146,7 +130,6 @@ function createBrowserLocalStorageCache(options) {
         return Promise.all([value, exists || events.miss(value)]);
       }).then(([value]) => value);
     },
-
     set(key, value) {
       return Promise.resolve().then(() => {
         const namespace = getNamespace();
@@ -155,7 +138,6 @@ function createBrowserLocalStorageCache(options) {
         return value;
       });
     },
-
     delete(key) {
       return Promise.resolve().then(() => {
         const namespace = getNamespace();
@@ -163,13 +145,11 @@ function createBrowserLocalStorageCache(options) {
         getStorage().setItem(namespaceKey, JSON.stringify(namespace));
       });
     },
-
     clear() {
       return Promise.resolve().then(() => {
         getStorage().removeItem(namespaceKey);
       });
     }
-
   };
 }
 
@@ -181,30 +161,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()
@@ -215,7 +189,6 @@ function createFallbackableCache(options) {
         }).get(key, defaultValue, events);
       });
     },
-
     set(key, value) {
       return current.set(key, value).catch(() => {
         return createFallbackableCache({
@@ -223,7 +196,6 @@ function createFallbackableCache(options) {
         }).set(key, value);
       });
     },
-
     delete(key) {
       return current.delete(key).catch(() => {
         return createFallbackableCache({
@@ -231,7 +203,6 @@ function createFallbackableCache(options) {
         }).delete(key);
       });
     },
-
     clear() {
       return current.clear().catch(() => {
         return createFallbackableCache({
@@ -239,7 +210,6 @@ function createFallbackableCache(options) {
         }).clear();
       });
     }
-
   };
 }
 
@@ -252,30 +222,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();
     }
-
   };
 }
 
@@ -284,16 +248,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,
@@ -302,6 +264,7 @@ function createStatefulHost(host, status = 'up') {
 }
 
 function _defineProperty(obj, key, value) {
+  key = _toPropertyKey(key);
   if (key in obj) {
     Object.defineProperty(obj, key, {
       value: value,
@@ -312,92 +275,96 @@ function _defineProperty(obj, key, value) {
   } else {
     obj[key] = value;
   }
-
   return obj;
 }
+function _toPrimitive(input, hint) {
+  if (typeof input !== "object" || input === null) return input;
+  var prim = input[Symbol.toPrimitive];
+  if (prim !== undefined) {
+    var res = prim.call(input, hint || "default");
+    if (typeof res !== "object") return res;
+    throw new TypeError("@@toPrimitive must return a primitive value.");
+  }
+  return (hint === "string" ? String : Number)(input);
+}
+function _toPropertyKey(arg) {
+  var key = _toPrimitive(arg, "string");
+  return typeof key === "symbol" ? key : String(key);
+}
 
 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');
   }
-
 }
 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);
@@ -427,14 +394,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({
@@ -465,9 +434,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
       }
     }
@@ -492,53 +464,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 = { ...baseQueryParameters,
+    const queryParameters = {
+      ...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,
@@ -551,25 +519,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,
@@ -578,12 +540,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,
@@ -594,102 +555,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,
@@ -698,33 +642,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,
@@ -742,17 +684,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;
 }
@@ -786,6 +724,7 @@ exports.DEFAULT_READ_TIMEOUT_NODE = DEFAULT_READ_TIMEOUT_NODE;
 exports.DEFAULT_WRITE_TIMEOUT_BROWSER = DEFAULT_WRITE_TIMEOUT_BROWSER;
 exports.DEFAULT_WRITE_TIMEOUT_NODE = DEFAULT_WRITE_TIMEOUT_NODE;
 exports.DeserializationError = DeserializationError;
+exports.DetailedApiError = DetailedApiError;
 exports.ErrorWithStackTrace = ErrorWithStackTrace;
 exports.RetryError = RetryError;
 exports.createAlgoliaAgent = createAlgoliaAgent;