@commercetools/sdk-client-v2 2.0.2 → 2.1.0

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

@@ -22,7 +22,6 @@ function _defineProperty(obj, key, value) {
   } else {
     obj[key] = value;
   }
-
   return obj;
 }
 
@@ -31,7 +30,6 @@ var METHODS = ['ACL', 'BIND', 'CHECKOUT', 'CONNECT', 'COPY', 'DELETE', 'GET', 'H
 /**
  * @throws {Error}
  */
-
 function validate(funcName, request, options = {
   allowedMethods: METHODS
 }) {
@@ -41,19 +39,18 @@ function validate(funcName, request, options = {
 }
 
 let _options;
-
 function compose(...funcs) {
   funcs = funcs.filter(func => typeof func === 'function');
   if (funcs.length === 1) return funcs[0];
   return funcs.reduce((a, b) => (...args) => a(b(...args)));
 }
-
 function process$1(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
+  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
   const opt = {
     total: Number.POSITIVE_INFINITY,
     accumulate: true,
@@ -61,15 +58,14 @@ function process$1(request, fn, processOpt) {
   };
   return new Promise((resolve, reject) => {
     let _path,
-        _queryString = '';
-
+      _queryString = '';
     if (request && request.uri) {
       const [path, queryString] = request.uri.split('?');
       _path = path;
       _queryString = queryString;
     }
-
-    const requestQuery = { ...qs__default["default"].parse(_queryString)
+    const requestQuery = {
+      ...qs__default["default"].parse(_queryString)
     };
     const query = {
       // defaults
@@ -79,11 +75,11 @@ function process$1(request, fn, processOpt) {
     };
     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,
+      const originalQueryString = qs__default["default"].stringify({
+        ...query,
         limit
       });
       const enhancedQuery = {
@@ -94,45 +90,42 @@ function process$1(request, fn, processOpt) {
         } : {})
       };
       const enhancedQueryString = qs__default["default"].stringify(enhancedQuery);
-      const enhancedRequest = { ...request,
+      const enhancedRequest = {
+        ...request,
         uri: `${_path}?${enhancedQueryString}&${originalQueryString}`
       };
-
       try {
         const payload = await createClient(_options).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
+        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
-
+    };
 
+    // Start iterating through pages
     processPage();
   });
 }
@@ -146,7 +139,6 @@ function createClient(options) {
      * Given a request object,
      */
     process: process$1,
-
     execute(request) {
       validate('exec', request);
       return new Promise((resolve, reject) => {
@@ -165,9 +157,9 @@ function createClient(options) {
             rs.resolve(resObj);
           }
         };
-
         const dispatch = compose(...options.middlewares)(resolver);
-        dispatch(request, // Initial response shape
+        dispatch(request,
+        // Initial response shape
         {
           resolve,
           reject,
@@ -176,14 +168,12 @@ function createClient(options) {
         });
       });
     }
-
   };
 }
 
 // POST https://{host}/oauth/token?grant_type=client_credentials&scope={scope}
 // Authorization: Basic QWxhZGRpbjpvcGVuIHNlc2FtZQ==
 const Buffer$1 = require('buffer/').Buffer;
-
 function buildRequestForClientCredentialsFlow(options) {
   if (!options) throw new Error('Missing required options');
   if (!options.host) throw new Error('Missing required option (host)');
@@ -195,9 +185,9 @@ function buildRequestForClientCredentialsFlow(options) {
   } = options.credentials;
   if (!(clientId && clientSecret)) throw new Error('Missing required credentials (clientId, clientSecret)');
   const scope = options.scopes ? options.scopes.join(' ') : undefined;
-  const basicAuth = Buffer$1.from(`${clientId}:${clientSecret}`).toString('base64'); // This is mostly useful for internal testing purposes to be able to check
+  const basicAuth = Buffer$1.from(`${clientId}:${clientSecret}`).toString('base64');
+  // This is mostly useful for internal testing purposes to be able to check
   // other oauth endpoints.
-
   const oauthUri = options.oauthUri || '/oauth/token';
   const url = options.host.replace(/\/$/, '') + oauthUri;
   const body = `grant_type=client_credentials${scope ? `&scope=${scope}` : ''}`;
@@ -231,10 +221,9 @@ function buildRequestForPasswordFlow(options) {
    * This is mostly useful for internal testing purposes to be able to check
    * other oauth endpoints.
    */
-
   const oauthUri = options.oauthUri || `/oauth/${pKey}/customers/token`;
-  const url = options.host.replace(/\/$/, '') + oauthUri; // encode username and password as requested by the system
-
+  const url = options.host.replace(/\/$/, '') + oauthUri;
+  // encode username and password as requested by the system
   const body = `grant_type=password&username=${encodeURIComponent(username)}&password=${encodeURIComponent(password)}${scopeStr}`;
   return {
     basicAuth,
@@ -253,9 +242,9 @@ function buildRequestForRefreshTokenFlow(options) {
     clientSecret
   } = options.credentials;
   if (!(clientId && clientSecret)) throw new Error('Missing required credentials (clientId, clientSecret)');
-  const basicAuth = Buffer$1.from(`${clientId}:${clientSecret}`).toString('base64'); // This is mostly useful for internal testing purposes to be able to check
+  const basicAuth = Buffer$1.from(`${clientId}:${clientSecret}`).toString('base64');
+  // This is mostly useful for internal testing purposes to be able to check
   // other oauth endpoints.
-
   const oauthUri = options.oauthUri || '/oauth/token';
   const url = options.host.replace(/\/$/, '') + oauthUri;
   const body = `grant_type=refresh_token&refresh_token=${encodeURIComponent(options.refreshToken)}`;
@@ -272,25 +261,26 @@ function buildRequestForAnonymousSessionFlow(options) {
   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
+  return {
+    ...result
   };
 }
 
 const Buffer = require('buffer/').Buffer;
-
 function mergeAuthHeader(token, req) {
-  return { ...req,
-    headers: { ...req.headers,
+  return {
+    ...req,
+    headers: {
+      ...req.headers,
       Authorization: `Bearer ${token}`
     }
   };
 }
-
 function calculateExpirationTime(expiresIn) {
-  return Date.now() + // Add a gap of 5 minutes before expiration time.
+  return Date.now() +
+  // Add a gap of 5 minutes before expiration time.
   expiresIn * 1000 - 5 * 60 * 1000;
 }
-
 async function executeRequest({
   fetcher,
   url,
@@ -312,27 +302,28 @@ async function executeRequest({
       },
       body
     });
-
     if (_res.ok) {
       const {
         access_token: token,
         expires_in: expiresIn,
         refresh_token: refreshToken
       } = await _res.json();
-      const expirationTime = calculateExpirationTime(expiresIn); // cache new generated token
+      const expirationTime = calculateExpirationTime(expiresIn);
 
+      // cache new generated token
       tokenCache.set({
         token,
         expirationTime,
         refreshToken
-      }, tokenCacheKey); // Dispatch all pending requests
+      }, tokenCacheKey);
 
+      // Dispatch all pending requests
       requestState.set(false);
+
       /**
        * Freeze and copy pending queue, reset original one for accepting
        * new pending tasks
        */
-
       const executionQueue = pendingTasks.slice();
       pendingTasks = [];
       executionQueue.forEach(task => {
@@ -342,31 +333,28 @@ async function executeRequest({
          * console.log('test', cache, pendingTasks)
          * Continue by calling the task's own next function
          */
-
         task.next(requestWithAuth, task.response);
       });
       return;
-    } // Handle error response
-
+    }
 
+    // Handle error response
     let parsed;
     const text = await _res.text();
-
     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
      */
-
     requestState.set(false);
     response.reject(error);
   } catch (error) {
@@ -380,7 +368,6 @@ async function executeRequest({
     if (response && typeof response.reject === 'function') response.reject(error);
   }
 }
-
 function authMiddlewareBase({
   request,
   response,
@@ -394,50 +381,50 @@ function authMiddlewareBase({
   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 (!fetcher) fetcher = fetch;
+  // 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;
-  } // If there was a token in the tokenCache, and it's not expired, append
+  }
+  // If there was a token in the tokenCache, and it's not expired, append
   // the token in the `Authorization` header.
-
-
   const tokenObj = tokenCache.get(tokenCacheKey);
-
   if (tokenObj && tokenObj.token && Date.now() < tokenObj.expirationTime) {
     const requestWithAuth = mergeAuthHeader(tokenObj.token, request);
     next(requestWithAuth, response);
     return;
   }
+
   /**
    * Keep pending tasks until a token is fetched
    * Save next function as well, to call it once the token has been fetched, which prevents
    * unexpected behaviour in a context in which the next function uses global vars
    * or Promises to capture the token to hand it to other libraries, e.g. Apollo
    */
-
-
   pendingTasks.push({
     request,
     response,
     next
-  }); // If a token is currently being fetched, just wait ;)
+  });
 
-  if (requestState.get()) return; // Mark that a token is being fetched
+  // If a token is currently being fetched, just wait ;)
+  if (requestState.get()) return;
 
+  // Mark that a token is being fetched
   requestState.set(true);
+
   /**
    * If there was a refreshToken in the tokenCache, and there was an expired
    * token or no token in the tokenCache, use the refreshToken flow
    */
-
   if (tokenObj && tokenObj.refreshToken && (!tokenObj.token || tokenObj.token && Date.now() > tokenObj.expirationTime)) {
     if (!userOptions) throw new Error('Missing required options');
     executeRequest({
       fetcher,
-      ...buildRequestForRefreshTokenFlow({ ...userOptions,
+      ...buildRequestForRefreshTokenFlow({
+        ...userOptions,
         refreshToken: tokenObj.refreshToken
       }),
       tokenCacheKey,
@@ -447,9 +434,9 @@ function authMiddlewareBase({
       response
     });
     return;
-  } // Token and refreshToken are not present or invalid. Request a new token...
-
+  }
 
+  // Token and refreshToken are not present or invalid. Request a new token...
   executeRequest({
     fetcher,
     url,
@@ -466,16 +453,18 @@ function authMiddlewareBase({
 function store(initVal) {
   let value = initVal;
   return {
-    get: () => value,
-    set: val => {
+    get: TokenCacheOption => value,
+    set: (val, TokenCacheOption) => {
       value = val;
-      return value;
     }
   };
 }
 
 function createAuthMiddlewareForAnonymousSessionFlow$1(options) {
-  const tokenCache = options.tokenCache || store({});
+  const tokenCache = options.tokenCache || store({
+    token: '',
+    expirationTime: -1
+  });
   const pendingTasks = [];
   const requestState = store(false);
   return next => (request, response) => {
@@ -485,7 +474,6 @@ function createAuthMiddlewareForAnonymousSessionFlow$1(options) {
       next(request, response);
       return;
     }
-
     const params = {
       request,
       response,
@@ -521,7 +509,6 @@ function createAuthMiddlewareForClientCredentialsFlow$1(options) {
       next(request, response);
       return;
     }
-
     const params = {
       request,
       response,
@@ -540,17 +527,18 @@ 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
      */
-
     if (!authorization || (request.headers && request.headers.authorization || request.headers && request.headers.Authorization) && force === false) {
       return next(request, response);
     }
-
-    const requestWithAuth = { ...request,
-      headers: { ...request.headers,
+    const requestWithAuth = {
+      ...request,
+      headers: {
+        ...request.headers,
         Authorization: authorization
       }
     };
@@ -569,7 +557,6 @@ function createAuthMiddlewareForPasswordFlow$1(options) {
       next(request, response);
       return;
     }
-
     const params = {
       request,
       response,
@@ -584,7 +571,10 @@ function createAuthMiddlewareForPasswordFlow$1(options) {
 }
 
 function createAuthMiddlewareForRefreshTokenFlow$1(options) {
-  const tokenCache = options.tokenCache || store({});
+  const tokenCache = options.tokenCache || store({
+    token: '',
+    expirationTime: -1
+  });
   const pendingTasks = [];
   const requestState = store(false);
   return next => (request, response) => {
@@ -594,7 +584,6 @@ function createAuthMiddlewareForRefreshTokenFlow$1(options) {
       next(request, response);
       return;
     }
-
     const params = {
       request,
       response,
@@ -619,8 +608,10 @@ var authMiddlewares = /*#__PURE__*/Object.freeze({
 
 function createCorrelationIdMiddleware(options) {
   return next => (request, response) => {
-    const nextRequest = { ...request,
-      headers: { ...request.headers,
+    const nextRequest = {
+      ...request,
+      headers: {
+        ...request.headers,
         'X-Correlation-ID': options.generate()
       }
     };
@@ -636,16 +627,11 @@ function defineError(statusCode, message, meta = {}) {
   this.constructor.prototype.__proto__ = Error.prototype;
   if (Error.captureStackTrace) Error.captureStackTrace(this, this.constructor);
 }
-
 function NetworkError(...args) {
-  defineError.call(this, 0
-  /* special code to indicate network errors */
-  , ...args);
+  defineError.call(this, 0 /* special code to indicate network errors */, ...args);
 }
 function HttpError(...args) {
-  defineError.call(this,
-  /* code will be passed as arg */
-  ...args);
+  defineError.call(this, /* code will be passed as arg */...args);
 }
 function BadRequest(...args) {
   defineError.call(this, 400, ...args);
@@ -672,39 +658,34 @@ function getErrorByCode(code) {
   switch (code) {
     case 0:
       return NetworkError;
-
     case 400:
       return BadRequest;
-
     case 401:
       return Unauthorized;
-
     case 403:
       return Forbidden;
-
     case 404:
       return NotFound;
-
     case 409:
       return ConcurrentModification;
-
     case 500:
       return InternalServerError;
-
     case 503:
       return ServiceUnavailable;
-
     default:
       return undefined;
   }
 }
 
 function parseHeaders(headers) {
-  if (headers.raw) // node-fetch
-    return headers.raw(); // Tmp fix for Firefox until it supports iterables
+  if (headers.raw)
+    // node-fetch
+    return headers.raw();
 
-  if (!headers.forEach) return {}; // whatwg-fetch
+  // Tmp fix for Firefox until it supports iterables
+  if (!headers.forEach) return {};
 
+  // whatwg-fetch
   const map = {};
   headers.forEach((value, name) => {
     map[name] = value;
@@ -712,10 +693,10 @@ function parseHeaders(headers) {
   return map;
 }
 
+// performs a proper buffer check
 function isBuffer(obj) {
   return obj != null && obj.constructor != null && typeof obj.constructor.isBuffer === 'function' && obj.constructor.isBuffer(obj);
 }
-
 function createError({
   statusCode,
   message,
@@ -726,23 +707,21 @@ function createError({
   const ResponseError = getErrorByCode(statusCode);
   if (ResponseError) return new ResponseError(errorMessage, rest);
   return new HttpError(statusCode, errorMessage, rest);
-} // calculates the delay duration exponentially
-// More info about the algorithm use here https://goo.gl/Xk8h5f
-
+}
 
+// calculates the delay duration exponentially
+// More info about the algorithm use here https://goo.gl/Xk8h5f
 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 * 2 ** retryCount), maxDelay) : retryDelay;
   return retryDelay;
 }
-
 function maskAuthData(request, maskSensitiveHeaderData) {
   if (maskSensitiveHeaderData) {
     if (request && request.headers && request.headers.authorization) request.headers.authorization = 'Bearer ********';
     if (request && request.headers && request.headers.Authorization) request.headers.Authorization = 'Bearer ********';
   }
 }
-
 function createHttpMiddleware({
   host,
   credentialsMode,
@@ -758,6 +737,8 @@ function createHttpMiddleware({
     backoff = true,
     retryDelay = 200,
     maxDelay = Infinity,
+    // If set to true reinitialize the abort controller when the timeout is reached and apply the retry config
+    retryOnAbort = false,
     retryCodes = [503]
   } = {},
   fetch: fetcher,
@@ -767,7 +748,6 @@ function createHttpMiddleware({
   if (!fetcher) throw new Error('`fetch` is not available. Please pass in `fetch` as an option or have it globally available.');
   if (timeout && !getAbortController) throw new Error('`AbortController` is not available. Please pass in `getAbortController` as an option or have AbortController globally available when using timeout.');
   let fetchFunction;
-
   if (fetcher) {
     fetchFunction = fetcher;
   } else {
@@ -776,71 +756,65 @@ function createHttpMiddleware({
     // For reference of this pattern: https://github.com/apollographql/apollo-link/blob/498b413a5b5199b0758ce898b3bb55451f57a2fa/packages/apollo-link-http/src/httpLink.ts#L49
     fetchFunction = fetch;
   }
-
   if (!Array.isArray(retryCodes)) {
     throw new Error('`retryCodes` option must be an array of retry status (error) codes.');
   }
-
   return next => (request, response) => {
-    let abortController;
-    if (timeout || getAbortController) abortController = (getAbortController ? getAbortController() : null) || new AbortController();
     const url = host.replace(/\/$/, '') + request.uri;
-    const requestHeader = { ...request.headers
-    }; // Unset the content-type header if explicitly asked to (passing `null` as value).
+    const requestHeader = {
+      ...request.headers
+    };
 
+    // Unset the content-type header if explicitly asked to (passing `null` as value).
     if (requestHeader['Content-Type'] === null) {
       delete requestHeader['Content-Type'];
     }
-
     if (!(Object.prototype.hasOwnProperty.call(requestHeader, 'Content-Type') || Object.prototype.hasOwnProperty.call(requestHeader, 'content-type'))) {
       requestHeader['Content-Type'] = 'application/json';
-    } // Ensure body is a string if content type is application/json
-
+    }
 
+    // Ensure body is a string if content type is application/json
     const body = ['application/json', 'application/graphql'].indexOf(requestHeader['Content-Type']) > -1 && typeof request.body === 'string' || isBuffer(request.body) ? request.body : JSON.stringify(request.body || undefined);
-
     if (body && (typeof body === 'string' || isBuffer(body))) {
       requestHeader['Content-Length'] = _.Buffer.byteLength(body).toString();
     }
-
     const fetchOptions = {
       method: request.method,
       headers: requestHeader
     };
-
     if (credentialsMode) {
       fetchOptions.credentialsMode = credentialsMode;
     }
-
-    if (abortController) {
-      fetchOptions.signal = abortController.signal;
-    }
-
     if (body) {
       fetchOptions.body = body;
     }
-
-    let retryCount = 0; // wrap in a fn so we can retry if error occur
-
+    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);
+      let abortController;
+      if (timeout) {
+        // Initialize the abort controller in case we do a retry on an aborted request to rest the signal
+        abortController = (getAbortController ? getAbortController() : null) || new AbortController();
+        fetchOptions.signal = abortController.signal;
+        // Set the timer
+        timer = setTimeout(() => {
+          abortController.abort();
+        }, timeout);
+      }
       fetchFunction(url, fetchOptions).then(res => {
         if (res.ok) {
           if (fetchOptions.method === 'HEAD') {
-            next(request, { ...response,
+            next(request, {
+              ...response,
               statusCode: res.status
             });
             return;
           }
-
           res.text().then(result => {
             // Try to parse the response as JSON
             let parsed;
-
             try {
               parsed = result.length > 0 ? JSON.parse(result) : {};
             } catch (err) {
@@ -849,39 +823,35 @@ function createHttpMiddleware({
                 retryCount += 1;
                 return;
               }
-
               parsed = result;
             }
-
-            const parsedResponse = { ...response,
+            const parsedResponse = {
+              ...response,
               body: parsed,
               statusCode: res.status
             };
             if (includeResponseHeaders) parsedResponse.headers = parseHeaders(res.headers);
-
             if (includeOriginalRequest) {
-              parsedResponse.request = { ...fetchOptions
+              parsedResponse.request = {
+                ...fetchOptions
               };
               maskAuthData(parsedResponse.request, maskSensitiveHeaderData);
             }
-
             next(request, parsedResponse);
           });
           return;
-        } // Server responded with an error. Try to parse it as JSON, then
-        // return a proper error type with all necessary meta information.
-
+        }
 
+        // 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;
           }
-
           const error = createError({
             statusCode: res.status,
             ...(includeRequestInErrorResponse ? {
@@ -897,7 +867,6 @@ function createHttpMiddleware({
               body: parsed
             })
           });
-
           if (enableRetry && (retryCodes.indexOf(error.statusCode) !== -1 || (retryCodes === null || retryCodes === void 0 ? void 0 : retryCodes.indexOf(error.message)) !== -1)) {
             if (retryCount < maxRetries) {
               setTimeout(executeFetch, calcDelayDuration(retryCount, retryDelay, maxRetries, backoff, maxDelay));
@@ -905,29 +874,35 @@ function createHttpMiddleware({
               return;
             }
           }
-
-          maskAuthData(error.originalRequest, maskSensitiveHeaderData); // Let the final resolver to reject the promise
-
-          const parsedResponse = { ...response,
+          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
+      },
+      // 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;
+        // Retry when enabled and either the request was not aborted or retryOnAbort is enabled
+        if (enableRetry && (retryOnAbort || !abortController || !abortController.signal)) {
+          if (retryCount < maxRetries) {
+            setTimeout(executeFetch, calcDelayDuration(retryCount, retryDelay, maxRetries, backoff, maxDelay));
+            retryCount += 1;
+            return;
+          }
         }
-        const error = new NetworkError(e.message, { ...(includeRequestInErrorResponse ? {
+        const error = new NetworkError(e.message, {
+          ...(includeRequestInErrorResponse ? {
             originalRequest: request
           } : {}),
           retryCount
         });
         maskAuthData(error.originalRequest, maskSensitiveHeaderData);
-        next(request, { ...response,
+        next(request, {
+          ...response,
           error,
           statusCode: 0
         });
@@ -935,7 +910,6 @@ function createHttpMiddleware({
         clearTimeout(timer);
       });
     }
-
     executeFetch();
   };
 }
@@ -962,42 +936,41 @@ function createQueueMiddleware({
 }) {
   const queue = [];
   let runningCount = 0;
-
   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
+    runningCount -= 1;
 
+    // Check if there are any other pending tasks and execute them
     if (queue.length && runningCount <= concurrency) {
       const 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,
-
+    const patchedResponse = {
+      ...response,
       resolve(data) {
         // Resolve original promise
         response.resolve(data);
         dequeue(next);
       },
-
       reject(error) {
         // Reject original promise
         response.reject(error);
         dequeue(next);
       }
+    };
 
-    }; // Add task to the queue
-
+    // Add task to the queue
     queue.push({
       request,
       response: patchedResponse
-    }); // If possible, run the task straight away
+    });
 
+    // If possible, run the task straight away
     if (runningCount < concurrency) {
       const nextTask = queue.shift();
       runningCount += 1;
@@ -1008,7 +981,7 @@ function createQueueMiddleware({
 
 var packageJson = {
 	name: "@commercetools/sdk-client-v2",
-	version: "2.0.2",
+	version: "2.1.0",
 	engines: {
 		node: ">=14"
 	},
@@ -1060,7 +1033,7 @@ var packageJson = {
 		"abort-controller": "3.0.0",
 		"common-tags": "1.8.2",
 		dotenv: "16.0.3",
-		jest: "29.2.1",
+		jest: "29.3.0",
 		nock: "12.0.3",
 		"organize-imports-cli": "0.10.0"
 	},
@@ -1080,10 +1053,8 @@ var packageJson = {
   the specific test.
 */
 const isBrowser = () => typeof window !== 'undefined' && 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})`
@@ -1091,31 +1062,38 @@ function getSystemInfo() {
 
   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
+  if (!options || Object.keys(options).length === 0 || !{}.hasOwnProperty.call(options, 'name')) throw new Error('Missing required option `name`');
 
-  const baseInfo = options.version ? `${options.name}/${options.version}` : options.name; // Library info
+  // 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
+  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
+  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})`;
 
-  const systemInfo = getSystemInfo(); // customName
+  // System info
+  const systemInfo = getSystemInfo();
 
+  // customName
   const customAgent = options.customAgent || '';
   return [baseInfo, systemInfo, libraryInfo, contactInfo, customAgent].filter(Boolean).join(' ');
 }
 
 function createUserAgentMiddleware(options) {
-  const userAgent = createUserAgent({ ...options,
+  const userAgent = createUserAgent({
+    ...options,
     name: `commercetools-sdk-javascript-v2/${packageJson.version}`
   });
   return next => (request, response) => {
-    const requestWithUserAgent = { ...request,
-      headers: { ...request.headers,
+    const requestWithUserAgent = {
+      ...request,
+      headers: {
+        ...request.headers,
         'User-Agent': userAgent
       }
     };
@@ -1133,27 +1111,18 @@ const {
 class ClientBuilder {
   constructor() {
     _defineProperty(this, "projectKey", void 0);
-
     _defineProperty(this, "authMiddleware", void 0);
-
     _defineProperty(this, "httpMiddleware", void 0);
-
     _defineProperty(this, "userAgentMiddleware", void 0);
-
     _defineProperty(this, "correlationIdMiddleware", void 0);
-
     _defineProperty(this, "loggerMiddleware", void 0);
-
     _defineProperty(this, "queueMiddleware", void 0);
-
     _defineProperty(this, "middlewares", []);
   }
-
   withProjectKey(key) {
     this.projectKey = key;
     return this;
   }
-
   defaultClient(baseUri, credentials, oauthUri, projectKey) {
     return this.withClientCredentialsFlow({
       host: oauthUri,
@@ -1164,17 +1133,14 @@ class ClientBuilder {
       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',
@@ -1189,7 +1155,6 @@ class ClientBuilder {
       ...options
     }));
   }
-
   withPasswordFlow(options) {
     return this.withAuthMiddleware(createAuthMiddlewareForPasswordFlow({
       host: options.host || 'https://auth.europe-west1.gcp.commercetools.com',
@@ -1206,7 +1171,6 @@ class ClientBuilder {
       ...options
     }));
   }
-
   withAnonymousSessionFlow(options) {
     return this.withAuthMiddleware(createAuthMiddlewareForAnonymousSessionFlow({
       host: options.host || 'https://auth.europe-west1.gcp.commercetools.com',
@@ -1220,7 +1184,6 @@ class ClientBuilder {
       ...options
     }));
   }
-
   withRefreshTokenFlow(options) {
     return this.withAuthMiddleware(createAuthMiddlewareForRefreshTokenFlow({
       host: options.host || 'https://auth.europe-west1.gcp.commercetools.com',
@@ -1234,14 +1197,12 @@ class ClientBuilder {
       ...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',
@@ -1250,12 +1211,10 @@ class ClientBuilder {
     });
     return this;
   }
-
   withUserAgentMiddleware(options) {
     this.userAgentMiddleware = createUserAgentMiddleware(options);
     return this;
   }
-
   withQueueMiddleware(options) {
     this.queueMiddleware = createQueueMiddleware({
       concurrency: options.concurrency || 20,
@@ -1263,12 +1222,10 @@ class ClientBuilder {
     });
     return this;
   }
-
   withLoggerMiddleware() {
     this.loggerMiddleware = createLoggerMiddleware();
     return this;
   }
-
   withCorrelationIdMiddleware(options) {
     this.correlationIdMiddleware = createCorrelationIdMiddleware({
       generate: options.generate || null,
@@ -1276,7 +1233,6 @@ class ClientBuilder {
     });
     return this;
   }
-
   build() {
     const middlewares = this.middlewares.slice();
     if (this.correlationIdMiddleware) middlewares.push(this.correlationIdMiddleware);
@@ -1289,7 +1245,6 @@ class ClientBuilder {
       middlewares
     });
   }
-
 }
 
 exports.ClientBuilder = ClientBuilder;