@commercetools/sdk-client-v2 0.1.2 → 1.0.2

package/dist/commercetools-sdk-client-v2.browser.cjs.js

@@ -25,206 +25,24 @@ function _defineProperty(obj, key, value) {
   return obj;
 }
 
-function ownKeys(object, enumerableOnly) {
-  var keys = Object.keys(object);
-
-  if (Object.getOwnPropertySymbols) {
-    var symbols = Object.getOwnPropertySymbols(object);
-
-    if (enumerableOnly) {
-      symbols = symbols.filter(function (sym) {
-        return Object.getOwnPropertyDescriptor(object, sym).enumerable;
-      });
-    }
-
-    keys.push.apply(keys, symbols);
-  }
-
-  return keys;
-}
-
-function _objectSpread2(target) {
-  for (var i = 1; i < arguments.length; i++) {
-    var source = arguments[i] != null ? arguments[i] : {};
-
-    if (i % 2) {
-      ownKeys(Object(source), true).forEach(function (key) {
-        _defineProperty(target, key, source[key]);
-      });
-    } else if (Object.getOwnPropertyDescriptors) {
-      Object.defineProperties(target, Object.getOwnPropertyDescriptors(source));
-    } else {
-      ownKeys(Object(source)).forEach(function (key) {
-        Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key));
-      });
-    }
-  }
-
-  return target;
-}
-
-function _classCallCheck(instance, Constructor) {
-  if (!(instance instanceof Constructor)) {
-    throw new TypeError("Cannot call a class as a function");
-  }
-}
-
-function _defineProperties(target, props) {
-  for (var i = 0; i < props.length; i++) {
-    var descriptor = props[i];
-    descriptor.enumerable = descriptor.enumerable || false;
-    descriptor.configurable = true;
-    if ("value" in descriptor) descriptor.writable = true;
-    Object.defineProperty(target, descriptor.key, descriptor);
-  }
-}
-
-function _createClass(Constructor, protoProps, staticProps) {
-  if (protoProps) _defineProperties(Constructor.prototype, protoProps);
-  if (staticProps) _defineProperties(Constructor, staticProps);
-  return Constructor;
-}
-
-function asyncGeneratorStep(gen, resolve, reject, _next, _throw, key, arg) {
-  try {
-    var info = gen[key](arg);
-    var value = info.value;
-  } catch (error) {
-    reject(error);
-    return;
-  }
-
-  if (info.done) {
-    resolve(value);
-  } else {
-    Promise.resolve(value).then(_next, _throw);
-  }
-}
-
-function _asyncToGenerator(fn) {
-  return function () {
-    var self = this,
-        args = arguments;
-    return new Promise(function (resolve, reject) {
-      var gen = fn.apply(self, args);
-
-      function _next(value) {
-        asyncGeneratorStep(gen, resolve, reject, _next, _throw, "next", value);
-      }
-
-      function _throw(err) {
-        asyncGeneratorStep(gen, resolve, reject, _next, _throw, "throw", err);
-      }
-
-      _next(undefined);
-    });
-  };
-}
-
-function _arrayWithHoles(arr) {
-  if (Array.isArray(arr)) return arr;
-}
-
-function _iterableToArrayLimit(arr, i) {
-  var _i = arr == null ? null : typeof Symbol !== "undefined" && arr[Symbol.iterator] || arr["@@iterator"];
-
-  if (_i == null) return;
-  var _arr = [];
-  var _n = true;
-  var _d = false;
-
-  var _s, _e;
-
-  try {
-    for (_i = _i.call(arr); !(_n = (_s = _i.next()).done); _n = true) {
-      _arr.push(_s.value);
-
-      if (i && _arr.length === i) break;
-    }
-  } catch (err) {
-    _d = true;
-    _e = err;
-  } finally {
-    try {
-      if (!_n && _i["return"] != null) _i["return"]();
-    } finally {
-      if (_d) throw _e;
-    }
-  }
-
-  return _arr;
-}
-
-function _arrayLikeToArray(arr, len) {
-  if (len == null || len > arr.length) len = arr.length;
-
-  for (var i = 0, arr2 = new Array(len); i < len; i++) arr2[i] = arr[i];
-
-  return arr2;
-}
-
-function _unsupportedIterableToArray(o, minLen) {
-  if (!o) return;
-  if (typeof o === "string") return _arrayLikeToArray(o, minLen);
-  var n = Object.prototype.toString.call(o).slice(8, -1);
-  if (n === "Object" && o.constructor) n = o.constructor.name;
-  if (n === "Map" || n === "Set") return Array.from(o);
-  if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen);
-}
-
-function _nonIterableRest() {
-  throw new TypeError("Invalid attempt to destructure non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
-}
-
-function _slicedToArray(arr, i) {
-  return _arrayWithHoles(arr) || _iterableToArrayLimit(arr, i) || _unsupportedIterableToArray(arr, i) || _nonIterableRest();
-}
-
-function _arrayWithoutHoles(arr) {
-  if (Array.isArray(arr)) return _arrayLikeToArray(arr);
-}
-
-function _iterableToArray(iter) {
-  if (typeof Symbol !== "undefined" && iter[Symbol.iterator] != null || iter["@@iterator"] != null) return Array.from(iter);
-}
-
-function _nonIterableSpread() {
-  throw new TypeError("Invalid attempt to spread non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
-}
-
-function _toConsumableArray(arr) {
-  return _arrayWithoutHoles(arr) || _iterableToArray(arr) || _unsupportedIterableToArray(arr) || _nonIterableSpread();
-}
-
 var METHODS = ['ACL', 'BIND', 'CHECKOUT', 'CONNECT', 'COPY', 'DELETE', 'GET', 'HEAD', 'LINK', 'LOCK', 'M-SEARCH', 'MERGE', 'MKACTIVITY', 'MKCALENDAR', 'MKCOL', 'MOVE', 'NOTIFY', 'OPTIONS', 'PATCH', 'POST', 'PROPFIND', 'PROPPATCH', 'PURGE', 'PUT', 'REBIND', 'REPORT', 'SEARCH', 'SOURCE', 'SUBSCRIBE', 'TRACE', 'UNBIND', 'UNLINK', 'UNLOCK', 'UNSUBSCRIBE'];
 
 /**
  * @throws {Error}
  */
 
-function validate(funcName, request) {
-  var options = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {
-    allowedMethods: METHODS
-  };
-  if (!request) throw new Error("The \"".concat(funcName, "\" function requires a \"Request\" object as an argument. See https://commercetools.github.io/nodejs/sdk/Glossary.html#clientrequest"));
-  if (typeof request.uri !== 'string') throw new Error("The \"".concat(funcName, "\" Request object requires a valid uri. See https://commercetools.github.io/nodejs/sdk/Glossary.html#clientrequest"));
-  if (!options.allowedMethods.includes(request.method)) throw new Error("The \"".concat(funcName, "\" Request object requires a valid method. See https://commercetools.github.io/nodejs/sdk/Glossary.html#clientrequest"));
+function validate(funcName, request, options = {
+  allowedMethods: METHODS
+}) {
+  if (!request) throw new Error(`The "${funcName}" function requires a "Request" object as an argument. See https://commercetools.github.io/nodejs/sdk/Glossary.html#clientrequest`);
+  if (typeof request.uri !== 'string') throw new Error(`The "${funcName}" Request object requires a valid uri. See https://commercetools.github.io/nodejs/sdk/Glossary.html#clientrequest`);
+  if (!options.allowedMethods.includes(request.method)) throw new Error(`The "${funcName}" Request object requires a valid method. See https://commercetools.github.io/nodejs/sdk/Glossary.html#clientrequest`);
 }
 
-function compose() {
-  for (var _len = arguments.length, funcs = new Array(_len), _key = 0; _key < _len; _key++) {
-    funcs[_key] = arguments[_key];
-  }
-
-  funcs = funcs.filter(function (func) {
-    return typeof func === 'function';
-  });
+function compose(...funcs) {
+  funcs = funcs.filter(func => typeof func === 'function');
   if (funcs.length === 1) return funcs[0];
-  return funcs.reduce(function (a, b) {
-    return function () {
-      return a(b.apply(void 0, arguments));
-    };
-  });
+  return funcs.reduce((a, b) => (...args) => a(b(...args)));
 }
 
 function createClient(options) {
@@ -235,16 +53,16 @@ function createClient(options) {
     /**
      * Given a request object,
      */
-    execute: function execute(request) {
+    execute(request) {
       validate('exec', request);
-      return new Promise(function (resolve, reject) {
-        var resolver = function resolver(rq, rs) {
+      return new Promise((resolve, reject) => {
+        const resolver = (rq, rs) => {
           // Note: pick the promise `resolve` and `reject` function from
           // the response object. This is not necessary the same function
           // given from the `new Promise` constructor, as middlewares could
           // override those functions for custom behaviours.
           if (rs.error) rs.reject(rs.error);else {
-            var resObj = {
+            const resObj = {
               body: rs.body || {},
               statusCode: rs.statusCode
             };
@@ -254,182 +72,134 @@ function createClient(options) {
           }
         };
 
-        var dispatch = compose.apply(void 0, _toConsumableArray(options.middlewares))(resolver);
+        const dispatch = compose(...options.middlewares)(resolver);
         dispatch(request, // Initial response shape
         {
-          resolve: resolve,
-          reject: reject,
+          resolve,
+          reject,
           body: undefined,
           error: undefined
         });
       });
     },
-    process: function process(request, fn, processOpt) {
-      var _this = this;
 
+    process(request, fn, processOpt) {
       validate('process', request, {
         allowedMethods: ['GET']
       });
       if (typeof fn !== 'function') throw new Error('The "process" function accepts a "Function" as a second argument that returns a Promise. See https://commercetools.github.io/nodejs/sdk/api/sdkClient.html#processrequest-processfn-options'); // Set default process options
 
-      var opt = _objectSpread2({
+      const opt = {
         total: Number.POSITIVE_INFINITY,
-        accumulate: true
-      }, processOpt);
-
-      return new Promise(function (resolve, reject) {
-        var _path,
+        accumulate: true,
+        ...processOpt
+      };
+      return new Promise((resolve, reject) => {
+        let _path,
             _queryString = '';
 
         if (request && request.uri) {
-          var _request$uri$split = request.uri.split('?'),
-              _request$uri$split2 = _slicedToArray(_request$uri$split, 2),
-              path = _request$uri$split2[0],
-              queryString = _request$uri$split2[1];
-
+          const [path, queryString] = request.uri.split('?');
           _path = path;
           _queryString = queryString;
         }
 
-        var requestQuery = _objectSpread2({}, qs__default["default"].parse(_queryString));
-
-        var query = _objectSpread2({
+        const requestQuery = { ...qs__default["default"].parse(_queryString)
+        };
+        const query = {
           // defaults
-          limit: 20
-        }, requestQuery);
-
-        var hasFirstPageBeenProcessed = false;
-        var itemsToGet = opt.total;
-
-        var processPage = /*#__PURE__*/function () {
-          var _ref = _asyncToGenerator( /*#__PURE__*/regeneratorRuntime.mark(function _callee(lastId) {
-            var acc,
-                limit,
-                originalQueryString,
-                enhancedQuery,
-                enhancedQueryString,
-                enhancedRequest,
-                payload,
-                _payload$body,
-                results,
-                resultsLength,
-                result,
-                accumulated,
-                last,
-                newLastId,
-                _args = arguments;
-
-            return regeneratorRuntime.wrap(function _callee$(_context) {
-              while (1) {
-                switch (_context.prev = _context.next) {
-                  case 0:
-                    acc = _args.length > 1 && _args[1] !== undefined ? _args[1] : [];
-                    // Use the lesser value between limit and itemsToGet in query
-                    limit = query.limit < itemsToGet ? query.limit : itemsToGet;
-                    originalQueryString = qs__default["default"].stringify(_objectSpread2(_objectSpread2({}, query), {}, {
-                      limit: limit
-                    }));
-                    enhancedQuery = _objectSpread2({
-                      sort: 'id asc',
-                      withTotal: false
-                    }, lastId ? {
-                      where: "id > \"".concat(lastId, "\"")
-                    } : {});
-                    enhancedQueryString = qs__default["default"].stringify(enhancedQuery);
-                    enhancedRequest = _objectSpread2(_objectSpread2({}, request), {}, {
-                      uri: "".concat(_path, "?").concat(enhancedQueryString, "&").concat(originalQueryString)
-                    });
-                    _context.prev = 6;
-                    _context.next = 9;
-                    return _this.execute(enhancedRequest);
-
-                  case 9:
-                    payload = _context.sent;
-                    _payload$body = payload.body, results = _payload$body.results, resultsLength = _payload$body.count;
-
-                    if (!(!resultsLength && hasFirstPageBeenProcessed)) {
-                      _context.next = 13;
-                      break;
-                    }
-
-                    return _context.abrupt("return", resolve(acc || []));
-
-                  case 13:
-                    _context.next = 15;
-                    return Promise.resolve(fn(payload));
-
-                  case 15:
-                    result = _context.sent;
-                    hasFirstPageBeenProcessed = true;
-                    if (opt.accumulate) accumulated = acc.concat(result || []);
-                    itemsToGet -= resultsLength; // If there are no more items to get, it means the total number
-                    // of items in the original request have been fetched so we
-                    // resolve the promise.
-                    // Also, if we get less results in a page then the limit set it
-                    // means that there are no more pages and that we can finally
-                    // resolve the promise.
-
-                    if (!(resultsLength < query.limit || !itemsToGet)) {
-                      _context.next = 21;
-                      break;
-                    }
-
-                    return _context.abrupt("return", resolve(accumulated || []));
-
-                  case 21:
-                    last = results[resultsLength - 1];
-                    newLastId = last && last.id;
-                    processPage(newLastId, accumulated);
-                    _context.next = 29;
-                    break;
-
-                  case 26:
-                    _context.prev = 26;
-                    _context.t0 = _context["catch"](6);
-                    reject(_context.t0);
-
-                  case 29:
-                  case "end":
-                    return _context.stop();
-                }
-              }
-            }, _callee, null, [[6, 26]]);
-          }));
-
-          return function processPage(_x) {
-            return _ref.apply(this, arguments);
+          limit: 20,
+          // merge given query params
+          ...requestQuery
+        };
+        let hasFirstPageBeenProcessed = false;
+        let itemsToGet = opt.total;
+
+        const processPage = async (lastId, acc = []) => {
+          // Use the lesser value between limit and itemsToGet in query
+          const limit = query.limit < itemsToGet ? query.limit : itemsToGet;
+          const originalQueryString = qs__default["default"].stringify({ ...query,
+            limit
+          });
+          const enhancedQuery = {
+            sort: 'id asc',
+            withTotal: false,
+            ...(lastId ? {
+              where: `id > "${lastId}"`
+            } : {})
           };
-        }(); // Start iterating through pages
+          const enhancedQueryString = qs__default["default"].stringify(enhancedQuery);
+          const enhancedRequest = { ...request,
+            uri: `${_path}?${enhancedQueryString}&${originalQueryString}`
+          };
+
+          try {
+            const payload = await this.execute(enhancedRequest);
+            const {
+              results,
+              count: resultsLength
+            } = payload.body;
+
+            if (!resultsLength && hasFirstPageBeenProcessed) {
+              return resolve(acc || []);
+            }
+
+            const result = await Promise.resolve(fn(payload));
+            let accumulated;
+            hasFirstPageBeenProcessed = true;
+            if (opt.accumulate) accumulated = acc.concat(result || []);
+            itemsToGet -= resultsLength; // If there are no more items to get, it means the total number
+            // of items in the original request have been fetched so we
+            // resolve the promise.
+            // Also, if we get less results in a page then the limit set it
+            // means that there are no more pages and that we can finally
+            // resolve the promise.
+
+            if (resultsLength < query.limit || !itemsToGet) {
+              return resolve(accumulated || []);
+            }
+
+            const last = results[resultsLength - 1];
+            const newLastId = last && last.id;
+            processPage(newLastId, accumulated);
+          } catch (error) {
+            reject(error);
+          }
+        }; // Start iterating through pages
 
 
         processPage();
       });
     }
+
   };
 }
 
 // POST https://{host}/oauth/token?grant_type=client_credentials&scope={scope}
 // Authorization: Basic QWxhZGRpbjpvcGVuIHNlc2FtZQ==
+const Buffer$2 = require('buffer/').Buffer;
+
 function buildRequestForClientCredentialsFlow(options) {
   if (!options) throw new Error('Missing required options');
   if (!options.host) throw new Error('Missing required option (host)');
   if (!options.projectKey) throw new Error('Missing required option (projectKey)');
   if (!options.credentials) throw new Error('Missing required option (credentials)');
-  var _options$credentials = options.credentials,
-      clientId = _options$credentials.clientId,
-      clientSecret = _options$credentials.clientSecret;
+  const {
+    clientId,
+    clientSecret
+  } = options.credentials;
   if (!(clientId && clientSecret)) throw new Error('Missing required credentials (clientId, clientSecret)');
-  var scope = options.scopes ? options.scopes.join(' ') : undefined;
-  var basicAuth = Buffer.from("".concat(clientId, ":").concat(clientSecret)).toString('base64'); // This is mostly useful for internal testing purposes to be able to check
+  const scope = options.scopes ? options.scopes.join(' ') : undefined;
+  const basicAuth = Buffer$2.from(`${clientId}:${clientSecret}`).toString('base64'); // This is mostly useful for internal testing purposes to be able to check
   // other oauth endpoints.
 
-  var oauthUri = options.oauthUri || '/oauth/token';
-  var url = options.host.replace(/\/$/, '') + oauthUri;
-  var body = "grant_type=client_credentials".concat(scope ? "&scope=".concat(scope) : '');
+  const oauthUri = options.oauthUri || '/oauth/token';
+  const url = options.host.replace(/\/$/, '') + oauthUri;
+  const body = `grant_type=client_credentials${scope ? `&scope=${scope}` : ''}`;
   return {
-    basicAuth: basicAuth,
-    url: url,
-    body: body
+    basicAuth,
+    url,
+    body
   };
 }
 function buildRequestForPasswordFlow(options) {
@@ -437,31 +207,34 @@ function buildRequestForPasswordFlow(options) {
   if (!options.host) throw new Error('Missing required option (host)');
   if (!options.projectKey) throw new Error('Missing required option (projectKey)');
   if (!options.credentials) throw new Error('Missing required option (credentials)');
-  var _options$credentials2 = options.credentials,
-      clientId = _options$credentials2.clientId,
-      clientSecret = _options$credentials2.clientSecret,
-      user = _options$credentials2.user;
-  var pKey = options.projectKey;
+  const {
+    clientId,
+    clientSecret,
+    user
+  } = options.credentials;
+  const pKey = options.projectKey;
   if (!(clientId && clientSecret && user)) throw new Error('Missing required credentials (clientId, clientSecret, user)');
-  var username = user.username,
-      password = user.password;
+  const {
+    username,
+    password
+  } = user;
   if (!(username && password)) throw new Error('Missing required user credentials (username, password)');
-  var scope = (options.scopes || []).join(' ');
-  var scopeStr = scope ? "&scope=".concat(scope) : '';
-  var basicAuth = Buffer.from("".concat(clientId, ":").concat(clientSecret)).toString('base64');
+  const scope = (options.scopes || []).join(' ');
+  const scopeStr = scope ? `&scope=${scope}` : '';
+  const basicAuth = Buffer$2.from(`${clientId}:${clientSecret}`).toString('base64');
   /**
    * This is mostly useful for internal testing purposes to be able to check
    * other oauth endpoints.
    */
 
-  var oauthUri = options.oauthUri || "/oauth/".concat(pKey, "/customers/token");
-  var url = options.host.replace(/\/$/, '') + oauthUri; // encode username and password as requested by platform
+  const oauthUri = options.oauthUri || `/oauth/${pKey}/customers/token`;
+  const url = options.host.replace(/\/$/, '') + oauthUri; // encode username and password as requested by platform
 
-  var body = "grant_type=password&username=".concat(encodeURIComponent(username), "&password=").concat(encodeURIComponent(password)).concat(scopeStr);
+  const body = `grant_type=password&username=${encodeURIComponent(username)}&password=${encodeURIComponent(password)}${scopeStr}`;
   return {
-    basicAuth: basicAuth,
-    url: url,
-    body: body
+    basicAuth,
+    url,
+    body
   };
 }
 function buildRequestForRefreshTokenFlow(options) {
@@ -470,38 +243,42 @@ function buildRequestForRefreshTokenFlow(options) {
   if (!options.projectKey) throw new Error('Missing required option (projectKey)');
   if (!options.credentials) throw new Error('Missing required option (credentials)');
   if (!options.refreshToken) throw new Error('Missing required option (refreshToken)');
-  var _options$credentials3 = options.credentials,
-      clientId = _options$credentials3.clientId,
-      clientSecret = _options$credentials3.clientSecret;
+  const {
+    clientId,
+    clientSecret
+  } = options.credentials;
   if (!(clientId && clientSecret)) throw new Error('Missing required credentials (clientId, clientSecret)');
-  var basicAuth = Buffer.from("".concat(clientId, ":").concat(clientSecret)).toString('base64'); // This is mostly useful for internal testing purposes to be able to check
+  const basicAuth = Buffer$2.from(`${clientId}:${clientSecret}`).toString('base64'); // This is mostly useful for internal testing purposes to be able to check
   // other oauth endpoints.
 
-  var oauthUri = options.oauthUri || '/oauth/token';
-  var url = options.host.replace(/\/$/, '') + oauthUri;
-  var body = "grant_type=refresh_token&refresh_token=".concat(encodeURIComponent(options.refreshToken));
+  const oauthUri = options.oauthUri || '/oauth/token';
+  const url = options.host.replace(/\/$/, '') + oauthUri;
+  const body = `grant_type=refresh_token&refresh_token=${encodeURIComponent(options.refreshToken)}`;
   return {
-    basicAuth: basicAuth,
-    url: url,
-    body: body
+    basicAuth,
+    url,
+    body
   };
 }
 function buildRequestForAnonymousSessionFlow(options) {
   if (!options) throw new Error('Missing required options');
   if (!options.projectKey) throw new Error('Missing required option (projectKey)');
-  var pKey = options.projectKey;
-  options.oauthUri = options.oauthUri || "/oauth/".concat(pKey, "/anonymous/token");
-  var result = buildRequestForClientCredentialsFlow(options);
-  if (options.credentials.anonymousId) result.body += "&anonymous_id=".concat(options.credentials.anonymousId);
-  return _objectSpread2({}, result);
+  const pKey = options.projectKey;
+  options.oauthUri = options.oauthUri || `/oauth/${pKey}/anonymous/token`;
+  const result = buildRequestForClientCredentialsFlow(options);
+  if (options.credentials.anonymousId) result.body += `&anonymous_id=${options.credentials.anonymousId}`;
+  return { ...result
+  };
 }
 
+const Buffer$1 = require('buffer/').Buffer;
+
 function mergeAuthHeader(token, req) {
-  return _objectSpread2(_objectSpread2({}, req), {}, {
-    headers: _objectSpread2(_objectSpread2({}, req.headers), {}, {
-      Authorization: "Bearer ".concat(token)
-    })
-  });
+  return { ...req,
+    headers: { ...req.headers,
+      Authorization: `Bearer ${token}`
+    }
+  };
 }
 
 function calculateExpirationTime(expiresIn) {
@@ -509,136 +286,108 @@ function calculateExpirationTime(expiresIn) {
   expiresIn * 1000 - 2 * 60 * 60 * 1000;
 }
 
-function executeRequest(_x) {
-  return _executeRequest.apply(this, arguments);
-}
-
-function _executeRequest() {
-  _executeRequest = _asyncToGenerator( /*#__PURE__*/regeneratorRuntime.mark(function _callee(_ref) {
-    var fetcher, url, basicAuth, body, tokenCache, requestState, pendingTasks, response, tokenCacheKey, _res, _yield$_res$json, token, expiresIn, refreshToken, expirationTime, executionQueue, parsed, text, error;
-
-    return regeneratorRuntime.wrap(function _callee$(_context) {
-      while (1) {
-        switch (_context.prev = _context.next) {
-          case 0:
-            fetcher = _ref.fetcher, url = _ref.url, basicAuth = _ref.basicAuth, body = _ref.body, tokenCache = _ref.tokenCache, requestState = _ref.requestState, pendingTasks = _ref.pendingTasks, response = _ref.response, tokenCacheKey = _ref.tokenCacheKey;
-            _context.prev = 1;
-            _context.next = 4;
-            return fetcher(url, {
-              method: 'POST',
-              headers: {
-                Authorization: "Basic ".concat(basicAuth),
-                'Content-Length': Buffer.byteLength(body).toString(),
-                'Content-Type': 'application/x-www-form-urlencoded'
-              },
-              body: body
-            });
+async function executeRequest({
+  fetcher,
+  url,
+  basicAuth,
+  body,
+  tokenCache,
+  requestState,
+  pendingTasks,
+  response,
+  tokenCacheKey
+}) {
+  try {
+    const _res = await fetcher(url, {
+      method: 'POST',
+      headers: {
+        Authorization: `Basic ${basicAuth}`,
+        'Content-Length': Buffer$1.byteLength(body).toString(),
+        'Content-Type': 'application/x-www-form-urlencoded'
+      },
+      body
+    });
 
-          case 4:
-            _res = _context.sent;
+    if (_res.ok) {
+      const {
+        access_token: token,
+        expires_in: expiresIn,
+        refresh_token: refreshToken
+      } = await _res.json();
+      const expirationTime = calculateExpirationTime(expiresIn); // cache new generated token
+
+      tokenCache.set({
+        token,
+        expirationTime,
+        refreshToken
+      }, tokenCacheKey); // Dispatch all pending requests
+
+      requestState.set(false);
+      /**
+       * Freeze and copy pending queue, reset original one for accepting
+       * new pending tasks
+       */
 
-            if (!_res.ok) {
-              _context.next = 19;
-              break;
-            }
+      const executionQueue = pendingTasks.slice();
+      pendingTasks = [];
+      executionQueue.forEach(task => {
+        // Assign the new token in the request header
+        const requestWithAuth = mergeAuthHeader(token, task.request);
+        /**
+         * console.log('test', cache, pendingTasks)
+         * Continue by calling the task's own next function
+         */
+
+        task.next(requestWithAuth, task.response);
+      });
+      return;
+    } // Handle error response
 
-            _context.next = 8;
-            return _res.json();
-
-          case 8:
-            _yield$_res$json = _context.sent;
-            token = _yield$_res$json.access_token;
-            expiresIn = _yield$_res$json.expires_in;
-            refreshToken = _yield$_res$json.refresh_token;
-            expirationTime = calculateExpirationTime(expiresIn); // cache new generated token
-
-            tokenCache.set({
-              token: token,
-              expirationTime: expirationTime,
-              refreshToken: refreshToken
-            }, tokenCacheKey); // Dispatch all pending requests
-
-            requestState.set(false);
-            /**
-             * Freeze and copy pending queue, reset original one for accepting
-             * new pending tasks
-             */
-
-            executionQueue = pendingTasks.slice();
-            pendingTasks = [];
-            executionQueue.forEach(function (task) {
-              // Assign the new token in the request header
-              var requestWithAuth = mergeAuthHeader(token, task.request);
-              /**
-               * console.log('test', cache, pendingTasks)
-               * Continue by calling the task's own next function
-               */
-
-              task.next(requestWithAuth, task.response);
-            });
-            return _context.abrupt("return");
 
-          case 19:
-            _context.next = 21;
-            return _res.text();
+    let parsed;
+    const text = await _res.text();
 
-          case 21:
-            text = _context.sent;
+    try {
+      parsed = JSON.parse(text);
+    } catch (error) {
+      /* noop */
+    }
 
-            try {
-              parsed = JSON.parse(text);
-            } catch (error) {
-              /* noop */
-            }
+    const error = new Error(parsed ? parsed.message : text);
+    if (parsed) error.body = parsed;
+    /**
+     * to notify that token is either fetched or failed
+     * in the below case token failed to be fetched
+     * and reset requestState to false
+     * so requestState could be shared between multi authMiddlewareBase functions
+     */
 
-            error = new Error(parsed ? parsed.message : text);
-            if (parsed) error.body = parsed;
-            /**
-             * to notify that token is either fetched or failed
-             * in the below case token failed to be fetched
-             * and reset requestState to false
-             * so requestState could be shared between multi authMiddlewareBase functions
-             */
-
-            requestState.set(false);
-            response.reject(error);
-            _context.next = 33;
-            break;
-
-          case 29:
-            _context.prev = 29;
-            _context.t0 = _context["catch"](1);
-
-            /**
-             * to notify that token is either fetched or failed
-             * in the below case token failed to be fetched
-             * and reset requestState to false
-             * so requestState could be shared between multi authMiddlewareBase functions
-             */
-            requestState.set(false);
-            if (response && typeof response.reject === 'function') response.reject(_context.t0);
-
-          case 33:
-          case "end":
-            return _context.stop();
-        }
-      }
-    }, _callee, null, [[1, 29]]);
-  }));
-  return _executeRequest.apply(this, arguments);
+    requestState.set(false);
+    response.reject(error);
+  } catch (error) {
+    /**
+     * to notify that token is either fetched or failed
+     * in the below case token failed to be fetched
+     * and reset requestState to false
+     * so requestState could be shared between multi authMiddlewareBase functions
+     */
+    requestState.set(false);
+    if (response && typeof response.reject === 'function') response.reject(error);
+  }
 }
 
-function authMiddlewareBase(_ref2, next, userOptions) {
-  var request = _ref2.request,
-      response = _ref2.response,
-      url = _ref2.url,
-      basicAuth = _ref2.basicAuth,
-      body = _ref2.body,
-      pendingTasks = _ref2.pendingTasks,
-      requestState = _ref2.requestState,
-      tokenCache = _ref2.tokenCache,
-      tokenCacheKey = _ref2.tokenCacheKey,
-      fetcher = _ref2.fetch;
+function authMiddlewareBase({
+  request,
+  response,
+  url,
+  basicAuth,
+  body,
+  pendingTasks,
+  requestState,
+  tokenCache,
+  tokenCacheKey,
+  fetch: fetcher
+}, next, userOptions) {
   if (!fetcher && typeof fetch === 'undefined') throw new Error('`fetch` is not available. Please pass in `fetch` as an option or have it globally available.');
   if (!fetcher) fetcher = fetch; // Check if there is already a `Authorization` header in the request.
   // If so, then go directly to the next middleware.
@@ -650,10 +399,10 @@ function authMiddlewareBase(_ref2, next, userOptions) {
   // the token in the `Authorization` header.
 
 
-  var tokenObj = tokenCache.get(tokenCacheKey);
+  const tokenObj = tokenCache.get(tokenCacheKey);
 
   if (tokenObj && tokenObj.token && Date.now() < tokenObj.expirationTime) {
-    var requestWithAuth = mergeAuthHeader(tokenObj.token, request);
+    const requestWithAuth = mergeAuthHeader(tokenObj.token, request);
     next(requestWithAuth, response);
     return;
   }
@@ -666,9 +415,9 @@ function authMiddlewareBase(_ref2, next, userOptions) {
 
 
   pendingTasks.push({
-    request: request,
-    response: response,
-    next: next
+    request,
+    response,
+    next
   }); // If a token is currently being fetched, just wait ;)
 
   if (requestState.get()) return; // Mark that a token is being fetched
@@ -681,41 +430,39 @@ function authMiddlewareBase(_ref2, next, userOptions) {
 
   if (tokenObj && tokenObj.refreshToken && (!tokenObj.token || tokenObj.token && Date.now() > tokenObj.expirationTime)) {
     if (!userOptions) throw new Error('Missing required options');
-    executeRequest(_objectSpread2(_objectSpread2({
-      fetcher: fetcher
-    }, buildRequestForRefreshTokenFlow(_objectSpread2(_objectSpread2({}, userOptions), {}, {
-      refreshToken: tokenObj.refreshToken
-    }))), {}, {
-      tokenCacheKey: tokenCacheKey,
-      tokenCache: tokenCache,
-      requestState: requestState,
-      pendingTasks: pendingTasks,
-      response: response
-    }));
+    executeRequest({
+      fetcher,
+      ...buildRequestForRefreshTokenFlow({ ...userOptions,
+        refreshToken: tokenObj.refreshToken
+      }),
+      tokenCacheKey,
+      tokenCache,
+      requestState,
+      pendingTasks,
+      response
+    });
     return;
   } // Token and refreshToken are not present or invalid. Request a new token...
 
 
   executeRequest({
-    fetcher: fetcher,
-    url: url,
-    basicAuth: basicAuth,
-    body: body,
-    tokenCacheKey: tokenCacheKey,
-    tokenCache: tokenCache,
-    requestState: requestState,
-    pendingTasks: pendingTasks,
-    response: response
+    fetcher,
+    url,
+    basicAuth,
+    body,
+    tokenCacheKey,
+    tokenCache,
+    requestState,
+    pendingTasks,
+    response
   });
 }
 
 function store(initVal) {
-  var value = initVal;
+  let value = initVal;
   return {
-    get: function get() {
-      return value;
-    },
-    set: function set(val) {
+    get: () => value,
+    set: val => {
       value = val;
       return value;
     }
@@ -723,30 +470,27 @@ function store(initVal) {
 }
 
 function createAuthMiddlewareForAnonymousSessionFlow$1(options) {
-  var tokenCache = store({});
-  var pendingTasks = [];
-  var requestState = store(false);
-  return function (next) {
-    return function (request, response) {
-      // Check if there is already a `Authorization` header in the request.
-      // If so, then go directly to the next middleware.
-      if (request.headers && request.headers.authorization || request.headers && request.headers.Authorization) {
-        next(request, response);
-        return;
-      }
-
-      var params = _objectSpread2(_objectSpread2({
-        request: request,
-        response: response
-      }, buildRequestForAnonymousSessionFlow(options)), {}, {
-        pendingTasks: pendingTasks,
-        requestState: requestState,
-        tokenCache: tokenCache,
-        fetch: options.fetch
-      });
+  const tokenCache = store({});
+  const pendingTasks = [];
+  const requestState = store(false);
+  return next => (request, response) => {
+    // Check if there is already a `Authorization` header in the request.
+    // If so, then go directly to the next middleware.
+    if (request.headers && request.headers.authorization || request.headers && request.headers.Authorization) {
+      next(request, response);
+      return;
+    }
 
-      authMiddlewareBase(params, next, options);
+    const params = {
+      request,
+      response,
+      ...buildRequestForAnonymousSessionFlow(options),
+      pendingTasks,
+      requestState,
+      tokenCache,
+      fetch: options.fetch
     };
+    authMiddlewareBase(params, next, options);
   };
 }
 
@@ -759,186 +503,127 @@ function buildTokenCacheKey(options) {
 }
 
 function createAuthMiddlewareForClientCredentialsFlow$1(options) {
-  var tokenCache = options.tokenCache || store({
+  const tokenCache = options.tokenCache || store({
     token: '',
     expirationTime: -1
   });
-  var requestState = store(false);
-  var pendingTasks = [];
-  return function (next) {
-    return function (request, response) {
-      // Check if there is already a `Authorization` header in the request.
-      // If so, then go directly to the next middleware.
-      if (request.headers && request.headers.authorization || request.headers && request.headers.Authorization) {
-        next(request, response);
-        return;
-      }
-
-      var params = _objectSpread2(_objectSpread2({
-        request: request,
-        response: response
-      }, buildRequestForClientCredentialsFlow(options)), {}, {
-        pendingTasks: pendingTasks,
-        requestState: requestState,
-        tokenCache: tokenCache,
-        tokenCacheKey: buildTokenCacheKey(options),
-        fetch: options.fetch
-      });
+  const requestState = store(false);
+  const pendingTasks = [];
+  return next => (request, response) => {
+    // Check if there is already a `Authorization` header in the request.
+    // If so, then go directly to the next middleware.
+    if (request.headers && request.headers.authorization || request.headers && request.headers.Authorization) {
+      next(request, response);
+      return;
+    }
 
-      authMiddlewareBase(params, next);
+    const params = {
+      request,
+      response,
+      ...buildRequestForClientCredentialsFlow(options),
+      pendingTasks,
+      requestState,
+      tokenCache,
+      tokenCacheKey: buildTokenCacheKey(options),
+      fetch: options.fetch
     };
+    authMiddlewareBase(params, next);
   };
 }
 
-function createAuthMiddlewareWithExistingToken$1() {
-  var authorization = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : '';
-  var options = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
-  return function (next) {
-    return function (request, response) {
-      if (typeof authorization !== 'string') throw new Error('authorization must be a string');
-      var force = options.force === undefined ? true : options.force;
-      /** The request will not be modified if:
-       *  1. no argument is passed
-       *  2. force is false and authorization header exists
-       */
-
-      if (!authorization || (request.headers && request.headers.authorization || request.headers && request.headers.Authorization) && force === false) {
-        return next(request, response);
-      }
+function createAuthMiddlewareWithExistingToken$1(authorization = '', options = {}) {
+  return next => (request, response) => {
+    if (typeof authorization !== 'string') throw new Error('authorization must be a string');
+    const force = options.force === undefined ? true : options.force;
+    /** The request will not be modified if:
+     *  1. no argument is passed
+     *  2. force is false and authorization header exists
+     */
 
-      var requestWithAuth = _objectSpread2(_objectSpread2({}, request), {}, {
-        headers: _objectSpread2(_objectSpread2({}, request.headers), {}, {
-          Authorization: authorization
-        })
-      });
+    if (!authorization || (request.headers && request.headers.authorization || request.headers && request.headers.Authorization) && force === false) {
+      return next(request, response);
+    }
 
-      return next(requestWithAuth, response);
+    const requestWithAuth = { ...request,
+      headers: { ...request.headers,
+        Authorization: authorization
+      }
     };
+    return next(requestWithAuth, response);
   };
 }
 
 function createAuthMiddlewareForPasswordFlow$1(options) {
-  var tokenCache = store({});
-  var pendingTasks = [];
-  var requestState = store(false);
-  return function (next) {
-    return function (request, response) {
-      // Check if there is already a `Authorization` header in the request.
-      // If so, then go directly to the next middleware.
-      if (request.headers && request.headers.authorization || request.headers && request.headers.Authorization) {
-        next(request, response);
-        return;
-      }
-
-      var params = _objectSpread2(_objectSpread2({
-        request: request,
-        response: response
-      }, buildRequestForPasswordFlow(options)), {}, {
-        pendingTasks: pendingTasks,
-        requestState: requestState,
-        tokenCache: tokenCache,
-        fetch: options.fetch
-      });
+  const tokenCache = store({});
+  const pendingTasks = [];
+  const requestState = store(false);
+  return next => (request, response) => {
+    // Check if there is already a `Authorization` header in the request.
+    // If so, then go directly to the next middleware.
+    if (request.headers && request.headers.authorization || request.headers && request.headers.Authorization) {
+      next(request, response);
+      return;
+    }
 
-      authMiddlewareBase(params, next, options);
+    const params = {
+      request,
+      response,
+      ...buildRequestForPasswordFlow(options),
+      pendingTasks,
+      requestState,
+      tokenCache,
+      fetch: options.fetch
     };
+    authMiddlewareBase(params, next, options);
   };
 }
 
 function createAuthMiddlewareForRefreshTokenFlow$1(options) {
-  var tokenCache = store({});
-  var pendingTasks = [];
-  var requestState = store(false);
-  return function (next) {
-    return function (request, response) {
-      // Check if there is already a `Authorization` header in the request.
-      // If so, then go directly to the next middleware.
-      if (request.headers && request.headers.authorization || request.headers && request.headers.Authorization) {
-        next(request, response);
-        return;
-      }
-
-      var params = _objectSpread2(_objectSpread2({
-        request: request,
-        response: response
-      }, buildRequestForRefreshTokenFlow(options)), {}, {
-        pendingTasks: pendingTasks,
-        requestState: requestState,
-        tokenCache: tokenCache,
-        fetch: options.fetch
-      });
+  const tokenCache = store({});
+  const pendingTasks = [];
+  const requestState = store(false);
+  return next => (request, response) => {
+    // Check if there is already a `Authorization` header in the request.
+    // If so, then go directly to the next middleware.
+    if (request.headers && request.headers.authorization || request.headers && request.headers.Authorization) {
+      next(request, response);
+      return;
+    }
 
-      authMiddlewareBase(params, next);
+    const params = {
+      request,
+      response,
+      ...buildRequestForRefreshTokenFlow(options),
+      pendingTasks,
+      requestState,
+      tokenCache,
+      fetch: options.fetch
     };
+    authMiddlewareBase(params, next);
   };
 }
 
-function createCorrelationIdMiddleware(options) {
-  return function (next) {
-    return function (request, response) {
-      var nextRequest = _objectSpread2(_objectSpread2({}, request), {}, {
-        headers: _objectSpread2(_objectSpread2({}, request.headers), {}, {
-          'X-Correlation-ID': options.generate()
-        })
-      });
+var authMiddlewares = /*#__PURE__*/Object.freeze({
+  __proto__: null,
+  createAuthMiddlewareForAnonymousSessionFlow: createAuthMiddlewareForAnonymousSessionFlow$1,
+  createAuthMiddlewareForClientCredentialsFlow: createAuthMiddlewareForClientCredentialsFlow$1,
+  createAuthMiddlewareWithExistingToken: createAuthMiddlewareWithExistingToken$1,
+  createAuthMiddlewareForPasswordFlow: createAuthMiddlewareForPasswordFlow$1,
+  createAuthMiddlewareForRefreshTokenFlow: createAuthMiddlewareForRefreshTokenFlow$1
+});
 
-      next(nextRequest, response);
+function createCorrelationIdMiddleware(options) {
+  return next => (request, response) => {
+    const nextRequest = { ...request,
+      headers: { ...request.headers,
+        'X-Correlation-ID': options.generate()
+      }
     };
+    next(nextRequest, response);
   };
 }
 
-function _typeof(obj) {
-  "@babel/helpers - typeof";
-
-  if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") {
-    _typeof = function (obj) {
-      return typeof obj;
-    };
-  } else {
-    _typeof = function (obj) {
-      return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj;
-    };
-  }
-
-  return _typeof(obj);
-}
-
-function _objectWithoutPropertiesLoose(source, excluded) {
-  if (source == null) return {};
-  var target = {};
-  var sourceKeys = Object.keys(source);
-  var key, i;
-
-  for (i = 0; i < sourceKeys.length; i++) {
-    key = sourceKeys[i];
-    if (excluded.indexOf(key) >= 0) continue;
-    target[key] = source[key];
-  }
-
-  return target;
-}
-
-function _objectWithoutProperties(source, excluded) {
-  if (source == null) return {};
-  var target = _objectWithoutPropertiesLoose(source, excluded);
-  var key, i;
-
-  if (Object.getOwnPropertySymbols) {
-    var sourceSymbolKeys = Object.getOwnPropertySymbols(source);
-
-    for (i = 0; i < sourceSymbolKeys.length; i++) {
-      key = sourceSymbolKeys[i];
-      if (excluded.indexOf(key) >= 0) continue;
-      if (!Object.prototype.propertyIsEnumerable.call(source, key)) continue;
-      target[key] = source[key];
-    }
-  }
-
-  return target;
-}
-
-function defineError(statusCode, message) {
-  var meta = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
+function defineError(statusCode, message, meta = {}) {
   this.status = this.statusCode = this.code = statusCode;
   this.message = message;
   Object.assign(this, meta);
@@ -947,70 +632,36 @@ function defineError(statusCode, message) {
   if (Error.captureStackTrace) Error.captureStackTrace(this, this.constructor);
 }
 
-function NetworkError() {
-  for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
-    args[_key] = arguments[_key];
-  }
-
-  defineError.call.apply(defineError, [this, 0
+function NetworkError(...args) {
+  defineError.call(this, 0
   /* special code to indicate network errors */
-  ].concat(args));
+  , ...args);
 }
-function HttpError() {
-  for (var _len2 = arguments.length, args = new Array(_len2), _key2 = 0; _key2 < _len2; _key2++) {
-    args[_key2] = arguments[_key2];
-  }
-
-  defineError.call.apply(defineError, [this].concat(args));
+function HttpError(...args) {
+  defineError.call(this,
+  /* code will be passed as arg */
+  ...args);
 }
-function BadRequest() {
-  for (var _len3 = arguments.length, args = new Array(_len3), _key3 = 0; _key3 < _len3; _key3++) {
-    args[_key3] = arguments[_key3];
-  }
-
-  defineError.call.apply(defineError, [this, 400].concat(args));
+function BadRequest(...args) {
+  defineError.call(this, 400, ...args);
 }
-function Unauthorized() {
-  for (var _len4 = arguments.length, args = new Array(_len4), _key4 = 0; _key4 < _len4; _key4++) {
-    args[_key4] = arguments[_key4];
-  }
-
-  defineError.call.apply(defineError, [this, 401].concat(args));
+function Unauthorized(...args) {
+  defineError.call(this, 401, ...args);
 }
-function Forbidden() {
-  for (var _len5 = arguments.length, args = new Array(_len5), _key5 = 0; _key5 < _len5; _key5++) {
-    args[_key5] = arguments[_key5];
-  }
-
-  defineError.call.apply(defineError, [this, 403].concat(args));
+function Forbidden(...args) {
+  defineError.call(this, 403, ...args);
 }
-function NotFound() {
-  for (var _len6 = arguments.length, args = new Array(_len6), _key6 = 0; _key6 < _len6; _key6++) {
-    args[_key6] = arguments[_key6];
-  }
-
-  defineError.call.apply(defineError, [this, 404].concat(args));
+function NotFound(...args) {
+  defineError.call(this, 404, ...args);
 }
-function ConcurrentModification() {
-  for (var _len7 = arguments.length, args = new Array(_len7), _key7 = 0; _key7 < _len7; _key7++) {
-    args[_key7] = arguments[_key7];
-  }
-
-  defineError.call.apply(defineError, [this, 409].concat(args));
+function ConcurrentModification(...args) {
+  defineError.call(this, 409, ...args);
 }
-function InternalServerError() {
-  for (var _len8 = arguments.length, args = new Array(_len8), _key8 = 0; _key8 < _len8; _key8++) {
-    args[_key8] = arguments[_key8];
-  }
-
-  defineError.call.apply(defineError, [this, 500].concat(args));
+function InternalServerError(...args) {
+  defineError.call(this, 500, ...args);
 }
-function ServiceUnavailable() {
-  for (var _len9 = arguments.length, args = new Array(_len9), _key9 = 0; _key9 < _len9; _key9++) {
-    args[_key9] = arguments[_key9];
-  }
-
-  defineError.call.apply(defineError, [this, 503].concat(args));
+function ServiceUnavailable(...args) {
+  defineError.call(this, 503, ...args);
 }
 function getErrorByCode(code) {
   switch (code) {
@@ -1049,23 +700,23 @@ function parseHeaders(headers) {
 
   if (!headers.forEach) return {}; // whatwg-fetch
 
-  var map = {};
-  headers.forEach(function (value, name) {
+  const map = {};
+  headers.forEach((value, name) => {
     map[name] = value;
   });
   return map;
 }
 
-var _excluded = ["statusCode", "message"];
-
-function createError(_ref) {
-  var statusCode = _ref.statusCode,
-      message = _ref.message,
-      rest = _objectWithoutProperties(_ref, _excluded);
+const Buffer = require('buffer/').Buffer;
 
-  var errorMessage = message || 'Unexpected non-JSON error response';
-  if (statusCode === 404) errorMessage = "URI not found: ".concat(rest.originalRequest.uri);
-  var ResponseError = getErrorByCode(statusCode);
+function createError({
+  statusCode,
+  message,
+  ...rest
+}) {
+  let errorMessage = message || 'Unexpected non-JSON error response';
+  if (statusCode === 404) errorMessage = `URI not found: ${rest.originalRequest.uri}`;
+  const ResponseError = getErrorByCode(statusCode);
   if (ResponseError) return new ResponseError(errorMessage, rest);
   return new HttpError(statusCode, errorMessage, rest);
 } // calculates the delay duration exponentially
@@ -1074,7 +725,7 @@ function createError(_ref) {
 
 function calcDelayDuration(retryCount, retryDelay, maxRetries, backoff, maxDelay) {
   if (backoff) return retryCount !== 0 // do not increase if it's the first retry
-  ? Math.min(Math.round((Math.random() + 1) * retryDelay * Math.pow(2, retryCount)), maxDelay) : retryDelay;
+  ? Math.min(Math.round((Math.random() + 1) * retryDelay * 2 ** retryCount), maxDelay) : retryDelay;
   return retryDelay;
 }
 
@@ -1085,30 +736,27 @@ function maskAuthData(request, maskSensitiveHeaderData) {
   }
 }
 
-function createHttpMiddleware(_ref2) {
-  var host = _ref2.host,
-      credentialsMode = _ref2.credentialsMode,
-      includeResponseHeaders = _ref2.includeResponseHeaders,
-      includeOriginalRequest = _ref2.includeOriginalRequest,
-      _ref2$maskSensitiveHe = _ref2.maskSensitiveHeaderData,
-      maskSensitiveHeaderData = _ref2$maskSensitiveHe === void 0 ? true : _ref2$maskSensitiveHe,
-      enableRetry = _ref2.enableRetry,
-      timeout = _ref2.timeout,
-      _ref2$retryConfig = _ref2.retryConfig;
-  _ref2$retryConfig = _ref2$retryConfig === void 0 ? {} : _ref2$retryConfig;
-  var _ref2$retryConfig$max = _ref2$retryConfig.maxRetries,
-      maxRetries = _ref2$retryConfig$max === void 0 ? 10 : _ref2$retryConfig$max,
-      _ref2$retryConfig$bac = _ref2$retryConfig.backoff,
-      backoff = _ref2$retryConfig$bac === void 0 ? true : _ref2$retryConfig$bac,
-      _ref2$retryConfig$ret = _ref2$retryConfig.retryDelay,
-      retryDelay = _ref2$retryConfig$ret === void 0 ? 200 : _ref2$retryConfig$ret,
-      _ref2$retryConfig$max2 = _ref2$retryConfig.maxDelay,
-      maxDelay = _ref2$retryConfig$max2 === void 0 ? Infinity : _ref2$retryConfig$max2,
-      fetcher = _ref2.fetch,
-      getAbortController = _ref2.getAbortController;
+function createHttpMiddleware({
+  host,
+  credentialsMode,
+  includeResponseHeaders,
+  includeOriginalRequest,
+  maskSensitiveHeaderData = true,
+  enableRetry,
+  timeout,
+  retryConfig: {
+    // encourage exponential backoff to prevent spamming the server if down
+    maxRetries = 10,
+    backoff = true,
+    retryDelay = 200,
+    maxDelay = Infinity
+  } = {},
+  fetch: fetcher,
+  getAbortController
+}) {
   if (!fetcher && typeof fetch === 'undefined') throw new Error('`fetch` is not available. Please pass in `fetch` as an option or have it globally available.');
   if (timeout && !getAbortController && typeof AbortController === 'undefined') throw new Error('`AbortController` is not available. Please pass in `getAbortController` as an option or have AbortController globally available when using timeout.');
-  var fetchFunction;
+  let fetchFunction;
 
   if (fetcher) {
     fetchFunction = fetcher;
@@ -1119,259 +767,222 @@ function createHttpMiddleware(_ref2) {
     fetchFunction = fetch;
   }
 
-  return function (next) {
-    return function (request, response) {
-      var abortController;
-      if (timeout || getAbortController) abortController = (getAbortController ? getAbortController() : null) || new AbortController();
-      var url = host.replace(/\/$/, '') + request.uri;
-      var body = typeof request.body === 'string' || Buffer.isBuffer(request.body) ? request.body : // NOTE: `stringify` of `null` gives the String('null')
-      JSON.stringify(request.body || undefined);
-
-      var requestHeader = _objectSpread2({}, request.headers);
-
-      if (!Object.prototype.hasOwnProperty.call(requestHeader, 'Content-Type')) {
-        requestHeader['Content-Type'] = 'application/json';
-      }
-
-      if (body) {
-        requestHeader['Content-Length'] = Buffer.byteLength(body).toString();
-      }
-
-      var fetchOptions = {
-        method: request.method,
-        headers: requestHeader
-      };
-
-      if (credentialsMode) {
-        fetchOptions.credentialsMode = credentialsMode;
-      }
-
-      if (abortController) {
-        fetchOptions.signal = abortController.signal;
-      }
-
-      if (body) {
-        fetchOptions.body = body;
-      }
-
-      var retryCount = 0; // wrap in a fn so we can retry if error occur
-
-      function executeFetch() {
-        // Kick off timer for abortController directly before fetch.
-        var timer;
-        if (timeout) timer = setTimeout(function () {
-          abortController.abort();
-        }, timeout);
-        fetchFunction(url, fetchOptions).then(function (res) {
-          if (res.ok) {
-            if (fetchOptions.method === 'HEAD') {
-              next(request, _objectSpread2(_objectSpread2({}, response), {}, {
-                statusCode: res.status
-              }));
-              return;
-            }
+  return next => (request, response) => {
+    let abortController;
+    if (timeout || getAbortController) abortController = (getAbortController ? getAbortController() : null) || new AbortController();
+    const url = host.replace(/\/$/, '') + request.uri;
+    const body = typeof request.body === 'string' || Buffer.isBuffer(request.body) ? request.body : // NOTE: `stringify` of `null` gives the String('null')
+    JSON.stringify(request.body || undefined);
+    const requestHeader = { ...request.headers
+    };
 
-            res.text().then(function (result) {
-              // Try to parse the response as JSON
-              var parsed;
+    if (!Object.prototype.hasOwnProperty.call(requestHeader, 'Content-Type')) {
+      requestHeader['Content-Type'] = 'application/json';
+    }
 
-              try {
-                parsed = result.length > 0 ? JSON.parse(result) : {};
-              } catch (err) {
-                if (enableRetry && retryCount < maxRetries) {
-                  setTimeout(executeFetch, calcDelayDuration(retryCount, retryDelay, maxRetries, backoff, maxDelay));
-                  retryCount += 1;
-                  return;
-                }
+    if (body) {
+      requestHeader['Content-Length'] = Buffer.byteLength(body).toString();
+    }
 
-                parsed = result;
-              }
+    const fetchOptions = {
+      method: request.method,
+      headers: requestHeader
+    };
 
-              var parsedResponse = _objectSpread2(_objectSpread2({}, response), {}, {
-                body: parsed,
-                statusCode: res.status
-              });
+    if (credentialsMode) {
+      fetchOptions.credentialsMode = credentialsMode;
+    }
 
-              if (includeResponseHeaders) parsedResponse.headers = parseHeaders(res.headers);
+    if (abortController) {
+      fetchOptions.signal = abortController.signal;
+    }
 
-              if (includeOriginalRequest) {
-                parsedResponse.request = _objectSpread2({}, fetchOptions);
-                maskAuthData(parsedResponse.request, maskSensitiveHeaderData);
-              }
+    if (body) {
+      fetchOptions.body = body;
+    }
 
-              next(request, parsedResponse);
+    let retryCount = 0; // wrap in a fn so we can retry if error occur
+
+    function executeFetch() {
+      // Kick off timer for abortController directly before fetch.
+      let timer;
+      if (timeout) timer = setTimeout(() => {
+        abortController.abort();
+      }, timeout);
+      fetchFunction(url, fetchOptions).then(res => {
+        if (res.ok) {
+          if (fetchOptions.method === 'HEAD') {
+            next(request, { ...response,
+              statusCode: res.status
             });
             return;
           }
 
-          if (res.status === 503 && enableRetry) if (retryCount < maxRetries) {
-            setTimeout(executeFetch, calcDelayDuration(retryCount, retryDelay, maxRetries, backoff, maxDelay));
-            retryCount += 1;
-            return;
-          } // Server responded with an error. Try to parse it as JSON, then
-          // return a proper error type with all necessary meta information.
-
-          res.text().then(function (text) {
-            // Try to parse the error response as JSON
-            var parsed;
+          res.text().then(result => {
+            // Try to parse the response as JSON
+            let parsed;
 
             try {
-              parsed = JSON.parse(text);
-            } catch (error) {
-              parsed = text;
-            }
+              parsed = result.length > 0 ? JSON.parse(result) : {};
+            } catch (err) {
+              if (enableRetry && retryCount < maxRetries) {
+                setTimeout(executeFetch, calcDelayDuration(retryCount, retryDelay, maxRetries, backoff, maxDelay));
+                retryCount += 1;
+                return;
+              }
 
-            var error = createError(_objectSpread2({
-              statusCode: res.status,
-              originalRequest: request,
-              retryCount: retryCount,
-              headers: parseHeaders(res.headers)
-            }, _typeof(parsed) === 'object' ? {
-              message: parsed.message,
-              body: parsed
-            } : {
-              message: parsed,
-              body: parsed
-            }));
-            maskAuthData(error.originalRequest, maskSensitiveHeaderData); // Let the final resolver to reject the promise
+              parsed = result;
+            }
 
-            var parsedResponse = _objectSpread2(_objectSpread2({}, response), {}, {
-              error: error,
+            const parsedResponse = { ...response,
+              body: parsed,
               statusCode: res.status
-            });
+            };
+            if (includeResponseHeaders) parsedResponse.headers = parseHeaders(res.headers);
+
+            if (includeOriginalRequest) {
+              parsedResponse.request = { ...fetchOptions
+              };
+              maskAuthData(parsedResponse.request, maskSensitiveHeaderData);
+            }
 
             next(request, parsedResponse);
           });
-        }, // We know that this is a "network" error thrown by the `fetch` library
-        function (e) {
-          if (enableRetry) if (retryCount < maxRetries) {
-            setTimeout(executeFetch, calcDelayDuration(retryCount, retryDelay, maxRetries, backoff, maxDelay));
-            retryCount += 1;
-            return;
+          return;
+        }
+
+        if (res.status === 503 && enableRetry) if (retryCount < maxRetries) {
+          setTimeout(executeFetch, calcDelayDuration(retryCount, retryDelay, maxRetries, backoff, maxDelay));
+          retryCount += 1;
+          return;
+        } // Server responded with an error. Try to parse it as JSON, then
+        // return a proper error type with all necessary meta information.
+
+        res.text().then(text => {
+          // Try to parse the error response as JSON
+          let parsed;
+
+          try {
+            parsed = JSON.parse(text);
+          } catch (error) {
+            parsed = text;
           }
-          var error = new NetworkError(e.message, {
+
+          const error = createError({
+            statusCode: res.status,
             originalRequest: request,
-            retryCount: retryCount
+            retryCount,
+            headers: parseHeaders(res.headers),
+            ...(typeof parsed === 'object' ? {
+              message: parsed.message,
+              body: parsed
+            } : {
+              message: parsed,
+              body: parsed
+            })
           });
-          maskAuthData(error.originalRequest, maskSensitiveHeaderData);
-          next(request, _objectSpread2(_objectSpread2({}, response), {}, {
-            error: error,
-            statusCode: 0
-          }));
-        })["finally"](function () {
-          clearTimeout(timer);
+          maskAuthData(error.originalRequest, maskSensitiveHeaderData); // Let the final resolver to reject the promise
+
+          const parsedResponse = { ...response,
+            error,
+            statusCode: res.status
+          };
+          next(request, parsedResponse);
         });
-      }
+      }, // We know that this is a "network" error thrown by the `fetch` library
+      e => {
+        if (enableRetry) if (retryCount < maxRetries) {
+          setTimeout(executeFetch, calcDelayDuration(retryCount, retryDelay, maxRetries, backoff, maxDelay));
+          retryCount += 1;
+          return;
+        }
+        const error = new NetworkError(e.message, {
+          originalRequest: request,
+          retryCount
+        });
+        maskAuthData(error.originalRequest, maskSensitiveHeaderData);
+        next(request, { ...response,
+          error,
+          statusCode: 0
+        });
+      }).finally(() => {
+        clearTimeout(timer);
+      });
+    }
 
-      executeFetch();
-    };
+    executeFetch();
   };
 }
 
 function createLoggerMiddleware() {
-  return function (next) {
-    return function (request, response) {
-      var error = response.error,
-          body = response.body,
-          statusCode = response.statusCode;
-      console.log('Request: ', request);
-      console.log('Response: ', {
-        error: error,
-        body: body,
-        statusCode: statusCode
-      });
-      next(request, response);
-    };
+  return next => (request, response) => {
+    const {
+      error,
+      body,
+      statusCode
+    } = response;
+    console.log('Request: ', request);
+    console.log('Response: ', {
+      error,
+      body,
+      statusCode
+    });
+    next(request, response);
   };
 }
 
-function createQueueMiddleware(_ref) {
-  var _ref$concurrency = _ref.concurrency,
-      concurrency = _ref$concurrency === void 0 ? 20 : _ref$concurrency;
-  var queue = [];
-  var runningCount = 0;
+function createQueueMiddleware({
+  concurrency = 20
+}) {
+  const queue = [];
+  let runningCount = 0;
 
-  var dequeue = function dequeue(next) {
+  const dequeue = next => {
     // We assume here that this task has been completed
     runningCount -= 1; // Check if there are any other pending tasks and execute them
 
     if (queue.length && runningCount <= concurrency) {
-      var nextTask = queue.shift();
+      const nextTask = queue.shift();
       runningCount += 1;
       next(nextTask.request, nextTask.response);
     }
   };
 
-  return function (next) {
-    return function (request, response) {
-      // Override response `resolve` and `reject` to know when the request has
-      // been completed and therefore trigger a pending task in the queue.
-      var patchedResponse = _objectSpread2(_objectSpread2({}, response), {}, {
-        resolve: function resolve(data) {
-          // Resolve original promise
-          response.resolve(data);
-          dequeue(next);
-        },
-        reject: function reject(error) {
-          // Reject original promise
-          response.reject(error);
-          dequeue(next);
-        }
-      }); // Add task to the queue
-
-
-      queue.push({
-        request: request,
-        response: patchedResponse
-      }); // If possible, run the task straight away
-
-      if (runningCount < concurrency) {
-        var nextTask = queue.shift();
-        runningCount += 1;
-        next(nextTask.request, nextTask.response);
+  return next => (request, response) => {
+    // Override response `resolve` and `reject` to know when the request has
+    // been completed and therefore trigger a pending task in the queue.
+    const patchedResponse = { ...response,
+
+      resolve(data) {
+        // Resolve original promise
+        response.resolve(data);
+        dequeue(next);
+      },
+
+      reject(error) {
+        // Reject original promise
+        response.reject(error);
+        dequeue(next);
       }
-    };
-  };
-}
-
-/*
-  This is the easiest way, for this use case, to detect if we're running in
-  Node.js or in a browser environment. In other cases, this won't be even a
-  problem as Rollup will provide the correct polyfill in the bundle.
-  The main advantage by doing it this way is that it allows to easily test
-  the code running in both environments, by overriding `global.window` in
-  the specific test.
-*/
-var isBrowser = function isBrowser() {
-  return window.document && window.document.nodeType === 9;
-};
-
-function getSystemInfo() {
-  if (isBrowser()) return window.navigator.userAgent;
-  var nodeVersion = process.version.slice(1); // const platformInfo = `(${process.platform}; ${process.arch})`
-  // return `Node.js/${nodeVersion} ${platformInfo}`
-
-  return "node.js/".concat(nodeVersion);
-}
-
-function createUserAgent(options) {
-  if (!options || Object.keys(options).length === 0 || !{}.hasOwnProperty.call(options, 'name')) throw new Error('Missing required option `name`'); // Main info
-
-  var baseInfo = options.version ? "".concat(options.name, "/").concat(options.version) : options.name; // Library info
 
-  var libraryInfo = null;
-  if (options.libraryName && !options.libraryVersion) libraryInfo = options.libraryName;else if (options.libraryName && options.libraryVersion) libraryInfo = "".concat(options.libraryName, "/").concat(options.libraryVersion); // Contact info
+    }; // Add task to the queue
 
-  var contactInfo = null;
-  if (options.contactUrl && !options.contactEmail) contactInfo = "(+".concat(options.contactUrl, ")");else if (!options.contactUrl && options.contactEmail) contactInfo = "(+".concat(options.contactEmail, ")");else if (options.contactUrl && options.contactEmail) contactInfo = "(+".concat(options.contactUrl, "; +").concat(options.contactEmail, ")"); // System info
+    queue.push({
+      request,
+      response: patchedResponse
+    }); // If possible, run the task straight away
 
-  var systemInfo = getSystemInfo();
-  return [baseInfo, systemInfo, libraryInfo, contactInfo].filter(Boolean).join(' ');
+    if (runningCount < concurrency) {
+      const nextTask = queue.shift();
+      runningCount += 1;
+      next(nextTask.request, nextTask.response);
+    }
+  };
 }
 
 var packageJson = {
 	name: "@commercetools/sdk-client-v2",
-	version: "0.1.2",
+	version: "1.0.2",
 	description: "commercetools TypeScript SDK client.",
 	keywords: [
 		"commercetools",
@@ -1400,6 +1011,7 @@ var packageJson = {
 		url: "https://github.com/commercetools/commercetools-sdk-typescript/issues"
 	},
 	dependencies: {
+		buffer: "^6.0.3",
 		"node-fetch": "^2.6.1",
 		querystring: "^0.2.1"
 	},
@@ -1416,9 +1028,9 @@ var packageJson = {
 	},
 	devDependencies: {
 		"abort-controller": "3.0.0",
-		"common-tags": "^1.8.0",
-		dotenv: "^10.0.0",
-		jest: "27.0.6",
+		"common-tags": "1.8.2",
+		dotenv: "10.0.0",
+		jest: "27.3.1",
 		nock: "12.0.3",
 		"organize-imports-cli": "0.8.0"
 	},
@@ -1429,33 +1041,65 @@ var packageJson = {
 	}
 };
 
+/*
+  This is the easiest way, for this use case, to detect if we're running in
+  Node.js or in a browser environment. In other cases, this won't be even a
+  problem as Rollup will provide the correct polyfill in the bundle.
+  The main advantage by doing it this way is that it allows to easily test
+  the code running in both environments, by overriding `global.window` in
+  the specific test.
+*/
+const isBrowser = () => window.document && window.document.nodeType === 9;
+
+function getSystemInfo() {
+  var _process;
+
+  if (isBrowser()) return window.navigator.userAgent;
+  const nodeVersion = ((_process = process) === null || _process === void 0 ? void 0 : _process.version.slice(1)) || '12'; // temporary fix for rn environment
+  // const platformInfo = `(${process.platform}; ${process.arch})`
+  // return `Node.js/${nodeVersion} ${platformInfo}`
+
+  return `node.js/${nodeVersion}`;
+}
+
+function createUserAgent(options) {
+  if (!options || Object.keys(options).length === 0 || !{}.hasOwnProperty.call(options, 'name')) throw new Error('Missing required option `name`'); // Main info
+
+  const baseInfo = options.version ? `${options.name}/${options.version}` : options.name; // Library info
+
+  let libraryInfo = null;
+  if (options.libraryName && !options.libraryVersion) libraryInfo = options.libraryName;else if (options.libraryName && options.libraryVersion) libraryInfo = `${options.libraryName}/${options.libraryVersion}`; // Contact info
+
+  let contactInfo = null;
+  if (options.contactUrl && !options.contactEmail) contactInfo = `(+${options.contactUrl})`;else if (!options.contactUrl && options.contactEmail) contactInfo = `(+${options.contactEmail})`;else if (options.contactUrl && options.contactEmail) contactInfo = `(+${options.contactUrl}; +${options.contactEmail})`; // System info
+
+  const systemInfo = getSystemInfo();
+  return [baseInfo, systemInfo, libraryInfo, contactInfo].filter(Boolean).join(' ');
+}
+
 function createUserAgentMiddleware() {
-  var userAgent = createUserAgent({
-    name: "commercetools-sdk-javascript-v2/".concat(packageJson.version)
+  const userAgent = createUserAgent({
+    name: `commercetools-sdk-javascript-v2/${packageJson.version}`
   });
-  return function (next) {
-    return function (request, response) {
-      var requestWithUserAgent = _objectSpread2(_objectSpread2({}, request), {}, {
-        headers: _objectSpread2(_objectSpread2({}, request.headers), {}, {
-          'User-Agent': userAgent
-        })
-      });
-
-      next(requestWithUserAgent, response);
+  return next => (request, response) => {
+    const requestWithUserAgent = { ...request,
+      headers: { ...request.headers,
+        'User-Agent': userAgent
+      }
     };
+    next(requestWithUserAgent, response);
   };
 }
 
-var createAuthMiddlewareForPasswordFlow = createAuthMiddlewareForPasswordFlow$1,
-    createAuthMiddlewareForAnonymousSessionFlow = createAuthMiddlewareForAnonymousSessionFlow$1,
-    createAuthMiddlewareForClientCredentialsFlow = createAuthMiddlewareForClientCredentialsFlow$1,
-    createAuthMiddlewareForRefreshTokenFlow = createAuthMiddlewareForRefreshTokenFlow$1,
-    createAuthMiddlewareWithExistingToken = createAuthMiddlewareWithExistingToken$1;
-
-var ClientBuilder = /*#__PURE__*/function () {
-  function ClientBuilder() {
-    _classCallCheck(this, ClientBuilder);
-
+const {
+  createAuthMiddlewareForPasswordFlow,
+  createAuthMiddlewareForAnonymousSessionFlow,
+  createAuthMiddlewareForClientCredentialsFlow,
+  createAuthMiddlewareForRefreshTokenFlow,
+  createAuthMiddlewareWithExistingToken
+} = authMiddlewares;
+class ClientBuilder {
+  constructor() {
     _defineProperty(this, "projectKey", void 0);
 
     _defineProperty(this, "authMiddleware", void 0);
@@ -1473,158 +1117,148 @@ var ClientBuilder = /*#__PURE__*/function () {
     _defineProperty(this, "middlewares", []);
   }
 
-  _createClass(ClientBuilder, [{
-    key: "withProjectKey",
-    value: function withProjectKey(key) {
-      this.projectKey = key;
-      return this;
-    }
-  }, {
-    key: "defaultClient",
-    value: function defaultClient(baseUri, credentials, oauthUri, projectKey) {
-      return this.withClientCredentialsFlow({
-        host: oauthUri,
-        projectKey: projectKey || this.projectKey,
-        credentials: credentials
-      }).withHttpMiddleware({
-        host: baseUri,
-        fetch: fetch__default["default"]
-      }).withLoggerMiddleware();
-    }
-  }, {
-    key: "withAuthMiddleware",
-    value: function withAuthMiddleware(authMiddleware) {
-      this.authMiddleware = authMiddleware;
-      return this;
-    }
-  }, {
-    key: "withMiddleware",
-    value: function withMiddleware(middleware) {
-      this.middlewares.push(middleware);
-      return this;
-    }
-  }, {
-    key: "withClientCredentialsFlow",
-    value: function withClientCredentialsFlow(options) {
-      return this.withAuthMiddleware(createAuthMiddlewareForClientCredentialsFlow(_objectSpread2({
-        host: options.host || 'https://auth.europe-west1.gcp.commercetools.com',
-        projectKey: options.projectKey || this.projectKey,
-        credentials: {
-          clientId: options.credentials.clientId || '',
-          clientSecret: options.credentials.clientSecret || ''
-        },
-        oauthUri: options.oauthUri || '',
-        scopes: options.scopes,
-        fetch: options.fetch || fetch__default["default"]
-      }, options)));
-    }
-  }, {
-    key: "withPasswordFlow",
-    value: function withPasswordFlow(options) {
-      return this.withAuthMiddleware(createAuthMiddlewareForPasswordFlow(_objectSpread2({
-        host: options.host || 'https://auth.europe-west1.gcp.commercetools.com',
-        projectKey: options.projectKey || this.projectKey,
-        credentials: {
-          clientId: process.env.myClientId,
-          clientSecret: process.env.myClientSecret,
-          user: {
-            username: options.credentials.user.username || '',
-            password: options.credentials.user.password || ''
-          }
-        },
-        fetch: options.fetch || fetch__default["default"]
-      }, options)));
-    }
-  }, {
-    key: "withAnonymousSessionFlow",
-    value: function withAnonymousSessionFlow(options) {
-      return this.withAuthMiddleware(createAuthMiddlewareForAnonymousSessionFlow(_objectSpread2({
-        host: options.host || 'https://auth.europe-west1.gcp.commercetools.com',
-        projectKey: this.projectKey || options.projectKey,
-        credentials: {
-          clientId: options.credentials.clientId || '',
-          clientSecret: options.credentials.clientSecret || '',
-          anonymousId: options.credentials.anonymousId || ''
-        },
-        fetch: options.fetch || fetch__default["default"]
-      }, options)));
-    }
-  }, {
-    key: "withRefreshTokenFlow",
-    value: function withRefreshTokenFlow(options) {
-      return this.withAuthMiddleware(createAuthMiddlewareForRefreshTokenFlow(_objectSpread2({
-        host: options.host || 'https://auth.europe-west1.gcp.commercetools.com',
-        projectKey: this.projectKey || options.projectKey,
-        credentials: {
-          clientId: options.credentials.clientId || '',
-          clientSecret: options.credentials.clientSecret || ''
-        },
-        fetch: options.fetch || fetch__default["default"],
-        refreshToken: options.refreshToken || ''
-      }, options)));
-    }
-  }, {
-    key: "withExistingTokenFlow",
-    value: function withExistingTokenFlow(authorization, options) {
-      return this.withAuthMiddleware(createAuthMiddlewareWithExistingToken(authorization, _objectSpread2({
-        force: options.force || true
-      }, options)));
-    }
-  }, {
-    key: "withHttpMiddleware",
-    value: function withHttpMiddleware(options) {
-      this.httpMiddleware = createHttpMiddleware(_objectSpread2({
-        host: options.host || 'https://api.europe-west1.gcp.commercetools.com',
-        fetch: options.fetch || fetch__default["default"]
-      }, options));
-      return this;
-    }
-  }, {
-    key: "withUserAgentMiddleware",
-    value: function withUserAgentMiddleware() {
-      this.userAgentMiddleware = createUserAgentMiddleware();
-      return this;
-    }
-  }, {
-    key: "withQueueMiddleware",
-    value: function withQueueMiddleware(options) {
-      this.queueMiddleware = createQueueMiddleware(_objectSpread2({
-        concurrency: options.concurrency || 20
-      }, options));
-      return this;
-    }
-  }, {
-    key: "withLoggerMiddleware",
-    value: function withLoggerMiddleware() {
-      this.loggerMiddleware = createLoggerMiddleware();
-      return this;
-    }
-  }, {
-    key: "withCorrelationIdMiddleware",
-    value: function withCorrelationIdMiddleware(options) {
-      this.correlationIdMiddleware = createCorrelationIdMiddleware(_objectSpread2({
-        generate: options.generate || null
-      }, options));
-      return this;
-    }
-  }, {
-    key: "build",
-    value: function build() {
-      var middlewares = this.middlewares.slice();
-      if (this.correlationIdMiddleware) middlewares.push(this.correlationIdMiddleware);
-      if (this.userAgentMiddleware) middlewares.push(this.userAgentMiddleware);
-      if (this.authMiddleware) middlewares.push(this.authMiddleware);
-      if (this.loggerMiddleware) middlewares.push(this.loggerMiddleware);
-      if (this.queueMiddleware) middlewares.push(this.queueMiddleware);
-      if (this.httpMiddleware) middlewares.push(this.httpMiddleware);
-      return createClient({
-        middlewares: middlewares
-      });
-    }
-  }]);
+  withProjectKey(key) {
+    this.projectKey = key;
+    return this;
+  }
+
+  defaultClient(baseUri, credentials, oauthUri, projectKey) {
+    return this.withClientCredentialsFlow({
+      host: oauthUri,
+      projectKey: projectKey || this.projectKey,
+      credentials
+    }).withHttpMiddleware({
+      host: baseUri,
+      fetch: fetch__default["default"]
+    }).withLoggerMiddleware();
+  }
+
+  withAuthMiddleware(authMiddleware) {
+    this.authMiddleware = authMiddleware;
+    return this;
+  }
+
+  withMiddleware(middleware) {
+    this.middlewares.push(middleware);
+    return this;
+  }
+
+  withClientCredentialsFlow(options) {
+    return this.withAuthMiddleware(createAuthMiddlewareForClientCredentialsFlow({
+      host: options.host || 'https://auth.europe-west1.gcp.commercetools.com',
+      projectKey: options.projectKey || this.projectKey,
+      credentials: {
+        clientId: options.credentials.clientId || '',
+        clientSecret: options.credentials.clientSecret || ''
+      },
+      oauthUri: options.oauthUri || '',
+      scopes: options.scopes,
+      fetch: options.fetch || fetch__default["default"],
+      ...options
+    }));
+  }
+
+  withPasswordFlow(options) {
+    return this.withAuthMiddleware(createAuthMiddlewareForPasswordFlow({
+      host: options.host || 'https://auth.europe-west1.gcp.commercetools.com',
+      projectKey: options.projectKey || this.projectKey,
+      credentials: {
+        clientId: options.credentials.clientId || '',
+        clientSecret: options.credentials.clientSecret || '',
+        user: {
+          username: options.credentials.user.username || '',
+          password: options.credentials.user.password || ''
+        }
+      },
+      fetch: options.fetch || fetch__default["default"],
+      ...options
+    }));
+  }
+
+  withAnonymousSessionFlow(options) {
+    return this.withAuthMiddleware(createAuthMiddlewareForAnonymousSessionFlow({
+      host: options.host || 'https://auth.europe-west1.gcp.commercetools.com',
+      projectKey: this.projectKey || options.projectKey,
+      credentials: {
+        clientId: options.credentials.clientId || '',
+        clientSecret: options.credentials.clientSecret || '',
+        anonymousId: options.credentials.anonymousId || ''
+      },
+      fetch: options.fetch || fetch__default["default"],
+      ...options
+    }));
+  }
 
-  return ClientBuilder;
-}();
+  withRefreshTokenFlow(options) {
+    return this.withAuthMiddleware(createAuthMiddlewareForRefreshTokenFlow({
+      host: options.host || 'https://auth.europe-west1.gcp.commercetools.com',
+      projectKey: this.projectKey || options.projectKey,
+      credentials: {
+        clientId: options.credentials.clientId || '',
+        clientSecret: options.credentials.clientSecret || ''
+      },
+      fetch: options.fetch || fetch__default["default"],
+      refreshToken: options.refreshToken || '',
+      ...options
+    }));
+  }
+
+  withExistingTokenFlow(authorization, options) {
+    return this.withAuthMiddleware(createAuthMiddlewareWithExistingToken(authorization, {
+      force: options.force || true,
+      ...options
+    }));
+  }
+
+  withHttpMiddleware(options) {
+    this.httpMiddleware = createHttpMiddleware({
+      host: options.host || 'https://api.europe-west1.gcp.commercetools.com',
+      fetch: options.fetch || fetch__default["default"],
+      ...options
+    });
+    return this;
+  }
+
+  withUserAgentMiddleware() {
+    this.userAgentMiddleware = createUserAgentMiddleware();
+    return this;
+  }
+
+  withQueueMiddleware(options) {
+    this.queueMiddleware = createQueueMiddleware({
+      concurrency: options.concurrency || 20,
+      ...options
+    });
+    return this;
+  }
+
+  withLoggerMiddleware() {
+    this.loggerMiddleware = createLoggerMiddleware();
+    return this;
+  }
+
+  withCorrelationIdMiddleware(options) {
+    this.correlationIdMiddleware = createCorrelationIdMiddleware({
+      generate: options.generate || null,
+      ...options
+    });
+    return this;
+  }
+
+  build() {
+    const middlewares = this.middlewares.slice();
+    if (this.correlationIdMiddleware) middlewares.push(this.correlationIdMiddleware);
+    if (this.userAgentMiddleware) middlewares.push(this.userAgentMiddleware);
+    if (this.authMiddleware) middlewares.push(this.authMiddleware);
+    if (this.loggerMiddleware) middlewares.push(this.loggerMiddleware);
+    if (this.queueMiddleware) middlewares.push(this.queueMiddleware);
+    if (this.httpMiddleware) middlewares.push(this.httpMiddleware);
+    return createClient({
+      middlewares
+    });
+  }
+
+}
 
 exports.ClientBuilder = ClientBuilder;
 exports.createAuthForAnonymousSessionFlow = createAuthMiddlewareForAnonymousSessionFlow$1;