@commercetools/ts-client 1.2.1 → 2.0.1

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

@@ -112,10 +112,11 @@ function createError({
   return new HttpError(statusCode, errorMessage, rest);
 }
 
-function predicate(retryCodes, response) {
-  return !
-  // retryCodes.includes(response?.error?.message) ||
-  [503, ...retryCodes].includes(response?.status || response?.statusCode);
+function hasResponseRetryCode(retryCodes, response) {
+  return (
+    // retryCodes.includes(response?.error?.message) ||
+    [503, ...retryCodes].includes(response?.status || response?.statusCode)
+  );
 }
 async function executeHttpClientRequest(fetcher, config) {
   async function sendRequest() {
@@ -142,14 +143,17 @@ async function executor(request) {
   const data = await executeHttpClientRequest(async options => {
     const {
       enableRetry,
-      retryConfig
+      retryConfig,
+      abortController
     } = rest;
     const {
       retryCodes = [],
       maxDelay = Infinity,
       maxRetries = 3,
       backoff = true,
-      retryDelay = 200
+      retryDelay = 200,
+      // If set to true reinitialize the abort controller when the timeout is reached and apply the retry config
+      retryOnAbort = true
     } = retryConfig || {};
     let result,
       data,
@@ -175,15 +179,41 @@ async function executor(request) {
       });
     }
     async function executeWithRetry() {
+      const executeWithTryCatch = async (retryCodes, retryWhenAborted) => {
+        let _response = {};
+        try {
+          _response = await execute();
+          if (_response.status > 299 && hasResponseRetryCode(retryCodes, _response)) return {
+            _response,
+            shouldRetry: true
+          };
+        } catch (e) {
+          if (e.name.includes('AbortError') && retryWhenAborted) {
+            return {
+              _response: e,
+              shouldRetry: true
+            };
+          } else {
+            throw e;
+          }
+        }
+        return {
+          _response,
+          shouldRetry: false
+        };
+      };
+      const retryWhenAborted = retryOnAbort || !abortController || !abortController.signal;
       // first attempt
-      let _response = await execute();
-      if (predicate(retryCodes, _response)) return _response;
-
+      let {
+        _response,
+        shouldRetry
+      } = await executeWithTryCatch(retryCodes, retryWhenAborted);
       // retry attempts
-      while (enableRetry && retryCount < maxRetries) {
+      while (enableRetry && shouldRetry && retryCount < maxRetries) {
         retryCount++;
-        _response = await execute();
-        if (predicate(retryCodes, _response)) return _response;
+        const execution = await executeWithTryCatch(retryCodes, retryWhenAborted);
+        _response = execution._response;
+        shouldRetry = execution.shouldRetry;
 
         // delay next execution
         const timer = calculateRetryDelay({
@@ -423,7 +453,6 @@ function createUserAgent(options) {
 function validateHttpOptions(options) {
   if (!options.host) throw new Error('Request `host` or `url` is missing or invalid, please pass in a valid host e.g `host: http://a-valid-host-url`');
   if (!options.httpClient && typeof options.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 (options.timeout && !options.getAbortController) throw new Error('`AbortController` is not available. Please pass in `getAbortController` as an option or have AbortController globally available when using timeout.');
 }
 
 /**
@@ -629,7 +658,10 @@ async function executeRequest$1(options) {
    * and there's either no token or the token is expired
    */
   if (tokenCacheObject && tokenCacheObject.refreshToken && (!tokenCacheObject.token || tokenCacheObject.token && Date.now() > tokenCacheObject.expirationTime)) {
-    if (!userOption) throw new Error('Missing required options.');
+    if (!userOption) {
+      requestState.set(false);
+      throw new Error('Missing required options.');
+    }
     const opt = {
       ...buildRequestForRefreshTokenFlow({
         ...userOption,
@@ -702,8 +734,10 @@ async function executeRequest$1(options) {
     const error = new Error(response.data.message ? response.data.message : JSON.stringify(response.data));
     /**
      * reject the error immediately
-     * and free up the middleware chain
+     * and free up the middleware chain and
+     * release the requestState by setting it to false
      */
+    requestState.set(false);
     request.reject({
       ...request,
       headers: {
@@ -718,6 +752,10 @@ async function executeRequest$1(options) {
       }
     });
   } catch (error) {
+    /**
+     * on error release the state by setting it to false
+     */
+    requestState.set(false);
     return {
       ...request,
       headers: {
@@ -905,7 +943,7 @@ function createAuthMiddlewareForRefreshTokenFlow$1(options) {
   };
 }
 
-function createConcurrentModificationMiddleware$1() {
+function createConcurrentModificationMiddleware$1(modifierFunction) {
   return next => {
     return async request => {
       const response = await next(request);
@@ -919,13 +957,17 @@ function createConcurrentModificationMiddleware$1() {
 
         // update the resource version here
         if (version) {
-          request.body = typeof request.body == 'string' ? {
-            ...JSON.parse(request.body),
-            version
-          } : {
-            ...request.body,
-            version
-          };
+          if (modifierFunction) {
+            request.body = await modifierFunction(version, request, response);
+          } else {
+            request.body = typeof request.body == 'string' ? {
+              ...JSON.parse(request.body),
+              version
+            } : {
+              ...request.body,
+              version
+            };
+          }
           return next(request);
         }
       }
@@ -947,7 +989,7 @@ function createCorrelationIdMiddleware$1(options) {
   };
 }
 
-function createErrorMiddleware$1(options) {
+function createErrorMiddleware(options) {
   return next => async request => {
     const response = await next(request);
     if (response.error) {
@@ -979,7 +1021,8 @@ async function executeRequest({
     request,
     abortController,
     maskSensitiveHeaderData,
-    includeRequestInErrorResponse
+    includeRequestInErrorResponse,
+    includeResponseHeaders
   } = clientOptions;
   try {
     if (timeout) timer = setTimeout(() => {
@@ -994,6 +1037,9 @@ async function executeRequest({
         body: clientOptions.body
       } : {})
     });
+    if (!includeResponseHeaders) {
+      response.headers = null;
+    }
     if (response.statusCode >= 200 && response.statusCode < 300) {
       if (clientOptions.method == 'HEAD') {
         return {
@@ -1037,7 +1083,7 @@ async function executeRequest({
     };
   } catch (e) {
     // We know that this is a network error
-    const headers = getHeaders(e.response?.headers);
+    const headers = includeResponseHeaders ? getHeaders(e.response?.headers) : null;
     const statusCode = e.response?.status || e.response?.data0 || 0;
     const message = e.response?.data?.message;
     const error = createError({
@@ -1074,7 +1120,8 @@ function createHttpMiddleware$1(options) {
     retryConfig,
     getAbortController,
     includeOriginalRequest,
-    includeRequestInErrorResponse,
+    includeRequestInErrorResponse = true,
+    includeResponseHeaders = true,
     maskSensitiveHeaderData,
     httpClientOptions
   } = options;
@@ -1110,6 +1157,7 @@ function createHttpMiddleware$1(options) {
         headers: requestHeader,
         includeRequestInErrorResponse,
         maskSensitiveHeaderData,
+        includeResponseHeaders,
         ...httpClientOptions
       };
       if (credentialsMode) {
@@ -1143,43 +1191,17 @@ function createHttpMiddleware$1(options) {
   };
 }
 
-// error, info, success
 function createLoggerMiddleware$1(options) {
   return next => {
     return async request => {
       let response = await next(request);
       const originalResponse = Object.assign({}, response);
       const {
-        loggerFn = console.log,
-        // logLevel = 'ERROR',
-        maskSensitiveHeaderData = true,
-        includeOriginalRequest = true,
-        includeResponseHeaders = true
-        // includeRequestInErrorResponse
+        loggerFn = console.log
       } = options || {};
-      if (includeOriginalRequest && maskSensitiveHeaderData) {
-        maskAuthData(response.request);
-      }
-      if (!includeOriginalRequest) {
-        const {
-          request,
-          ...rest
-        } = response;
-        response = rest;
-      }
-      if (!includeResponseHeaders) {
-        const {
-          headers,
-          ...rest
-        } = response;
-        response = rest;
-      }
       if (loggerFn && typeof loggerFn == 'function') {
         loggerFn(response);
-        // return originalResponse
       }
-
-      // console.log({ Response: response })
       return originalResponse;
     };
   };
@@ -1231,7 +1253,7 @@ function createQueueMiddleware$1({
 
 var packageJson = {
 	name: "@commercetools/ts-client",
-	version: "1.2.1",
+	version: "2.0.1",
 	engines: {
 		node: ">=14"
 	},
@@ -1267,7 +1289,7 @@ var packageJson = {
 		"abort-controller": "3.0.0",
 		buffer: "^6.0.3",
 		"node-fetch": "^2.6.1",
-		uuid: "9.0.1"
+		uuid: "10.0.0"
 	},
 	files: [
 		"dist",
@@ -1290,7 +1312,8 @@ var packageJson = {
 	scripts: {
 		organize_imports: "find src -type f -name '*.ts' | xargs organize-imports-cli",
 		postbuild: "yarn organize_imports",
-		post_process_generate: "yarn organize_imports"
+		post_process_generate: "yarn organize_imports",
+		docs: "typedoc --out docs"
 	}
 };
 
@@ -1298,7 +1321,7 @@ function createUserAgentMiddleware$1(options) {
   return next => async request => {
     const userAgent = createUserAgent({
       ...options,
-      name: `commercetools-sdk-javascript-v3/${packageJson.version}`
+      name: `${options.name ? options.name + '/' : ''}commercetools-sdk-javascript-v3/${packageJson.version}`
     });
     const requestWithUserAgent = {
       ...request,
@@ -1320,7 +1343,7 @@ var middleware = /*#__PURE__*/Object.freeze({
   createAuthMiddlewareForRefreshTokenFlow: createAuthMiddlewareForRefreshTokenFlow$1,
   createConcurrentModificationMiddleware: createConcurrentModificationMiddleware$1,
   createCorrelationIdMiddleware: createCorrelationIdMiddleware$1,
-  createErrorMiddleware: createErrorMiddleware$1,
+  createErrorMiddleware: createErrorMiddleware,
   createHttpMiddleware: createHttpMiddleware$1,
   createLoggerMiddleware: createLoggerMiddleware$1,
   createQueueMiddleware: createQueueMiddleware$1,
@@ -1486,8 +1509,7 @@ const {
   createLoggerMiddleware,
   createQueueMiddleware,
   createUserAgentMiddleware,
-  createConcurrentModificationMiddleware,
-  createErrorMiddleware
+  createConcurrentModificationMiddleware
 } = middleware;
 class ClientBuilder {
   constructor() {
@@ -1499,7 +1521,9 @@ class ClientBuilder {
     _defineProperty(this, "loggerMiddleware", void 0);
     _defineProperty(this, "queueMiddleware", void 0);
     _defineProperty(this, "concurrentMiddleware", void 0);
-    _defineProperty(this, "errorMiddleware", void 0);
+    _defineProperty(this, "telemetryMiddleware", void 0);
+    _defineProperty(this, "beforeMiddleware", void 0);
+    _defineProperty(this, "afterMiddleware", void 0);
     _defineProperty(this, "middlewares", []);
     this.userAgentMiddleware = createUserAgentMiddleware({});
   }
@@ -1618,30 +1642,49 @@ class ClientBuilder {
     });
     return this;
   }
-  withConcurrentModificationMiddleware() {
-    this.concurrentMiddleware = createConcurrentModificationMiddleware();
+  withConcurrentModificationMiddleware(options) {
+    this.concurrentMiddleware = createConcurrentModificationMiddleware(options?.concurrentModificationHandlerFn);
     return this;
   }
-  withErrorMiddleware(options) {
-    this.errorMiddleware = createErrorMiddleware(options);
+  withTelemetryMiddleware(options) {
+    const {
+      createTelemetryMiddleware,
+      ...rest
+    } = options;
+    this.withUserAgentMiddleware({
+      customAgent: rest?.userAgent || 'typescript-sdk-apm-middleware'
+    });
+    this.telemetryMiddleware = createTelemetryMiddleware(rest);
+    return this;
+  }
+  withBeforeExecutionMiddleware(options) {
+    const {
+      middleware,
+      ...rest
+    } = options || {};
+    this.beforeMiddleware = options.middleware(rest);
+    return this;
+  }
+  withAfterExecutionMiddleware(options) {
+    const {
+      middleware,
+      ...rest
+    } = options || {};
+    this.afterMiddleware = options.middleware(rest);
     return this;
   }
   build() {
     const middlewares = this.middlewares.slice();
-
-    /**
-     * - use default retry policy if not explicity added
-     * - add retry middleware to be used by concurrent modification
-     *   middleware if not explicitly added as part of the middleware
-     */
+    if (this.telemetryMiddleware) middlewares.push(this.telemetryMiddleware);
     if (this.correlationIdMiddleware) middlewares.push(this.correlationIdMiddleware);
     if (this.userAgentMiddleware) middlewares.push(this.userAgentMiddleware);
     if (this.authMiddleware) middlewares.push(this.authMiddleware);
+    if (this.beforeMiddleware) middlewares.push(this.beforeMiddleware);
     if (this.queueMiddleware) middlewares.push(this.queueMiddleware);
     if (this.loggerMiddleware) middlewares.push(this.loggerMiddleware);
-    if (this.errorMiddleware) middlewares.push(this.errorMiddleware);
     if (this.concurrentMiddleware) middlewares.push(this.concurrentMiddleware);
     if (this.httpMiddleware) middlewares.push(this.httpMiddleware);
+    if (this.afterMiddleware) middlewares.push(this.afterMiddleware);
     return createClient({
       middlewares
     });