@algolia/client-common 5.2.3 → 5.2.4-beta.2

package/dist/common.esm.js

@@ -0,0 +1,653 @@
+// src/createAuth.ts
+function createAuth(appId, apiKey, authMode = "WithinHeaders") {
+  const credentials = {
+    "x-algolia-api-key": apiKey,
+    "x-algolia-application-id": appId
+  };
+  return {
+    headers() {
+      return authMode === "WithinHeaders" ? credentials : {};
+    },
+    queryParameters() {
+      return authMode === "WithinQueryParameters" ? credentials : {};
+    }
+  };
+}
+
+// src/createEchoRequester.ts
+function getUrlParams({
+  host,
+  search,
+  pathname
+}) {
+  const urlSearchParams = search.split("?");
+  if (urlSearchParams.length === 1) {
+    return {
+      host,
+      algoliaAgent: "",
+      searchParams: void 0,
+      path: pathname
+    };
+  }
+  const splitSearchParams = urlSearchParams[1].split("&");
+  let algoliaAgent = "";
+  const searchParams = {};
+  if (splitSearchParams.length > 0) {
+    splitSearchParams.forEach((param) => {
+      const [key, value] = param.split("=");
+      if (key === "x-algolia-agent") {
+        algoliaAgent = value;
+        return;
+      }
+      searchParams[key] = value;
+    });
+  }
+  return {
+    host,
+    algoliaAgent,
+    searchParams: Object.keys(searchParams).length === 0 ? void 0 : searchParams,
+    path: pathname
+  };
+}
+function createEchoRequester({ getURL, status = 200 }) {
+  function send(request) {
+    const { host, searchParams, algoliaAgent, path } = getUrlParams(getURL(request.url));
+    const content = {
+      ...request,
+      data: request.data ? JSON.parse(request.data) : void 0,
+      path,
+      host,
+      algoliaAgent,
+      searchParams
+    };
+    return Promise.resolve({
+      content: JSON.stringify(content),
+      isTimedOut: false,
+      status
+    });
+  }
+  return { send };
+}
+
+// src/createIterablePromise.ts
+function createIterablePromise({
+  func,
+  validate,
+  aggregator,
+  error,
+  timeout = () => 0
+}) {
+  const retry = (previousResponse) => {
+    return new Promise((resolve, reject) => {
+      func(previousResponse).then((response) => {
+        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());
+      }).catch((err) => {
+        reject(err);
+      });
+    });
+  };
+  return retry();
+}
+
+// src/cache/createBrowserLocalStorageCache.ts
+function createBrowserLocalStorageCache(options) {
+  let storage;
+  const namespaceKey = `algolia-client-js-${options.key}`;
+  function getStorage() {
+    if (storage === void 0) {
+      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 * 1e3 : null;
+    const namespace = getNamespace();
+    const filteredNamespaceWithoutOldFormattedCacheItems = Object.fromEntries(
+      Object.entries(namespace).filter(([, cacheItem]) => {
+        return cacheItem.timestamp !== void 0;
+      })
+    );
+    setNamespace(filteredNamespaceWithoutOldFormattedCacheItems);
+    if (!timeToLive) {
+      return;
+    }
+    const filteredNamespaceWithoutExpiredItems = Object.fromEntries(
+      Object.entries(filteredNamespaceWithoutOldFormattedCacheItems).filter(([, cacheItem]) => {
+        const currentTimestamp = (/* @__PURE__ */ 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(() => {
+        removeOutdatedCacheItems();
+        return getNamespace()[JSON.stringify(key)];
+      }).then((value) => {
+        return Promise.all([value ? value.value : defaultValue(), value !== void 0]);
+      }).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)] = {
+          timestamp: (/* @__PURE__ */ new Date()).getTime(),
+          value
+        };
+        getStorage().setItem(namespaceKey, JSON.stringify(namespace));
+        return value;
+      });
+    },
+    delete(key) {
+      return Promise.resolve().then(() => {
+        const namespace = getNamespace();
+        delete namespace[JSON.stringify(key)];
+        getStorage().setItem(namespaceKey, JSON.stringify(namespace));
+      });
+    },
+    clear() {
+      return Promise.resolve().then(() => {
+        getStorage().removeItem(namespaceKey);
+      });
+    }
+  };
+}
+
+// src/cache/createNullCache.ts
+function createNullCache() {
+  return {
+    get(_key, defaultValue, events = {
+      miss: () => Promise.resolve()
+    }) {
+      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();
+    }
+  };
+}
+
+// src/cache/createFallbackableCache.ts
+function createFallbackableCache(options) {
+  const caches = [...options.caches];
+  const current = caches.shift();
+  if (current === void 0) {
+    return createNullCache();
+  }
+  return {
+    get(key, defaultValue, events = {
+      miss: () => Promise.resolve()
+    }) {
+      return current.get(key, defaultValue, events).catch(() => {
+        return createFallbackableCache({ caches }).get(key, defaultValue, events);
+      });
+    },
+    set(key, value) {
+      return current.set(key, value).catch(() => {
+        return createFallbackableCache({ caches }).set(key, value);
+      });
+    },
+    delete(key) {
+      return current.delete(key).catch(() => {
+        return createFallbackableCache({ caches }).delete(key);
+      });
+    },
+    clear() {
+      return current.clear().catch(() => {
+        return createFallbackableCache({ caches }).clear();
+      });
+    }
+  };
+}
+
+// src/cache/createMemoryCache.ts
+function createMemoryCache(options = { serializable: true }) {
+  let cache = {};
+  return {
+    get(key, defaultValue, events = {
+      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();
+    }
+  };
+}
+
+// src/transporter/createStatefulHost.ts
+var EXPIRATION_DELAY = 2 * 60 * 1e3;
+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, status, lastUpdate, isUp, isTimedOut };
+}
+
+// src/transporter/errors.ts
+var AlgoliaError = class extends Error {
+  name = "AlgoliaError";
+  constructor(message, name) {
+    super(message);
+    if (name) {
+      this.name = name;
+    }
+  }
+};
+var ErrorWithStackTrace = class extends AlgoliaError {
+  stackTrace;
+  constructor(message, stackTrace, name) {
+    super(message, name);
+    this.stackTrace = stackTrace;
+  }
+};
+var RetryError = class extends ErrorWithStackTrace {
+  constructor(stackTrace) {
+    super(
+      "Unreachable hosts - your application id may be incorrect. If the error persists, please reach out to the Algolia Support team: https://alg.li/support.",
+      stackTrace,
+      "RetryError"
+    );
+  }
+};
+var ApiError = class extends ErrorWithStackTrace {
+  status;
+  constructor(message, status, stackTrace, name = "ApiError") {
+    super(message, stackTrace, name);
+    this.status = status;
+  }
+};
+var DeserializationError = class extends AlgoliaError {
+  response;
+  constructor(message, response) {
+    super(message, "DeserializationError");
+    this.response = response;
+  }
+};
+var DetailedApiError = class extends ApiError {
+  error;
+  constructor(message, status, error, stackTrace) {
+    super(message, status, stackTrace, "DetailedApiError");
+    this.error = error;
+  }
+};
+
+// src/transporter/helpers.ts
+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}${host.port ? `:${host.port}` : ""}/${path.charAt(0) === "/" ? path.substring(1) : path}`;
+  if (queryParametersAsString.length) {
+    url += `?${queryParametersAsString}`;
+  }
+  return url;
+}
+function serializeQueryParameters(parameters) {
+  return Object.keys(parameters).filter((key) => parameters[key] !== void 0).sort().map(
+    (key) => `${key}=${encodeURIComponent(
+      Object.prototype.toString.call(parameters[key]) === "[object Array]" ? parameters[key].join(",") : parameters[key]
+    ).replaceAll("+", "%20")}`
+  ).join("&");
+}
+function serializeData(request, requestOptions) {
+  if (request.method === "GET" || request.data === void 0 && requestOptions.data === void 0) {
+    return void 0;
+  }
+  const data = Array.isArray(request.data) ? request.data : { ...request.data, ...requestOptions.data };
+  return JSON.stringify(data);
+}
+function serializeHeaders(baseHeaders, requestHeaders, requestOptionsHeaders) {
+  const headers = {
+    Accept: "application/json",
+    ...baseHeaders,
+    ...requestHeaders,
+    ...requestOptionsHeaders
+  };
+  const serializedHeaders = {};
+  Object.keys(headers).forEach((header) => {
+    const value = headers[header];
+    serializedHeaders[header.toLowerCase()] = value;
+  });
+  return serializedHeaders;
+}
+function deserializeSuccess(response) {
+  try {
+    return JSON.parse(response.content);
+  } catch (e) {
+    throw new DeserializationError(e.message, response);
+  }
+}
+function deserializeFailure({ content, status }, stackFrame) {
+  try {
+    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 {
+  }
+  return new ApiError(content, status, stackFrame);
+}
+
+// src/transporter/responses.ts
+function isNetworkError({ isTimedOut, status }) {
+  return !isTimedOut && ~~status === 0;
+}
+function isRetryable({ isTimedOut, status }) {
+  return isTimedOut || isNetworkError({ isTimedOut, status }) || ~~(status / 100) !== 2 && ~~(status / 100) !== 4;
+}
+function isSuccess({ status }) {
+  return ~~(status / 100) === 2;
+}
+
+// src/transporter/stackTrace.ts
+function stackTraceWithoutCredentials(stackTrace) {
+  return stackTrace.map((stackFrame) => stackFrameWithoutCredentials(stackFrame));
+}
+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,
+        ...modifiedHeaders
+      }
+    }
+  };
+}
+
+// src/transporter/createTransporter.ts
+function createTransporter({
+  hosts,
+  hostsCache,
+  baseHeaders,
+  baseQueryParameters,
+  algoliaAgent,
+  timeouts,
+  requester,
+  requestsCache,
+  responsesCache
+}) {
+  async function createRetryableOptions(compatibleHosts) {
+    const statefulHosts = await Promise.all(
+      compatibleHosts.map((compatibleHost) => {
+        return hostsCache.get(compatibleHost, () => {
+          return Promise.resolve(createStatefulHost(compatibleHost));
+        });
+      })
+    );
+    const hostsUp = statefulHosts.filter((host) => host.isUp());
+    const hostsTimedOut = statefulHosts.filter((host) => host.isTimedOut());
+    const hostsAvailable = [...hostsUp, ...hostsTimedOut];
+    const compatibleHostsAvailable = hostsAvailable.length > 0 ? hostsAvailable : compatibleHosts;
+    return {
+      hosts: compatibleHostsAvailable,
+      getTimeout(timeoutsCount, baseTimeout) {
+        const timeoutMultiplier = hostsTimedOut.length === 0 && timeoutsCount === 0 ? 1 : hostsTimedOut.length + 3 + timeoutsCount;
+        return timeoutMultiplier * baseTimeout;
+      }
+    };
+  }
+  async function retryableRequest(request, requestOptions, isRead = true) {
+    const stackTrace = [];
+    const data = serializeData(request, requestOptions);
+    const headers = serializeHeaders(baseHeaders, request.headers, requestOptions.headers);
+    const dataQueryParameters = request.method === "GET" ? {
+      ...request.data,
+      ...requestOptions.data
+    } : {};
+    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)) {
+        if (!requestOptions.queryParameters[key] || Object.prototype.toString.call(requestOptions.queryParameters[key]) === "[object Object]") {
+          queryParameters[key] = requestOptions.queryParameters[key];
+        } else {
+          queryParameters[key] = requestOptions.queryParameters[key].toString();
+        }
+      }
+    }
+    let timeoutsCount = 0;
+    const retry = async (retryableHosts, getTimeout) => {
+      const host = retryableHosts.pop();
+      if (host === void 0) {
+        throw new RetryError(stackTraceWithoutCredentials(stackTrace));
+      }
+      const timeout = { ...timeouts, ...requestOptions.timeouts };
+      const payload = {
+        data,
+        headers,
+        method: request.method,
+        url: serializeUrl(host, request.path, queryParameters),
+        connectTimeout: getTimeout(timeoutsCount, timeout.connect),
+        responseTimeout: getTimeout(timeoutsCount, isRead ? timeout.read : timeout.write)
+      };
+      const pushToStackTrace = (response2) => {
+        const stackFrame = {
+          request: payload,
+          response: response2,
+          host,
+          triesLeft: retryableHosts.length
+        };
+        stackTrace.push(stackFrame);
+        return stackFrame;
+      };
+      const response = await requester.send(payload);
+      if (isRetryable(response)) {
+        const stackFrame = pushToStackTrace(response);
+        if (response.isTimedOut) {
+          timeoutsCount++;
+        }
+        console.log("Retryable failure", stackFrameWithoutCredentials(stackFrame));
+        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);
+    };
+    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 = {}) {
+    const isRead = request.useReadTransporter || request.method === "GET";
+    if (!isRead) {
+      return retryableRequest(request, requestOptions, isRead);
+    }
+    const createRetryableRequest = () => {
+      return retryableRequest(request, requestOptions);
+    };
+    const cacheable = requestOptions.cacheable || request.cacheable;
+    if (cacheable !== true) {
+      return createRetryableRequest();
+    }
+    const key = {
+      request,
+      requestOptions,
+      transporter: {
+        queryParameters: baseQueryParameters,
+        headers: baseHeaders
+      }
+    };
+    return responsesCache.get(
+      key,
+      () => {
+        return requestsCache.get(
+          key,
+          () => (
+            /**
+             * 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.
+         */
+        miss: (response) => responsesCache.set(key, response)
+      }
+    );
+  }
+  return {
+    hostsCache,
+    requester,
+    timeouts,
+    algoliaAgent,
+    baseHeaders,
+    baseQueryParameters,
+    hosts,
+    request: createRequest,
+    requestsCache,
+    responsesCache
+  };
+}
+
+// src/createAlgoliaAgent.ts
+function createAlgoliaAgent(version) {
+  const algoliaAgent = {
+    value: `Algolia for JavaScript (${version})`,
+    add(options) {
+      const addedAlgoliaAgent = `; ${options.segment}${options.version !== void 0 ? ` (${options.version})` : ""}`;
+      if (algoliaAgent.value.indexOf(addedAlgoliaAgent) === -1) {
+        algoliaAgent.value = `${algoliaAgent.value}${addedAlgoliaAgent}`;
+      }
+      return algoliaAgent;
+    }
+  };
+  return algoliaAgent;
+}
+
+// src/getAlgoliaAgent.ts
+function getAlgoliaAgent({ algoliaAgents, client, version }) {
+  const defaultAlgoliaAgent = createAlgoliaAgent(version).add({
+    segment: client,
+    version
+  });
+  algoliaAgents.forEach((algoliaAgent) => defaultAlgoliaAgent.add(algoliaAgent));
+  return defaultAlgoliaAgent;
+}
+
+// src/constants.ts
+var DEFAULT_CONNECT_TIMEOUT_BROWSER = 1e3;
+var DEFAULT_READ_TIMEOUT_BROWSER = 2e3;
+var DEFAULT_WRITE_TIMEOUT_BROWSER = 3e4;
+var DEFAULT_CONNECT_TIMEOUT_NODE = 2e3;
+var DEFAULT_READ_TIMEOUT_NODE = 5e3;
+var DEFAULT_WRITE_TIMEOUT_NODE = 3e4;
+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
+};
+//# sourceMappingURL=common.esm.js.map