@commercelayer/sdk 7.0.0-beta.1 → 7.0.0-beta.11

package/lib/client.js

@@ -0,0 +1,161 @@
+import { SdkError, handleError, isExpiredTokenError, ErrorType } from './error';
+import config from './config';
+import { fetchURL } from './fetch';
+import { extractTokenData, isTokenExpired } from './util';
+import Debug from './debug';
+
+var __typeError = (msg) => {
+  throw TypeError(msg);
+};
+var __accessCheck = (obj, member, msg) => member.has(obj) || __typeError("Cannot " + msg);
+var __privateGet = (obj, member, getter) => (__accessCheck(obj, member, "read from private field"), getter ? getter.call(obj) : member.get(obj));
+var __privateAdd = (obj, member, value) => member.has(obj) ? __typeError("Cannot add the same private member more than once") : member instanceof WeakSet ? member.add(obj) : member.set(obj, value);
+var __privateSet = (obj, member, value, setter) => (__accessCheck(obj, member, "write to private field"), member.set(obj, value), value);
+var _baseUrl, _accessToken, _organization, _domain, _clientConfig, _interceptors;
+const debug = Debug("client");
+const baseURL = (organization, domain) => {
+  return `https://${organization.toLowerCase()}.${domain || config.default.domain}/api`;
+};
+const _ApiClient = class _ApiClient {
+  constructor(options) {
+    __privateAdd(this, _baseUrl);
+    __privateAdd(this, _accessToken);
+    __privateAdd(this, _organization);
+    __privateAdd(this, _domain);
+    __privateAdd(this, _clientConfig);
+    __privateAdd(this, _interceptors);
+    debug("new client instance %O", options);
+    __privateSet(this, _baseUrl, baseURL(options.organization ?? "", options.domain));
+    __privateSet(this, _accessToken, options.accessToken);
+    __privateSet(this, _organization, options.organization ?? "");
+    __privateSet(this, _domain, options.domain);
+    const fetchConfig = {
+      timeout: options.timeout || config.client.timeout,
+      fetch: options.fetch,
+      refreshToken: options.refreshToken
+    };
+    const customHeaders = this.customHeaders(options.headers);
+    const headers = {
+      ...customHeaders,
+      "Accept": "application/vnd.api+json",
+      "Content-Type": "application/vnd.api+json",
+      "Authorization": "Bearer " + __privateGet(this, _accessToken)
+    };
+    if (options.userAgent) headers["User-Agent"] = options.userAgent;
+    fetchConfig.headers = headers;
+    __privateSet(this, _clientConfig, fetchConfig);
+    debug("fetch config: %O", fetchConfig);
+    __privateSet(this, _interceptors, {});
+  }
+  static create(options) {
+    if ((!options.organization || !options.domain) && options.accessToken) {
+      const tokenData = extractTokenData(options.accessToken);
+      if (!options.organization && tokenData?.organization) options.organization = tokenData.organization;
+      if (!options.domain && tokenData?.domain) options.domain = tokenData.domain;
+    }
+    for (const attr of config.client.requiredAttributes)
+      if (!options[attr]) throw new SdkError({ message: `Undefined '${attr}' parameter` });
+    return new _ApiClient(options);
+  }
+  get interceptors() {
+    return __privateGet(this, _interceptors);
+  }
+  get requestHeaders() {
+    if (!__privateGet(this, _clientConfig).headers) __privateGet(this, _clientConfig).headers = {};
+    return __privateGet(this, _clientConfig).headers;
+  }
+  /*
+  set requestHeaders(headers: RequestHeaders) {
+  	this.#clientConfig.headers = { ...this.#clientConfig.headers, ...headers }
+  }
+  */
+  config(config2) {
+    debug("config %o", config2);
+    const def = __privateGet(this, _clientConfig);
+    if (!def.headers) def.headers = {};
+    if (config2.timeout) def.timeout = config2.timeout;
+    if (config2.userAgent) this.userAgent(config2.userAgent);
+    if (config2.fetch) __privateGet(this, _clientConfig).fetch = config2.fetch;
+    if (config2.refreshToken) __privateGet(this, _clientConfig).refreshToken = config2.refreshToken;
+    if (config2.organization || config2.domain) __privateSet(this, _baseUrl, baseURL(config2.organization || __privateGet(this, _organization), config2.domain || __privateGet(this, _domain)));
+    if (config2.organization) __privateSet(this, _organization, config2.organization);
+    if (config2.domain) __privateSet(this, _domain, config2.domain);
+    if (config2.accessToken) {
+      __privateSet(this, _accessToken, config2.accessToken);
+      def.headers.Authorization = "Bearer " + __privateGet(this, _accessToken);
+    }
+    if (config2.headers) def.headers = { ...def.headers, ...this.customHeaders(config2.headers) };
+    return this;
+  }
+  userAgent(userAgent) {
+    if (userAgent) this.requestHeaders["User-Agent"] = userAgent;
+    return this;
+  }
+  async request(method, path, body, options) {
+    debug("request %s %s, %O, %O", method, path, body || {}, options || {});
+    if (options?.userAgent) debug("User-Agent header ignored in request config");
+    const baseUrl = options?.organization ? baseURL(options.organization, options.domain) : __privateGet(this, _baseUrl);
+    const url = new URL(`${baseUrl}/${path}`);
+    const bodyData = body ? JSON.stringify({ data: body }) : void 0;
+    const headers = { ...this.requestHeaders, ...this.customHeaders(options?.headers) };
+    const accessToken = options?.accessToken || __privateGet(this, _accessToken);
+    if (accessToken) headers.Authorization = "Bearer " + accessToken;
+    const requestOptions = { method, body: bodyData, headers };
+    const timeout = options?.timeout || __privateGet(this, _clientConfig).timeout;
+    if (timeout) {
+      if (AbortSignal?.timeout) requestOptions.signal = AbortSignal.timeout(timeout);
+      else debug("Timeout not set. Undefined function: %s", "AbortSignal.timeout");
+    }
+    if (options?.params) Object.entries(options?.params).forEach(([name, value]) => {
+      url.searchParams.append(name, String(value));
+    });
+    const clientOptions = {
+      interceptors: this.interceptors,
+      fetch: options?.fetch || __privateGet(this, _clientConfig).fetch
+    };
+    try {
+      return await fetchURL(url, requestOptions, clientOptions).catch((error) => handleError(error));
+    } catch (err) {
+      if (isExpiredTokenError(err) && __privateGet(this, _clientConfig).refreshToken && isTokenExpired(__privateGet(this, _accessToken))) {
+        debug("Access token has expired");
+        const newAccessToken = await __privateGet(this, _clientConfig).refreshToken(__privateGet(this, _accessToken)).catch((e) => {
+          debug("Refresh token error: %s", e.message);
+          const tokenError = new SdkError({ message: "Error refreshing access token", type: ErrorType.TOKEN_REFRESH });
+          tokenError.source = e;
+          throw tokenError;
+        });
+        if (newAccessToken) {
+          debug("Access token refreshed");
+          this.config({ accessToken: newAccessToken });
+          if (requestOptions.headers) requestOptions.headers.Authorization = `Bearer ${newAccessToken}`;
+          const response = await fetchURL(url, requestOptions, clientOptions).catch((error) => handleError(error));
+          return response;
+        }
+      } else throw err;
+    }
+  }
+  customHeaders(headers) {
+    const customHeaders = {};
+    if (headers) {
+      for (const [name, value] of Object.entries(headers))
+        if (!["accept", "content-type", "authorization", "user-agent"].includes(name.toLowerCase())) customHeaders[name] = value;
+    }
+    return customHeaders;
+  }
+  get currentAccessToken() {
+    return __privateGet(this, _accessToken);
+  }
+  get currentOrganization() {
+    return __privateGet(this, _organization);
+  }
+};
+_baseUrl = new WeakMap();
+_accessToken = new WeakMap();
+_organization = new WeakMap();
+_domain = new WeakMap();
+_clientConfig = new WeakMap();
+_interceptors = new WeakMap();
+let ApiClient = _ApiClient;
+var client_default = ApiClient;
+
+export { client_default as default };