chargebee 3.7.0 → 3.8.0-beta.1

package/README.md

@@ -143,6 +143,72 @@ const chargebeeSiteEU = new Chargebee({
 
 An attribute `api_version` is added to the [Event](https://apidocs.chargebee.com/docs/api/events) resource, which indicates the API version based on which the event content is structured. In your webhook servers, ensure this `api_version` is the same as the [API version](https://apidocs.chargebee.com/docs/api#versions) used by your webhook server's client library.
 
+### Retry Handling
+
+Chargebee's SDK includes built-in retry logic to handle temporary network issues and server-side errors. This feature is **disabled by default** but can be **enabled when needed**.
+
+#### Key features include:
+
+- **Automatic retries for specific HTTP status codes**: Retries are automatically triggered for status codes `500`, `502`, `503`, and `504`.
+- **Exponential backoff**: Retry delays increase exponentially to prevent overwhelming the server.
+- **Rate limit management**: If a `429 Too Many Requests` response is received with a `Retry-After` header, the SDK waits for the specified duration before retrying.  
+  > *Note: Exponential backoff and max retries do not apply in this case.*
+- **Customizable retry behavior**: Retry logic can be configured using the `retryConfig` parameter in the environment configuration.
+
+#### Example: Customizing Retry Logic
+
+You can enable and configure the retry logic by passing a `retryConfig` object when initializing the Chargebee environment:
+
+```typescript
+import Chargebee from 'chargebee';
+
+const chargebee = new Chargebee({
+  site: "{{site}}",
+  apiKey: "{{api-key}}",
+  retryConfig: {
+    enabled: true, // Enable retry logic
+    maxRetries: 5, // Maximum number of retries
+    delayMs: 300, // Initial delay between retries in milliseconds
+    retryOn: [500, 502, 503, 504], // HTTP status codes to retry on
+  },
+});
+
+try {
+  const { customer } = await chargebee.customer.create({
+    email: "john@test.com",
+  });
+  console.log("Customer created:", customer);
+} catch (err) {
+  console.error("Request failed after retries:", err);
+}
+```
+
+#### Example: Rate Limit retry logic
+
+You can enable and configure the retry logic for rate-limit by passing a `retryConfig` object when initializing the Chargebee environment:
+
+```typescript
+import Chargebee from 'chargebee';
+
+const chargebee = new Chargebee({
+  site: "{{site}}",
+  apiKey: "{{api-key}}",
+  retryConfig: {
+    enabled: true,
+    retryOn: [429], 
+  },
+});
+
+try {
+  const { customer } = await chargebee.customer.create({
+    email: "john@test.com",
+  });
+  console.log("Customer created:", customer);
+} catch (err) {
+  console.error("Request failed after retries:", err);
+}
+```
+
 ## Feedback
 
 If you find any bugs or have any questions / feedback, open an issue in this repository or reach out to us on dx@chargebee.com

package/cjs/RequestWrapper.js

@@ -1,8 +1,8 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.RequestWrapper = void 0;
-const util_js_1 = require("./util.js");
-const coreCommon_js_1 = require("./coreCommon.js");
+const util_1 = require("./util");
+const coreCommon_1 = require("./coreCommon");
 const node_buffer_1 = require("node:buffer");
 class RequestWrapper {
     constructor(args, apiCall, envArg) {
@@ -23,73 +23,134 @@ class RequestWrapper {
         }
         return idParam;
     }
-    request() {
+    static parseRetryAfter(retryAfter) {
+        if (!retryAfter)
+            return null;
+        const seconds = parseInt(retryAfter, 10);
+        if (!isNaN(seconds)) {
+            return seconds * 1000;
+        }
+        return null;
+    }
+    async request() {
         let env = {};
-        (0, util_js_1.extend)(true, env, this.envArg);
+        (0, util_1.extend)(true, env, this.envArg);
+        const retryConfig = Object.assign({ enabled: false, maxRetries: 3, delayMs: 200, retryOn: [500, 502, 503, 504] }, env.retryConfig);
         const urlIdParam = this.apiCall.hasIdInUrl ? this.args[0] : null;
         let params = this.apiCall.hasIdInUrl
             ? this.args[1]
             : this.args[0];
         let headers = this.apiCall.hasIdInUrl ? this.args[2] : this.args[1];
         Object.assign(this.httpHeaders, headers);
-        const promise = new Promise(async (resolve, reject) => {
-            function callBackWrapper(err, response) {
-                if (err) {
-                    reject(err);
-                }
-                else {
-                    resolve(response);
-                }
+        if (this.apiCall.httpMethod === 'POST' &&
+            !this.httpHeaders['chargebee-idempotency-key'] &&
+            this.apiCall.options &&
+            this.apiCall.options.isIdempotent) {
+            this.httpHeaders['chargebee-idempotency-key'] = (0, util_1.generateUUIDv4)();
+        }
+        const makeRequest = async (attempt = 0) => {
+            let path = (0, util_1.getApiURL)(env, this.apiCall.urlPrefix, this.apiCall.urlSuffix, urlIdParam);
+            if (typeof params === 'undefined' || params === null) {
+                params = {};
             }
+            if (this.apiCall.httpMethod === 'GET') {
+                const queryParam = this.apiCall.isListReq
+                    ? (0, util_1.encodeListParams)((0, util_1.serialize)(params))
+                    : (0, util_1.encodeParams)((0, util_1.serialize)(params));
+                path += '?' + queryParam;
+                params = {};
+            }
+            const jsonKeys = this.apiCall.jsonKeys;
+            const data = this.apiCall.isJsonRequest
+                ? JSON.stringify(params)
+                : (0, util_1.encodeParams)(params, undefined, undefined, undefined, jsonKeys);
+            const requestHeaders = Object.assign({}, this.httpHeaders);
+            if (data.length) {
+                (0, util_1.extend)(true, requestHeaders, {
+                    'Content-Length': data.length,
+                });
+            }
+            const contentType = this.apiCall.isJsonRequest
+                ? 'application/json;charset=UTF-8'
+                : 'application/x-www-form-urlencoded; charset=utf-8';
+            (0, util_1.extend)(true, requestHeaders, {
+                Authorization: 'Basic ' + node_buffer_1.Buffer.from(env.apiKey + ':').toString('base64'),
+                Accept: 'application/json',
+                'Content-Type': contentType,
+                'User-Agent': 'Chargebee-NodeJs-Client ' + env.clientVersion,
+                'Lang-Version': typeof process === 'undefined' ? '' : process.version,
+            });
+            if (attempt > 0) {
+                requestHeaders['X-CB-Retry-Attempt'] = attempt.toString();
+            }
+            const resp = await this.envArg.httpClient.makeApiRequest({
+                host: (0, util_1.getHost)(env, this.apiCall.subDomain),
+                port: env.port,
+                path,
+                method: this.apiCall.httpMethod,
+                protocol: env.protocol,
+                headers: requestHeaders,
+                data,
+                timeout: env.timeout,
+            });
+            return new Promise((resolve, reject) => {
+                (0, coreCommon_1.handleResponse)((err, response) => {
+                    if (err)
+                        return reject(err);
+                    return resolve(response);
+                }, resp);
+            });
+        };
+        const delay = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
+        const withRetry = async (retryCount, startTime) => {
+            var _a, _b, _c, _d, _e, _f;
             try {
-                let path = (0, util_js_1.getApiURL)(env, this.apiCall.urlPrefix, this.apiCall.urlSuffix, urlIdParam);
-                if (typeof params === 'undefined' || params === null) {
-                    params = {};
-                }
-                if (this.apiCall.httpMethod === 'GET') {
-                    params = (0, util_js_1.serialize)(params);
-                    let queryParam = this.apiCall.isListReq
-                        ? (0, util_js_1.encodeListParams)(params)
-                        : (0, util_js_1.encodeParams)(params);
-                    path += '?' + queryParam;
-                    params = {};
+                return await makeRequest(retryCount);
+            }
+            catch (err) {
+                const statusCode = (_d = (_c = (_a = err.statusCode) !== null && _a !== void 0 ? _a : (_b = err.response) === null || _b === void 0 ? void 0 : _b.statusCode) !== null && _c !== void 0 ? _c : err.http_code) !== null && _d !== void 0 ? _d : err.http_status_code;
+                const isRateLimitError = statusCode === 429 && retryConfig.enabled;
+                if (isRateLimitError) {
+                    const headers = ((_e = err.response) === null || _e === void 0 ? void 0 : _e.headers) || err.headers || {};
+                    const retryAfterHeader = (_f = headers['retry-after']) === null || _f === void 0 ? void 0 : _f.toLowerCase();
+                    const parsedDelay = RequestWrapper.parseRetryAfter(retryAfterHeader);
+                    if (!parsedDelay) {
+                        (0, util_1.log)(env, {
+                            level: 'ERROR',
+                            message: `Rate limit error occurred, but no retry-after header found. Retrying in ${retryConfig.delayMs}ms.`,
+                        });
+                        throw err;
+                    }
+                    (0, util_1.log)(env, {
+                        level: 'INFO',
+                        message: `Rate limit error occurred. Retrying in ${parsedDelay}ms.`,
+                    });
+                    await delay(parsedDelay);
                 }
-                const jsonKeys = this.apiCall.jsonKeys;
-                let data = this.apiCall.isJsonRequest
-                    ? JSON.stringify(params)
-                    : (0, util_js_1.encodeParams)(params, undefined, undefined, undefined, jsonKeys);
-                if (data.length) {
-                    (0, util_js_1.extend)(true, this.httpHeaders, {
-                        'Content-Length': data.length,
+                else {
+                    const canRetry = retryConfig.enabled &&
+                        retryConfig.retryOn.includes(statusCode) &&
+                        retryCount < retryConfig.maxRetries;
+                    if (!canRetry) {
+                        (0, util_1.log)(env, {
+                            level: 'ERROR',
+                            message: `Request failed after ${retryCount} retries: ${err.message}`,
+                        });
+                        throw err;
+                    }
+                    let retryDelayMs = retryConfig.delayMs * Math.pow(2, retryCount) +
+                        Math.random() * 100;
+                    (0, util_1.log)(env, {
+                        level: 'INFO',
+                        message: `Retrying request [${retryCount + 1}/${retryConfig.maxRetries}] in ${retryDelayMs}ms due to status code ${statusCode}.`,
                     });
+                    await delay(retryDelayMs);
                 }
-                const contentType = this.apiCall.isJsonRequest
-                    ? 'application/json;charset=UTF-8'
-                    : 'application/x-www-form-urlencoded; charset=utf-8';
-                (0, util_js_1.extend)(true, this.httpHeaders, {
-                    Authorization: 'Basic ' + node_buffer_1.Buffer.from(env.apiKey + ':').toString('base64'),
-                    Accept: 'application/json',
-                    'Content-Type': contentType,
-                    'User-Agent': 'Chargebee-NodeJs-Client ' + env.clientVersion,
-                    'Lang-Version': typeof process === 'undefined' ? '' : process.version,
-                });
-                const resp = await this.envArg.httpClient.makeApiRequest({
-                    host: (0, util_js_1.getHost)(env, this.apiCall.subDomain),
-                    port: env.port,
-                    path,
-                    method: this.apiCall.httpMethod,
-                    protocol: env.protocol,
-                    headers: this.httpHeaders,
-                    data: data,
-                    timeout: env.timeout,
-                });
-                (0, coreCommon_js_1.handleResponse)(callBackWrapper, resp);
+                return await withRetry(retryCount + 1, startTime);
             }
-            catch (err) {
-                callBackWrapper(err, null);
-            }
-        });
-        return (0, util_js_1.callbackifyPromise)(promise);
+        };
+        const promise = withRetry(0, Date.now());
+        return (0, util_1.callbackifyPromise)(promise);
     }
 }
 exports.RequestWrapper = RequestWrapper;

package/cjs/asyncApiSupport.js

@@ -1,9 +1,9 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.waitForProcessToComplete = void 0;
-const util_js_1 = require("./util.js");
+const util_1 = require("./util");
 const waitForProcessToComplete = (retrieveHandling, env) => {
-    if (typeof retrieveHandling == 'undefined' || !(0, util_js_1.isFunction)(retrieveHandling)) {
+    if (typeof retrieveHandling == 'undefined' || !(0, util_1.isFunction)(retrieveHandling)) {
         throw new Error('The handling parameter should be a method.');
     }
     const DummyRequestWrapper = function () {
@@ -12,15 +12,15 @@ const waitForProcessToComplete = (retrieveHandling, env) => {
     const _request = function (callBack, envOptions) {
         const jsonConstructor = {}.constructor;
         if (typeof envOptions !== 'undefined') {
-            (0, util_js_1.extend)(true, env, envOptions);
+            (0, util_1.extend)(true, env, envOptions);
         }
         else if (typeof callBack !== 'undefined' &&
             callBack.constructor === jsonConstructor &&
-            !(0, util_js_1.isFunction)(callBack)) {
-            (0, util_js_1.extend)(true, env, callBack);
+            !(0, util_1.isFunction)(callBack)) {
+            (0, util_1.extend)(true, env, callBack);
             callBack = undefined;
         }
-        if (typeof callBack !== 'undefined' && !(0, util_js_1.isFunction)(callBack)) {
+        if (typeof callBack !== 'undefined' && !(0, util_1.isFunction)(callBack)) {
             throw new Error('The callback parameter passed is incorrect.');
         }
         const promise = new Promise((resolve, reject) => {
@@ -32,7 +32,7 @@ const waitForProcessToComplete = (retrieveHandling, env) => {
                 reject(err);
             }
         });
-        return (0, util_js_1.callbackifyPromise)(promise, callBack);
+        return (0, util_1.callbackifyPromise)(promise, callBack);
     };
     return new DummyRequestWrapper();
 };

package/cjs/coreCommon.js

@@ -2,11 +2,11 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.handleResponse = void 0;
 exports.throwError = throwError;
-const chargebeeError_js_1 = require("./chargebeeError.js");
-const util_js_1 = require("./util.js");
+const chargebeeError_1 = require("./chargebeeError");
+const util_1 = require("./util");
 const IDEMPOTENCY_REPLAYED_HEADER = 'chargebee-idempotency-replayed';
 function throwError(callBack, rawError, headers) {
-    const error = new chargebeeError_js_1.ChargebeeError({
+    const error = new chargebeeError_1.ChargebeeError({
         message: rawError.message,
         type: rawError.type,
         api_error_code: rawError.errorCode,
@@ -31,7 +31,7 @@ const handleResponse = async (callback, response) => {
         }
         else {
             res.isIdempotencyReplayed = false;
-            if ((0, util_js_1.isNotUndefinedNEmpty)(headers[IDEMPOTENCY_REPLAYED_HEADER])) {
+            if ((0, util_1.isNotUndefinedNEmpty)(headers[IDEMPOTENCY_REPLAYED_HEADER])) {
                 res.isIdempotencyReplayed = headers[IDEMPOTENCY_REPLAYED_HEADER];
             }
             res.headers = headers;

package/cjs/createChargebee.js

@@ -1,24 +1,24 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.CreateChargebee = void 0;
-const RequestWrapper_js_1 = require("./RequestWrapper.js");
-const environment_js_1 = require("./environment.js");
-const api_endpoints_js_1 = require("./resources/api_endpoints.js");
-const util_js_1 = require("./util.js");
-const asyncApiSupport_js_1 = require("./asyncApiSupport.js");
+const RequestWrapper_1 = require("./RequestWrapper");
+const environment_1 = require("./environment");
+const api_endpoints_1 = require("./resources/api_endpoints");
+const util_1 = require("./util");
+const asyncApiSupport_1 = require("./asyncApiSupport");
 const CreateChargebee = (httpClient) => {
     const Chargebee = function (conf) {
-        this._env = Object.assign({}, environment_js_1.Environment);
-        (0, util_js_1.extend)(true, this._env, conf);
+        this._env = Object.assign({}, environment_1.Environment);
+        (0, util_1.extend)(true, this._env, conf);
         // @ts-ignore
         this._env.httpClient = httpClient;
         this._buildResources();
-        this._endpoints = api_endpoints_js_1.Endpoints;
+        this._endpoints = api_endpoints_1.Endpoints;
     };
     Chargebee.prototype = {
         _createApiFunc(apiCall, env) {
             return async function () {
-                const rw = new RequestWrapper_js_1.RequestWrapper(arguments, apiCall, env);
+                const rw = new RequestWrapper_1.RequestWrapper(arguments, apiCall, env);
                 return rw.getRequest();
             };
         },
@@ -32,7 +32,7 @@ const CreateChargebee = (httpClient) => {
                         return result;
                     }
                     else if (exportObj.status === 'in_process') {
-                        await (0, util_js_1.sleep)(this._env.exportWaitInMillis);
+                        await (0, util_1.sleep)(this._env.exportWaitInMillis);
                         continue;
                     }
                     else {
@@ -41,7 +41,7 @@ const CreateChargebee = (httpClient) => {
                 }
                 throw new Error('Export is taking too long');
             };
-            return (0, asyncApiSupport_js_1.waitForProcessToComplete)(retrieve);
+            return (0, asyncApiSupport_1.waitForProcessToComplete)(retrieve);
         },
         _timeMachineWait() {
             let count = 0;
@@ -53,7 +53,7 @@ const CreateChargebee = (httpClient) => {
                         return result;
                     }
                     else if (time_machine.time_travel_status === 'in_progress') {
-                        await (0, util_js_1.sleep)(this._env.timemachineWaitInMillis);
+                        await (0, util_1.sleep)(this._env.timemachineWaitInMillis);
                         continue;
                     }
                     else {
@@ -62,13 +62,13 @@ const CreateChargebee = (httpClient) => {
                 }
                 throw new Error('The time travel is taking too much time');
             };
-            return (0, asyncApiSupport_js_1.waitForProcessToComplete)(retrieve);
+            return (0, asyncApiSupport_1.waitForProcessToComplete)(retrieve);
         },
         _buildResources() {
-            for (const res in api_endpoints_js_1.Endpoints) {
+            for (const res in api_endpoints_1.Endpoints) {
                 this[res] = {};
                 // @ts-ignore
-                const apiCalls = api_endpoints_js_1.Endpoints[res];
+                const apiCalls = api_endpoints_1.Endpoints[res];
                 for (let apiIdx = 0; apiIdx < apiCalls.length; apiIdx++) {
                     const metaArr = apiCalls[apiIdx];
                     const apiCall = {
@@ -81,6 +81,7 @@ const CreateChargebee = (httpClient) => {
                         subDomain: metaArr[5],
                         isJsonRequest: metaArr[6],
                         jsonKeys: metaArr[7],
+                        options: metaArr[8],
                     };
                     this[res][apiCall.methodName] = this._createApiFunc(apiCall, this._env);
                 }

package/cjs/environment.js

@@ -11,7 +11,7 @@ exports.Environment = {
     hostSuffix: '.chargebee.com',
     apiPath: '/api/v2',
     timeout: DEFAULT_TIME_OUT,
-    clientVersion: 'v3.6.1',
+    clientVersion: 'v3.8.0-beta.1',
     port: DEFAULT_PORT,
     timemachineWaitInMillis: DEFAULT_TIME_MACHINE_WAIT,
     exportWaitInMillis: DEFAULT_EXPORT_WAIT,

package/cjs/net/ClientInterface.js

@@ -1,13 +1,13 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.HttpClientResponse = exports.HttpClient = void 0;
-const chargebeeError_js_1 = require("../chargebeeError.js");
+const chargebeeError_1 = require("../chargebeeError");
 class HttpClient {
     async makeApiRequest(props) {
         throw new Error('makeApiRequest is not implemented');
     }
     static timeOutError() {
-        const error = new chargebeeError_js_1.ChargebeeError({
+        const error = new chargebeeError_1.ChargebeeError({
             message: 'io_error',
             type: 'timeout',
             api_error_code: 'request aborted due to timeout.',

package/cjs/net/FetchClient.js

@@ -1,8 +1,8 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.FetchHttpClientResponse = exports.FetchHttpClient = void 0;
-const ClientInterface_js_1 = require("./ClientInterface.js");
-class FetchHttpClient extends ClientInterface_js_1.HttpClient {
+const ClientInterface_1 = require("./ClientInterface");
+class FetchHttpClient extends ClientInterface_1.HttpClient {
     async makeApiRequest(props) {
         const headers = this._createHeaders(props.headers);
         let url = `${props.protocol}://${props.host}:${props.port}${props.path}`;
@@ -33,7 +33,7 @@ class FetchHttpClient extends ClientInterface_js_1.HttpClient {
         const timeoutPromise = new Promise((_, reject) => {
             pendingTimeoutId = setTimeout(() => {
                 pendingTimeoutId = null;
-                reject(ClientInterface_js_1.HttpClient.timeOutError());
+                reject(ClientInterface_1.HttpClient.timeOutError());
             }, timeout);
         });
         const fetchPromise = fetch(url, fetchOptions);
@@ -47,14 +47,14 @@ class FetchHttpClient extends ClientInterface_js_1.HttpClient {
         const abort = new AbortController();
         let timeoutId = setTimeout(() => {
             timeoutId = null;
-            abort.abort(ClientInterface_js_1.HttpClient.timeOutError());
+            abort.abort(ClientInterface_1.HttpClient.timeOutError());
         }, timeout);
         try {
             return await fetch(url, Object.assign(Object.assign({}, fetchOptions), { signal: abort.signal }));
         }
         catch (err) {
             if (err.name === 'AbortError') {
-                return Promise.reject(ClientInterface_js_1.HttpClient.timeOutError());
+                return Promise.reject(ClientInterface_1.HttpClient.timeOutError());
             }
             else {
                 return Promise.reject(err);
@@ -68,7 +68,7 @@ class FetchHttpClient extends ClientInterface_js_1.HttpClient {
     }
 }
 exports.FetchHttpClient = FetchHttpClient;
-class FetchHttpClientResponse extends ClientInterface_js_1.HttpClientResponse {
+class FetchHttpClientResponse extends ClientInterface_1.HttpClientResponse {
     constructor(response) {
         super(response.status, FetchHttpClientResponse._transformHeadersToObject(response.headers));
         this._res = response;

package/cjs/net/NodeClient.js

@@ -1,10 +1,10 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.NodeHttpClientResponse = exports.NodeHttpClient = void 0;
-const ClientInterface_js_1 = require("./ClientInterface.js");
+const ClientInterface_1 = require("./ClientInterface");
 const http = require("http");
 const https = require("https");
-class NodeHttpClient extends ClientInterface_js_1.HttpClient {
+class NodeHttpClient extends ClientInterface_1.HttpClient {
     async makeApiRequest(props) {
         const protocol = props.protocol === 'http' ? http : https;
         const requestPromise = new Promise((resolve, reject) => {
@@ -16,7 +16,7 @@ class NodeHttpClient extends ClientInterface_js_1.HttpClient {
                 headers: props.headers,
             });
             req.setTimeout(props.timeout, () => {
-                throw ClientInterface_js_1.HttpClient.timeOutError();
+                throw ClientInterface_1.HttpClient.timeOutError();
             });
             req.on('response', (res) => {
                 resolve(new NodeHttpClientResponse(res));
@@ -31,7 +31,7 @@ class NodeHttpClient extends ClientInterface_js_1.HttpClient {
     }
 }
 exports.NodeHttpClient = NodeHttpClient;
-class NodeHttpClientResponse extends ClientInterface_js_1.HttpClientResponse {
+class NodeHttpClientResponse extends ClientInterface_1.HttpClientResponse {
     constructor(res) {
         //@ts-ignore
         super(res.statusCode, res.headers);