getta 0.4.7 → 1.0.0

package/dist/main/index.mjs

@@ -0,0 +1,621 @@
+import _defineProperty from '@babel/runtime/helpers/defineProperty';
+import 'core-js/modules/es.array.push.js';
+import { merge, castArray } from 'lodash-es';
+import { Md5 } from 'ts-md5';
+import queryString from 'query-string';
+
+const ARRAY_BUFFER_FORMAT = 'arrayBuffer';
+const BLOB_FORMAT = 'blob';
+const FORM_DATA_FORMAT = 'formData';
+const JSON_FORMAT = 'json';
+const TEXT_FORMAT = 'text';
+const STREAM_READERS = {
+  ARRAY_BUFFER_FORMAT,
+  BLOB_FORMAT,
+  FORM_DATA_FORMAT,
+  JSON_FORMAT,
+  TEXT_FORMAT
+};
+const DEFAULT_BODY_PARSER = body => body;
+const DEFAULT_FETCH_TIMEOUT = 5000;
+const DEFAULT_HEADERS = {
+  'content-type': 'application/json'
+};
+const DEFAULT_MAX_REDIRECTS = 5;
+const DEFAULT_MAX_RETRIES = 3;
+const DEFAULT_PATH_TEMPLATE_REGEX = /({type})|({id})|({id,\+})|({brief\|standard})/g;
+const OPTIONAL_PATH_TEMPLATE_REGEX = /({\w+\?})/g;
+const DEFAULT_RATE_LIMIT = 50;
+const DEFAULT_REQUEST_RETRY_WAIT = 100;
+const MISSING_BASE_PATH_ERROR = `Getta expected to receive 'basePath' in the constructor options,
+  but recevied undefined.`;
+const MAX_REDIRECTS_EXCEEDED_ERROR = 'The request exceeded the maximum number of redirects, which is';
+const MAX_RETRIES_EXCEEDED_ERROR = 'The request exceeded the maximum number of retries, which is';
+const INVALID_FETCH_METHOD_ERROR = "Getta expected to receive 'get', 'post', 'put' or 'delete', but received";
+const RESOURCE_NOT_FOUND_ERROR = 'The requested resource could not been found.';
+const FETCH_TIMEOUT_ERROR = 'The request timed out. Getta did not get a response within';
+const GET_METHOD = 'get';
+const POST_METHOD = 'post';
+const PUT_METHOD = 'put';
+const DELETE_METHOD = 'delete';
+const FETCH_METHODS = [GET_METHOD, POST_METHOD, PUT_METHOD, DELETE_METHOD];
+const INFORMATION_REPSONSE = 'information';
+const SUCCESSFUL_REPSONSE = 'successful';
+const REDIRECTION_REPSONSE = 'redirection';
+const CLIENT_ERROR_REPSONSE = 'clientError';
+const SERVER_ERROR_REPSONSE = 'serverError';
+const NOT_MODIFIED_STATUS_CODE = 304;
+const NOT_FOUND_STATUS_CODE = 404;
+const COOKIE_HEADER = 'Cookie';
+const ETAG_HEADER = 'ETag';
+const LOCATION_HEADER = 'Location';
+const IF_NONE_MATCH_HEADER = 'If-None-Match';
+const CACHE_CONTROL_HEADER = 'Cache-Control';
+const REQUEST_SENT = 'request_sent';
+const RESPONSE_RECEIVED = 'response_received';
+
+const defaultPathTemplateCallback = (pathTemplate, data, pathTemplateRegExp) => {
+  const dataKeys = Object.keys(data);
+  return pathTemplate.replace(pathTemplateRegExp, match => {
+    for (const key of dataKeys) {
+      if (match.includes(key) && data[key]) {
+        return data[key];
+      }
+    }
+    return '';
+  });
+};
+
+const buildEndpoint = (basePath, path, {
+  optionalPathTemplateRegExp,
+  pathTemplateCallback,
+  pathTemplateData,
+  pathTemplateRegExp,
+  queryParams
+}) => {
+  const pathJoiner = basePath.endsWith('/') || path.startsWith('/') ? '' : '/';
+  let endpoint = `${basePath}${pathJoiner}${path}`;
+  if (pathTemplateData) {
+    endpoint = pathTemplateCallback(endpoint, pathTemplateData, pathTemplateRegExp);
+  }
+  endpoint = endpoint.replace(optionalPathTemplateRegExp, '');
+  if (endpoint.endsWith('/')) {
+    endpoint = endpoint.slice(0, Math.max(0, endpoint.length - 1));
+  }
+  if (queryParams && Object.keys(queryParams).length > 0) {
+    const queryJoin = queryString.extract(endpoint) ? '&' : '?';
+    endpoint = `${endpoint}${queryJoin}${queryString.stringify(queryParams)}`;
+  }
+  return endpoint;
+};
+
+const delay = ms => {
+  return new Promise(resolve => setTimeout(resolve, ms));
+};
+
+const getResponseGroup = status => {
+  switch (true) {
+    case status < 200:
+      {
+        return INFORMATION_REPSONSE;
+      }
+    case status < 300:
+      {
+        return SUCCESSFUL_REPSONSE;
+      }
+    case status < 400:
+      {
+        return REDIRECTION_REPSONSE;
+      }
+    case status < 500:
+      {
+        return CLIENT_ERROR_REPSONSE;
+      }
+    default:
+      {
+        return SERVER_ERROR_REPSONSE;
+      }
+  }
+};
+
+const isCacheabilityValid = cacheability => {
+  const noCache = cacheability.metadata.cacheControl.noCache ?? false;
+  return !noCache && cacheability.checkTTL();
+};
+
+class Getta {
+  constructor(options) {
+    _defineProperty(this, "_basePath", void 0);
+    _defineProperty(this, "_bodyParser", void 0);
+    _defineProperty(this, "_cache", void 0);
+    _defineProperty(this, "_conditionalRequestsEnabled", void 0);
+    _defineProperty(this, "_fetchTimeout", void 0);
+    _defineProperty(this, "_headers", void 0);
+    _defineProperty(this, "_log", void 0);
+    _defineProperty(this, "_maxRedirects", void 0);
+    _defineProperty(this, "_maxRetries", void 0);
+    _defineProperty(this, "_optionalPathTemplateRegExp", void 0);
+    _defineProperty(this, "_pathTemplateCallback", void 0);
+    _defineProperty(this, "_pathTemplateRegExp", void 0);
+    _defineProperty(this, "_performance", void 0);
+    _defineProperty(this, "_queryParams", void 0);
+    _defineProperty(this, "_rateLimit", void 0);
+    _defineProperty(this, "_rateLimitCount", 0);
+    _defineProperty(this, "_rateLimitedRequestQueue", []);
+    _defineProperty(this, "_rateLimitPerSecond", void 0);
+    _defineProperty(this, "_rateLimitTimer", undefined);
+    _defineProperty(this, "_requestRetryWait", void 0);
+    _defineProperty(this, "_requestTracker", {
+      active: [],
+      pending: new Map()
+    });
+    _defineProperty(this, "_streamReader", void 0);
+    const {
+      basePath,
+      bodyParser = DEFAULT_BODY_PARSER,
+      cache,
+      enableConditionalRequests = true,
+      fetchTimeout = DEFAULT_FETCH_TIMEOUT,
+      headers,
+      log,
+      maxRedirects = DEFAULT_MAX_REDIRECTS,
+      maxRetries = DEFAULT_MAX_RETRIES,
+      optionalPathTemplateRegExp = OPTIONAL_PATH_TEMPLATE_REGEX,
+      pathTemplateCallback = defaultPathTemplateCallback,
+      pathTemplateRegExp = DEFAULT_PATH_TEMPLATE_REGEX,
+      performance,
+      queryParams = {},
+      rateLimit = false,
+      rateLimitPerSecond = DEFAULT_RATE_LIMIT,
+      requestRetryWait = DEFAULT_REQUEST_RETRY_WAIT,
+      streamReader = JSON_FORMAT
+    } = options;
+    if (!basePath) {
+      throw new Error(MISSING_BASE_PATH_ERROR);
+    }
+    this._basePath = basePath;
+    this._bodyParser = bodyParser;
+    this._cache = cache;
+    this._conditionalRequestsEnabled = enableConditionalRequests;
+    this._fetchTimeout = fetchTimeout;
+    this._headers = {
+      ...DEFAULT_HEADERS,
+      ...headers
+    };
+    this._log = log;
+    this._maxRedirects = maxRedirects;
+    this._maxRetries = maxRetries;
+    this._optionalPathTemplateRegExp = optionalPathTemplateRegExp;
+    this._pathTemplateCallback = pathTemplateCallback;
+    this._pathTemplateRegExp = pathTemplateRegExp;
+    this._performance = performance;
+    this._queryParams = queryParams;
+    this._rateLimit = rateLimit;
+    this._rateLimitPerSecond = rateLimitPerSecond;
+    this._requestRetryWait = requestRetryWait;
+    this._streamReader = streamReader;
+  }
+  get cache() {
+    return this._cache;
+  }
+  createShortcut(name, path, {
+    method,
+    ...otherOptions
+  }) {
+    if (!FETCH_METHODS.includes(method)) {
+      throw new Error(`${INVALID_FETCH_METHOD_ERROR} ${method}`);
+    }
+    this[name] = async ({
+      method: requestMethod,
+      ...otherOptionOverrides
+    } = {}, context) => this[requestMethod ?? method](path, merge({}, otherOptions, otherOptionOverrides), context);
+  }
+  async delete(path, options = {}, context) {
+    return this._delete(path, options, context);
+  }
+  async get(path, options = {}, context) {
+    return this._get(path, options, context);
+  }
+  async post(path, options, context) {
+    return this._request(path, {
+      ...options,
+      method: POST_METHOD
+    }, context);
+  }
+  async put(path, options, context) {
+    return this._request(path, {
+      ...options,
+      method: PUT_METHOD
+    }, context);
+  }
+  _addRequestToRateLimitedQueue(endpoint, options, context) {
+    return new Promise(resolve => {
+      this._rateLimitedRequestQueue.push([resolve, endpoint, options, context]);
+    });
+  }
+  async _cacheEntryDelete(requestHash) {
+    if (!this._cache) {
+      return false;
+    }
+    return this._cache.delete(requestHash);
+  }
+  async _cacheEntryGet(requestHash) {
+    if (!this._cache) {
+      return undefined;
+    }
+    return this._cache.get(requestHash);
+  }
+  async _cacheEntryHas(requestHash) {
+    if (!this._cache) {
+      return false;
+    }
+    try {
+      return await this._cache.has(requestHash);
+    } catch {
+      return false;
+    }
+  }
+  async _cacheEntrySet(requestHash, data, cacheHeaders) {
+    if (!this._cache) {
+      return undefined;
+    }
+    return this._cache.set(requestHash, data, {
+      cacheHeaders
+    });
+  }
+  async _delete(path, {
+    headers = {},
+    pathTemplateData,
+    queryParams = {},
+    ...rest
+  }, context) {
+    const endpoint = buildEndpoint(this._basePath, path, {
+      optionalPathTemplateRegExp: this._optionalPathTemplateRegExp,
+      pathTemplateCallback: this._pathTemplateCallback,
+      pathTemplateData,
+      pathTemplateRegExp: this._pathTemplateRegExp,
+      queryParams: {
+        ...this._queryParams,
+        ...queryParams
+      }
+    });
+    const requestHash = Md5.hashStr(endpoint);
+    const cacheability = await this._cacheEntryHas(requestHash);
+    if (cacheability) {
+      void this._cacheEntryDelete(requestHash);
+    }
+    return this._fetch(endpoint, {
+      headers: {
+        ...this._headers,
+        ...headers
+      },
+      method: DELETE_METHOD,
+      ...rest
+    }, context);
+  }
+  async _fetch(endpoint, options, context = {}) {
+    context.startTime = this._performance.now();
+    try {
+      const {
+        redirects,
+        retries,
+        ...rest
+      } = options;
+      return await new Promise((resolve, reject) => {
+        void (async () => {
+          const fetchTimer = setTimeout(() => {
+            reject(new Error(`${FETCH_TIMEOUT_ERROR} ${this._fetchTimeout}ms.`));
+          }, this._fetchTimeout);
+          if (this._rateLimit) {
+            this._startRateLimit();
+            if (!(this._rateLimitCount < this._rateLimitPerSecond)) {
+              clearTimeout(fetchTimer);
+              resolve(await this._addRequestToRateLimitedQueue(endpoint, options, context));
+              return;
+            }
+          }
+          if (!redirects && !retries) {
+            this._log?.(REQUEST_SENT, {
+              context: {
+                redirects,
+                retries,
+                url: endpoint,
+                ...rest,
+                ...context
+              },
+              stats: {
+                startTime: context.startTime
+              }
+            });
+          }
+          const res = await fetch(endpoint, rest);
+          clearTimeout(fetchTimer);
+          const {
+            body,
+            headers,
+            status
+          } = res;
+          const responseGroup = getResponseGroup(status);
+          if (responseGroup === REDIRECTION_REPSONSE && headers.has(LOCATION_HEADER)) {
+            resolve(await this._fetchRedirectHandler(res, headers.get(LOCATION_HEADER), {
+              redirects,
+              status,
+              ...rest
+            }, context));
+            return;
+          }
+          if (responseGroup === SERVER_ERROR_REPSONSE) {
+            resolve(await this._fetchRetryHandler(res, endpoint, {
+              retries,
+              ...rest
+            }, context));
+            return;
+          }
+          const fetchRes = res;
+          try {
+            Object.defineProperty(fetchRes, 'data', {
+              enumerable: true,
+              value: body ? this._bodyParser(await res[this._streamReader]()) : undefined,
+              writable: true
+            });
+            this._logResponse(fetchRes, endpoint, options, context);
+            resolve(fetchRes);
+          } catch (error) {
+            reject([error, new Error(`Unable to ${rest.method} ${endpoint} due to previous error`)]);
+          }
+        })();
+      });
+    } catch (error) {
+      const fetchRes = {
+        errors: castArray(error)
+      };
+      this._logResponse(fetchRes, endpoint, options, context);
+      return fetchRes;
+    }
+  }
+  async _fetchRedirectHandler(res, endpoint, options, context) {
+    const {
+      method,
+      redirects = 1,
+      status,
+      ...rest
+    } = options;
+    if (redirects === this._maxRedirects) {
+      const fetchRes = res;
+      fetchRes.errors = [new Error(`${MAX_REDIRECTS_EXCEEDED_ERROR} ${this._maxRedirects}.`)];
+      this._logResponse(fetchRes, endpoint, options, context);
+      return fetchRes;
+    }
+    const redirectMethod = status === 303 ? GET_METHOD : method;
+    return this._fetch(endpoint, {
+      method: redirectMethod,
+      redirects: redirects + 1,
+      ...rest
+    });
+  }
+  async _fetchRetryHandler(res, endpoint, options, context) {
+    const {
+      retries = 1,
+      ...rest
+    } = options;
+    if (retries === this._maxRetries) {
+      const fetchRes = res;
+      fetchRes.errors = [new Error(`${MAX_RETRIES_EXCEEDED_ERROR} ${this._maxRetries}.`)];
+      this._logResponse(fetchRes, endpoint, options, context);
+      return fetchRes;
+    }
+    await delay(this._requestRetryWait);
+    return this._fetch(endpoint, {
+      retries: retries + 1,
+      ...rest
+    });
+  }
+  async _get(path, {
+    headers = {},
+    pathTemplateData,
+    queryParams = {}
+  }, context) {
+    const endpoint = buildEndpoint(this._basePath, path, {
+      optionalPathTemplateRegExp: this._optionalPathTemplateRegExp,
+      pathTemplateCallback: this._pathTemplateCallback,
+      pathTemplateData,
+      pathTemplateRegExp: this._pathTemplateRegExp,
+      queryParams: {
+        ...this._queryParams,
+        ...queryParams
+      }
+    });
+    const requestHash = Md5.hashStr(endpoint);
+    const cacheability = await this._cacheEntryHas(requestHash);
+    if (cacheability) {
+      if (isCacheabilityValid(cacheability)) {
+        return {
+          data: await this._cacheEntryGet(requestHash),
+          headers: new Headers({
+            'cache-control': cacheability.printCacheControl()
+          })
+        };
+      }
+      if (this._conditionalRequestsEnabled && cacheability.metadata.etag) {
+        headers[IF_NONE_MATCH_HEADER] = cacheability.metadata.etag;
+      }
+    }
+    const pendingRequest = this._trackRequest(requestHash);
+    if (pendingRequest) {
+      return pendingRequest;
+    }
+    return this._getResolve(requestHash, await this._fetch(endpoint, {
+      headers: {
+        ...this._headers,
+        ...headers
+      },
+      method: GET_METHOD
+    }, context));
+  }
+  async _getResolve(requestHash, res) {
+    const {
+      data,
+      headers,
+      status
+    } = res;
+    if (status === NOT_FOUND_STATUS_CODE) {
+      void this._cacheEntryDelete(requestHash);
+      let {
+        errors
+      } = res;
+      if (!errors) {
+        errors = [];
+      }
+      errors.push(new Error(RESOURCE_NOT_FOUND_ERROR));
+      res.errors = errors;
+    } else if (status === NOT_MODIFIED_STATUS_CODE) {
+      const cachedData = await this._cacheEntryGet(requestHash);
+      if (cachedData) {
+        void this._cacheEntrySet(requestHash, cachedData, {
+          cacheControl: headers.get(CACHE_CONTROL_HEADER) ?? undefined,
+          etag: headers.get(ETAG_HEADER) ?? undefined
+        });
+        res.data = cachedData;
+      }
+    } else if (data) {
+      void this._cacheEntrySet(requestHash, data, {
+        cacheControl: headers.get(CACHE_CONTROL_HEADER) ?? undefined,
+        etag: headers.get(ETAG_HEADER) ?? undefined
+      });
+    }
+    this._resolvePendingRequests(requestHash, res);
+    this._requestTracker.active = this._requestTracker.active.filter(value => value !== requestHash);
+    return res;
+  }
+  _logResponse(res, endpoint, options, context) {
+    const {
+      data,
+      errors,
+      headers,
+      status
+    } = res;
+    const {
+      method,
+      redirects,
+      retries
+    } = options;
+    const {
+      startTime,
+      ...otherContext
+    } = context;
+    const endTime = this._performance.now();
+    const duration = startTime ? endTime - startTime : 0;
+    this._log?.(RESPONSE_RECEIVED, {
+      context: {
+        body: data ? {
+          data
+        } : {
+          errors: errors ?? []
+        },
+        headers,
+        method,
+        redirects,
+        retries,
+        status,
+        url: endpoint,
+        ...otherContext
+      },
+      stats: {
+        duration,
+        endTime,
+        startTime
+      }
+    });
+  }
+  async _releaseRateLimitedRequestQueue() {
+    for (const [resolve, endpoint, options, context] of this._rateLimitedRequestQueue) {
+      resolve(await this._fetch(endpoint, options, context));
+    }
+    this._rateLimitedRequestQueue = [];
+  }
+  async _request(path, {
+    body,
+    headers,
+    method,
+    pathTemplateData,
+    queryParams,
+    ...rest
+  }, context) {
+    const endpoint = buildEndpoint(this._basePath, path, {
+      optionalPathTemplateRegExp: this._optionalPathTemplateRegExp,
+      pathTemplateCallback: this._pathTemplateCallback,
+      pathTemplateData,
+      pathTemplateRegExp: this._pathTemplateRegExp,
+      queryParams: {
+        ...this._queryParams,
+        ...queryParams
+      }
+    });
+    return this._fetch(endpoint, {
+      body,
+      headers: {
+        ...this._headers,
+        ...headers
+      },
+      method,
+      ...rest
+    }, context);
+  }
+  _resolvePendingRequests(requestHash, responseData) {
+    const pendingRequests = this._requestTracker.pending.get(requestHash);
+    if (!pendingRequests) {
+      return;
+    }
+    for (const {
+      resolve
+    } of pendingRequests) {
+      resolve(responseData);
+    }
+    this._requestTracker.pending.delete(requestHash);
+  }
+  _setPendingRequest(requestHash, resolver) {
+    let pending = this._requestTracker.pending.get(requestHash);
+    if (!pending) pending = [];
+    pending.push(resolver);
+    this._requestTracker.pending.set(requestHash, pending);
+  }
+  _startRateLimit() {
+    if (!this._rateLimitTimer) {
+      this._rateLimitTimer = setTimeout(() => {
+        this._rateLimitTimer = undefined;
+        this._rateLimitCount = 0;
+        if (this._rateLimitedRequestQueue.length > 0) {
+          void this._releaseRateLimitedRequestQueue();
+        }
+      }, 1000);
+    }
+    this._rateLimitCount += 1;
+  }
+  _trackRequest(requestHash) {
+    if (this._requestTracker.active.includes(requestHash)) {
+      return new Promise(resolve => {
+        this._setPendingRequest(requestHash, {
+          resolve
+        });
+      });
+    }
+    this._requestTracker.active.push(requestHash);
+    return;
+  }
+}
+const createRestClient = (options, shortcuts) => {
+  const getta = new Getta(options);
+  if (!shortcuts) {
+    return getta;
+  }
+  for (const key of Object.keys(shortcuts)) {
+    const shortcut = shortcuts[key];
+    if (shortcut) {
+      getta.createShortcut(key, ...shortcut);
+    }
+  }
+  return getta;
+};
+
+export { ARRAY_BUFFER_FORMAT, BLOB_FORMAT, CACHE_CONTROL_HEADER, CLIENT_ERROR_REPSONSE, COOKIE_HEADER, DEFAULT_BODY_PARSER, DEFAULT_FETCH_TIMEOUT, DEFAULT_HEADERS, DEFAULT_MAX_REDIRECTS, DEFAULT_MAX_RETRIES, DEFAULT_PATH_TEMPLATE_REGEX, DEFAULT_RATE_LIMIT, DEFAULT_REQUEST_RETRY_WAIT, DELETE_METHOD, ETAG_HEADER, FETCH_METHODS, FETCH_TIMEOUT_ERROR, FORM_DATA_FORMAT, GET_METHOD, Getta, IF_NONE_MATCH_HEADER, INFORMATION_REPSONSE, INVALID_FETCH_METHOD_ERROR, JSON_FORMAT, LOCATION_HEADER, MAX_REDIRECTS_EXCEEDED_ERROR, MAX_RETRIES_EXCEEDED_ERROR, MISSING_BASE_PATH_ERROR, NOT_FOUND_STATUS_CODE, NOT_MODIFIED_STATUS_CODE, OPTIONAL_PATH_TEMPLATE_REGEX, POST_METHOD, PUT_METHOD, REDIRECTION_REPSONSE, REQUEST_SENT, RESOURCE_NOT_FOUND_ERROR, RESPONSE_RECEIVED, SERVER_ERROR_REPSONSE, STREAM_READERS, SUCCESSFUL_REPSONSE, TEXT_FORMAT, createRestClient, defaultPathTemplateCallback };
+//# sourceMappingURL=index.mjs.map