@commercetools/ts-client 1.2.1 → 2.0.1

package/CHANGELOG.md

@@ -1,5 +1,17 @@
 # @commercetools/ts-client
 
+## 2.0.1
+
+### Patch Changes
+
+- [#767](https://github.com/commercetools/commercetools-sdk-typescript/pull/767) [`d82a9e0`](https://github.com/commercetools/commercetools-sdk-typescript/commit/d82a9e0e6666e076183172a9229ffcda8e28905a) Thanks [@ajimae](https://github.com/ajimae)! - Fix issues with request state not being reset back to default on error when fetching token.
+
+## 2.0.0
+
+### Major Changes
+
+- [#708](https://github.com/commercetools/commercetools-sdk-typescript/pull/708) [`e7e5ac7`](https://github.com/commercetools/commercetools-sdk-typescript/commit/e7e5ac73de07a8ce141ec0bc2b2abf492462ec73) Thanks [@lojzatran](https://github.com/lojzatran)! - Make ts-sdk-v3 consistent with v2
+
 ## 1.2.1
 
 ### Patch Changes

package/README.md

@@ -78,7 +78,6 @@ const client: Client = new ClientBuilder()
   .withHttpMiddleware(httpMiddlewareOptions)
   .withRetryMiddleware(retryOptions)
   .withMiddleware(middleware({})) // <<<------------------- add the custom middleware here
-  .withErrorMiddleware({})
   .build()
 
 const apiRoot = createApiBuilderFromCtpClient(client)

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

@@ -121,10 +121,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() {
@@ -151,14 +152,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,
@@ -184,15 +188,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({
@@ -432,7 +462,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.');
 }
 
 /**
@@ -638,7 +667,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,
@@ -711,8 +743,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: {
@@ -727,6 +761,10 @@ async function executeRequest$1(options) {
       }
     });
   } catch (error) {
+    /**
+     * on error release the state by setting it to false
+     */
+    requestState.set(false);
     return {
       ...request,
       headers: {
@@ -914,7 +952,7 @@ function createAuthMiddlewareForRefreshTokenFlow$1(options) {
   };
 }
 
-function createConcurrentModificationMiddleware$1() {
+function createConcurrentModificationMiddleware$1(modifierFunction) {
   return next => {
     return async request => {
       const response = await next(request);
@@ -928,13 +966,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);
         }
       }
@@ -956,7 +998,7 @@ function createCorrelationIdMiddleware$1(options) {
   };
 }
 
-function createErrorMiddleware$1(options) {
+function createErrorMiddleware(options) {
   return next => async request => {
     const response = await next(request);
     if (response.error) {
@@ -988,7 +1030,8 @@ async function executeRequest({
     request,
     abortController,
     maskSensitiveHeaderData,
-    includeRequestInErrorResponse
+    includeRequestInErrorResponse,
+    includeResponseHeaders
   } = clientOptions;
   try {
     if (timeout) timer = setTimeout(() => {
@@ -1003,6 +1046,9 @@ async function executeRequest({
         body: clientOptions.body
       } : {})
     });
+    if (!includeResponseHeaders) {
+      response.headers = null;
+    }
     if (response.statusCode >= 200 && response.statusCode < 300) {
       if (clientOptions.method == 'HEAD') {
         return {
@@ -1046,7 +1092,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({
@@ -1083,7 +1129,8 @@ function createHttpMiddleware$1(options) {
     retryConfig,
     getAbortController,
     includeOriginalRequest,
-    includeRequestInErrorResponse,
+    includeRequestInErrorResponse = true,
+    includeResponseHeaders = true,
     maskSensitiveHeaderData,
     httpClientOptions
   } = options;
@@ -1119,6 +1166,7 @@ function createHttpMiddleware$1(options) {
         headers: requestHeader,
         includeRequestInErrorResponse,
         maskSensitiveHeaderData,
+        includeResponseHeaders,
         ...httpClientOptions
       };
       if (credentialsMode) {
@@ -1152,43 +1200,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;
     };
   };
@@ -1240,7 +1262,7 @@ function createQueueMiddleware$1({
 
 var packageJson = {
 	name: "@commercetools/ts-client",
-	version: "1.2.1",
+	version: "2.0.1",
 	engines: {
 		node: ">=14"
 	},
@@ -1276,7 +1298,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",
@@ -1299,7 +1321,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"
 	}
 };
 
@@ -1307,7 +1330,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,
@@ -1329,7 +1352,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,
@@ -1495,8 +1518,7 @@ const {
   createLoggerMiddleware,
   createQueueMiddleware,
   createUserAgentMiddleware,
-  createConcurrentModificationMiddleware,
-  createErrorMiddleware
+  createConcurrentModificationMiddleware
 } = middleware;
 class ClientBuilder {
   constructor() {
@@ -1508,7 +1530,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({});
   }
@@ -1627,30 +1651,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
     });