@commercetools/ts-client 2.1.0-alpha.0 → 2.1.0

package/dist/commercetools-ts-client.browser.esm.js

@@ -1,9 +1,7 @@
 import fetch$1 from 'node-fetch';
-import { v4 } from 'uuid';
-import { Buffer } from 'buffer/';
 import AbortController from 'abort-controller';
 
-function toPrimitive(t, r) {
+function _toPrimitive(t, r) {
   if ("object" != typeof t || !t) return t;
   var e = t[Symbol.toPrimitive];
   if (void 0 !== e) {
@@ -14,24 +12,18 @@ function toPrimitive(t, r) {
   return ("string" === r ? String : Number)(t);
 }
 
-function toPropertyKey(t) {
-  var i = toPrimitive(t, "string");
+function _toPropertyKey(t) {
+  var i = _toPrimitive(t, "string");
   return "symbol" == typeof i ? i : i + "";
 }
 
-function _defineProperty(obj, key, value) {
-  key = toPropertyKey(key);
-  if (key in obj) {
-    Object.defineProperty(obj, key, {
-      value: value,
-      enumerable: true,
-      configurable: true,
-      writable: true
-    });
-  } else {
-    obj[key] = value;
-  }
-  return obj;
+function _defineProperty(e, r, t) {
+  return (r = _toPropertyKey(r)) in e ? Object.defineProperty(e, r, {
+    value: t,
+    enumerable: !0,
+    configurable: !0,
+    writable: !0
+  }) : e[r] = t, e;
 }
 
 const HEADERS_CONTENT_TYPES = ['application/json', 'application/graphql'];
@@ -183,10 +175,12 @@ async function executor(request) {
         let _response = {};
         try {
           _response = await execute();
-          if (_response.status > 399 && hasResponseRetryCode(retryCodes, _response)) return {
-            _response,
-            shouldRetry: true
-          };
+          if (_response.status > 399 && hasResponseRetryCode(retryCodes, _response)) {
+            return {
+              _response,
+              shouldRetry: true
+            };
+          }
         } catch (e) {
           if (e.name.includes('AbortError') && retryWhenAborted) {
             return {
@@ -231,7 +225,7 @@ async function executor(request) {
     try {
       // try to parse the `fetch` response as text
       if (response.text && typeof response.text == 'function') {
-        result = await response.text();
+        result = (await response.text()) || response[Object.getOwnPropertySymbols(response)[1]];
         data = JSON.parse(result);
       } else {
         // axios response
@@ -257,7 +251,8 @@ async function executor(request) {
 }
 
 function generateID() {
-  return v4();
+  // @ts-ignore
+  return ([1e6] + -1e3 + -4e3 + -8e3 + -1e11).replace(/[018]/g, c => (parseInt(c) ^ Math.floor(Math.random() * 256) & 15 >> parseInt(c) / 4).toString(16));
 }
 
 function parse(headers) {
@@ -446,16 +441,11 @@ function createUserAgent(options) {
   return [baseInfo, systemInfo, libraryInfo, contactInfo, customAgent].filter(Boolean).join(' ');
 }
 
-function responseCache() {
-  let val;
-  return {
-    set(response) {
-      val = response;
-    },
-    get() {
-      return val;
-    }
-  };
+function byteLength(body) {
+  if (typeof body === 'string') return body.length.toString();
+  if (body && typeof body === 'object') return new TextEncoder().encode(JSON.stringify(body)).length.toString();
+  if (body instanceof Uint8Array) return body.length.toString();
+  return '0';
 }
 
 /**
@@ -518,7 +508,8 @@ 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');
+  const basicAuth = btoa(`${clientId}:${clientSecret}`);
+
   // This is mostly useful for internal testing purposes to be able to check
   // other oauth endpoints.
   const oauthUri = options.oauthUri || '/oauth/token';
@@ -564,9 +555,10 @@ 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
-  // other oauth endpoints.
+  const basicAuth = btoa(`${clientId}:${clientSecret}`);
+
+  // 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)}`;
@@ -600,7 +592,7 @@ function buildRequestForPasswordFlow(options) {
   if (!(username && password)) throw new Error('Missing required user credentials (username, password)');
   const scope = (options.scopes || []).join(' ');
   const scopeStr = scope ? `&scope=${scope}` : '';
-  const basicAuth = Buffer.from(`${clientId}:${clientSecret}`).toString('base64');
+  const basicAuth = btoa(`${clientId}:${clientSecret}`);
 
   /**
    * This is mostly useful for internal testing purposes to be able to check
@@ -620,48 +612,16 @@ function buildRequestForPasswordFlow(options) {
 
 async function executeRequest$1(options) {
   const {
-    request,
     httpClient,
     tokenCache,
-    tokenCacheKey,
     userOption,
-    tokenCacheObject,
-    next
+    tokenCacheObject
   } = options;
   let url = options.url;
   let body = options.body;
   let basicAuth = options.basicAuth;
-
-  // get the pending object from option
-  // let pendingTasks: Array<Task> = 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
-  // ) {
-  //   return next(
-  //     mergeAuthHeader(
-  //       tokenCacheObject.token, request
-  //     )
-  //   );
-  // }
-
-  /**
-   * 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 })
-
   /**
    * use refreshToken flow if there is refresh-token
    * and there's either no token or the token is expired
@@ -692,7 +652,7 @@ async function executeRequest$1(options) {
       headers: {
         Authorization: `Basic ${basicAuth}`,
         'Content-Type': 'application/x-www-form-urlencoded',
-        'Content-Length': Buffer.byteLength(body).toString()
+        'Content-Length': byteLength(body)
       },
       httpClient,
       body
@@ -713,74 +673,23 @@ async function executeRequest$1(options) {
         expirationTime,
         refreshToken
       });
-
-      /**
-       * Freeze and copy pending queue, reset
-       * original one for accepting new pending tasks
-       */
-      // const requestQueue = pendingTasks.slice()
-
-      // // reset pendingTask queue
-      // pendingTasks = []
-
-      // if (requestQueue.length === 1) {
-      //   return mergeAuthHeader(token, requestQueue.pop().request)
-      // }
-
-      // // execute all pending tasks if any
-      // for (let i = 0; i < pendingTasks.length; i++) {
-      //   const task: Task = pendingTasks[i];
-      //   const requestWithAuth = mergeAuthHeader(token, task.request)
-
-      //   // execute task
-      //   // task.next(requestWithAuth)
-
-      //   pendingTasks[i].request = requestWithAuth;
-      // }
-
-      // return pendingTasks;
       return Promise.resolve(true);
     }
-    const error = new Error(response.data.message ? response.data.message : JSON.stringify(response.data));
-    /**
-     * reject the error immediately
-     * and free up the middleware chain
-     */
-    return request.reject({
-      ...request,
-      headers: {
-        ...request.headers
-      },
-      response: {
-        statusCode: response.statusCode || response.data.statusCode,
-        error: {
-          error,
-          body: response
-        }
-      }
+
+    // bubble up the error for the catch block
+    throw createError({
+      code: response.data.error,
+      statusCode: response.data.statusCode,
+      message: response.data.message,
+      error: response.data.errors
     });
   } catch (error) {
-    request.reject({
-      ...request,
-      headers: {
-        ...request.headers
-      },
-      response: {
-        body: null,
-        statusCode: error.statusCode || 0,
-        error: {
-          ...response,
-          error,
-          body: response
-        }
-      }
-    });
+    // throw error and free up the middleware chain
+    throw error;
   }
 }
 
 function createAuthMiddlewareForAnonymousSessionFlow$1(options) {
-  // const pendingTasks: Array<Task> = []
-  // const requestState = new Mutex()
   const tokenCache = options.tokenCache || store({
     token: '',
     expirationTime: -1
@@ -795,6 +704,11 @@ function createAuthMiddlewareForAnonymousSessionFlow$1(options) {
         // move on
         return next(request);
       }
+
+      /**
+       * If there is a token in the tokenCache, and it's not
+       * expired, append the token in the `Authorization` header.
+       */
       tokenCacheObject = tokenCache.get(tokenCacheKey);
       if (tokenCacheObject && tokenCacheObject.token && Date.now() < tokenCacheObject.expirationTime) {
         return next(mergeAuthHeader(tokenCacheObject.token, request));
@@ -802,8 +716,6 @@ function createAuthMiddlewareForAnonymousSessionFlow$1(options) {
 
       // prepare request options
       const requestOptions = {
-        // requestState,
-        // pendingTasks,
         request,
         tokenCache,
         tokenCacheKey,
@@ -823,18 +735,14 @@ function createAuthMiddlewareForAnonymousSessionFlow$1(options) {
         tokenFetchPromise = null;
       }
 
-      // Now the token is present in the tokenCache
+      // Now the token is present in the tokenCache and can be accessed
       tokenCacheObject = tokenCache.get(tokenCacheKey);
-      if (tokenCacheObject && tokenCacheObject.token && Date.now() < tokenCacheObject.expirationTime) {
-        return next(mergeAuthHeader(tokenCacheObject.token, request));
-      }
+      return next(mergeAuthHeader(tokenCacheObject.token, request));
     };
   };
 }
 
 function createAuthMiddlewareForClientCredentialsFlow$1(options) {
-  // const requestState = new Mutex()
-  // const pendingTasks: Array<Task> = []
   const tokenCache = options.tokenCache || store({
     token: '',
     expirationTime: -1
@@ -849,6 +757,11 @@ function createAuthMiddlewareForClientCredentialsFlow$1(options) {
         // move on
         return next(request);
       }
+
+      /**
+       * If there is a token in the tokenCache, and it's not
+       * expired, append the token in the `Authorization` header.
+       */
       tokenCacheObject = tokenCache.get(tokenCacheKey);
       if (tokenCacheObject && tokenCacheObject.token && Date.now() < tokenCacheObject.expirationTime) {
         return next(mergeAuthHeader(tokenCacheObject.token, request));
@@ -856,8 +769,6 @@ function createAuthMiddlewareForClientCredentialsFlow$1(options) {
 
       // prepare request options
       const requestOptions = {
-        // requestState,
-        // pendingTasks,
         request,
         tokenCache,
         tokenCacheKey,
@@ -879,9 +790,7 @@ function createAuthMiddlewareForClientCredentialsFlow$1(options) {
 
       // Now the token is present in the tokenCache
       tokenCacheObject = tokenCache.get(tokenCacheKey);
-      if (tokenCacheObject && tokenCacheObject.token && Date.now() < tokenCacheObject.expirationTime) {
-        return next(mergeAuthHeader(tokenCacheObject.token, request));
-      }
+      return next(mergeAuthHeader(tokenCacheObject.token, request));
     };
   };
 }
@@ -922,12 +831,20 @@ function createAuthMiddlewareForPasswordFlow$1(options) {
   const tokenCacheKey = buildTokenCacheKey(options);
   return next => {
     return async request => {
+      // if here is a token in the header, then move on to the next middleware
       if (request.headers && (request.headers.Authorization || request.headers.authorization)) {
         return next(request);
       }
+
+      /**
+       * If there is a token in the tokenCache, and it's not
+       * expired, append the token in the `Authorization` header.
+       */
+      tokenCacheObject = tokenCache.get(tokenCacheKey);
+      if (tokenCacheObject && tokenCacheObject.token && Date.now() < tokenCacheObject.expirationTime) {
+        return next(mergeAuthHeader(tokenCacheObject.token, request));
+      }
       const requestOptions = {
-        // requestState,
-        // pendingTasks,
         request,
         tokenCache,
         tokenCacheKey,
@@ -949,9 +866,7 @@ function createAuthMiddlewareForPasswordFlow$1(options) {
 
       // Now the token is present in the tokenCache
       tokenCacheObject = tokenCache.get(tokenCacheKey);
-      if (tokenCacheObject && tokenCacheObject.token && Date.now() < tokenCacheObject.expirationTime) {
-        return next(mergeAuthHeader(tokenCacheObject.token, request));
-      }
+      return next(mergeAuthHeader(tokenCacheObject.token, request));
     };
   };
 }
@@ -961,10 +876,6 @@ function createAuthMiddlewareForRefreshTokenFlow$1(options) {
     token: '',
     tokenCacheKey: null
   });
-
-  // const pendingTasks: Array<Task> = []
-  // const requestState = new Mutex()
-
   let tokenCacheObject;
   let tokenFetchPromise = null;
   const tokenCacheKey = buildTokenCacheKey(options);
@@ -974,10 +885,17 @@ function createAuthMiddlewareForRefreshTokenFlow$1(options) {
         return next(request);
       }
 
+      /**
+       * If there is a token in the tokenCache, and it's not
+       * expired, append the token in the `Authorization` header.
+       */
+      tokenCacheObject = tokenCache.get(tokenCacheKey);
+      if (tokenCacheObject && tokenCacheObject.token && Date.now() < tokenCacheObject.expirationTime) {
+        return next(mergeAuthHeader(tokenCacheObject.token, request));
+      }
+
       // prepare request options
       const requestOptions = {
-        // pendingTasks,
-        // requestState,
         request,
         tokenCache,
         httpClient: options.httpClient || fetch,
@@ -997,9 +915,7 @@ function createAuthMiddlewareForRefreshTokenFlow$1(options) {
 
       // Now the token is present in the tokenCache
       tokenCacheObject = tokenCache.get(tokenCacheKey);
-      if (tokenCacheObject && tokenCacheObject.token && Date.now() < tokenCacheObject.expirationTime) {
-        return next(mergeAuthHeader(tokenCacheObject.token, request));
-      }
+      return next(mergeAuthHeader(tokenCacheObject.token, request));
     };
   };
 }
@@ -1007,7 +923,6 @@ function createAuthMiddlewareForRefreshTokenFlow$1(options) {
 function createConcurrentModificationMiddleware$1(modifierFunction) {
   return next => {
     return async request => {
-      request['concurrent'] = true;
       const response = await next(request);
       if (response.statusCode == 409) {
         /**
@@ -1015,11 +930,11 @@ function createConcurrentModificationMiddleware$1(modifierFunction) {
          * from the error body and update
          * request with the currentVersion
          */
-        const version = response.error?.body?.errors?.[0]?.currentVersion;
+        const version = response.error.body?.errors?.[0]?.currentVersion;
 
         // update the resource version here
         if (version) {
-          if (modifierFunction) {
+          if (modifierFunction && typeof modifierFunction == 'function') {
             request.body = await modifierFunction(version, request, response);
           } else {
             request.body = typeof request.body == 'string' ? {
@@ -1030,18 +945,10 @@ function createConcurrentModificationMiddleware$1(modifierFunction) {
               version
             };
           }
-          return next({
-            ...request,
-            response
-          });
+          return next(request);
         }
       }
-      request.continue = true;
-      delete request['concurrent'];
-      return next({
-        ...request,
-        response
-      });
+      return response;
     };
   };
 }
@@ -1080,20 +987,12 @@ function createErrorMiddleware(options) {
   };
 }
 
-let result;
-const cache = responseCache();
 async function executeRequest({
   url,
   httpClient,
   clientOptions
 }) {
   let timer;
-
-  // don't make further api calls
-  if (clientOptions.request['continue']) {
-    delete clientOptions.request['continue'];
-    return cache.get();
-  }
   const {
     timeout,
     request,
@@ -1120,22 +1019,19 @@ async function executeRequest({
     }
     if (response.statusCode >= 200 && response.statusCode < 300) {
       if (clientOptions.method == 'HEAD') {
-        const _result = {
+        return {
           body: null,
           statusCode: response.statusCode,
           retryCount: response.retryCount,
           headers: getHeaders(response.headers)
         };
-        cache.set(_result);
-        return _result;
       }
-      result = {
+      return {
         body: response.data,
         statusCode: response.statusCode,
         retryCount: response.retryCount,
         headers: getHeaders(response.headers)
       };
-      return result;
     }
     const error = createError({
       message: response?.data?.message || response?.message,
@@ -1155,18 +1051,17 @@ async function executeRequest({
      * handle non-ok (error) response
      * build error body
      */
-    result = {
+    return {
       body: response.data,
       code: response.statusCode,
       statusCode: response.statusCode,
       headers: getHeaders(response.headers),
       error
     };
-    return result;
   } catch (e) {
     // We know that this is a network error
     const headers = includeResponseHeaders ? getHeaders(e.response?.headers) : null;
-    const statusCode = e.response?.status || e.response?.data || 0;
+    const statusCode = e.response?.status || e.response?.data0 || 0;
     const message = e.response?.data?.message;
     const error = createError({
       statusCode,
@@ -1182,16 +1077,11 @@ async function executeRequest({
         uri: request.uri
       })
     });
-    result = {
+    throw {
       body: error,
       error
     };
-    return result;
   } finally {
-    /**
-     * finally cache the response 
-     */
-    cache.set(result);
     clearTimeout(timer);
   }
 }
@@ -1234,7 +1124,7 @@ function createHttpMiddleware$1(options) {
       // 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();
+        requestHeader['Content-Length'] = byteLength(body);
       }
       const clientOptions = {
         enableRetry,
@@ -1267,9 +1157,6 @@ function createHttpMiddleware$1(options) {
         clientOptions,
         httpClient
       });
-      if (request['concurrent']) {
-        return response;
-      }
       const responseWithRequest = {
         ...request,
         includeOriginalRequest,
@@ -1302,48 +1189,56 @@ function createQueueMiddleware$1({
 }) {
   let runningCount = 0;
   const queue = [];
-  const dequeue = next => {
+  const waitForSlot = () => {
+    if (0 >= concurrency) return Promise.resolve();
+    return new Promise(resolve => {
+      const tryNext = () => {
+        if (runningCount < concurrency) {
+          runningCount++;
+          resolve();
+        } else {
+          queue.push(tryNext);
+        }
+      };
+      tryNext();
+    });
+  };
+
+  // Function to free up a slot after a request is completed
+  const freeSlot = () => {
     runningCount--;
-    if (queue.length && runningCount <= concurrency) {
-      const nextTask = queue.shift();
-      runningCount++;
-      return next(nextTask.request);
+    if (queue.length > 0) {
+      const nextInQueue = queue.shift();
+      if (nextInQueue) {
+        nextInQueue();
+      }
     }
   };
-  const enqueue = ({
-    request
-  }) => queue.push({
-    request
-  });
   return next => request => {
-    // wrap and override resolve and reject functions
-    const patchedRequest = {
-      ...request,
-      resolve(data) {
-        request.resolve(data);
-        dequeue(next);
-      },
-      reject(error) {
-        request.reject(error);
-        dequeue(next);
-      }
-    };
+    return waitForSlot().then(() => {
+      const patchedRequest = {
+        ...request,
+        resolve(data) {
+          request.resolve(data);
+          freeSlot();
+        },
+        reject(error) {
+          request.reject(error);
+          freeSlot();
+        }
+      };
 
-    // enqueue requests
-    enqueue({
-      request: patchedRequest
+      // Process the next middleware
+      return next(patchedRequest).finally(() => {
+        freeSlot();
+      });
     });
-    if (runningCount < concurrency) {
-      runningCount++;
-      const nextTask = queue.shift();
-      return next(nextTask.request);
-    }
   };
 }
 
 var packageJson = {
 	name: "@commercetools/ts-client",
-	version: "2.1.0-alpha.0",
+	version: "2.1.0",
 	engines: {
 		node: ">=14"
 	},
@@ -1377,16 +1272,11 @@ var packageJson = {
 	},
 	dependencies: {
 		"abort-controller": "3.0.0",
-		buffer: "^6.0.3",
-		"node-fetch": "^2.6.1",
-		uuid: "10.0.0"
+		"node-fetch": "^2.6.1"
 	},
 	files: [
 		"dist",
-		"CHANGELOG.md",
-		"LICENSE",
-		"README.md",
-		"package.json"
+		"CHANGELOG.md"
 	],
 	author: "Chukwuemeka Ajima <meeky.ae@gmail.com>",
 	main: "dist/commercetools-ts-client.cjs.js",
@@ -1541,6 +1431,7 @@ function process$1(request, fn, processOpt) {
 function createClient(middlewares) {
   _options = middlewares;
   validateClient(middlewares);
+  let _maskSensitiveHeaderData = false;
   const resolver = {
     async resolve(rs) {
       const {
@@ -1553,25 +1444,20 @@ function createClient(middlewares) {
         retryCount,
         ...rest
       } = response;
-      // _maskSensitiveHeaderData = maskSensitiveHeaderData
-
+      _maskSensitiveHeaderData = maskSensitiveHeaderData;
       const res = {
         body: null,
         error: null,
         reject: rs.reject,
         resolve: rs.resolve,
         ...rest,
+        ...(includeOriginalRequest ? {
+          originalRequest: request
+        } : {}),
         ...(response?.retryCount ? {
           retryCount: response.retryCount
-        } : {}),
-        ...(includeOriginalRequest ? {
-          originalRequest: maskSensitiveHeaderData ? maskAuthData(request) : request
         } : {})
       };
-      if (res.error) {
-        rs.reject(res.error);
-      }
-      rs.resolve(res);
       return res;
     }
   };
@@ -1581,11 +1467,20 @@ function createClient(middlewares) {
     execute(request) {
       validate('exec', request);
       return new Promise(async (resolve, reject) => {
-        return dispatch({
-          reject,
-          resolve,
-          ...request
-        });
+        try {
+          const response = await dispatch({
+            reject,
+            resolve,
+            ...request
+          });
+          if (response.error) return reject(response.error);
+          if (response.originalRequest && _maskSensitiveHeaderData) {
+            response.originalRequest = maskAuthData(response.originalRequest);
+          }
+          resolve(response);
+        } catch (err) {
+          reject(err);
+        }
       });
     }
   };