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

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

@@ -3,7 +3,6 @@
 Object.defineProperty(exports, '__esModule', { value: true });
 
 var fetch$1 = require('node-fetch');
-var asyncMutex = require('async-mutex');
 var uuid = require('uuid');
 var _ = require('buffer/');
 var AbortController = require('abort-controller');
@@ -193,7 +192,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
           };
@@ -456,6 +455,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
@@ -623,6 +634,7 @@ async function executeRequest$1(options) {
     tokenCache,
     tokenCacheKey,
     userOption,
+    tokenCacheObject,
     next
   } = options;
   let url = options.url;
@@ -630,20 +642,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
@@ -651,10 +669,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
@@ -712,30 +727,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
@@ -749,7 +769,7 @@ async function executeRequest$1(options) {
       }
     });
   } catch (error) {
-    return {
+    request.reject({
       ...request,
       headers: {
         ...request.headers
@@ -763,17 +783,19 @@ async function executeRequest$1(options) {
           body: response
         }
       }
-    };
+    });
   }
 }
 
 function createAuthMiddlewareForAnonymousSessionFlow$1(options) {
-  const pendingTasks = [];
-  const requestState = new asyncMutex.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 => {
@@ -782,13 +804,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__default["default"],
         ...buildRequestForAnonymousSessionFlow(options),
@@ -796,28 +822,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 asyncMutex.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 => {
@@ -826,30 +858,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__default["default"],
         ...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));
       }
     };
   };
@@ -886,8 +926,8 @@ function createAuthMiddlewareForPasswordFlow$1(options) {
     token: '',
     expirationTime: -1
   });
-  const pendingTasks = [];
-  const requestState = new asyncMutex.Mutex();
+  let tokenCacheObject;
+  let tokenFetchPromise = null;
   const tokenCacheKey = buildTokenCacheKey(options);
   return next => {
     return async request => {
@@ -895,10 +935,10 @@ function createAuthMiddlewareForPasswordFlow$1(options) {
         return next(request);
       }
       const requestOptions = {
+        // requestState,
+        // pendingTasks,
         request,
-        requestState,
         tokenCache,
-        pendingTasks,
         tokenCacheKey,
         httpClient: options.httpClient || fetch__default["default"],
         ...buildRequestForPasswordFlow(options),
@@ -906,16 +946,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));
       }
     };
   };
@@ -926,8 +970,13 @@ function createAuthMiddlewareForRefreshTokenFlow$1(options) {
     token: '',
     tokenCacheKey: null
   });
-  const pendingTasks = [];
-  const requestState = new asyncMutex.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)) {
@@ -936,25 +985,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));
       }
     };
   };
@@ -963,6 +1016,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) {
         /**
@@ -970,7 +1024,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) {
@@ -985,10 +1039,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
+      });
     };
   };
 }
@@ -1027,12 +1089,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,
@@ -1059,19 +1129,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,
@@ -1091,17 +1164,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,
@@ -1117,11 +1191,16 @@ async function executeRequest({
         uri: request.uri
       })
     });
-    return {
+    result = {
       body: error,
       error
     };
+    return result;
   } finally {
+    /**
+     * finally cache the response 
+     */
+    cache.set(result);
     clearTimeout(timer);
   }
 }
@@ -1197,6 +1276,9 @@ function createHttpMiddleware$1(options) {
         clientOptions,
         httpClient
       });
+      if (request['concurrent']) {
+        return response;
+      }
       const responseWithRequest = {
         ...request,
         includeOriginalRequest,
@@ -1270,7 +1352,7 @@ function createQueueMiddleware$1({
 
 var packageJson = {
 	name: "@commercetools/ts-client",
-	version: "2.0.5",
+	version: "2.1.0-alpha.0",
 	engines: {
 		node: ">=14"
 	},
@@ -1304,14 +1386,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",
@@ -1466,7 +1550,6 @@ function process$1(request, fn, processOpt) {
 function createClient(middlewares) {
   _options = middlewares;
   validateClient(middlewares);
-  let _maskSensitiveHeaderData = false;
   const resolver = {
     async resolve(rs) {
       const {
@@ -1479,20 +1562,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;
     }
   };
@@ -1502,20 +1590,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
+        });
       });
     }
   };