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

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

@@ -1,10 +1,7 @@
 import fetch$1 from 'node-fetch';
-import { Mutex } from 'async-mutex';
-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) {
@@ -15,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'];
@@ -184,10 +175,12 @@ async function executor(request) {
         let _response = {};
         try {
           _response = await execute();
-          if (_response.status > 299 && 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 {
@@ -232,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,8 +250,16 @@ async function executor(request) {
   return data;
 }
 
+// import { v4 as uuidv4 } from 'uuid'
+
+// export default function generateID() {
+//   return uuidv4()
+// }
+
 function generateID() {
-  return v4();
+  // @ts-ignore
+  const str = ([1e6] + -1e3 + -4e3 + -8e3 + -1e11).replace(/[018]/g, c => (c ^ crypto.getRandomValues(new Uint8Array(1))[0] & 15 >> c / 4).toString(16));
+  return 'abcdef'[Math.floor(Math.random() * 'abcdef'.length)] + '' + str;
 }
 
 function parse(headers) {
@@ -447,6 +448,13 @@ function createUserAgent(options) {
   return [baseInfo, systemInfo, libraryInfo, contactInfo, customAgent].filter(Boolean).join(' ');
 }
 
+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';
+}
+
 /**
  * validate some essential http options
  * @param options
@@ -507,7 +515,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';
@@ -553,9 +562,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)}`;
@@ -589,7 +599,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
@@ -609,44 +619,16 @@ function buildRequestForPasswordFlow(options) {
 
 async function executeRequest$1(options) {
   const {
-    request,
     httpClient,
     tokenCache,
-    tokenCacheKey,
     userOption,
-    next
+    tokenCacheObject
   } = options;
   let url = options.url;
   let body = options.body;
   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
-    };
-  }
-
-  /**
-   * 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
@@ -677,7 +659,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
@@ -698,73 +680,29 @@ 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 < requestQueue.length; i++) {
-        const task = requestQueue[i];
-        const requestWithAuth = mergeAuthHeader(token, task.request);
-
-        // execute task
-        task.next(requestWithAuth);
-      }
-      return;
+      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({
-      ...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) {
-    return {
-      ...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 = [];
-  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 => {
@@ -774,12 +712,19 @@ function createAuthMiddlewareForAnonymousSessionFlow$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 = {
         request,
-        requestState,
         tokenCache,
-        pendingTasks,
         tokenCacheKey,
         httpClient: options.httpClient || fetch$1,
         ...buildRequestForAnonymousSessionFlow(options),
@@ -787,28 +732,32 @@ 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 tokenCache = options.tokenCache || store({
     token: '',
     expirationTime: -1
   });
+  let tokenCacheObject;
+  let tokenFetchPromise = null;
   const tokenCacheKey = buildTokenCacheKey(options);
   return next => {
     return async request => {
@@ -818,29 +767,40 @@ function createAuthMiddlewareForClientCredentialsFlow$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 = {
         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,19 +837,27 @@ 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 => {
+      // 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,
-        requestState,
         tokenCache,
-        pendingTasks,
         tokenCacheKey,
         httpClient: options.httpClient || fetch$1,
         ...buildRequestForPasswordFlow(options),
@@ -897,16 +865,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,35 +889,47 @@ function createAuthMiddlewareForRefreshTokenFlow$1(options) {
     token: '',
     tokenCacheKey: null
   });
-  const pendingTasks = [];
-  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)) {
         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,
-        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));
       }
     };
   };
@@ -1108,7 +1092,7 @@ async function executeRequest({
         uri: request.uri
       })
     });
-    return {
+    throw {
       body: error,
       error
     };
@@ -1155,7 +1139,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,
@@ -1219,49 +1203,52 @@ function createQueueMiddleware$1({
   concurrency = 20
 }) {
   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,
-      resolve(data) {
-        request.resolve(data);
-        dequeue(next);
-      },
-      reject(error) {
-        request.reject(error);
-        dequeue(next);
-      }
-    };
+  const waitForSlot = () => {
+    // dont allow negative or 0 value for concurrency
+    if (0 >= concurrency) return Promise.resolve();
+    return new Promise(resolve => {
+      const tryNext = () => {
+        if (runningCount < concurrency) {
+          runningCount++;
+          resolve();
+        } else {
+          // Retry until a slot becomes available
+          setTimeout(tryNext, 10);
+        }
+      };
 
-    // enqueue requests
-    enqueue({
-      request: patchedRequest
+      // start
+      tryNext();
     });
-    if (runningCount < concurrency) {
-      runningCount++;
-      const nextTask = queue.shift();
-      return next(nextTask.request);
-    }
+  };
+  return next => {
+    return async request => {
+      return waitForSlot().then(async () => {
+        // Patch the request to override resolve and reject
+        const patchedRequest = {
+          ...request,
+          resolve(data) {
+            request.resolve(data);
+            runningCount--;
+          },
+          reject(error) {
+            request.reject(error);
+            runningCount--;
+          }
+        };
+        try {
+          return next(patchedRequest);
+        } finally {
+          runningCount--;
+        }
+      });
+    };
   };
 }
 
 var packageJson = {
 	name: "@commercetools/ts-client",
-	version: "2.0.5",
+	version: "2.1.0-alpha.1",
 	engines: {
 		node: ">=14"
 	},
@@ -1295,14 +1282,14 @@ 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"
+		"node-fetch": "^2.6.1"
 	},
 	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",