chargebee 3.7.0 → 3.8.0-beta.1

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,5 +1,5 @@
-import { extend, callbackifyPromise, getApiURL, encodeListParams, encodeParams, serialize, getHost, } from './util.js';
-import { handleResponse } from './coreCommon.js';
+import { extend, callbackifyPromise, getApiURL, encodeListParams, encodeParams, serialize, getHost, log, generateUUIDv4 as uuidv4, } from './util';
+import { handleResponse } from './coreCommon';
 import { Buffer } from 'node:buffer';
 export class RequestWrapper {
     constructor(args, apiCall, envArg) {
@@ -20,72 +20,133 @@ export 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 = {};
         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'] = 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';
+            extend(true, requestHeaders, {
+                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,
+            });
+            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/asyncApiSupport.js

@@ -1,4 +1,4 @@
-import { isFunction, extend, callbackifyPromise } from './util.js';
+import { isFunction, extend, callbackifyPromise } from './util';
 export const waitForProcessToComplete = (retrieveHandling, env) => {
     if (typeof retrieveHandling == 'undefined' || !isFunction(retrieveHandling)) {
         throw new Error('The handling parameter should be a method.');

package/esm/coreCommon.js

@@ -1,5 +1,5 @@
-import { ChargebeeError } from './chargebeeError.js';
-import { isNotUndefinedNEmpty } from './util.js';
+import { ChargebeeError } from './chargebeeError';
+import { isNotUndefinedNEmpty } from './util';
 const IDEMPOTENCY_REPLAYED_HEADER = 'chargebee-idempotency-replayed';
 export function throwError(callBack, rawError, headers) {
     const error = new ChargebeeError({

package/esm/createChargebee.js

@@ -1,8 +1,8 @@
-import { RequestWrapper } from './RequestWrapper.js';
-import { Environment } from './environment.js';
-import { Endpoints } from './resources/api_endpoints.js';
-import { extend, sleep } from './util.js';
-import { waitForProcessToComplete } from './asyncApiSupport.js';
+import { RequestWrapper } from './RequestWrapper';
+import { Environment } from './environment';
+import { Endpoints } from './resources/api_endpoints';
+import { extend, sleep } from './util';
+import { waitForProcessToComplete } from './asyncApiSupport';
 export const CreateChargebee = (httpClient) => {
     const Chargebee = function (conf) {
         this._env = Object.assign({}, Environment);
@@ -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.6.1',
+    clientVersion: 'v3.8.0-beta.1',
     port: DEFAULT_PORT,
     timemachineWaitInMillis: DEFAULT_TIME_MACHINE_WAIT,
     exportWaitInMillis: DEFAULT_EXPORT_WAIT,

package/esm/net/ClientInterface.js

@@ -1,4 +1,4 @@
-import { ChargebeeError } from '../chargebeeError.js';
+import { ChargebeeError } from '../chargebeeError';
 export class HttpClient {
     async makeApiRequest(props) {
         throw new Error('makeApiRequest is not implemented');

package/esm/net/FetchClient.js

@@ -1,4 +1,4 @@
-import { HttpClient, HttpClientResponse, } from './ClientInterface.js';
+import { HttpClient, HttpClientResponse, } from './ClientInterface';
 export class FetchHttpClient extends HttpClient {
     async makeApiRequest(props) {
         const headers = this._createHeaders(props.headers);

package/esm/net/NodeClient.js

@@ -1,4 +1,4 @@
-import { HttpClient, HttpClientResponse, } from './ClientInterface.js';
+import { HttpClient, HttpClientResponse, } from './ClientInterface';
 import * as http from 'http';
 import * as https from 'https';
 export class NodeHttpClient extends HttpClient {