@commercetools/ts-client 0.0.0-beta.1 → 0.0.0-beta.10

package/README.md

@@ -16,14 +16,13 @@ yarn add @commercetools/platform-sdk
 
 ```ts
 import {
-  type Next
+  type Next,
   type HttpMiddlewareOptions,
-  type AuthMiddlewareBaseOptions
+  type AuthMiddlewareBaseOptions,
   type ClientRequest,
   type MiddlewareRequest,
   type MiddlewareResponse,
-  type Client
-
+  type Client,
   ClientBuilder,
 } from '@commercetools/ts-client'
 import { createApiBuilderFromCtpClient } from '@commercetools/platform-sdk'
@@ -51,7 +50,7 @@ const retryOptions = {
   maxRetries: 3,
   retryDelay: 200,
   backoff: true,
-  retryCodes: [200]
+  retryCodes: [200],
 }
 
 // custom middleware
@@ -69,8 +68,13 @@ function middleware(options) {
 
 const client: Client = new ClientBuilder()
   .withPasswordFlow(authMiddlewareOptions)
-  .withLoggerMiddleware({ includeOriginalRequest: false, includeResponseHeaders: false })
-  .withCorrelationIdMiddleware({ generate: () => 'fake-correlation-id' + Math.floor(Math.random() + 2) })
+  .withLoggerMiddleware({
+    includeOriginalRequest: false,
+    includeResponseHeaders: false,
+  })
+  .withCorrelationIdMiddleware({
+    generate: () => 'fake-correlation-id' + Math.floor(Math.random() + 2),
+  })
   .withHttpMiddleware(httpMiddlewareOptions)
   .withRetryMiddleware(retryOptions)
   .withMiddleware(middleware({})) // <<<------------------- add the custom middleware here

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

@@ -155,6 +155,11 @@ function mergeAuthHeader(token, req) {
   };
 }
 
+function predicate$1(retryCodes, response) {
+  return ! // retryCodes.includes(response?.error?.message) ||
+  [503, ...retryCodes].includes(response?.status || response?.statusCode);
+}
+
 async function executeHttpClientRequest(fetcher, config) {
   async function sendRequest() {
     const response = await fetcher({ ...config,
@@ -178,23 +183,68 @@ async function executor(request) {
     ...rest
   } = request;
   const data = await executeHttpClientRequest(async options => {
-    const response = await httpClient(url, { ...rest,
-      ...options,
-      headers: { ...rest.headers,
-        ...options.headers,
-        // axios header encoding
-        'Accept-Encoding': 'application/json'
-      },
-      // for axios
-      ...(rest.body ? {
-        data: rest.body
-      } : {}),
-      withCredentials: options.credentialsMode === 'include'
-    });
+    const {
+      enableRetry,
+      retryConfig
+    } = rest;
+    const {
+      retryCodes = [],
+      maxDelay = Infinity,
+      maxRetries = 3,
+      backoff = true,
+      retryDelay = 200
+    } = retryConfig || {};
+    let retryCount = 0; // validate the `retryCodes` option
+
+    validateRetryCodes(retryCodes);
+
+    async function execute() {
+      return httpClient(url, { ...rest,
+        ...options,
+        headers: { ...rest.headers,
+          ...options.headers,
+          // axios header encoding
+          'Accept-Encoding': 'application/json'
+        },
+        // for axios
+        ...(rest.body ? {
+          data: rest.body
+        } : {}),
+        withCredentials: options.credentialsMode === 'include'
+      });
+    }
+
+    async function executeWithRetry() {
+      // first attempt
+      let _response = await execute();
+
+      if (predicate$1(retryCodes, _response)) return _response; // retry attempts
+
+      while (enableRetry && retryCount < maxRetries) {
+        retryCount++;
+        _response = await execute();
+        if (predicate$1(retryCodes, _response)) return _response; // delay next execution
+
+        const timer = calculateRetryDelay({
+          retryCount,
+          retryDelay,
+          maxRetries,
+          backoff,
+          maxDelay
+        });
+        await sleep(timer);
+      }
+
+      return _response;
+    }
+
+    const response = await executeWithRetry(); // parse response as json or return the data object (for axios response)
+
     const data = response.json && typeof response.json == 'function' ? await response.json() : response.data || response;
     return {
       data,
-      statusCode: response.status || response.statusCode,
+      retryCount,
+      statusCode: response.status || response.statusCode || data.statusCode,
       headers: response.headers
     };
   },
@@ -215,6 +265,102 @@ function sleep(ms) {
 
 var METHODS = ['ACL', 'BIND', 'CHECKOUT', 'CONNECT', 'COPY', 'DELETE', 'GET', 'HEAD', 'LINK', 'LOCK', 'M-SEARCH', 'MERGE', 'MKACTIVITY', 'MKCALENDAR', 'MKCOL', 'MOVE', 'NOTIFY', 'OPTIONS', 'PATCH', 'POST', 'PROPFIND', 'PROPPATCH', 'PURGE', 'PUT', 'REBIND', 'REPORT', 'SEARCH', 'SOURCE', 'SUBSCRIBE', 'TRACE', 'UNBIND', 'UNLINK', 'UNLOCK', 'UNSUBSCRIBE'];
 
+// class DefineError {
+//   name: string
+//   code: number
+//   status: number
+//   statusCode: number
+//   message: string
+//   constructor(statusCode: number, message: string, meta: object) {
+//     this.status = this.statusCode = this.code = statusCode
+//     this.message = message
+//     Object.assign(this, meta)
+//     this.name = this.constructor.name
+//     this.constructor.prototype.__proto__ = Error.prototype
+//     if (Error.captureStackTrace) Error.captureStackTrace(this, this.constructor)
+//   }
+// }
+function DefineError(statusCode, message, meta = {}) {
+  // eslint-disable-next-line no-multi-assign
+  this.status = this.statusCode = this.code = statusCode;
+  this.message = message;
+  Object.assign(this, meta);
+  this.name = this.constructor.name; // eslint-disable-next-line no-proto
+
+  this.constructor.prototype.__proto__ = Error.prototype;
+  if (Error.captureStackTrace) Error.captureStackTrace(this, this.constructor);
+}
+
+function NetworkError(...args) {
+  DefineError.call(this, 0, ...args);
+}
+function HttpError(...args) {
+  DefineError.call(this, ...args);
+}
+function BadRequest(...args) {
+  DefineError.call(this, 400, ...args);
+}
+function Unauthorized(...args) {
+  DefineError.call(this, 401, ...args);
+}
+function Forbidden(...args) {
+  DefineError.call(this, 403, ...args);
+}
+function NotFound(...args) {
+  DefineError.call(this, 404);
+}
+function ConcurrentModification(...args) {
+  DefineError.call(this, 409, ...args);
+}
+function InternalServerError(...args) {
+  DefineError.call(this, 500, ...args);
+}
+function ServiceUnavailable(...args) {
+  DefineError.call(this, 503, ...args);
+}
+function getErrorByCode(code) {
+  switch (code) {
+    case 0:
+      return NetworkError;
+
+    case 400:
+      return BadRequest;
+
+    case 401:
+      return Unauthorized;
+
+    case 403:
+      return Forbidden;
+
+    case 404:
+      return NotFound;
+
+    case 409:
+      return ConcurrentModification;
+
+    case 500:
+      return InternalServerError;
+
+    case 503:
+      return ServiceUnavailable;
+
+    default:
+      return undefined;
+  }
+}
+
+function createError({
+  statusCode,
+  message,
+  ...rest
+}) {
+  let errorMessage = message || 'Unexpected non-JSON error response';
+  if (statusCode === 404) errorMessage = `URI not found: ${rest.originalRequest.uri}`;
+  const ResponseError = getErrorByCode(statusCode);
+  if (ResponseError) return new ResponseError(errorMessage, rest);
+  return new HttpError(statusCode, errorMessage, rest);
+}
+
 /**
  * validate some essential http options
  * @param options
@@ -370,26 +516,30 @@ function createClient(middlewares) {
   const resolver = {
     async resolve(rs) {
       const {
-        reject,
-        resolve,
         response,
-        retryCount,
+        includeOriginalRequest,
         ...rest
       } = rs;
+      const {
+        retryCount,
+        ...restt
+      } = response;
       const res = {
         body: null,
         error: null,
-        reject,
-        resolve,
-        ...(retryCount ? {
-          retryCount
+        reject: rs.reject,
+        resolve: rs.resolve,
+        ...restt,
+        ...(includeOriginalRequest ? {
+          originalRequest: rest
         } : {}),
-        request: rest,
-        ...response
-      };
+        ...(response?.retryCount ? {
+          retryCount: response.retryCount
+        } : {})
+      }; // if (res.error) console.log(res)
 
       if (res.error) {
-        res.reject(res);
+        res.reject(res.error);
         return res;
       }
 
@@ -444,13 +594,15 @@ function createCorrelationIdMiddleware$1(options) {
 
 async function executeRequest$1({
   url,
-  clientOptions,
-  httpClient
+  httpClient,
+  clientOptions
 }) {
   let timer;
   const {
     timeout,
-    abortController
+    request,
+    abortController,
+    includeRequestInErrorResponse
   } = clientOptions;
 
   try {
@@ -470,33 +622,60 @@ async function executeRequest$1({
     if (response.statusCode >= 200 && response.statusCode < 300) {
       if (clientOptions.method == 'HEAD') {
         return {
+          body: null,
           statusCode: response.statusCode,
+          retryCount: response.retryCount,
           headers: getHeaders(response.headers)
         };
       }
 
       return {
-        body: response.data || response,
+        body: response.data,
         statusCode: response.statusCode,
+        retryCount: response.retryCount,
         headers: getHeaders(response.headers)
       };
     }
+
+    const error = createError({
+      message: response.data.message || response.message,
+      statusCode: response.statusCode || response.data.statusCode,
+      headers: getHeaders(response.headers),
+      method: clientOptions.method,
+      body: response.data,
+      retryCount: response.retryCount,
+      ...(includeRequestInErrorResponse ? {
+        originalRequest: request
+      } : {})
+    });
     /**
      * handle non-ok (error) response
      * build error body
      */
 
-
     return {
-      error: {
-        message: response.message || response.data.message,
-        method: clientOptions.method,
-        ...response
-      }
+      body: response.data,
+      code: response.statusCode,
+      statusCode: response.statusCode,
+      headers: getHeaders(response.headers),
+      error // error: {
+      //   statusCode: response.statusCode || response.data.statusCode,
+      //   message: response.data.message,
+      //   method: clientOptions.method,
+      //   ...response.data,
+      // },
+
     };
-  } catch (error) {
+  } catch (e) {
+    const error = new NetworkError(e.message, {
+      statusCode: 0,
+      body: e,
+      error: e
+    });
     return {
       // We know that this is a network error
+      statusCode: 0,
+      body: error,
       error
     };
   } finally {
@@ -512,7 +691,11 @@ function createHttpMiddleware$1(options) {
     credentialsMode,
     httpClient,
     timeout,
+    enableRetry,
+    retryConfig,
     getAbortController,
+    includeOriginalRequest,
+    includeRequestInErrorResponse,
     httpClientOptions
   } = options;
   return next => {
@@ -535,8 +718,12 @@ function createHttpMiddleware$1(options) {
       }
 
       const clientOptions = {
+        enableRetry,
+        retryConfig,
+        request: request,
         method: request.method,
         headers: requestHeader,
+        includeRequestInErrorResponse,
         ...httpClientOptions
       };
 
@@ -564,6 +751,7 @@ function createHttpMiddleware$1(options) {
         httpClient
       });
       const responseWithRequest = { ...request,
+        includeOriginalRequest,
         response
       };
       return next(responseWithRequest);
@@ -642,21 +830,31 @@ function createRetryMiddleware$1(options) {
 
     async function executeRequest() {
       // first attenpt
+      // retryCount++
       response = await next(request);
-      retryCount++;
 
       if (predicate(retryCodes, response)) {
-        return { ...response
+        request.resolve({ ...response
+        });
+        return { ...response // retryCount
+
         };
       }
 
       while (retryCount < maxRetries) {
         // check if the response if worth retrying for subsequest calls
-        response = await next(request);
         retryCount++;
+        response = await next({ ...request,
+          retryCount
+        });
 
         if (predicate(retryCodes, response)) {
-          return { ...response
+          // request.resolve({
+          //   ...response,
+          //   retryCount
+          // })
+          return { ...response,
+            retryCount
           };
         } // delay next execution
 
@@ -669,7 +867,11 @@ function createRetryMiddleware$1(options) {
           maxDelay
         });
         await sleep(timer);
-      }
+      } // response.reject({
+      //   ...response,
+      //   retryCount
+      // })
+
 
       return { ...response,
         retryCount
@@ -728,7 +930,7 @@ function createLoggerMiddleware$1(options) {
 
 var packageJson = {
 	name: "@commercetools/ts-client",
-	version: "0.0.1-beta.0",
+	version: "0.0.0-beta.9",
 	engines: {
 		node: ">=14"
 	},
@@ -761,7 +963,6 @@ var packageJson = {
 		url: "https://github.com/commercetools/commercetools-sdk-typescript/issues"
 	},
 	dependencies: {
-		axios: "^1.2.0",
 		buffer: "^6.0.3",
 		"node-fetch": "^2.6.1",
 		querystring: "^0.2.1"
@@ -1110,6 +1311,7 @@ async function executeRequest(options) {
       headers: { ...request.headers
       },
       response: {
+        body: null,
         statusCode: error.statusCode || 0,
         error: { ...response,
           error,
@@ -1322,6 +1524,7 @@ const {
   createErrorMiddleware
 } = middleware;
 class ClientBuilder {
+  // private retryMiddleware: Nullable<Middleware>
   constructor() {
     _defineProperty(this, "projectKey", void 0);
 
@@ -1337,8 +1540,6 @@ class ClientBuilder {
 
     _defineProperty(this, "queueMiddleware", void 0);
 
-    _defineProperty(this, "retryMiddleware", void 0);
-
     _defineProperty(this, "concurrentMiddleware", void 0);
 
     _defineProperty(this, "errorMiddleware", void 0);
@@ -1433,13 +1634,13 @@ class ClientBuilder {
       refreshToken: options.refreshToken || null,
       ...options
     }));
-  }
+  } // public withRetryMiddleware(options: RetryMiddlewareOptions): ClientBuilder {
+  //   this.retryMiddleware = createRetryMiddleware({
+  //     ...options,
+  //   })
+  //   return this
+  // }
 
-  withRetryMiddleware(options) {
-    this.retryMiddleware = createRetryMiddleware({ ...options
-    });
-    return this;
-  }
 
   withExistingTokenFlow(authorization, options) {
     return this.withAuthMiddleware(createAuthMiddlewareForExistingTokenFlow(authorization, {
@@ -1501,15 +1702,16 @@ class ClientBuilder {
      * - add retry middleware to be used by concurrent modification
      *   middleware if not explicitly added as part of the middleware
      */
+    // if (!this.retryMiddleware && this.concurrentMiddleware)
+    //   this.withRetryMiddleware({})
 
-    if (!this.retryMiddleware && this.concurrentMiddleware) this.withRetryMiddleware({});
     if (this.correlationIdMiddleware) middlewares.push(this.correlationIdMiddleware);
     if (this.userAgentMiddleware) middlewares.push(this.userAgentMiddleware);
     if (this.authMiddleware) middlewares.push(this.authMiddleware);
     if (this.queueMiddleware) middlewares.push(this.queueMiddleware);
     if (this.loggerMiddleware) middlewares.push(this.loggerMiddleware);
-    if (this.errorMiddleware) middlewares.push(this.errorMiddleware);
-    if (this.retryMiddleware) middlewares.push(this.retryMiddleware);
+    if (this.errorMiddleware) middlewares.push(this.errorMiddleware); // if (this.retryMiddleware) middlewares.push(this.retryMiddleware)
+
     if (this.concurrentMiddleware) middlewares.push(this.concurrentMiddleware);
     if (this.httpMiddleware) middlewares.push(this.httpMiddleware);
     return createClient({