@commercelayer/sdk/lib/chunk-IKHD5UQP.cjs

Commerce Layer Javascript SDK

'use strict';

var chunkJVF5KY2J_cjs = require('./chunk-JVF5KY2J.cjs');

// src/error.ts
var ErrorType = /* @__PURE__ */ ((ErrorType2) => {
  ErrorType2["CLIENT"] = "client";
  ErrorType2["REQUEST"] = "request";
  ErrorType2["RESPONSE"] = "response";
  ErrorType2["CANCEL"] = "cancel";
  ErrorType2["PARSE"] = "parse";
  ErrorType2["TIMEOUT"] = "timeout";
  ErrorType2["TOKEN_REFRESH"] = "token-refresh";
  return ErrorType2;
})(ErrorType || {});
var SdkError = class _SdkError extends Error {
  static NAME = "SdkError";
  static isSdkError(error) {
    return error && [_SdkError.NAME, ApiError.NAME].includes(error.name) && Object.values(ErrorType).includes(error.type);
  }
  type;
  code;
  source;
  constructor(error) {
    super(error.message);
    this.name = _SdkError.NAME;
    this.type = error.type || "client" /* CLIENT */;
  }
};
var ApiError = class _ApiError extends SdkError {
  static NAME = "ApiError";
  static isApiError(error) {
    return SdkError.isSdkError(error) && error.name === _ApiError.NAME && error.type === "response" /* RESPONSE */;
  }
  errors = [];
  status;
  statusText;
  // constructor(error: SdkError)
  constructor(error) {
    super({ ...error, type: "response" /* RESPONSE */ });
    this.name = _ApiError.NAME;
  }
  first() {
    return this.errors?.length > 0 ? this.errors[0] : void 0;
  }
};
var isRequestError = (error) => {
  return error instanceof TypeError && error.message !== "fetch failed";
};
var isCancelError = (error) => {
  return error instanceof DOMException && error.name === "AbortError";
};
var isTimeoutError = (error) => {
  return error instanceof DOMException && error.name === "TimeoutError";
};
var isExpiredTokenError = (error) => {
  const invalidTokenCodes = [
    "INVALID_TOKEN"
    /*, 'UNAUTHORIZED' */
  ];
  return ApiError.isApiError(error) && error.status === 401 && (invalidTokenCodes.includes(error.code || "") || error.errors && error.errors.length > 0 && invalidTokenCodes.includes(error.errors[0].code));
};
var handleError = (error) => {
  if (SdkError.isSdkError(error) || ApiError.isApiError(error)) throw error;
  let sdkError = new SdkError({ message: error.message });
  if (FetchError.isFetchError(error)) {
    const apiError = new ApiError(sdkError);
    apiError.type = "response" /* RESPONSE */;
    apiError.status = error.status;
    apiError.statusText = error.statusText;
    apiError.code = String(apiError.status);
    apiError.errors = error.errors || [];
    if (!apiError.message && apiError.statusText) apiError.message = apiError.statusText;
    sdkError = apiError;
  } else if (isRequestError(error)) {
    sdkError.type = "request" /* REQUEST */;
  } else if (isCancelError(error)) {
    sdkError.type = "cancel" /* CANCEL */;
  } else if (isTimeoutError(error)) {
    sdkError.type = "timeout" /* TIMEOUT */;
  } else {
    sdkError.type = "client" /* CLIENT */;
    sdkError.source = error;
  }
  throw sdkError;
};
function isSdkError(error) {
  return SdkError.isSdkError(error);
}
function isApiError(error) {
  return ApiError.isApiError(error);
}

// src/fetch.ts
var debug = chunkJVF5KY2J_cjs.debug_default("fetch");
var FetchError = class _FetchError extends Error {
  static NAME = "FetchError";
  static isFetchError = (error) => {
    return error instanceof _FetchError;
  };
  #errors;
  #status;
  #statusText;
  #request;
  constructor(status, statusText, body, request) {
    super(statusText);
    this.#status = status;
    this.#statusText = statusText;
    if (body) this.#errors = body.errors;
    if (request) this.#request = request;
    this.name = _FetchError.NAME;
  }
  get errors() {
    return this.#errors;
  }
  get status() {
    return this.#status;
  }
  get statusText() {
    return this.#statusText;
  }
  get request() {
    return this.#request;
  }
};
var fetchURL = async (url, requestOptions, clientOptions) => {
  debug("fetch: %s, %O, native[%s]", url, requestOptions || {}, clientOptions?.fetch ? "no" : "yes");
  const interceptors = clientOptions?.interceptors;
  if (interceptors?.request?.onSuccess) ({ url, options: requestOptions } = await interceptors.request.onSuccess({ url, options: requestOptions }));
  const fetchClient = clientOptions?.fetch || fetch;
  let response = await fetchClient(url, requestOptions);
  if (response.ok) {
    if (interceptors?.rawReader?.onSuccess) await interceptors.rawReader.onSuccess(response);
    if (interceptors?.response?.onSuccess) response = await interceptors.response.onSuccess(response);
  } else {
    if (interceptors?.rawReader?.onFailure) await interceptors.rawReader.onFailure(response);
  }
  const responseBody = response.body && response.status !== 204 ? await response.json().then((json) => {
    debug("response: %O", json);
    return json;
  }).catch((err) => {
    debug("error: %s", err.message);
    if (response.ok) throw new SdkError({ message: "Error parsing API response body", type: "parse" /* PARSE */ });
  }) : void 0;
  if (!response.ok) {
    let error = new FetchError(response.status, response.statusText, responseBody, requestOptions);
    if (interceptors?.response?.onFailure) error = await interceptors.response.onFailure(error);
    if (error) throw error;
  }
  return responseBody;
};

exports.ApiError = ApiError;
exports.ErrorType = ErrorType;
exports.FetchError = FetchError;
exports.SdkError = SdkError;
exports.fetchURL = fetchURL;
exports.handleError = handleError;
exports.isApiError = isApiError;
exports.isExpiredTokenError = isExpiredTokenError;
exports.isSdkError = isSdkError;
//# sourceMappingURL=chunk-IKHD5UQP.cjs.map
//# sourceMappingURL=chunk-IKHD5UQP.cjs.map