chargebee 3.8.0 → 3.10.0

package/CHANGELOG.md

@@ -1,3 +1,19 @@
+### v3.10.0 (2025-06-30)
+* * * 
+
+### New Features
+* Added `userAgentSuffix` to the environment config to allow appending custom text to the `User-Agent` header.
+
+
+### v3.9.0 (2025-06-23)
+* * * 
+
+### New Features
+* Added built-in retry support for handling transient errors and rate-limiting.
+* Retries are now supported for HTTP status codes 500, 502, 503, 504, and 429.
+* Includes exponential backoff for server errors and Retry-After respect for rate limits (429).
+* Configurable via retryConfig during SDK initialization.
+
 ### v3.8.0 (2025-06-19)
 * * * 
 

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

@@ -23,72 +23,136 @@ class RequestWrapper {
         }
         return idParam;
     }
-    request() {
-        let env = {};
-        (0, util_js_1.extend)(true, env, this.envArg);
+    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);
+        const env = _env;
+        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 &&
+            retryConfig.enabled) {
+            this.httpHeaders['chargebee-idempotency-key'] = (0, util_js_1.generateUUIDv4)();
+        }
+        const makeRequest = async (attempt = 0) => {
+            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') {
+                const queryParam = this.apiCall.isListReq
+                    ? (0, util_js_1.encodeListParams)((0, util_js_1.serialize)(params))
+                    : (0, util_js_1.encodeParams)((0, util_js_1.serialize)(params));
+                path += '?' + queryParam;
+                params = {};
+            }
+            const jsonKeys = this.apiCall.jsonKeys;
+            const data = this.apiCall.isJsonRequest
+                ? JSON.stringify(params)
+                : (0, util_js_1.encodeParams)(params, undefined, undefined, undefined, jsonKeys);
+            const requestHeaders = Object.assign({}, this.httpHeaders);
+            if (data.length) {
+                (0, util_js_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';
+            const userAgent = `Chargebee-NodeJs-Client ${env.clientVersion}${env.userAgentSuffix ? ';' + env.userAgentSuffix : ''}`;
+            (0, util_js_1.extend)(true, requestHeaders, {
+                Authorization: 'Basic ' + node_buffer_1.Buffer.from(env.apiKey + ':').toString('base64'),
+                Accept: 'application/json',
+                'Content-Type': contentType,
+                'User-Agent': userAgent,
+                '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_js_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_js_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_js_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_js_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_js_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_js_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);
-            }
-        });
+        };
+        const promise = withRetry(0, Date.now());
         return (0, util_js_1.callbackifyPromise)(promise);
     }
 }

package/cjs/createChargebee.js

@@ -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.8.0',
+    clientVersion: 'v3.10.0',
     port: DEFAULT_PORT,
     timemachineWaitInMillis: DEFAULT_TIME_MACHINE_WAIT,
     exportWaitInMillis: DEFAULT_EXPORT_WAIT,

package/cjs/util.js

@@ -7,53 +7,50 @@ exports.serialize = serialize;
 exports.encodeListParams = encodeListParams;
 exports.getHost = getHost;
 exports.encodeParams = encodeParams;
+exports.log = log;
+exports.generateUUIDv4 = generateUUIDv4;
 const extend = (deep, target, copy) => {
     _extendsFn(deep, target, copy);
 };
 exports.extend = extend;
 const _extendsFn = (...args) => {
-    {
-        let options, name, src, copy, copyIsArray, clone, target = args[0] || {}, i = 1, length = args.length, deep = false;
-        if (typeof target === 'boolean') {
-            deep = target;
-            target = args[1] || {};
-            i = 2;
-        }
-        if (typeof target !== 'object' && typeof target !== 'function') {
-            target = {};
-        }
-        if (length === i) {
-            target = this;
-            --i;
-        }
-        for (; i < length; i++) {
-            if ((options = args[i]) !== null) {
-                for (name in options) {
-                    src = target[name];
-                    copy = options[name];
-                    if (target === copy) {
-                        continue;
-                    }
-                    if (deep &&
-                        copy &&
-                        (typeof copy === 'object' || (copyIsArray = (0, exports.isArray)(copy)))) {
-                        if (copyIsArray) {
-                            copyIsArray = false;
-                            clone = src && (0, exports.isArray)(src) ? src : [];
-                        }
-                        else {
-                            clone = src && typeof src === 'object' ? src : {};
-                        }
-                        target[name] = (0, exports.extend)(deep, clone, copy);
+    let options, name, src, copy, copyIsArray, clone;
+    let target = args[0] || {};
+    let i = 1;
+    const length = args.length;
+    let deep = false;
+    if (typeof target === 'boolean') {
+        deep = target;
+        target = args[1] || {};
+        i = 2;
+    }
+    if (typeof target !== 'object' && typeof target !== 'function') {
+        target = {};
+    }
+    for (; i < length; i++) {
+        if ((options = args[i]) !== null && options !== undefined) {
+            for (name in options) {
+                src = target[name];
+                copy = options[name];
+                if (target === copy) {
+                    continue;
+                }
+                if (deep && copy && (typeof copy === 'object' || (0, exports.isArray)(copy))) {
+                    if ((0, exports.isArray)(copy)) {
+                        clone = (0, exports.isArray)(src) ? src : [];
                     }
-                    else if (copy !== undefined) {
-                        target[name] = copy;
+                    else {
+                        clone = (0, exports.isObject)(src) ? src : {};
                     }
+                    target[name] = _extendsFn(deep, clone, copy);
+                }
+                else if (copy !== undefined) {
+                    target[name] = copy;
                 }
             }
         }
-        return target;
     }
+    return target;
 };
 const isArray = (obj) => {
     return (Array.isArray(obj) ||
@@ -221,3 +218,31 @@ function encodeParams(paramObj, serialized, scope, index, jsonKeys, level = 0) {
     }
     return serialized.join('&').replace(/%20/g, '+');
 }
+function log(env, { level = 'INFO', message = '', context = {}, functionName = '' }) {
+    if (!env.enableDebugLogs) {
+        return;
+    }
+    const timestamp = new Date().toISOString();
+    const service = 'chargebee-node';
+    const metaString = Object.entries(context)
+        .map(([key, value]) => `${key}=${value}`)
+        .join(', ');
+    const logLine = `[${timestamp}] [${level.toUpperCase()}] [${service}] ${functionName} - ${message}${metaString ? ` (${metaString})` : ''}`;
+    console.debug(logLine);
+}
+const crypto_1 = require("crypto");
+function generateUUIDv4() {
+    const bytes = (0, crypto_1.randomBytes)(16);
+    // Set version to 4 (UUIDv4)
+    bytes[6] = (bytes[6] & 0x0f) | 0x40;
+    // Set variant to 10xxxxxx
+    bytes[8] = (bytes[8] & 0x3f) | 0x80;
+    const hex = bytes.toString('hex');
+    return [
+        hex.slice(0, 8),
+        hex.slice(8, 12),
+        hex.slice(12, 16),
+        hex.slice(16, 20),
+        hex.slice(20),
+    ].join('-');
+}

package/esm/RequestWrapper.js

@@ -1,4 +1,4 @@
-import { extend, callbackifyPromise, getApiURL, encodeListParams, encodeParams, serialize, getHost, } from './util.js';
+import { extend, callbackifyPromise, getApiURL, encodeListParams, encodeParams, serialize, getHost, log, generateUUIDv4 as uuidv4, } from './util.js';
 import { handleResponse } from './coreCommon.js';
 import { Buffer } from 'node:buffer';
 export class RequestWrapper {
@@ -20,72 +20,136 @@ export class RequestWrapper {
         }
         return idParam;
     }
-    request() {
-        let env = {};
-        extend(true, env, this.envArg);
+    static parseRetryAfter(retryAfter) {
+        if (!retryAfter)
+            return null;
+        const seconds = parseInt(retryAfter, 10);
+        if (!isNaN(seconds)) {
+            return seconds * 1000;
+        }
+        return null;
+    }
+    async request() {
+        let _env = {};
+        extend(true, _env, this.envArg);
+        const env = _env;
+        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 &&
+            retryConfig.enabled) {
+            this.httpHeaders['chargebee-idempotency-key'] = uuidv4();
+        }
+        const makeRequest = async (attempt = 0) => {
+            let path = 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
+                    ? encodeListParams(serialize(params))
+                    : encodeParams(serialize(params));
+                path += '?' + queryParam;
+                params = {};
+            }
+            const jsonKeys = this.apiCall.jsonKeys;
+            const data = this.apiCall.isJsonRequest
+                ? JSON.stringify(params)
+                : encodeParams(params, undefined, undefined, undefined, jsonKeys);
+            const requestHeaders = Object.assign({}, this.httpHeaders);
+            if (data.length) {
+                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';
+            const userAgent = `Chargebee-NodeJs-Client ${env.clientVersion}${env.userAgentSuffix ? ';' + env.userAgentSuffix : ''}`;
+            extend(true, requestHeaders, {
+                Authorization: 'Basic ' + Buffer.from(env.apiKey + ':').toString('base64'),
+                Accept: 'application/json',
+                'Content-Type': contentType,
+                'User-Agent': userAgent,
+                '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: 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) => {
+                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 = getApiURL(env, this.apiCall.urlPrefix, this.apiCall.urlSuffix, urlIdParam);
-                if (typeof params === 'undefined' || params === null) {
-                    params = {};
-                }
-                if (this.apiCall.httpMethod === 'GET') {
-                    params = serialize(params);
-                    let queryParam = this.apiCall.isListReq
-                        ? encodeListParams(params)
-                        : 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) {
+                        log(env, {
+                            level: 'ERROR',
+                            message: `Rate limit error occurred, but no retry-after header found. Retrying in ${retryConfig.delayMs}ms.`,
+                        });
+                        throw err;
+                    }
+                    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)
-                    : encodeParams(params, undefined, undefined, undefined, jsonKeys);
-                if (data.length) {
-                    extend(true, this.httpHeaders, {
-                        'Content-Length': data.length,
+                else {
+                    const canRetry = retryConfig.enabled &&
+                        retryConfig.retryOn.includes(statusCode) &&
+                        retryCount < retryConfig.maxRetries;
+                    if (!canRetry) {
+                        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;
+                    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';
-                extend(true, this.httpHeaders, {
-                    Authorization: 'Basic ' + 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: getHost(env, this.apiCall.subDomain),
-                    port: env.port,
-                    path,
-                    method: this.apiCall.httpMethod,
-                    protocol: env.protocol,
-                    headers: this.httpHeaders,
-                    data: data,
-                    timeout: env.timeout,
-                });
-                handleResponse(callBackWrapper, resp);
+                return await withRetry(retryCount + 1, startTime);
             }
-            catch (err) {
-                callBackWrapper(err, null);
-            }
-        });
+        };
+        const promise = withRetry(0, Date.now());
         return callbackifyPromise(promise);
     }
 }

package/esm/createChargebee.js

@@ -78,6 +78,7 @@ export 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/esm/environment.js

@@ -8,7 +8,7 @@ export const Environment = {
     hostSuffix: '.chargebee.com',
     apiPath: '/api/v2',
     timeout: DEFAULT_TIME_OUT,
-    clientVersion: 'v3.8.0',
+    clientVersion: 'v3.10.0',
     port: DEFAULT_PORT,
     timemachineWaitInMillis: DEFAULT_TIME_MACHINE_WAIT,
     exportWaitInMillis: DEFAULT_EXPORT_WAIT,

package/esm/util.js

@@ -2,48 +2,43 @@ export const extend = (deep, target, copy) => {
     _extendsFn(deep, target, copy);
 };
 const _extendsFn = (...args) => {
-    {
-        let options, name, src, copy, copyIsArray, clone, target = args[0] || {}, i = 1, length = args.length, deep = false;
-        if (typeof target === 'boolean') {
-            deep = target;
-            target = args[1] || {};
-            i = 2;
-        }
-        if (typeof target !== 'object' && typeof target !== 'function') {
-            target = {};
-        }
-        if (length === i) {
-            target = this;
-            --i;
-        }
-        for (; i < length; i++) {
-            if ((options = args[i]) !== null) {
-                for (name in options) {
-                    src = target[name];
-                    copy = options[name];
-                    if (target === copy) {
-                        continue;
-                    }
-                    if (deep &&
-                        copy &&
-                        (typeof copy === 'object' || (copyIsArray = isArray(copy)))) {
-                        if (copyIsArray) {
-                            copyIsArray = false;
-                            clone = src && isArray(src) ? src : [];
-                        }
-                        else {
-                            clone = src && typeof src === 'object' ? src : {};
-                        }
-                        target[name] = extend(deep, clone, copy);
+    let options, name, src, copy, copyIsArray, clone;
+    let target = args[0] || {};
+    let i = 1;
+    const length = args.length;
+    let deep = false;
+    if (typeof target === 'boolean') {
+        deep = target;
+        target = args[1] || {};
+        i = 2;
+    }
+    if (typeof target !== 'object' && typeof target !== 'function') {
+        target = {};
+    }
+    for (; i < length; i++) {
+        if ((options = args[i]) !== null && options !== undefined) {
+            for (name in options) {
+                src = target[name];
+                copy = options[name];
+                if (target === copy) {
+                    continue;
+                }
+                if (deep && copy && (typeof copy === 'object' || isArray(copy))) {
+                    if (isArray(copy)) {
+                        clone = isArray(src) ? src : [];
                     }
-                    else if (copy !== undefined) {
-                        target[name] = copy;
+                    else {
+                        clone = isObject(src) ? src : {};
                     }
+                    target[name] = _extendsFn(deep, clone, copy);
+                }
+                else if (copy !== undefined) {
+                    target[name] = copy;
                 }
             }
         }
-        return target;
     }
+    return target;
 };
 export const isArray = (obj) => {
     return (Array.isArray(obj) ||
@@ -205,3 +200,31 @@ export function encodeParams(paramObj, serialized, scope, index, jsonKeys, level
     }
     return serialized.join('&').replace(/%20/g, '+');
 }
+export function log(env, { level = 'INFO', message = '', context = {}, functionName = '' }) {
+    if (!env.enableDebugLogs) {
+        return;
+    }
+    const timestamp = new Date().toISOString();
+    const service = 'chargebee-node';
+    const metaString = Object.entries(context)
+        .map(([key, value]) => `${key}=${value}`)
+        .join(', ');
+    const logLine = `[${timestamp}] [${level.toUpperCase()}] [${service}] ${functionName} - ${message}${metaString ? ` (${metaString})` : ''}`;
+    console.debug(logLine);
+}
+import { randomBytes } from 'crypto';
+export function generateUUIDv4() {
+    const bytes = randomBytes(16);
+    // Set version to 4 (UUIDv4)
+    bytes[6] = (bytes[6] & 0x0f) | 0x40;
+    // Set variant to 10xxxxxx
+    bytes[8] = (bytes[8] & 0x3f) | 0x80;
+    const hex = bytes.toString('hex');
+    return [
+        hex.slice(0, 8),
+        hex.slice(8, 12),
+        hex.slice(12, 16),
+        hex.slice(16, 20),
+        hex.slice(20),
+    ].join('-');
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "chargebee",
-  "version": "3.8.0",
+  "version": "3.10.0",
   "description": "A library for integrating with Chargebee.",
   "scripts": {
     "prepack": "npm install && npm run build",

package/types/index.d.ts

@@ -122,6 +122,34 @@ export type Config = {
    * @hostSuffix url host suffix, default value is .chargebee.com
    */
   hostSuffix?: string;
+
+  /**
+   * @retryConfig retry configuration for the client, default value is { enabled: false, maxRetries: 3, delayMs: 1000, retryOn: [500, 502, 503, 504]}
+   */
+  retryConfig?: RetryConfig;
+
+  /**
+   * @enableDebugLogs whether to enable debug logs, default value is false
+   */
+  enableDebugLogs?: boolean;
+
+  /**
+   * @userAgentSuffix optional string appended to the User-Agent header for additional logging
+   */
+  userAgentSuffix?: string;
+};
+
+export type RetryConfig = {
+  /**
+   * @enabled whether to enable retry logic, default value is false
+   * @maxRetries maximum number of retries, default value is 3
+   * @delayMs delay in milliseconds between retries, default value is 1000ms
+   * @retryOn array of HTTP status codes to retry on, default value is [500, 502, 503, 504]
+   */
+  enabled?: boolean;
+  maxRetries?: number;
+  delayMs?: number;
+  retryOn?: Array<number>;
 };
 declare module 'chargebee' {
   export default class Chargebee {