chargebee 2.40.0 → 3.0.0-beta.1

package/cjs/util.js

@@ -0,0 +1,218 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.sleep = exports.isFunction = exports.isNotUndefinedNEmpty = exports.trim = exports.isObject = exports.isArray = exports.extend = void 0;
+exports.callbackifyPromise = callbackifyPromise;
+exports.getApiURL = getApiURL;
+exports.serialize = serialize;
+exports.encodeListParams = encodeListParams;
+exports.getHost = getHost;
+exports.encodeParams = encodeParams;
+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);
+                    }
+                    else if (copy !== undefined) {
+                        target[name] = copy;
+                    }
+                }
+            }
+        }
+        return target;
+    }
+};
+const isArray = (obj) => {
+    return (Array.isArray(obj) ||
+        Object.prototype.toString.call(obj) === '[object Array]');
+};
+exports.isArray = isArray;
+const isObject = (obj) => {
+    return Object.prototype.toString.call(obj) === '[object Object]';
+};
+exports.isObject = isObject;
+// const indexOf = (array, item) => {
+//     if (![].indexOf(undefined)) {
+//         for (let i = 0; i < array.length; i++) {
+//             if (array[i] === item) {
+//                 return i;
+//             }
+//         }
+//         return -1;
+//     } else {
+//         return array.indexOf(item);
+//     }
+// }
+const trim = (str) => {
+    return str !== '' ? str : str.replace(/^\s+|\s+$/g, '');
+};
+exports.trim = trim;
+const isEmptyObject = (obj) => {
+    let name;
+    for (name in obj) {
+        return false;
+    }
+    return true;
+};
+const isNotUndefinedNEmpty = (obj) => {
+    if (typeof obj !== 'undefined' && !isEmptyObject(obj)) {
+        return true;
+    }
+    return false;
+};
+exports.isNotUndefinedNEmpty = isNotUndefinedNEmpty;
+const isFunction = (obj) => {
+    return typeof obj === 'function';
+};
+exports.isFunction = isFunction;
+const sleep = (milliseconds) => {
+    return new Promise((resolve) => setTimeout(resolve, milliseconds));
+};
+exports.sleep = sleep;
+function callbackifyPromise(promise, callback) {
+    if (callback) {
+        return promise.then((res) => {
+            setTimeout(() => {
+                callback(null, res);
+            }, 0);
+        }, (err) => {
+            setTimeout(() => {
+                callback(err, null);
+            }, 0);
+        });
+    }
+    return promise;
+}
+function getApiURL(env, urlPrefix, urlSuffix, urlIdParam) {
+    if (typeof env.apiKey === 'undefined' || typeof env.site === 'undefined') {
+        throw new Error('Your site or api key is not configured.');
+    }
+    return (env.apiPath +
+        urlPrefix +
+        (urlIdParam !== null //
+            ? '/' + encodeURIComponent(urlIdParam).replace(/%2F/g, '/')
+            : '') +
+        (urlSuffix !== null ? urlSuffix : ''));
+}
+function serialize(paramObj) {
+    let key, value;
+    let array_ops = ['in', 'not_in', 'between'];
+    for (key in paramObj) {
+        value = paramObj[key];
+        if (typeof value === 'object' && (0, exports.isObject)(value)) {
+            let old_key = key;
+            let child_key;
+            for (child_key in value) {
+                key = key + '[' + child_key + ']';
+                paramObj[key] = value[child_key];
+                if (array_ops.includes(child_key)) {
+                    paramObj[key] = JSON.stringify(value[child_key]);
+                }
+            }
+            delete paramObj[old_key];
+            serialize(paramObj);
+        }
+        else {
+            paramObj[key] = value;
+        }
+    }
+    return paramObj;
+}
+function encodeListParams(paramObj) {
+    let key, value;
+    for (key in paramObj) {
+        value = paramObj[key];
+        if (typeof value !== 'undefined' && value !== null && (0, exports.isArray)(value)) {
+            paramObj[key] = JSON.stringify(value);
+        }
+        else {
+            paramObj[key] = value;
+        }
+    }
+    return encodeParams(paramObj);
+}
+function getHost(env) {
+    return env.site + env.hostSuffix;
+}
+function encodeParams(paramObj, serialized, scope, index) {
+    let key, value;
+    if (typeof serialized === 'undefined' || serialized === null) {
+        serialized = [];
+    }
+    for (key in paramObj) {
+        value = paramObj[key];
+        if (scope) {
+            key = '' + scope + '[' + key + ']';
+        }
+        if (typeof index !== 'undefined' && index !== null) {
+            key = key + '[' + index + ']';
+        }
+        if ((0, exports.isArray)(value)) {
+            for (let arrIdx = 0; arrIdx < value.length; arrIdx++) {
+                if (typeof value[arrIdx] === 'object' || (0, exports.isArray)(value[arrIdx])) {
+                    encodeParams(value[arrIdx], serialized, key, arrIdx);
+                }
+                else {
+                    if (typeof value[arrIdx] !== 'undefined') {
+                        serialized.push(encodeURIComponent(key + '[' + arrIdx + ']') +
+                            '=' +
+                            encodeURIComponent((0, exports.trim)(value[arrIdx]) !== '' ? value[arrIdx] : ''));
+                    }
+                }
+            }
+        }
+        else if (key === 'meta_data') {
+            let attrVal = '';
+            if (value !== null) {
+                attrVal = encodeURIComponent(Object.prototype.toString.call(value) === '[object String]'
+                    ? (0, exports.trim)(value)
+                    : JSON.stringify(value));
+            }
+            serialized.push(encodeURIComponent(key) + '=' + attrVal);
+        }
+        else if (typeof value === 'object' && !(0, exports.isArray)(value)) {
+            encodeParams(value, serialized, key);
+        }
+        else {
+            if (typeof value !== 'undefined') {
+                serialized.push(encodeURIComponent(key) +
+                    '=' +
+                    encodeURIComponent((0, exports.trim)(value) !== '' ? value : ''));
+            }
+        }
+    }
+    return serialized.join('&').replace(/%20/g, '+');
+}

package/esm/RequestWrapper.js

@@ -0,0 +1,77 @@
+import { extend, callbackifyPromise, getApiURL, encodeListParams, encodeParams, serialize, getHost, } from './util.js';
+import { handleResponse } from './coreCommon.js';
+import { Buffer } from 'node:buffer';
+const IDEMPOTENCY_HEADER = 'chargebee-idempotency-key';
+export class RequestWrapper {
+    constructor(args, apiCall, envArg) {
+        this.getRequest = () => {
+            return this.request();
+        };
+        this.args = args;
+        this.apiCall = apiCall;
+        this.envArg = envArg;
+        this.httpHeaders = {};
+        if (this.apiCall.hasIdInUrl) {
+            RequestWrapper._validateIdParam(this.args[0]);
+        }
+    }
+    static _validateIdParam(idParam) {
+        if (!idParam || typeof idParam !== 'string' || idParam.trim().length < 1) {
+            throw new Error('the required id parameter missing or wrong');
+        }
+        return idParam;
+    }
+    request() {
+        let env = {};
+        extend(true, env, this.envArg);
+        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);
+                }
+            }
+            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 = {};
+            }
+            let data = encodeParams(params);
+            extend(true, this.httpHeaders, {
+                Authorization: 'Basic ' + Buffer.from(env.apiKey + ':').toString('base64'),
+                Accept: 'application/json',
+                'Content-Type': 'application/x-www-form-urlencoded; charset=utf-8',
+                'Content-Length': data.length,
+                'User-Agent': 'Chargebee-NodeJs-Client ' + env.clientVersion,
+                'Lang-Version': typeof process === 'undefined' ? '' : process.version,
+            });
+            const resp = await this.envArg.httpClient.makeApiRequest({
+                host: getHost(env),
+                port: env.port,
+                path,
+                method: this.apiCall.httpMethod,
+                protocol: env.protocol,
+                headers: this.httpHeaders,
+                data: data,
+                timeout: env.timeout,
+            });
+            handleResponse(callBackWrapper, resp);
+        });
+        return callbackifyPromise(promise);
+    }
+}

package/esm/asyncApiSupport.js

@@ -0,0 +1,35 @@
+import { isFunction, extend, callbackifyPromise } from './util.js';
+export const waitForProcessToComplete = (retrieveHandling, env) => {
+    if (typeof retrieveHandling == 'undefined' || !isFunction(retrieveHandling)) {
+        throw new Error('The handling parameter should be a method.');
+    }
+    const DummyRequestWrapper = function () {
+        this.request = _request;
+    };
+    const _request = function (callBack, envOptions) {
+        const jsonConstructor = {}.constructor;
+        if (typeof envOptions !== 'undefined') {
+            extend(true, env, envOptions);
+        }
+        else if (typeof callBack !== 'undefined' &&
+            callBack.constructor === jsonConstructor &&
+            !isFunction(callBack)) {
+            extend(true, env, callBack);
+            callBack = undefined;
+        }
+        if (typeof callBack !== 'undefined' && !isFunction(callBack)) {
+            throw new Error('The callback parameter passed is incorrect.');
+        }
+        const promise = new Promise((resolve, reject) => {
+            try {
+                const result = retrieveHandling();
+                resolve(result);
+            }
+            catch (err) {
+                reject(err);
+            }
+        });
+        return callbackifyPromise(promise, callBack);
+    };
+    return new DummyRequestWrapper();
+};

package/esm/chargebee.esm.js

@@ -0,0 +1,9 @@
+import { CreateChargebee } from './createChargebee.js';
+import { NodeHttpClient } from './net/NodeClient.js';
+import { FetchHttpClient } from './net/FetchClient.js';
+//@ts-ignore
+const httpClient = globalThis.fetch
+    ? new NodeHttpClient()
+    : new FetchHttpClient();
+const Chargebee = CreateChargebee(httpClient);
+export default Chargebee;

package/esm/chargebee.esm.worker.js

@@ -0,0 +1,5 @@
+import { CreateChargebee } from './createChargebee.js';
+import { FetchHttpClient } from './net/FetchClient.js';
+const httpClient = new FetchHttpClient();
+const Chargebee = CreateChargebee(httpClient);
+export default Chargebee;

package/esm/chargebeeError.js

@@ -0,0 +1,13 @@
+export class ChargebeeError extends Error {
+    constructor(rawError, headers) {
+        super(rawError.message);
+        this.message = rawError.message;
+        this.type = rawError.type;
+        this.api_error_code = rawError.api_error_code;
+        this.http_status_code = rawError.http_status_code;
+        this.http_code = rawError.http_code;
+        this.error_code = rawError.error_code;
+        this.detail = rawError === null || rawError === void 0 ? void 0 : rawError.detail;
+        this.headers = headers;
+    }
+}

package/esm/coreCommon.js

@@ -0,0 +1,67 @@
+import { ChargebeeError } from './chargebeeError.js';
+import { isNotUndefinedNEmpty } from './util.js';
+const IDEMPOTENCY_REPLAYED_HEADER = 'chargebee-idempotency-replayed';
+export function throwError(callBack, rawError, headers) {
+    const error = new ChargebeeError({
+        message: rawError.message,
+        type: rawError.type,
+        api_error_code: rawError.errorCode,
+        http_status_code: rawError.httpStatusCode,
+        http_code: rawError.httpStatusCode,
+        error_code: rawError.errorCode,
+    }, headers);
+    if (rawError['detail'] !== 'undefined') {
+        error['detail'] = rawError['detail'];
+    }
+    return callBack(error, null);
+}
+export const handleResponse = async (callback, response) => {
+    try {
+        const res = await response.toJson();
+        const status = response.getStatusCode();
+        const headers = response.getHeaders();
+        if (status && (status < 200 || status > 299)) {
+            res.http_status_code = status;
+            res.headers = headers;
+            return callback(res, null);
+        }
+        else {
+            res.isIdempotencyReplayed = false;
+            if (isNotUndefinedNEmpty(headers[IDEMPOTENCY_REPLAYED_HEADER])) {
+                res.isIdempotencyReplayed = headers[IDEMPOTENCY_REPLAYED_HEADER];
+            }
+            res.headers = headers;
+            return callback(null, res);
+        }
+    }
+    catch (error) {
+        const status = response.getStatusCode();
+        const headers = response.getHeaders();
+        switch (status) {
+            case 503:
+                return throwError(callback, {
+                    type: 'internal_temporary_error',
+                    httpStatusCode: 503,
+                    errorCode: 'internal_temporary_error',
+                    message: 'Sorry, the server is currently unable to handle the request due to a temporary overload or scheduled maintenance. Please retry after sometime.',
+                    detail: error,
+                }, headers);
+            case 504:
+                return throwError(callback, {
+                    type: 'gateway_timeout',
+                    httpStatusCode: 504,
+                    errorCode: 'gateway_timeout',
+                    message: 'The server did not receive a timely response from an upstream server, request aborted. If this problem persists, contact us at support@chargebee.com.',
+                    detail: error,
+                }, headers);
+            default:
+                return throwError(callback, {
+                    type: 'internal_error',
+                    httpStatusCode: 500,
+                    errorCode: 'internal_error',
+                    message: 'Sorry, something went wrong when trying to process the request. If this problem persists, contact us at support@chargebee.com.',
+                    detail: error,
+                }, headers);
+        }
+    }
+};

package/esm/createChargebee.js

@@ -0,0 +1,88 @@
+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';
+export const CreateChargebee = (httpClient) => {
+    const Chargebee = function (conf) {
+        this._env = Object.assign({}, Environment);
+        extend(true, this._env, conf);
+        // @ts-ignore
+        this._env.httpClient = httpClient;
+        this._buildResources();
+        this._endpoints = Endpoints;
+    };
+    Chargebee.prototype = {
+        _createApiFunc(apiCall, env) {
+            return async function () {
+                const rw = new RequestWrapper(arguments, apiCall, env);
+                return rw.getRequest();
+            };
+        },
+        _waitForExport(exportId) {
+            let count = 0;
+            const retrieve = async () => {
+                while (count++ < 30) {
+                    const result = await this.export.retrieve(exportId).request();
+                    const exportObj = result.export;
+                    if (exportObj.status === 'completed') {
+                        return result;
+                    }
+                    else if (exportObj.status === 'in_process') {
+                        await sleep(this._env.exportWaitInMillis);
+                        continue;
+                    }
+                    else {
+                        return result;
+                    }
+                }
+                throw new Error('Export is taking too long');
+            };
+            return waitForProcessToComplete(retrieve);
+        },
+        _timeMachineWait() {
+            let count = 0;
+            const retrieve = async () => {
+                while (count++ < 30) {
+                    const result = await this.time_machine.retrieve('delorean').request();
+                    const time_machine = result.time_machine;
+                    if (time_machine.time_travel_status === 'succeeded') {
+                        return result;
+                    }
+                    else if (time_machine.time_travel_status === 'in_progress') {
+                        await sleep(this._env.timemachineWaitInMillis);
+                        continue;
+                    }
+                    else {
+                        return result;
+                    }
+                }
+                throw new Error('The time travel is taking too much time');
+            };
+            return waitForProcessToComplete(retrieve);
+        },
+        _buildResources() {
+            for (const res in Endpoints) {
+                this[res] = {};
+                // @ts-ignore
+                const apiCalls = Endpoints[res];
+                for (let apiIdx = 0; apiIdx < apiCalls.length; apiIdx++) {
+                    const metaArr = apiCalls[apiIdx];
+                    const apiCall = {
+                        methodName: metaArr[0],
+                        httpMethod: metaArr[1],
+                        urlPrefix: metaArr[2],
+                        urlSuffix: metaArr[3],
+                        hasIdInUrl: metaArr[4],
+                        isListReq: metaArr[0] === 'list',
+                    };
+                    this[res][apiCall.methodName] = this._createApiFunc(apiCall, this._env);
+                }
+            }
+            this.export.wait_for_export_completion = this._waitForExport.bind(this);
+            this.timeMachine.wait_for_time_travel_completion =
+                this._timeMachineWait.bind(this);
+        },
+    };
+    return Chargebee;
+};

package/esm/environment.js

@@ -0,0 +1,15 @@
+const DEFAULT_PROTOCOL = 'https';
+const DEFAULT_TIME_OUT = 80000;
+const DEFAULT_PORT = 443;
+const DEFAULT_TIME_MACHINE_WAIT = 3000;
+const DEFAULT_EXPORT_WAIT = 3000;
+export const Environment = {
+    protocol: DEFAULT_PROTOCOL,
+    hostSuffix: '.chargebee.com',
+    apiPath: '/api/v2',
+    timeout: DEFAULT_TIME_OUT,
+    clientVersion: 'v3.0.0-beta.1',
+    port: DEFAULT_PORT,
+    timemachineWaitInMillis: DEFAULT_TIME_MACHINE_WAIT,
+    exportWaitInMillis: DEFAULT_EXPORT_WAIT,
+};

package/esm/filter.js

@@ -0,0 +1 @@
+"use strict";

package/esm/net/ClientInterface.js

@@ -0,0 +1,35 @@
+import { ChargebeeError } from '../chargebeeError.js';
+export class HttpClient {
+    async makeApiRequest(props) {
+        throw new Error('makeApiRequest is not implemented');
+    }
+    static timeOutError() {
+        const error = new ChargebeeError({
+            message: 'io_error',
+            type: 'timeout',
+            api_error_code: 'request aborted due to timeout.',
+            http_status_code: 504,
+            http_code: 504,
+            error_code: 'request aborted due to timeout.',
+        }, null);
+        return error;
+    }
+}
+export class HttpClientResponse {
+    constructor(statusCode, headers) {
+        this._statusCode = statusCode;
+        this._headers = headers;
+    }
+    getStatusCode() {
+        return this._statusCode;
+    }
+    getHeaders() {
+        return this._headers;
+    }
+    getRawResponse() {
+        throw new Error('getRawResponse not implemented.');
+    }
+    toJson() {
+        throw new Error('toJSON not implemented.');
+    }
+}

package/esm/net/FetchClient.js

@@ -0,0 +1,81 @@
+import { HttpClient, HttpClientResponse, } from './ClientInterface.js';
+export class FetchHttpClient extends HttpClient {
+    async makeApiRequest(props) {
+        const headers = this._createHeaders(props.headers);
+        let url = `${props.protocol}://${props.host}:${props.port}${props.path}`;
+        let fetchOptions = {
+            method: props.method,
+            headers: headers,
+            body: props.data ? props.data : undefined,
+        };
+        const response = globalThis.AbortController
+            ? await this.fetchWithAbortTimeout(url, fetchOptions, props.timeout)
+            : await this.fetchWithTimeout(url, fetchOptions, props.timeout);
+        return new FetchHttpClientResponse(response);
+    }
+    _createHeaders(httpHeaders) {
+        const headers = new Headers();
+        Object.entries(httpHeaders).forEach(([key, value]) => {
+            headers.append(key, String(value));
+        });
+        return headers;
+    }
+    async fetchWithTimeout(url, fetchOptions, timeout) {
+        let pendingTimeoutId;
+        const timeoutPromise = new Promise((_, reject) => {
+            pendingTimeoutId = setTimeout(() => {
+                pendingTimeoutId = null;
+                reject(HttpClient.timeOutError());
+            }, timeout);
+        });
+        const fetchPromise = fetch(url, fetchOptions);
+        return Promise.race([fetchPromise, timeoutPromise]).finally(() => {
+            if (pendingTimeoutId) {
+                clearTimeout(pendingTimeoutId);
+            }
+        });
+    }
+    async fetchWithAbortTimeout(url, fetchOptions, timeout) {
+        const abort = new AbortController();
+        let timeoutId = setTimeout(() => {
+            timeoutId = null;
+            abort.abort(HttpClient.timeOutError());
+        }, timeout);
+        const fetchPromise = fetch(url, Object.assign(Object.assign({}, fetchOptions), { signal: abort.signal }));
+        fetchPromise.finally(() => {
+            if (timeoutId) {
+                clearTimeout(timeoutId);
+            }
+        });
+        return fetchPromise.catch((err) => {
+            if (err.name === 'AbortError') {
+                throw HttpClient.timeOutError();
+            }
+            else {
+                throw err;
+            }
+        });
+    }
+}
+export class FetchHttpClientResponse extends HttpClientResponse {
+    constructor(response) {
+        super(response.status, FetchHttpClientResponse._transformHeadersToObject(response.headers));
+        this._res = response;
+    }
+    getRawResponse() {
+        return this._res;
+    }
+    toJson() {
+        return this._res.json();
+    }
+    static _transformHeadersToObject(headers) {
+        const headersObj = {};
+        for (const entry of headers) {
+            if (!Array.isArray(entry) || entry.length != 2) {
+                throw new Error('Headers should be an iterable object.');
+            }
+            headersObj[entry[0]] = entry[1];
+        }
+        return headersObj;
+    }
+}