@algolia/client-common 5.56.0 → 5.59.0

package/dist/common.cjs

@@ -40,6 +40,7 @@ __export(src_exports, {
   IndicesInSameAppError: () => IndicesInSameAppError,
   LogLevelEnum: () => LogLevelEnum,
   RetryError: () => RetryError,
+  StreamRequestError: () => StreamRequestError,
   createAlgoliaAgent: () => createAlgoliaAgent,
   createAuth: () => createAuth,
   createBrowserLocalStorageCache: () => createBrowserLocalStorageCache,
@@ -53,11 +54,19 @@ __export(src_exports, {
   deserializeFailure: () => deserializeFailure,
   deserializeSuccess: () => deserializeSuccess,
   deserializeSuccessWithHttpInfo: () => deserializeSuccessWithHttpInfo,
+  generateRequestId: () => generateRequestId,
   getAlgoliaAgent: () => getAlgoliaAgent,
+  getCorrelationId: () => getCorrelationId,
+  getLastCorrelationId: () => getLastCorrelationId,
+  headersFromError: () => headersFromError,
   isNetworkError: () => isNetworkError,
+  isRateLimited: () => isRateLimited,
+  isRateLimitedError: () => isRateLimitedError,
   isRetryable: () => isRetryable,
   isSuccess: () => isSuccess,
   iterSSEEvents: () => iterSSEEvents,
+  logWarning: () => logWarning,
+  parseRetryAfterMs: () => parseRetryAfterMs,
   serializeData: () => serializeData,
   serializeHeaders: () => serializeHeaders,
   serializeQueryParameters: () => serializeQueryParameters,
@@ -65,7 +74,8 @@ __export(src_exports, {
   shuffle: () => shuffle,
   stackFrameWithoutCredentials: () => stackFrameWithoutCredentials,
   stackTraceWithoutCredentials: () => stackTraceWithoutCredentials,
-  validateRequired: () => validateRequired
+  validateRequired: () => validateRequired,
+  withRequestId: () => withRequestId
 });
 module.exports = __toCommonJS(src_exports);
 
@@ -335,6 +345,16 @@ function createNullLogger() {
   };
 }
 
+// src/logger/logWarning.ts
+function logWarning(logger, message) {
+  if (logger.warn) {
+    void Promise.resolve(logger.warn(message)).catch(() => {
+    });
+  } else {
+    console.warn(message);
+  }
+}
+
 // src/sse.ts
 var MAX_LINE_BUFFER_SIZE = 10 * 1024 * 1024;
 async function* readableStreamToAsyncIterable(stream) {
@@ -538,38 +558,52 @@ var IndexAlreadyExistsError = class extends AlgoliaError {
   }
 };
 var ErrorWithStackTrace = class extends AlgoliaError {
-  constructor(message, stackTrace, name) {
-    super(message, name);
+  constructor(message, stackTrace, name, correlationId) {
+    super(correlationId ? `${message} (Correlation-ID: ${correlationId})` : message, name);
     __publicField(this, "stackTrace");
+    __publicField(this, "correlationId");
     this.stackTrace = stackTrace;
+    this.correlationId = correlationId;
   }
 };
 var RetryError = class extends ErrorWithStackTrace {
-  constructor(stackTrace) {
+  constructor(stackTrace, correlationId) {
     super(
       "Unreachable hosts - your application id may be incorrect. If the error persists, please visit our help center https://alg.li/support-unreachable-hosts or reach out to the Algolia Support team: https://alg.li/support",
       stackTrace,
-      "RetryError"
+      "RetryError",
+      correlationId
     );
   }
 };
 var ApiError = class extends ErrorWithStackTrace {
-  constructor(message, status, stackTrace, name = "ApiError") {
-    super(message, stackTrace, name);
+  constructor(message, status, stackTrace, name = "ApiError", correlationId) {
+    super(message, stackTrace, name, correlationId);
+    __publicField(this, "status");
+    this.status = status;
+  }
+};
+var StreamRequestError = class extends AlgoliaError {
+  constructor(status, body, headers) {
+    super(`HTTP ${status}: ${body}`, "StreamRequestError");
     __publicField(this, "status");
+    __publicField(this, "headers");
     this.status = status;
+    this.headers = headers;
   }
 };
 var DeserializationError = class extends AlgoliaError {
-  constructor(message, response) {
-    super(message, "DeserializationError");
+  constructor(message, response, correlationId) {
+    super(correlationId ? `${message} (Correlation-ID: ${correlationId})` : message, "DeserializationError");
     __publicField(this, "response");
+    __publicField(this, "correlationId");
     this.response = response;
+    this.correlationId = correlationId;
   }
 };
 var DetailedApiError = class extends ApiError {
-  constructor(message, status, error, stackTrace) {
-    super(message, status, stackTrace, "DetailedApiError");
+  constructor(message, status, error, stackTrace, correlationId) {
+    super(message, status, stackTrace, "DetailedApiError", correlationId);
     __publicField(this, "error");
     this.error = error;
   }
@@ -629,7 +663,7 @@ function deserializeSuccess(response) {
   try {
     return JSON.parse(response.content);
   } catch (e) {
-    throw new DeserializationError(e.message, response);
+    throw new DeserializationError(e.message, response, getCorrelationId(response.headers));
   }
 }
 function deserializeSuccessWithHttpInfo(response) {
@@ -640,19 +674,76 @@ function deserializeSuccessWithHttpInfo(response) {
     data: deserializeSuccess(response)
   };
 }
-function deserializeFailure({ content, status }, stackFrame) {
+function getCorrelationId(headers) {
+  if (!headers) {
+    return void 0;
+  }
+  if (headers["correlation-id"] !== void 0) {
+    return headers["correlation-id"];
+  }
+  const header = Object.keys(headers).find((key) => key.toLowerCase() === "correlation-id");
+  return header === void 0 ? void 0 : headers[header];
+}
+function getLastCorrelationId(stackTrace) {
+  for (let i = stackTrace.length - 1; i >= 0; i--) {
+    const correlationId = getCorrelationId(stackTrace[i].response.headers);
+    if (correlationId !== void 0) {
+      return correlationId;
+    }
+  }
+  return void 0;
+}
+function deserializeFailure(response, stackFrame) {
+  const { content, status } = response;
+  const correlationId = getCorrelationId(response.headers);
   try {
     const parsed = JSON.parse(content);
     if ("error" in parsed) {
-      return new DetailedApiError(parsed.message, status, parsed.error, stackFrame);
+      return new DetailedApiError(parsed.message, status, parsed.error, stackFrame, correlationId);
     }
-    return new ApiError(parsed.message, status, stackFrame);
+    return new ApiError(parsed.message, status, stackFrame, "ApiError", correlationId);
   } catch (e) {
   }
-  return new ApiError(content, status, stackFrame);
+  return new ApiError(content, status, stackFrame, "ApiError", correlationId);
+}
+
+// src/transporter/requestId.ts
+var BASE62_CHARS = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789";
+var REQUEST_ID_LENGTH = 11;
+function generateRequestId() {
+  var _a;
+  let requestId = "";
+  if (typeof ((_a = globalThis.crypto) == null ? void 0 : _a.getRandomValues) === "function") {
+    const bytes = new Uint8Array(REQUEST_ID_LENGTH);
+    globalThis.crypto.getRandomValues(bytes);
+    for (const byte of bytes) {
+      requestId += BASE62_CHARS[byte % BASE62_CHARS.length];
+    }
+    return requestId;
+  }
+  for (let i = 0; i < REQUEST_ID_LENGTH; i++) {
+    requestId += BASE62_CHARS[Math.floor(Math.random() * BASE62_CHARS.length)];
+  }
+  return requestId;
+}
+function hasRequestId(headers, queryParameters) {
+  return headers !== void 0 && Object.keys(headers).some((header) => header.toLowerCase() === "request-id") || queryParameters !== void 0 && Object.keys(queryParameters).some((parameter) => parameter.toLowerCase() === "x-algolia-request-id");
+}
+function withRequestId(transporter, requestOptions) {
+  if (transporter.requestIdChannel === void 0 || hasRequestId(transporter.baseHeaders, transporter.baseQueryParameters) || hasRequestId(requestOptions == null ? void 0 : requestOptions.headers, requestOptions == null ? void 0 : requestOptions.queryParameters)) {
+    return requestOptions;
+  }
+  if (transporter.requestIdChannel === "headers") {
+    return { ...requestOptions, headers: { ...requestOptions == null ? void 0 : requestOptions.headers, "request-id": generateRequestId() } };
+  }
+  return {
+    ...requestOptions,
+    queryParameters: { ...requestOptions == null ? void 0 : requestOptions.queryParameters, "x-algolia-request-id": generateRequestId() }
+  };
 }
 
 // src/transporter/responses.ts
+var DEFAULT_RATE_LIMIT_WAIT_MS = 1e3;
 function isNetworkError({ isTimedOut, status }) {
   return !isTimedOut && ~~status === 0;
 }
@@ -662,6 +753,37 @@ function isRetryable({ isTimedOut, status }) {
 function isSuccess({ status }) {
   return ~~(status / 100) === 2;
 }
+function isRateLimited({ status }) {
+  return ~~status === 429;
+}
+var HTTP_429_MESSAGE = /^HTTP 429(?:\D|$)/;
+function isRateLimitedError(error) {
+  if (typeof error === "object" && error !== null && "status" in error) {
+    return isRateLimited(error);
+  }
+  return error instanceof Error && HTTP_429_MESSAGE.test(error.message);
+}
+function headersFromError(error) {
+  if (typeof error === "object" && error !== null && "headers" in error) {
+    return error.headers;
+  }
+  return void 0;
+}
+function parseRetryAfterMs(headers) {
+  var _a;
+  const raw = (_a = headers == null ? void 0 : headers["retry-after"]) == null ? void 0 : _a.trim();
+  if (raw === void 0 || raw.length === 0) {
+    return DEFAULT_RATE_LIMIT_WAIT_MS;
+  }
+  if (!/^\d+$/.test(raw)) {
+    return DEFAULT_RATE_LIMIT_WAIT_MS;
+  }
+  const seconds = Number.parseInt(raw, 10);
+  if (seconds <= 0) {
+    return DEFAULT_RATE_LIMIT_WAIT_MS;
+  }
+  return seconds * 1e3;
+}
 
 // src/transporter/stackTrace.ts
 function stackTraceWithoutCredentials(stackTrace) {
@@ -694,8 +816,23 @@ function createTransporter({
   requestsCache,
   responsesCache,
   compress,
-  compression
+  compression,
+  requestIdChannel,
+  maxRateLimitRetries = 3
 }) {
+  function injectRequestId(headers, queryParameters) {
+    if (requestIdChannel === void 0 || headers["request-id"] !== void 0 || Object.keys(queryParameters).some((parameter) => parameter.toLowerCase() === "x-algolia-request-id")) {
+      return;
+    }
+    if (requestIdChannel === "headers") {
+      headers["request-id"] = generateRequestId();
+    } else {
+      queryParameters["x-algolia-request-id"] = generateRequestId();
+    }
+  }
+  const wait = (ms) => new Promise((resolve) => {
+    setTimeout(resolve, ms);
+  });
   async function createRetryableOptions(compatibleHosts) {
     const statefulHosts = await Promise.all(
       compatibleHosts.map((compatibleHost) => {
@@ -750,11 +887,13 @@ function createTransporter({
         }
       }
     }
+    injectRequestId(headers, queryParameters);
     let timeoutsCount = 0;
+    let rateLimitRetriesLeft = maxRateLimitRetries;
     const retry = async (retryableHosts, getTimeout) => {
       const host = retryableHosts.pop();
       if (host === void 0) {
-        throw new RetryError(stackTraceWithoutCredentials(stackTrace));
+        throw new RetryError(stackTraceWithoutCredentials(stackTrace), getLastCorrelationId(stackTrace));
       }
       const timeout = { ...timeouts, ...requestOptions.timeouts };
       const payload = {
@@ -776,6 +915,19 @@ function createTransporter({
         return stackFrame;
       };
       const response = await requester.send(payload);
+      if (isRateLimited(response) && rateLimitRetriesLeft > 0) {
+        rateLimitRetriesLeft--;
+        retryableHosts.push(host);
+        const stackFrame = pushToStackTrace(response);
+        const waitMs = parseRetryAfterMs(response.headers);
+        logger.info("Retryable failure", {
+          ...stackFrameWithoutCredentials(stackFrame),
+          wait: waitMs,
+          rateLimitRetriesLeft
+        });
+        await wait(waitMs);
+        return retry(retryableHosts, getTimeout);
+      }
       if (isRetryable(response)) {
         const stackFrame = pushToStackTrace(response);
         if (response.isTimedOut) {
@@ -878,6 +1030,7 @@ function createTransporter({
         }
       }
     }
+    injectRequestId(headers, queryParameters);
     const isRead = request.useReadTransporter || request.method === "GET";
     const compatibleHosts = hosts.filter(
       (host2) => host2.accept === "readWrite" || (isRead ? host2.accept === "read" : host2.accept === "write")
@@ -896,8 +1049,28 @@ function createTransporter({
       connectTimeout: timeout.connect,
       responseTimeout: isRead ? timeout.read : timeout.write
     };
-    const stream = await requester.sendStream(payload);
-    yield* iterSSEEvents(stream);
+    let rateLimitRetriesLeft = maxRateLimitRetries;
+    while (true) {
+      let stream;
+      try {
+        stream = await requester.sendStream(payload);
+      } catch (error) {
+        if (isRateLimitedError(error) && rateLimitRetriesLeft > 0) {
+          rateLimitRetriesLeft--;
+          const waitMs = parseRetryAfterMs(headersFromError(error));
+          logger.info("Retryable failure", {
+            wait: waitMs,
+            rateLimitRetriesLeft,
+            host
+          });
+          await wait(waitMs);
+          continue;
+        }
+        throw error;
+      }
+      yield* iterSSEEvents(stream);
+      return;
+    }
   }
   return {
     hostsCache,
@@ -907,7 +1080,9 @@ function createTransporter({
     algoliaAgent,
     baseHeaders,
     baseQueryParameters,
+    requestIdChannel,
     hosts,
+    maxRateLimitRetries,
     request: createRequest,
     requestWithHttpInfo: createRequestWithHttpInfo,
     requestStream,
@@ -949,6 +1124,7 @@ function validateRequired(field, method, value) {
   IndicesInSameAppError,
   LogLevelEnum,
   RetryError,
+  StreamRequestError,
   createAlgoliaAgent,
   createAuth,
   createBrowserLocalStorageCache,
@@ -962,11 +1138,19 @@ function validateRequired(field, method, value) {
   deserializeFailure,
   deserializeSuccess,
   deserializeSuccessWithHttpInfo,
+  generateRequestId,
   getAlgoliaAgent,
+  getCorrelationId,
+  getLastCorrelationId,
+  headersFromError,
   isNetworkError,
+  isRateLimited,
+  isRateLimitedError,
   isRetryable,
   isSuccess,
   iterSSEEvents,
+  logWarning,
+  parseRetryAfterMs,
   serializeData,
   serializeHeaders,
   serializeQueryParameters,
@@ -974,6 +1158,7 @@ function validateRequired(field, method, value) {
   shuffle,
   stackFrameWithoutCredentials,
   stackTraceWithoutCredentials,
-  validateRequired
+  validateRequired,
+  withRequestId
 });
 //# sourceMappingURL=common.cjs.map