@commercetools/ts-client 0.0.0-beta.8 → 1.0.0

package/dist/commercetools-ts-client.cjs.prod.js

@@ -6,12 +6,14 @@ var qs = require('querystring');
 var crytpo = require('crypto');
 var fetch$1 = require('node-fetch');
 var _ = require('buffer/');
+var AbortController = require('abort-controller');
 
 function _interopDefault (e) { return e && e.__esModule ? e : { 'default': e }; }
 
 var qs__default = /*#__PURE__*/_interopDefault(qs);
 var crytpo__default = /*#__PURE__*/_interopDefault(crytpo);
 var fetch__default = /*#__PURE__*/_interopDefault(fetch$1);
+var AbortController__default = /*#__PURE__*/_interopDefault(AbortController);
 
 const HEADERS_CONTENT_TYPES = ['application/json', 'application/graphql'];
 const CONCURRENCT_REQUEST = 20;
@@ -26,13 +28,14 @@ function parse(headers) {
     return result;
   }, {});
 }
-
 function getHeaders(headers) {
-  if (!headers) return null; // node-fetch
+  if (!headers) return null;
 
-  if (headers.raw && typeof headers.raw == 'function') return headers.raw(); // Tmp fix for Firefox until it supports iterables
+  // node-fetch
+  if (headers.raw && typeof headers.raw == 'function') return headers.raw();
 
-  if (!headers.forEach) return parse(headers); // whatwg-fetch
+  // Tmp fix for Firefox until it supports iterables
+  if (!headers.forEach) return parse(headers);
   return headers.forEach((value, name) => value);
 }
 
@@ -51,14 +54,16 @@ function calculateRetryDelay({
     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;
 }
 
+// TODO: Polyfill crypto for browsers
 function generateID() {
   return crytpo__default["default"].randomBytes(32).toString('base64').replace(/[\/\-=+]/gi, '');
 }
 
+// import { validateUserAgentOptions } from '../utils'
+
 /*
   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
@@ -68,68 +73,73 @@ function generateID() {
   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?.version.slice(1) || 'unknow'; // unknow environment like  React Native etc
-
-  const platformInfo = `(${process.platform}; ${process.arch})`; // return `node.js/${nodeVersion}`
+  const nodeVersion = ((_process = process) === null || _process === void 0 ? void 0 : _process.version.slice(1)) || 'unknow'; // unknow environment like  React Native etc
+  const platformInfo = `(${process.platform}; ${process.arch})`;
 
+  // return `node.js/${nodeVersion}`
   return `node.js/${nodeVersion} ${platformInfo}`;
 }
-
 function createUserAgent(options) {
   let libraryInfo = null;
   let contactInfo = null;
 
+  // validateUserAgentOptions(options)
   if (!options) {
     throw new Error('Missing required option `name`');
-  } // Main info
-
+  }
 
-  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
   if (options.libraryName && !options.libraryVersion) {
     libraryInfo = options.libraryName;
   } else if (options.libraryName && options.libraryVersion) {
     libraryInfo = `${options.libraryName}/${options.libraryVersion}`;
-  } // Contact info
-
+  }
 
+  // Contact 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})`;
-  } // System info
-
+  }
 
-  const systemInfo = getSystemInfo(); // customName
+  // System info
+  const systemInfo = getSystemInfo();
 
+  // customName
   const customAgent = options.customAgent || '';
   return [baseInfo, systemInfo, libraryInfo, contactInfo, customAgent].filter(Boolean).join(' ');
 }
 
 function maskAuthData(request) {
-  if (request?.headers) {
-    if (request.headers.Authorization) {
-      request.headers['Authorization'] = 'Bearer ********';
+  const _request = Object.assign({}, request);
+  if (_request !== null && _request !== void 0 && _request.headers) {
+    if (_request.headers.Authorization) {
+      _request.headers['Authorization'] = 'Bearer ********';
     }
-
-    if (request.headers.authorization) {
-      request.headers['authorization'] = 'Bearer ********';
+    if (_request.headers.authorization) {
+      _request.headers['authorization'] = 'Bearer ********';
     }
   }
+  return _request;
 }
 
 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;
 }
 
 function buildTokenCacheKey(options) {
-  if (!options?.credentials?.clientId || !options.projectKey || !options.host) throw new Error('Missing required options.');
+  var _options$credentials;
+  if (!(options !== null && options !== void 0 && (_options$credentials = options.credentials) !== null && _options$credentials !== void 0 && _options$credentials.clientId) || !options.projectKey || !options.host) throw new Error('Missing required options.');
   return {
     clientId: options.credentials.clientId,
     host: options.host,
@@ -148,34 +158,36 @@ function store(initVal) {
 }
 
 function mergeAuthHeader(token, req) {
-  return { ...req,
-    headers: { ...req.headers,
+  return {
+    ...req,
+    headers: {
+      ...req.headers,
       Authorization: `Bearer ${token}`
     }
   };
 }
 
-// type Response = {
-//   data: Record<string, any>
-//   statusCode: number
-//   headers: Record<string, any>
-// }
+function predicate(retryCodes, response) {
+  return !
+  // retryCodes.includes(response?.error?.message) ||
+  [503, ...retryCodes].includes((response === null || response === void 0 ? void 0 : response.status) || (response === null || response === void 0 ? void 0 : response.statusCode));
+}
 async function executeHttpClientRequest(fetcher, config) {
   async function sendRequest() {
-    const response = await fetcher({ ...config,
-      headers: { ...config.headers
+    const response = await fetcher({
+      ...config,
+      headers: {
+        ...config.headers
       }
-    }); // validations and error handlings can also be done here
+    });
 
+    // validations and error handlings can also be done here
     return response;
-  } // Attempt to send the request.
-
+  }
 
-  return sendRequest().catch(error => {
-    throw error;
-  });
+  // Attempt to send the request.
+  return sendRequest().catch(error => Promise.reject(error));
 }
-
 async function executor(request) {
   const {
     url,
@@ -183,22 +195,79 @@ async function executor(request) {
     ...rest
   } = request;
   const data = await executeHttpClientRequest(async options => {
-    const response = await httpClient(url, { ...rest,
-      ...options,
-      headers: { ...rest.headers,
-        ...options.headers,
-        // axios header encoding
-        'Accept-Encoding': 'application/json'
-      },
-      // for axios
-      ...(rest.body ? {
-        data: rest.body
-      } : {}),
-      withCredentials: options.credentialsMode === 'include'
-    });
-    const data = response.json && typeof response.json == 'function' ? await response.json() : response.data || response;
+    const {
+      enableRetry,
+      retryConfig
+    } = rest;
+    const {
+      retryCodes = [],
+      maxDelay = Infinity,
+      maxRetries = 3,
+      backoff = true,
+      retryDelay = 200
+    } = retryConfig || {};
+    let result,
+      data,
+      retryCount = 0;
+
+    // validate the `retryCodes` option
+    validateRetryCodes(retryCodes);
+    async function execute() {
+      return httpClient(url, {
+        ...rest,
+        ...options,
+        headers: {
+          ...rest.headers,
+          ...options.headers,
+          // axios header encoding
+          'Accept-Encoding': 'application/json'
+        },
+        // for axios
+        ...(rest.body ? {
+          data: rest.body
+        } : {}),
+        withCredentials: options.credentialsMode === 'include'
+      });
+    }
+    async function executeWithRetry() {
+      // first attempt
+      let _response = await execute();
+      if (predicate(retryCodes, _response)) return _response;
+
+      // retry attempts
+      while (enableRetry && retryCount < maxRetries) {
+        retryCount++;
+        _response = await execute();
+        if (predicate(retryCodes, _response)) return _response;
+
+        // delay next execution
+        const timer = calculateRetryDelay({
+          retryCount,
+          retryDelay,
+          maxRetries,
+          backoff,
+          maxDelay
+        });
+        await sleep(timer);
+      }
+      return _response;
+    }
+    const response = await executeWithRetry();
+    try {
+      // try to parse the `fetch` response as text
+      if (response.text && typeof response.text == 'function') {
+        result = await response.text();
+        data = JSON.parse(result);
+      } else {
+        // axios response
+        data = response.data || response;
+      }
+    } catch (err) {
+      data = result;
+    }
     return {
       data,
+      retryCount,
       statusCode: response.status || response.statusCode || data.statusCode,
       headers: response.headers
     };
@@ -220,6 +289,79 @@ function sleep(ms) {
 
 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'];
 
+function DefineError(statusCode, message, meta = {}) {
+  // eslint-disable-next-line no-multi-assign
+  this.status = this.statusCode = this.code = statusCode;
+  this.message = message;
+  Object.assign(this, meta);
+  this.name = this.constructor.name;
+  // eslint-disable-next-line no-proto
+  this.constructor.prototype.__proto__ = Error.prototype;
+  if (Error.captureStackTrace) Error.captureStackTrace(this, this.constructor);
+}
+function NetworkError(...args) {
+  DefineError.call(this, 0, ...args);
+}
+function HttpError(...args) {
+  DefineError.call(this, ...args);
+}
+function BadRequest(...args) {
+  DefineError.call(this, 400, ...args);
+}
+function Unauthorized(...args) {
+  DefineError.call(this, 401, ...args);
+}
+function Forbidden(...args) {
+  DefineError.call(this, 403, ...args);
+}
+function NotFound(...args) {
+  DefineError.call(this, 404, ...args);
+}
+function ConcurrentModification(...args) {
+  DefineError.call(this, 409, ...args);
+}
+function InternalServerError(...args) {
+  DefineError.call(this, 500, ...args);
+}
+function ServiceUnavailable(...args) {
+  DefineError.call(this, 503, ...args);
+}
+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 createError({
+  statusCode,
+  message,
+  ...rest
+}) {
+  var _rest$originalRequest;
+  let errorMessage = message || 'Unexpected non-JSON error response';
+  if (statusCode === 404) errorMessage = `URI not found: ${((_rest$originalRequest = rest.originalRequest) === null || _rest$originalRequest === void 0 ? void 0 : _rest$originalRequest.uri) || rest.uri}`;
+  const ResponseError = getErrorByCode(statusCode);
+  if (ResponseError) return new ResponseError(errorMessage, rest);
+  return new HttpError(statusCode, errorMessage, rest);
+}
+
 /**
  * validate some essential http options
  * @param options
@@ -229,34 +371,33 @@ function validateHttpOptions(options) {
   if (!options.httpClient && typeof options.httpClient !== 'function') throw new Error('An `httpClient` is not available, please pass in a `fetch` or `axios` instance as an option or have them globally available.');
   if (options.timeout && !options.getAbortController) throw new Error('`AbortController` is not available. Please pass in `getAbortController` as an option or have AbortController globally available when using timeout.');
 }
+
 /**
  *
  * @param retryCodes
  * @example
  * const retryCodes = [500, 504, "ETIMEDOUT"]
  */
-
 function validateRetryCodes(retryCodes) {
   if (!Array.isArray(retryCodes)) {
     throw new Error('`retryCodes` option must be an array of retry status (error) codes and/or messages.');
   }
 }
+
 /**
  * @param options
  */
-
 function validateClient(options) {
   if (!options) throw new Error('Missing required options');
   if (options.middlewares && !Array.isArray(options.middlewares)) throw new Error('Middlewares should be an array');
-
   if (!options.middlewares || !Array.isArray(options.middlewares) || !options.middlewares.length) {
     throw new Error('You need to provide at least one middleware');
   }
 }
+
 /**
  * @param options
  */
-
 function validate(funcName, request, options = {
   allowedMethods: METHODS
 }) {
@@ -269,21 +410,19 @@ function compose({
   middlewares
 }) {
   if (middlewares.length === 1) return middlewares[0];
-
   const _middlewares = middlewares.slice();
-
   return _middlewares.reduce((ac, cv) => (...args) => ac(cv.apply(null, args)));
-} // process batch requests
-
+}
 
+// process batch requests
 let _options;
-
 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,
@@ -291,15 +430,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
@@ -309,11 +447,11 @@ function process$1(request, fn, processOpt) {
     };
     let itemsToGet = opt.total;
     let hasFirstPageBeenProcessed = false;
-
     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 = {
@@ -324,48 +462,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 || {};
-
+        } = (payload === null || payload === void 0 ? void 0 : payload.body) || {};
         if (!resultsLength && hasFirstPageBeenProcessed) {
           return resolve(acc || []);
         }
-
-        const result = await Promise.resolve(fn(payload)); // const result = await fn(payload)
-
+        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); // return {
-        //   error
-        // }
+        reject(error);
       }
-    }; // Start iterating through pages
-
+    };
 
+    // Start iterating through pages
     processPage();
   });
 }
@@ -375,38 +507,39 @@ function createClient(middlewares) {
   const resolver = {
     async resolve(rs) {
       const {
-        reject,
-        resolve,
         response,
+        includeOriginalRequest,
+        maskSensitiveHeaderData,
+        ...request
+      } = rs;
+      const {
         retryCount,
         ...rest
-      } = rs;
+      } = response;
       const res = {
         body: null,
         error: null,
-        reject,
-        resolve,
-        ...(retryCount ? {
-          retryCount
+        reject: rs.reject,
+        resolve: rs.resolve,
+        ...rest,
+        ...(includeOriginalRequest ? {
+          originalRequest: maskSensitiveHeaderData ? maskAuthData(request) : request
         } : {}),
-        request: rest,
-        ...response
+        ...(response !== null && response !== void 0 && response.retryCount ? {
+          retryCount: response.retryCount
+        } : {})
       };
-
       if (res.error) {
-        res.reject(res);
+        res.reject(res.error);
         return res;
       }
-
       res.resolve(res);
       return res;
     }
-
   };
   const dispatch = compose(middlewares)(resolver.resolve);
   return {
     process: process$1,
-
     execute(request) {
       validate('exec', request);
       return new Promise((resolve, reject) => {
@@ -417,11 +550,27 @@ function createClient(middlewares) {
         });
       });
     }
-
   };
 }
 
+function _toPrimitive(input, hint) {
+  if (typeof input !== "object" || input === null) return input;
+  var prim = input[Symbol.toPrimitive];
+  if (prim !== undefined) {
+    var res = prim.call(input, hint || "default");
+    if (typeof res !== "object") return res;
+    throw new TypeError("@@toPrimitive must return a primitive value.");
+  }
+  return (hint === "string" ? String : Number)(input);
+}
+
+function _toPropertyKey(arg) {
+  var key = _toPrimitive(arg, "string");
+  return typeof key === "symbol" ? key : String(key);
+}
+
 function _defineProperty(obj, key, value) {
+  key = _toPropertyKey(key);
   if (key in obj) {
     Object.defineProperty(obj, key, {
       value: value,
@@ -432,14 +581,15 @@ function _defineProperty(obj, key, value) {
   } else {
     obj[key] = value;
   }
-
   return obj;
 }
 
 function createCorrelationIdMiddleware$1(options) {
   return next => request => {
-    const nextRequest = { ...request,
-      headers: { ...request.headers,
+    const nextRequest = {
+      ...request,
+      headers: {
+        ...request.headers,
         'X-Correlation-ID': options.generate && typeof options.generate == 'function' ? options.generate() : generateID()
       }
     };
@@ -449,16 +599,19 @@ function createCorrelationIdMiddleware$1(options) {
 
 async function executeRequest$1({
   url,
-  clientOptions,
-  httpClient
+  httpClient,
+  clientOptions
 }) {
   let timer;
   const {
     timeout,
-    abortController
+    request,
+    abortController,
+    maskSensitiveHeaderData,
+    includeRequestInErrorResponse
   } = clientOptions;
-
   try {
+    var _response$data, _response$data2;
     if (timeout) timer = setTimeout(() => {
       abortController.abort();
     }, timeout);
@@ -471,43 +624,68 @@ async function executeRequest$1({
         body: clientOptions.body
       } : {})
     });
-
     if (response.statusCode >= 200 && response.statusCode < 300) {
       if (clientOptions.method == 'HEAD') {
         return {
           body: null,
           statusCode: response.statusCode,
+          retryCount: response.retryCount,
           headers: getHeaders(response.headers)
         };
       }
-
       return {
         body: response.data,
         statusCode: response.statusCode,
+        retryCount: response.retryCount,
         headers: getHeaders(response.headers)
       };
     }
+    const error = createError({
+      message: (response === null || response === void 0 ? void 0 : (_response$data = response.data) === null || _response$data === void 0 ? void 0 : _response$data.message) || (response === null || response === void 0 ? void 0 : response.message),
+      statusCode: response.statusCode || (response === null || response === void 0 ? void 0 : (_response$data2 = response.data) === null || _response$data2 === void 0 ? void 0 : _response$data2.statusCode),
+      headers: getHeaders(response.headers),
+      method: clientOptions.method,
+      body: response.data,
+      retryCount: response.retryCount,
+      ...(includeRequestInErrorResponse ? {
+        originalRequest: maskSensitiveHeaderData ? maskAuthData(request) : request
+      } : {
+        uri: request.uri
+      })
+    });
+
     /**
      * handle non-ok (error) response
      * build error body
      */
-
-
     return {
       body: response.data,
       code: response.statusCode,
       statusCode: response.statusCode,
       headers: getHeaders(response.headers),
-      error: {
-        statusCode: response.statusCode || response.data.statusCode,
-        message: response.data.message,
-        method: clientOptions.method,
-        ...response.data
-      }
+      error
     };
-  } catch (error) {
+  } catch (e) {
+    var _e$response, _e$response2, _e$response3, _e$response4, _e$response4$data, _e$response5, _e$response6;
+    // We know that this is a network error
+    const headers = getHeaders((_e$response = e.response) === null || _e$response === void 0 ? void 0 : _e$response.headers);
+    const statusCode = ((_e$response2 = e.response) === null || _e$response2 === void 0 ? void 0 : _e$response2.status) || ((_e$response3 = e.response) === null || _e$response3 === void 0 ? void 0 : _e$response3.data0) || 0;
+    const message = (_e$response4 = e.response) === null || _e$response4 === void 0 ? void 0 : (_e$response4$data = _e$response4.data) === null || _e$response4$data === void 0 ? void 0 : _e$response4$data.message;
+    const error = createError({
+      statusCode,
+      code: statusCode,
+      status: statusCode,
+      message: message || e.message,
+      headers,
+      body: ((_e$response5 = e.response) === null || _e$response5 === void 0 ? void 0 : _e$response5.data) || e,
+      error: (_e$response6 = e.response) === null || _e$response6 === void 0 ? void 0 : _e$response6.data,
+      ...(includeRequestInErrorResponse ? {
+        originalRequest: maskSensitiveHeaderData ? maskAuthData(request) : request
+      } : {
+        uri: request.uri
+      })
+    });
     return {
-      // We know that this is a network error
       body: error,
       error
     };
@@ -515,7 +693,6 @@ async function executeRequest$1({
     clearTimeout(timer);
   }
 }
-
 function createHttpMiddleware$1(options) {
   // validate response
   validateHttpOptions(options);
@@ -524,58 +701,72 @@ function createHttpMiddleware$1(options) {
     credentialsMode,
     httpClient,
     timeout,
+    enableRetry,
+    retryConfig,
     getAbortController,
+    includeOriginalRequest,
+    includeRequestInErrorResponse,
+    maskSensitiveHeaderData,
     httpClientOptions
   } = options;
   return next => {
     return async request => {
       let abortController;
-      if (timeout || getAbortController) abortController = (getAbortController ? getAbortController() : null) || new AbortController();
+      if (timeout || getAbortController) abortController = (getAbortController ? getAbortController() : null) || new AbortController__default["default"]();
       const url = host.replace(/\/$/, '') + request.uri;
-      const requestHeader = { ...request.headers
-      }; // validate header
+      const requestHeader = {
+        ...request.headers
+      };
 
-      if (!(requestHeader['Content-Type'] || requestHeader['content-type'])) {
+      // validate header
+      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|graphql}
+      }
 
+      // Unset the content-type header if explicitly asked to (passing `null` as value).
+      if (requestHeader['Content-Type'] === null) {
+        delete requestHeader['Content-Type'];
+      }
 
+      // Ensure body is a string if content type is application/{json|graphql}
       const body = HEADERS_CONTENT_TYPES.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 clientOptions = {
+        enableRetry,
+        retryConfig,
+        request: request,
         method: request.method,
         headers: requestHeader,
+        includeRequestInErrorResponse,
+        maskSensitiveHeaderData,
         ...httpClientOptions
       };
-
       if (credentialsMode) {
-        clientOptions.credentialsMode = clientOptions.credentialsMode;
+        clientOptions.credentialsMode = credentialsMode;
       }
-
       if (abortController) {
         clientOptions.signal = abortController.signal;
       }
-
       if (timeout) {
         clientOptions.timeout = timeout;
         clientOptions.abortController = abortController;
       }
-
       if (body) {
         clientOptions.body = body;
-      } // get result from executed request
-
+      }
 
+      // get result from executed request
       const response = await executeRequest$1({
         url,
         clientOptions,
         httpClient
       });
-      const responseWithRequest = { ...request,
+      const responseWithRequest = {
+        ...request,
+        includeOriginalRequest,
+        maskSensitiveHeaderData,
         response
       };
       return next(responseWithRequest);
@@ -588,43 +779,37 @@ function createQueueMiddleware$1({
 }) {
   let runningCount = 0;
   const queue = [];
-
   const dequeue = next => {
     runningCount--;
-
     if (queue.length && runningCount <= concurrency) {
       const nextTask = queue.shift();
       runningCount++;
       return next(nextTask.request);
     }
   };
-
   const enqueue = ({
     request
   }) => queue.push({
     request
   });
-
   return next => request => {
     // wrap and override resolve and reject functions
-    const patchedRequest = { ...request,
-
+    const patchedRequest = {
+      ...request,
       resolve(data) {
         request.resolve(data);
         dequeue(next);
       },
-
       reject(error) {
         request.reject(error);
         dequeue(next);
       }
+    };
 
-    }; // enqueue requests
-
+    // enqueue requests
     enqueue({
       request: patchedRequest
     });
-
     if (runningCount < concurrency) {
       runningCount++;
       const nextTask = queue.shift();
@@ -633,66 +818,7 @@ function createQueueMiddleware$1({
   };
 }
 
-function predicate(retryCodes, response) {
-  return !(retryCodes.includes(response?.error?.message) || [503, ...retryCodes].includes(response?.statusCode));
-} // error, info, warn
-
-
-function createRetryMiddleware$1(options) {
-  return next => async request => {
-    const {
-      retryCodes = [],
-      maxDelay = Infinity,
-      maxRetries = 3,
-      backoff = true,
-      retryDelay = 200
-    } = options || {};
-    let response,
-        retryCount = 0; // validate the `retryCodes` option
-
-    validateRetryCodes(retryCodes);
-
-    async function executeRequest() {
-      // first attenpt
-      response = await next(request);
-      retryCount++;
-
-      if (predicate(retryCodes, response)) {
-        return { ...response
-        };
-      }
-
-      while (retryCount < maxRetries) {
-        // check if the response if worth retrying for subsequest calls
-        response = await next(request);
-        retryCount++;
-
-        if (predicate(retryCodes, response)) {
-          return { ...response
-          };
-        } // delay next execution
-
-
-        const timer = calculateRetryDelay({
-          retryCount,
-          retryDelay,
-          maxRetries,
-          backoff,
-          maxDelay
-        });
-        await sleep(timer);
-      }
-
-      return { ...response,
-        retryCount
-      };
-    } // invoke executeRequest
-
-
-    return executeRequest();
-  };
-}
-
+// error, info, success
 function createLoggerMiddleware$1(options) {
   return next => {
     return async request => {
@@ -703,14 +829,12 @@ function createLoggerMiddleware$1(options) {
         // logLevel = 'ERROR',
         maskSensitiveHeaderData = true,
         includeOriginalRequest = true,
-        includeResponseHeaders = true // includeRequestInErrorResponse
-
+        includeResponseHeaders = true
+        // includeRequestInErrorResponse
       } = options || {};
-
       if (includeOriginalRequest && maskSensitiveHeaderData) {
         maskAuthData(response.request);
       }
-
       if (!includeOriginalRequest) {
         const {
           request,
@@ -718,7 +842,6 @@ function createLoggerMiddleware$1(options) {
         } = response;
         response = rest;
       }
-
       if (!includeResponseHeaders) {
         const {
           headers,
@@ -726,13 +849,12 @@ function createLoggerMiddleware$1(options) {
         } = response;
         response = rest;
       }
-
       if (loggerFn && typeof loggerFn == 'function') {
         loggerFn(response);
-        return originalResponse;
-      } // console.log({ Response: response })
-
+        // return originalResponse
+      }
 
+      // console.log({ Response: response })
       return originalResponse;
     };
   };
@@ -740,7 +862,7 @@ function createLoggerMiddleware$1(options) {
 
 var packageJson = {
 	name: "@commercetools/ts-client",
-	version: "0.0.0-beta.7",
+	version: "1.0.0",
 	engines: {
 		node: ">=14"
 	},
@@ -773,6 +895,7 @@ var packageJson = {
 		url: "https://github.com/commercetools/commercetools-sdk-typescript/issues"
 	},
 	dependencies: {
+		"abort-controller": "3.0.0",
 		buffer: "^6.0.3",
 		"node-fetch": "^2.6.1",
 		querystring: "^0.2.1"
@@ -789,10 +912,9 @@ var packageJson = {
 		"./dist/commercetools-ts-client.esm.js": "./dist/commercetools-ts-client.browser.esm.js"
 	},
 	devDependencies: {
-		"abort-controller": "3.0.0",
 		"common-tags": "1.8.2",
-		dotenv: "16.0.2",
-		jest: "29.0.3",
+		dotenv: "16.0.3",
+		jest: "29.5.0",
 		nock: "12.0.3",
 		"organize-imports-cli": "0.10.0"
 	},
@@ -805,11 +927,14 @@ var packageJson = {
 
 function createUserAgentMiddleware$1(options) {
   return next => async request => {
-    const userAgent = createUserAgent({ ...options,
-      name: `commercetools-sdk-javascript-v2/${packageJson.version}`
+    const userAgent = createUserAgent({
+      ...options,
+      name: `commercetools-sdk-javascript-v3/${packageJson.version}`
     });
-    const requestWithUserAgent = { ...request,
-      headers: { ...request.headers,
+    const requestWithUserAgent = {
+      ...request,
+      headers: {
+        ...request.headers,
         'User-Agent': userAgent
       }
     };
@@ -821,23 +946,27 @@ function createConcurrentModificationMiddleware$1() {
   return next => {
     return async request => {
       const response = await next(request);
-
       if (response.statusCode == 409) {
+        var _response$error, _response$error$body, _response$error$body$, _response$error$body$2;
         /**
          * extract the currentVersion
          * from the error body and update
          * request with the currentVersion
          */
-        const version = response.error.body.errors[0].currentVersion; // update the resource version here
-
-        request.body = typeof request.body == 'string' ? { ...JSON.parse(request.body),
-          version
-        } : { ...request.body,
-          version
-        };
-        return next(request);
+        const version = (_response$error = response.error) === null || _response$error === void 0 ? void 0 : (_response$error$body = _response$error.body) === null || _response$error$body === void 0 ? void 0 : (_response$error$body$ = _response$error$body.errors) === null || _response$error$body$ === void 0 ? void 0 : (_response$error$body$2 = _response$error$body$[0]) === null || _response$error$body$2 === void 0 ? void 0 : _response$error$body$2.currentVersion;
+
+        // update the resource version here
+        if (version) {
+          request.body = typeof request.body == 'string' ? {
+            ...JSON.parse(request.body),
+            version
+          } : {
+            ...request.body,
+            version
+          };
+          return next(request);
+        }
       }
-
       return response;
     };
   };
@@ -846,20 +975,20 @@ function createConcurrentModificationMiddleware$1() {
 function createErrorMiddleware$1(options) {
   return next => async request => {
     const response = await next(request);
-
     if (response.error) {
       const {
         error
       } = response;
-      return { ...response,
+      return {
+        ...response,
         statusCode: error.statusCode || 0,
         headers: error.headers || getHeaders({}),
-        error: { ...error,
+        error: {
+          ...error,
           body: error.data || error
         }
       };
     }
-
     return response;
   };
 }
@@ -869,7 +998,6 @@ function createErrorMiddleware$1(options) {
  * @param {AuthMiddlewareOptions} options
  * @returns { IBuiltRequestParams } *
  */
-
 function buildRequestForClientCredentialsFlow(options) {
   // Validate options
   if (!options) throw new Error('Missing required options');
@@ -882,9 +1010,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.from(`${clientId}:${clientSecret}`).toString('base64'); // This is mostly useful for internal testing purposes to be able to check
+  const basicAuth = _.Buffer.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}` : ''}`;
@@ -894,12 +1022,12 @@ function buildRequestForClientCredentialsFlow(options) {
     basicAuth
   };
 }
+
 /**
  *
  * @param {AuthMiddlewareOptions} options
  * @returns {IBuiltRequestParams} *
  */
-
 function buildRequestForAnonymousSessionFlow(options) {
   if (!options) throw new Error('Missing required options');
   if (!options.projectKey) throw new Error('Missing required option (projectKey)');
@@ -907,15 +1035,16 @@ function buildRequestForAnonymousSessionFlow(options) {
   options.oauthUri = options.oauthUri || `/oauth/${projectKey}/anonymous/token`;
   const result = buildRequestForClientCredentialsFlow(options);
   if (options.credentials.anonymousId) result.body += `&anonymous_id=${options.credentials.anonymousId}`;
-  return { ...result
+  return {
+    ...result
   };
 }
+
 /**
  *
  * @param {RefreshAuthMiddlewareOptions} options
  * @returns {IBuiltRequestParams}
  */
-
 function buildRequestForRefreshTokenFlow(options) {
   if (!options) throw new Error('Missing required options');
   if (!options.host) throw new Error('Missing required option (host)');
@@ -927,9 +1056,9 @@ function buildRequestForRefreshTokenFlow(options) {
     clientSecret
   } = options.credentials;
   if (!(clientId && clientSecret)) throw new Error('Missing required credentials (clientId, clientSecret)');
-  const basicAuth = _.Buffer.from(`${clientId}:${clientSecret}`).toString('base64'); // This is mostly useful for internal testing purposes to be able to check
+  const basicAuth = _.Buffer.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)}`;
@@ -939,11 +1068,11 @@ function buildRequestForRefreshTokenFlow(options) {
     body
   };
 }
+
 /**
  * @param {PasswordAuthMiddlewareOptions} options
  * @returns {IBuiltRequestParams}
  */
-
 function buildRequestForPasswordFlow(options) {
   if (!options) throw new Error('Missing required options');
   if (!options.host) throw new Error('Missing required option (host)');
@@ -964,14 +1093,15 @@ function buildRequestForPasswordFlow(options) {
   const scope = (options.scopes || []).join(' ');
   const scopeStr = scope ? `&scope=${scope}` : '';
   const basicAuth = _.Buffer.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/${projectKey}/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,
@@ -992,58 +1122,62 @@ async function executeRequest(options) {
   } = options;
   let url = options.url;
   let body = options.body;
-  let basicAuth = options.basicAuth; // get the pending object from option
+  let basicAuth = options.basicAuth;
 
+  // get the pending object from option
   let pendingTasks = options.pendingTasks;
   if (!httpClient || typeof httpClient !== 'function') throw new Error('an `httpClient` is not available, please pass in a `fetch` or `axios` instance as an option or have them globally available.');
+
   /**
    * If there is a token in the tokenCache, and it's not
    * expired, append the token in the `Authorization` header.
    */
-
   const tokenCacheObject = tokenCache.get(tokenCacheKey);
-
   if (tokenCacheObject && tokenCacheObject.token && Date.now() < tokenCacheObject.expirationTime) {
     const requestWithAuth = mergeAuthHeader(tokenCacheObject.token, request);
-    return { ...requestWithAuth
+    return {
+      ...requestWithAuth
     };
   }
+
   /**
    * 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,
     next
-  }); // if a token is currently being fetched, then wait
+  });
 
-  if (requestState.get()) return; // signal that a token is being fetched
+  // if a token is currently being fetched, then wait
+  if (requestState.get()) return;
 
+  // signal that a token is being fetched
   requestState.set(true);
+
   /**
    * use refreshToken flow if there is refresh-token
    * and there's either no token or the token is expired
    */
-
   if (tokenCacheObject && tokenCacheObject.refreshToken && (!tokenCacheObject.token || tokenCacheObject.token && Date.now() > tokenCacheObject.expirationTime)) {
     if (!userOption) throw new Error('Missing required options.');
-    const opt = { ...buildRequestForRefreshTokenFlow({ ...userOption,
+    const opt = {
+      ...buildRequestForRefreshTokenFlow({
+        ...userOption,
         refreshToken: tokenCacheObject.refreshToken
       })
-    }; // reassign values
+    };
 
+    // reassign values
     url = opt.url;
     body = opt.body;
     basicAuth = opt.basicAuth;
-  } // request a new token
-
+  }
 
+  // request a new token
   let response;
-
   try {
     response = await executor({
       url,
@@ -1055,58 +1189,59 @@ async function executeRequest(options) {
       },
       httpClient,
       body
-    }); // if (response.statusCode  < 400) {
-
+    });
     if (response.statusCode >= 200 && response.statusCode < 300) {
+      var _response;
       const {
         access_token: token,
         expires_in: expiresIn,
-        // expires_at: expiresAt,
         refresh_token: refreshToken
-      } = response?.data; // calculate token expiration time
+      } = (_response = response) === null || _response === void 0 ? void 0 : _response.data;
 
-      const expirationTime = calculateExpirationTime(expiresIn); // cache new generated token, refreshToken and expiration time
+      // calculate token expiration time
+      const expirationTime = calculateExpirationTime(expiresIn);
 
+      // cache new generated token, refreshToken and expiration time
       tokenCache.set({
         token,
         expirationTime,
         refreshToken
-      }); // signal that a token fetch is complete
+      });
 
+      // signal that a token fetch is complete
       requestState.set(false);
+
       /**
        * Freeze and copy pending queue, reset
        * original one for accepting new pending tasks
        */
+      const requestQueue = pendingTasks.slice();
 
-      const requestQueue = pendingTasks.slice(); // const lastTask = requestQueue.pop()
       // reset pendingTask queue
-
       pendingTasks = [];
-
       if (requestQueue.length === 1) {
         return mergeAuthHeader(token, requestQueue.pop().request);
-      } // execute all pending tasks if any
-
+      }
 
+      // execute all pending tasks if any
       for (let i = 0; i < requestQueue.length; i++) {
         const task = requestQueue[i];
-        const requestWithAuth = mergeAuthHeader(token, task.request); // execute task
+        const requestWithAuth = mergeAuthHeader(token, task.request);
 
+        // execute task
         task.next(requestWithAuth);
       }
-
       return;
     }
-
     const error = new Error(response.data.message ? response.data.message : JSON.stringify(response.data));
     /**
      * reject the error immediately
      * and free up the middleware chain
      */
-
-    request.reject({ ...request,
-      headers: { ...request.headers
+    request.reject({
+      ...request,
+      headers: {
+        ...request.headers
       },
       response: {
         statusCode: response.statusCode || response.data.statusCode,
@@ -1117,13 +1252,16 @@ async function executeRequest(options) {
       }
     });
   } catch (error) {
-    return { ...request,
-      headers: { ...request.headers
+    return {
+      ...request,
+      headers: {
+        ...request.headers
       },
       response: {
         body: null,
         statusCode: error.statusCode || 0,
-        error: { ...response,
+        error: {
+          ...response,
           error,
           body: response
         }
@@ -1145,7 +1283,6 @@ function createAuthMiddlewareForPasswordFlow$1(options) {
       if (request.headers && (request.headers.Authorization || request.headers.authorization)) {
         return next(request);
       }
-
       const requestOptions = {
         request,
         requestState,
@@ -1156,10 +1293,10 @@ function createAuthMiddlewareForPasswordFlow$1(options) {
         ...buildRequestForPasswordFlow(options),
         userOption: options,
         next
-      }; // make request to coco
+      };
 
+      // make request to coco
       const requestWithAuth = await executeRequest(requestOptions);
-
       if (requestWithAuth) {
         return next(requestWithAuth);
       }
@@ -1181,9 +1318,9 @@ function createAuthMiddlewareForAnonymousSessionFlow$1(options) {
       if (request.headers && (request.headers.Authorization || request.headers.authorization)) {
         // move on
         return next(request);
-      } // prepare request options
-
+      }
 
+      // prepare request options
       const requestOptions = {
         request,
         requestState,
@@ -1194,10 +1331,10 @@ function createAuthMiddlewareForAnonymousSessionFlow$1(options) {
         ...buildRequestForAnonymousSessionFlow(options),
         userOption: options,
         next
-      }; // make request to coco
+      };
 
+      // make request to coco
       const requestWithAuth = await executeRequest(requestOptions);
-
       if (requestWithAuth) {
         return next(requestWithAuth);
       }
@@ -1219,9 +1356,9 @@ function createAuthMiddlewareForClientCredentialsFlow$1(options) {
       if (request.headers && (request.headers.Authorization || request.headers.authorization)) {
         // move on
         return next(request);
-      } // prepare request options
-
+      }
 
+      // prepare request options
       const requestOptions = {
         request,
         requestState,
@@ -1231,10 +1368,10 @@ function createAuthMiddlewareForClientCredentialsFlow$1(options) {
         httpClient: options.httpClient || fetch__default["default"],
         ...buildRequestForClientCredentialsFlow(options),
         next
-      }; // make request to coco
+      };
 
+      // make request to coco
       const requestWithAuth = await executeRequest(requestOptions);
-
       if (requestWithAuth) {
         // make the request and inject the token into the header
         return next(requestWithAuth);
@@ -1254,9 +1391,9 @@ function createAuthMiddlewareForRefreshTokenFlow$1(options) {
     return async request => {
       if (request.headers && (request.headers.Authorization || request.headers.authorization)) {
         return next(request);
-      } // prepare request options
-
+      }
 
+      // prepare request options
       const requestOptions = {
         request,
         requestState,
@@ -1265,10 +1402,10 @@ function createAuthMiddlewareForRefreshTokenFlow$1(options) {
         httpClient: options.httpClient || fetch,
         ...buildRequestForRefreshTokenFlow(options),
         next
-      }; // make request to coco
+      };
 
+      // make request to coco
       const requestWithAuth = await executeRequest(requestOptions);
-
       if (requestWithAuth) {
         return next(requestWithAuth);
       }
@@ -1280,19 +1417,20 @@ function createAuthMiddlewareForExistingTokenFlow$1(authorization, options) {
   return next => {
     return async request => {
       if (typeof authorization !== 'string') throw new Error('authorization must be a string');
-      const force = options?.force === undefined ? true : options.force;
+      const isForce = (options === null || options === void 0 ? void 0 : 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.authorization) && force === false) {
+      if (!authorization || request.headers && (request.headers.Authorization || request.headers.authorization) && isForce === false) {
         return next(request);
       }
-
-      const requestWithAuth = { ...request,
-        headers: { ...request.headers,
+      const requestWithAuth = {
+        ...request,
+        headers: {
+          ...request.headers,
           Authorization: authorization
         }
       };
@@ -1306,7 +1444,6 @@ var middleware = /*#__PURE__*/Object.freeze({
   createCorrelationIdMiddleware: createCorrelationIdMiddleware$1,
   createHttpMiddleware: createHttpMiddleware$1,
   createQueueMiddleware: createQueueMiddleware$1,
-  createRetryMiddleware: createRetryMiddleware$1,
   createLoggerMiddleware: createLoggerMiddleware$1,
   createUserAgentMiddleware: createUserAgentMiddleware$1,
   createConcurrentModificationMiddleware: createConcurrentModificationMiddleware$1,
@@ -1325,7 +1462,6 @@ const {
   createAuthMiddlewareForRefreshTokenFlow,
   createAuthMiddlewareForExistingTokenFlow,
   createCorrelationIdMiddleware,
-  createRetryMiddleware,
   createHttpMiddleware,
   createLoggerMiddleware,
   createQueueMiddleware,
@@ -1336,35 +1472,21 @@ 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, "retryMiddleware", void 0);
-
     _defineProperty(this, "concurrentMiddleware", void 0);
-
     _defineProperty(this, "errorMiddleware", void 0);
-
     _defineProperty(this, "middlewares", []);
-
     this.userAgentMiddleware = createUserAgentMiddleware({});
   }
-
   withProjectKey(key) {
     this.projectKey = key;
     return this;
   }
-
   defaultClient(baseUri, credentials, oauthUri, projectKey, scopes, httpClient) {
     return this.withClientCredentialsFlow({
       host: oauthUri,
@@ -1376,17 +1498,14 @@ class ClientBuilder {
       httpClient: httpClient || fetch__default["default"]
     });
   }
-
   withAuthMiddleware(authMiddleware) {
     this.authMiddleware = authMiddleware;
     return this;
   }
-
   withMiddleware(middleware) {
     this.middlewares.push(middleware);
     return this;
   }
-
   withClientCredentialsFlow(options) {
     return this.withAuthMiddleware(createAuthMiddlewareForClientCredentialsFlow({
       host: options.host || CTP_AUTH_URL,
@@ -1401,7 +1520,6 @@ class ClientBuilder {
       ...options
     }));
   }
-
   withPasswordFlow(options) {
     return this.withAuthMiddleware(createAuthMiddlewareForPasswordFlow({
       host: options.host || CTP_AUTH_URL,
@@ -1418,7 +1536,6 @@ class ClientBuilder {
       ...options
     }));
   }
-
   withAnonymousSessionFlow(options) {
     return this.withAuthMiddleware(createAuthMiddlewareForAnonymousSessionFlow({
       host: options.host || CTP_AUTH_URL,
@@ -1432,7 +1549,6 @@ class ClientBuilder {
       ...options
     }));
   }
-
   withRefreshTokenFlow(options) {
     return this.withAuthMiddleware(createAuthMiddlewareForRefreshTokenFlow({
       host: options.host || CTP_AUTH_URL,
@@ -1446,20 +1562,12 @@ class ClientBuilder {
       ...options
     }));
   }
-
-  withRetryMiddleware(options) {
-    this.retryMiddleware = createRetryMiddleware({ ...options
-    });
-    return this;
-  }
-
   withExistingTokenFlow(authorization, options) {
     return this.withAuthMiddleware(createAuthMiddlewareForExistingTokenFlow(authorization, {
       force: options.force || true,
       ...options
     }));
   }
-
   withHttpMiddleware(options) {
     this.httpMiddleware = createHttpMiddleware({
       host: options.host || CTP_API_URL,
@@ -1468,12 +1576,10 @@ class ClientBuilder {
     });
     return this;
   }
-
   withUserAgentMiddleware(options) {
     this.userAgentMiddleware = createUserAgentMiddleware(options);
     return this;
   }
-
   withQueueMiddleware(options) {
     this.queueMiddleware = createQueueMiddleware({
       concurrency: options.concurrency || CONCURRENCT_REQUEST,
@@ -1481,54 +1587,45 @@ class ClientBuilder {
     });
     return this;
   }
-
   withLoggerMiddleware(options) {
     this.loggerMiddleware = createLoggerMiddleware(options);
     return this;
   }
-
   withCorrelationIdMiddleware(options) {
     this.correlationIdMiddleware = createCorrelationIdMiddleware({
-      generate: options?.generate,
+      generate: options === null || options === void 0 ? void 0 : options.generate,
       ...options
     });
     return this;
   }
-
   withConcurrentModificationMiddleware() {
     this.concurrentMiddleware = createConcurrentModificationMiddleware();
     return this;
   }
-
   withErrorMiddleware(options) {
     this.errorMiddleware = createErrorMiddleware(options);
     return this;
-  } // builder
-
-
+  }
   build() {
     const middlewares = this.middlewares.slice();
+
     /**
      * - use default retry policy if not explicity added
      * - add retry middleware to be used by concurrent modification
      *   middleware if not explicitly added as part of the middleware
      */
-
-    if (!this.retryMiddleware && this.concurrentMiddleware) this.withRetryMiddleware({});
     if (this.correlationIdMiddleware) middlewares.push(this.correlationIdMiddleware);
     if (this.userAgentMiddleware) middlewares.push(this.userAgentMiddleware);
     if (this.authMiddleware) middlewares.push(this.authMiddleware);
     if (this.queueMiddleware) middlewares.push(this.queueMiddleware);
     if (this.loggerMiddleware) middlewares.push(this.loggerMiddleware);
     if (this.errorMiddleware) middlewares.push(this.errorMiddleware);
-    if (this.retryMiddleware) middlewares.push(this.retryMiddleware);
     if (this.concurrentMiddleware) middlewares.push(this.concurrentMiddleware);
     if (this.httpMiddleware) middlewares.push(this.httpMiddleware);
     return createClient({
       middlewares
     });
   }
-
 }
 
 exports.ClientBuilder = ClientBuilder;