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

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

@@ -1,5 +1,4 @@
 import fetch$1 from 'node-fetch';
-import { Mutex } from 'async-mutex';
 import { v4 } from 'uuid';
 import { Buffer } from 'buffer/';
 import AbortController from 'abort-controller';
@@ -184,7 +183,7 @@ async function executor(request) {
         let _response = {};
         try {
           _response = await execute();
-          if (_response.status > 299 && hasResponseRetryCode(retryCodes, _response)) return {
+          if (_response.status > 399 && hasResponseRetryCode(retryCodes, _response)) return {
             _response,
             shouldRetry: true
           };
@@ -447,6 +446,18 @@ function createUserAgent(options) {
   return [baseInfo, systemInfo, libraryInfo, contactInfo, customAgent].filter(Boolean).join(' ');
 }
 
+function responseCache() {
+  let val;
+  return {
+    set(response) {
+      val = response;
+    },
+    get() {
+      return val;
+    }
+  };
+}
+
 /**
  * validate some essential http options
  * @param options
@@ -614,6 +625,7 @@ async function executeRequest$1(options) {
     tokenCache,
     tokenCacheKey,
     userOption,
+    tokenCacheObject,
     next
   } = options;
   let url = options.url;
@@ -621,20 +633,26 @@ async function executeRequest$1(options) {
   let basicAuth = options.basicAuth;
 
   // get the pending object from option
-  let pendingTasks = options.pendingTasks;
+  // 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) {
-    const requestWithAuth = mergeAuthHeader(tokenCacheObject.token, request);
-    return {
-      ...requestWithAuth
-    };
-  }
+  // 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
@@ -642,10 +660,7 @@ async function executeRequest$1(options) {
    * 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
-  });
+  // pendingTasks.push({ request, next })
 
   /**
    * use refreshToken flow if there is refresh-token
@@ -703,30 +718,35 @@ async function executeRequest$1(options) {
        * Freeze and copy pending queue, reset
        * original one for accepting new pending tasks
        */
-      const requestQueue = pendingTasks.slice();
+      // const requestQueue = pendingTasks.slice()
 
-      // reset pendingTask queue
-      pendingTasks = [];
-      if (requestQueue.length === 1) {
-        return mergeAuthHeader(token, requestQueue.pop().request);
-      }
+      // // reset pendingTask queue
+      // pendingTasks = []
 
-      // execute all pending tasks if any
-      for (let i = 0; i < requestQueue.length; i++) {
-        const task = requestQueue[i];
-        const requestWithAuth = mergeAuthHeader(token, task.request);
+      // if (requestQueue.length === 1) {
+      //   return mergeAuthHeader(token, requestQueue.pop().request)
+      // }
 
-        // execute task
-        task.next(requestWithAuth);
-      }
-      return;
+      // // 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
      */
-    request.reject({
+    return request.reject({
       ...request,
       headers: {
         ...request.headers
@@ -740,7 +760,7 @@ async function executeRequest$1(options) {
       }
     });
   } catch (error) {
-    return {
+    request.reject({
       ...request,
       headers: {
         ...request.headers
@@ -754,17 +774,19 @@ async function executeRequest$1(options) {
           body: response
         }
       }
-    };
+    });
   }
 }
 
 function createAuthMiddlewareForAnonymousSessionFlow$1(options) {
-  const pendingTasks = [];
-  const requestState = new Mutex();
+  // const pendingTasks: Array<Task> = []
+  // const requestState = new Mutex()
   const tokenCache = options.tokenCache || store({
     token: '',
     expirationTime: -1
   });
+  let tokenCacheObject;
+  let tokenFetchPromise = null;
   const tokenCacheKey = buildTokenCacheKey(options);
   return next => {
     return async request => {
@@ -773,13 +795,17 @@ function createAuthMiddlewareForAnonymousSessionFlow$1(options) {
         // move on
         return next(request);
       }
+      tokenCacheObject = tokenCache.get(tokenCacheKey);
+      if (tokenCacheObject && tokenCacheObject.token && Date.now() < tokenCacheObject.expirationTime) {
+        return next(mergeAuthHeader(tokenCacheObject.token, request));
+      }
 
       // prepare request options
       const requestOptions = {
+        // requestState,
+        // pendingTasks,
         request,
-        requestState,
         tokenCache,
-        pendingTasks,
         tokenCacheKey,
         httpClient: options.httpClient || fetch$1,
         ...buildRequestForAnonymousSessionFlow(options),
@@ -787,28 +813,34 @@ function createAuthMiddlewareForAnonymousSessionFlow$1(options) {
         next
       };
 
-      // make request to coco
-      let requestWithAuth;
-      try {
-        await requestState.acquire();
-        requestWithAuth = await executeRequest$1(requestOptions);
-      } finally {
-        requestState.release();
+      // If a token is already being fetched, wait for it to finish
+      if (tokenFetchPromise) {
+        await tokenFetchPromise;
+      } else {
+        // Otherwise, fetch the token and let others wait for this process to complete
+        tokenFetchPromise = executeRequest$1(requestOptions);
+        await tokenFetchPromise;
+        tokenFetchPromise = null;
       }
-      if (requestWithAuth) {
-        return next(requestWithAuth);
+
+      // 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));
       }
     };
   };
 }
 
 function createAuthMiddlewareForClientCredentialsFlow$1(options) {
-  const requestState = new Mutex();
-  const pendingTasks = [];
+  // const requestState = new Mutex()
+  // const pendingTasks: Array<Task> = []
   const tokenCache = options.tokenCache || store({
     token: '',
     expirationTime: -1
   });
+  let tokenCacheObject;
+  let tokenFetchPromise = null;
   const tokenCacheKey = buildTokenCacheKey(options);
   return next => {
     return async request => {
@@ -817,30 +849,38 @@ function createAuthMiddlewareForClientCredentialsFlow$1(options) {
         // move on
         return next(request);
       }
+      tokenCacheObject = tokenCache.get(tokenCacheKey);
+      if (tokenCacheObject && tokenCacheObject.token && Date.now() < tokenCacheObject.expirationTime) {
+        return next(mergeAuthHeader(tokenCacheObject.token, request));
+      }
 
       // prepare request options
       const requestOptions = {
+        // requestState,
+        // pendingTasks,
         request,
-        requestState,
         tokenCache,
-        pendingTasks,
         tokenCacheKey,
+        tokenCacheObject,
         httpClient: options.httpClient || fetch$1,
         ...buildRequestForClientCredentialsFlow(options),
         next
       };
 
-      // make request to coco
-      let requestWithAuth;
-      try {
-        await requestState.acquire();
-        requestWithAuth = await executeRequest$1(requestOptions);
-      } finally {
-        requestState.release();
+      // If a token is already being fetched, wait for it to finish
+      if (tokenFetchPromise) {
+        await tokenFetchPromise;
+      } else {
+        // Otherwise, fetch the token and let others wait for this process to complete
+        tokenFetchPromise = executeRequest$1(requestOptions);
+        await tokenFetchPromise;
+        tokenFetchPromise = null;
       }
-      if (requestWithAuth) {
-        // make the request and inject the token into the header
-        return next(requestWithAuth);
+
+      // 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));
       }
     };
   };
@@ -877,8 +917,8 @@ function createAuthMiddlewareForPasswordFlow$1(options) {
     token: '',
     expirationTime: -1
   });
-  const pendingTasks = [];
-  const requestState = new Mutex();
+  let tokenCacheObject;
+  let tokenFetchPromise = null;
   const tokenCacheKey = buildTokenCacheKey(options);
   return next => {
     return async request => {
@@ -886,10 +926,10 @@ function createAuthMiddlewareForPasswordFlow$1(options) {
         return next(request);
       }
       const requestOptions = {
+        // requestState,
+        // pendingTasks,
         request,
-        requestState,
         tokenCache,
-        pendingTasks,
         tokenCacheKey,
         httpClient: options.httpClient || fetch$1,
         ...buildRequestForPasswordFlow(options),
@@ -897,16 +937,20 @@ function createAuthMiddlewareForPasswordFlow$1(options) {
         next
       };
 
-      // make request to coco
-      let requestWithAuth;
-      try {
-        await requestState.acquire();
-        requestWithAuth = await executeRequest$1(requestOptions);
-      } finally {
-        requestState.release();
+      // If a token is already being fetched, wait for it to finish
+      if (tokenFetchPromise) {
+        await tokenFetchPromise;
+      } else {
+        // Otherwise, fetch the token and let others wait for this process to complete
+        tokenFetchPromise = executeRequest$1(requestOptions);
+        await tokenFetchPromise;
+        tokenFetchPromise = null;
       }
-      if (requestWithAuth) {
-        return next(requestWithAuth);
+
+      // 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));
       }
     };
   };
@@ -917,8 +961,13 @@ function createAuthMiddlewareForRefreshTokenFlow$1(options) {
     token: '',
     tokenCacheKey: null
   });
-  const pendingTasks = [];
-  const requestState = new Mutex();
+
+  // const pendingTasks: Array<Task> = []
+  // const requestState = new Mutex()
+
+  let tokenCacheObject;
+  let tokenFetchPromise = null;
+  const tokenCacheKey = buildTokenCacheKey(options);
   return next => {
     return async request => {
       if (request.headers && (request.headers.Authorization || request.headers.authorization)) {
@@ -927,25 +976,29 @@ function createAuthMiddlewareForRefreshTokenFlow$1(options) {
 
       // prepare request options
       const requestOptions = {
+        // pendingTasks,
+        // requestState,
         request,
-        requestState,
         tokenCache,
-        pendingTasks,
         httpClient: options.httpClient || fetch,
         ...buildRequestForRefreshTokenFlow(options),
         next
       };
 
-      // make request to coco
-      let requestWithAuth;
-      try {
-        await requestState.acquire();
-        requestWithAuth = await executeRequest$1(requestOptions);
-      } finally {
-        requestState.release();
+      // If a token is already being fetched, wait for it to finish
+      if (tokenFetchPromise) {
+        await tokenFetchPromise;
+      } else {
+        // Otherwise, fetch the token and let others wait for this process to complete
+        tokenFetchPromise = executeRequest$1(requestOptions);
+        await tokenFetchPromise;
+        tokenFetchPromise = null;
       }
-      if (requestWithAuth) {
-        return next(requestWithAuth);
+
+      // 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));
       }
     };
   };
@@ -954,6 +1007,7 @@ 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) {
         /**
@@ -961,7 +1015,7 @@ 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) {
@@ -976,10 +1030,18 @@ function createConcurrentModificationMiddleware$1(modifierFunction) {
               version
             };
           }
-          return next(request);
+          return next({
+            ...request,
+            response
+          });
         }
       }
-      return response;
+      request.continue = true;
+      delete request['concurrent'];
+      return next({
+        ...request,
+        response
+      });
     };
   };
 }
@@ -1018,12 +1080,20 @@ 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,
@@ -1050,19 +1120,22 @@ async function executeRequest({
     }
     if (response.statusCode >= 200 && response.statusCode < 300) {
       if (clientOptions.method == 'HEAD') {
-        return {
+        const _result = {
           body: null,
           statusCode: response.statusCode,
           retryCount: response.retryCount,
           headers: getHeaders(response.headers)
         };
+        cache.set(_result);
+        return _result;
       }
-      return {
+      result = {
         body: response.data,
         statusCode: response.statusCode,
         retryCount: response.retryCount,
         headers: getHeaders(response.headers)
       };
+      return result;
     }
     const error = createError({
       message: response?.data?.message || response?.message,
@@ -1082,17 +1155,18 @@ async function executeRequest({
      * handle non-ok (error) response
      * build error body
      */
-    return {
+    result = {
       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?.data0 || 0;
+    const statusCode = e.response?.status || e.response?.data || 0;
     const message = e.response?.data?.message;
     const error = createError({
       statusCode,
@@ -1108,11 +1182,16 @@ async function executeRequest({
         uri: request.uri
       })
     });
-    return {
+    result = {
       body: error,
       error
     };
+    return result;
   } finally {
+    /**
+     * finally cache the response 
+     */
+    cache.set(result);
     clearTimeout(timer);
   }
 }
@@ -1188,6 +1267,9 @@ function createHttpMiddleware$1(options) {
         clientOptions,
         httpClient
       });
+      if (request['concurrent']) {
+        return response;
+      }
       const responseWithRequest = {
         ...request,
         includeOriginalRequest,
@@ -1261,7 +1343,7 @@ function createQueueMiddleware$1({
 
 var packageJson = {
 	name: "@commercetools/ts-client",
-	version: "2.0.5",
+	version: "2.1.0-alpha.0",
 	engines: {
 		node: ">=14"
 	},
@@ -1295,14 +1377,16 @@ var packageJson = {
 	},
 	dependencies: {
 		"abort-controller": "3.0.0",
-		"async-mutex": "^0.5.0",
 		buffer: "^6.0.3",
 		"node-fetch": "^2.6.1",
 		uuid: "10.0.0"
 	},
 	files: [
 		"dist",
-		"CHANGELOG.md"
+		"CHANGELOG.md",
+		"LICENSE",
+		"README.md",
+		"package.json"
 	],
 	author: "Chukwuemeka Ajima <meeky.ae@gmail.com>",
 	main: "dist/commercetools-ts-client.cjs.js",
@@ -1457,7 +1541,6 @@ function process$1(request, fn, processOpt) {
 function createClient(middlewares) {
   _options = middlewares;
   validateClient(middlewares);
-  let _maskSensitiveHeaderData = false;
   const resolver = {
     async resolve(rs) {
       const {
@@ -1470,20 +1553,25 @@ 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;
     }
   };
@@ -1493,20 +1581,11 @@ function createClient(middlewares) {
     execute(request) {
       validate('exec', request);
       return new Promise(async (resolve, reject) => {
-        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);
-        }
+        return dispatch({
+          reject,
+          resolve,
+          ...request
+        });
       });
     }
   };