@commercetools/ts-client 3.1.0 → 3.2.0

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

@@ -720,6 +720,63 @@ async function executeRequest$1(options) {
   }
 }
 
+async function authProcessor(request, tokenFetchPromise = null, tokenCacheObject, tokenCacheKey, tokenCache, builder, options, next) {
+  // prepare request options
+  const requestOptions = {
+    request,
+    tokenCache,
+    httpClient: options.httpClient || fetch,
+    httpClientOptions: options.httpClientOptions,
+    ...builder(options),
+    userOption: options,
+    next
+  };
+
+  /**
+   * check to see if the response for 401 errors
+   * @param r MiddlewareResponse
+   * @returns response
+   */
+  const checkAndRetryUnauthorizedError = async r => {
+    let _response = Object.assign({}, r);
+    if (_response.statusCode == 401) {
+      tokenFetchPromise = executeRequest$1(requestOptions);
+      await tokenFetchPromise;
+      tokenFetchPromise = null;
+      tokenCacheObject = tokenCache.get(tokenCacheKey);
+      _response = await next(mergeAuthHeader(tokenCacheObject.token, request));
+    }
+    return _response;
+  };
+  if (request.headers && (request.headers.Authorization || request.headers.authorization)) {
+    // move on
+    return checkAndRetryUnauthorizedError(await 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 checkAndRetryUnauthorizedError(await next(mergeAuthHeader(tokenCacheObject.token, request)));
+  }
+
+  // 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;
+  }
+
+  // Now the token is present in the tokenCache and can be accessed
+  tokenCacheObject = tokenCache.get(tokenCacheKey);
+  return next(mergeAuthHeader(tokenCacheObject.token, request));
+}
+
 function createAuthMiddlewareForAnonymousSessionFlow$1(options) {
   const tokenCache = options.tokenCache || store({
     token: '',
@@ -730,46 +787,7 @@ function createAuthMiddlewareForAnonymousSessionFlow$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)) {
-        // 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));
-      }
-
-      // prepare request options
-      const requestOptions = {
-        request,
-        tokenCache,
-        tokenCacheKey,
-        httpClient: options.httpClient || fetch,
-        httpClientOptions: options.httpClientOptions,
-        ...buildRequestForAnonymousSessionFlow(options),
-        userOption: options,
-        next
-      };
-
-      // 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;
-      }
-
-      // Now the token is present in the tokenCache and can be accessed
-      tokenCacheObject = tokenCache.get(tokenCacheKey);
-      return next(mergeAuthHeader(tokenCacheObject.token, request));
+      return authProcessor(request, tokenFetchPromise, tokenCacheObject, tokenCacheKey, tokenCache, buildRequestForAnonymousSessionFlow, options, next);
     };
   };
 }
@@ -784,46 +802,7 @@ function createAuthMiddlewareForClientCredentialsFlow$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)) {
-        // 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));
-      }
-
-      // prepare request options
-      const requestOptions = {
-        request,
-        tokenCache,
-        tokenCacheKey,
-        tokenCacheObject,
-        httpClient: options.httpClient || fetch,
-        httpClientOptions: options.httpClientOptions,
-        ...buildRequestForClientCredentialsFlow(options),
-        next
-      };
-
-      // 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;
-      }
-
-      // Now the token is present in the tokenCache
-      tokenCacheObject = tokenCache.get(tokenCacheKey);
-      return next(mergeAuthHeader(tokenCacheObject.token, request));
+      return authProcessor(request, tokenFetchPromise, tokenCacheObject, tokenCacheKey, tokenCache, buildRequestForClientCredentialsFlow, options, next);
     };
   };
 }
@@ -864,43 +843,7 @@ 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 = {
-        request,
-        tokenCache,
-        tokenCacheKey,
-        httpClient: options.httpClient || fetch,
-        httpClientOptions: options.httpClientOptions,
-        ...buildRequestForPasswordFlow(options),
-        userOption: options,
-        next
-      };
-
-      // 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;
-      }
-
-      // Now the token is present in the tokenCache
-      tokenCacheObject = tokenCache.get(tokenCacheKey);
-      return next(mergeAuthHeader(tokenCacheObject.token, request));
+      return authProcessor(request, tokenFetchPromise, tokenCacheObject, tokenCacheKey, tokenCache, buildRequestForPasswordFlow, options, next);
     };
   };
 }
@@ -915,42 +858,7 @@ function createAuthMiddlewareForRefreshTokenFlow$1(options) {
   const tokenCacheKey = buildTokenCacheKey(options);
   return next => {
     return async request => {
-      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));
-      }
-
-      // prepare request options
-      const requestOptions = {
-        request,
-        tokenCache,
-        httpClient: options.httpClient || fetch,
-        httpClientOptions: options.httpClientOptions,
-        ...buildRequestForRefreshTokenFlow(options),
-        next
-      };
-
-      // 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;
-      }
-
-      // Now the token is present in the tokenCache
-      tokenCacheObject = tokenCache.get(tokenCacheKey);
-      return next(mergeAuthHeader(tokenCacheObject.token, request));
+      return authProcessor(request, tokenFetchPromise, tokenCacheObject, tokenCacheKey, tokenCache, buildRequestForRefreshTokenFlow, options, next);
     };
   };
 }
@@ -1261,7 +1169,7 @@ function createQueueMiddleware$1({
 
 var packageJson = {
 	name: "@commercetools/ts-client",
-	version: "3.1.0",
+	version: "3.2.0",
 	engines: {
 		node: ">=18"
 	},

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

@@ -720,6 +720,63 @@ async function executeRequest$1(options) {
   }
 }
 
+async function authProcessor(request, tokenFetchPromise = null, tokenCacheObject, tokenCacheKey, tokenCache, builder, options, next) {
+  // prepare request options
+  const requestOptions = {
+    request,
+    tokenCache,
+    httpClient: options.httpClient || fetch,
+    httpClientOptions: options.httpClientOptions,
+    ...builder(options),
+    userOption: options,
+    next
+  };
+
+  /**
+   * check to see if the response for 401 errors
+   * @param r MiddlewareResponse
+   * @returns response
+   */
+  const checkAndRetryUnauthorizedError = async r => {
+    let _response = Object.assign({}, r);
+    if (_response.statusCode == 401) {
+      tokenFetchPromise = executeRequest$1(requestOptions);
+      await tokenFetchPromise;
+      tokenFetchPromise = null;
+      tokenCacheObject = tokenCache.get(tokenCacheKey);
+      _response = await next(mergeAuthHeader(tokenCacheObject.token, request));
+    }
+    return _response;
+  };
+  if (request.headers && (request.headers.Authorization || request.headers.authorization)) {
+    // move on
+    return checkAndRetryUnauthorizedError(await 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 checkAndRetryUnauthorizedError(await next(mergeAuthHeader(tokenCacheObject.token, request)));
+  }
+
+  // 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;
+  }
+
+  // Now the token is present in the tokenCache and can be accessed
+  tokenCacheObject = tokenCache.get(tokenCacheKey);
+  return next(mergeAuthHeader(tokenCacheObject.token, request));
+}
+
 function createAuthMiddlewareForAnonymousSessionFlow$1(options) {
   const tokenCache = options.tokenCache || store({
     token: '',
@@ -730,46 +787,7 @@ function createAuthMiddlewareForAnonymousSessionFlow$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)) {
-        // 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));
-      }
-
-      // prepare request options
-      const requestOptions = {
-        request,
-        tokenCache,
-        tokenCacheKey,
-        httpClient: options.httpClient || fetch,
-        httpClientOptions: options.httpClientOptions,
-        ...buildRequestForAnonymousSessionFlow(options),
-        userOption: options,
-        next
-      };
-
-      // 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;
-      }
-
-      // Now the token is present in the tokenCache and can be accessed
-      tokenCacheObject = tokenCache.get(tokenCacheKey);
-      return next(mergeAuthHeader(tokenCacheObject.token, request));
+      return authProcessor(request, tokenFetchPromise, tokenCacheObject, tokenCacheKey, tokenCache, buildRequestForAnonymousSessionFlow, options, next);
     };
   };
 }
@@ -784,46 +802,7 @@ function createAuthMiddlewareForClientCredentialsFlow$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)) {
-        // 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));
-      }
-
-      // prepare request options
-      const requestOptions = {
-        request,
-        tokenCache,
-        tokenCacheKey,
-        tokenCacheObject,
-        httpClient: options.httpClient || fetch,
-        httpClientOptions: options.httpClientOptions,
-        ...buildRequestForClientCredentialsFlow(options),
-        next
-      };
-
-      // 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;
-      }
-
-      // Now the token is present in the tokenCache
-      tokenCacheObject = tokenCache.get(tokenCacheKey);
-      return next(mergeAuthHeader(tokenCacheObject.token, request));
+      return authProcessor(request, tokenFetchPromise, tokenCacheObject, tokenCacheKey, tokenCache, buildRequestForClientCredentialsFlow, options, next);
     };
   };
 }
@@ -864,43 +843,7 @@ 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 = {
-        request,
-        tokenCache,
-        tokenCacheKey,
-        httpClient: options.httpClient || fetch,
-        httpClientOptions: options.httpClientOptions,
-        ...buildRequestForPasswordFlow(options),
-        userOption: options,
-        next
-      };
-
-      // 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;
-      }
-
-      // Now the token is present in the tokenCache
-      tokenCacheObject = tokenCache.get(tokenCacheKey);
-      return next(mergeAuthHeader(tokenCacheObject.token, request));
+      return authProcessor(request, tokenFetchPromise, tokenCacheObject, tokenCacheKey, tokenCache, buildRequestForPasswordFlow, options, next);
     };
   };
 }
@@ -915,42 +858,7 @@ function createAuthMiddlewareForRefreshTokenFlow$1(options) {
   const tokenCacheKey = buildTokenCacheKey(options);
   return next => {
     return async request => {
-      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));
-      }
-
-      // prepare request options
-      const requestOptions = {
-        request,
-        tokenCache,
-        httpClient: options.httpClient || fetch,
-        httpClientOptions: options.httpClientOptions,
-        ...buildRequestForRefreshTokenFlow(options),
-        next
-      };
-
-      // 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;
-      }
-
-      // Now the token is present in the tokenCache
-      tokenCacheObject = tokenCache.get(tokenCacheKey);
-      return next(mergeAuthHeader(tokenCacheObject.token, request));
+      return authProcessor(request, tokenFetchPromise, tokenCacheObject, tokenCacheKey, tokenCache, buildRequestForRefreshTokenFlow, options, next);
     };
   };
 }
@@ -1261,7 +1169,7 @@ function createQueueMiddleware$1({
 
 var packageJson = {
 	name: "@commercetools/ts-client",
-	version: "3.1.0",
+	version: "3.2.0",
 	engines: {
 		node: ">=18"
 	},