chargebee 2.40.0 → 3.0.0-beta.1

package/cjs/environment.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Environment = void 0;
+const DEFAULT_PROTOCOL = 'https';
+const DEFAULT_TIME_OUT = 80000;
+const DEFAULT_PORT = 443;
+const DEFAULT_TIME_MACHINE_WAIT = 3000;
+const DEFAULT_EXPORT_WAIT = 3000;
+exports.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/cjs/filter.js

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

package/cjs/net/ClientInterface.js

@@ -0,0 +1,40 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.HttpClientResponse = exports.HttpClient = void 0;
+const chargebeeError_js_1 = require("../chargebeeError.js");
+class HttpClient {
+    async makeApiRequest(props) {
+        throw new Error('makeApiRequest is not implemented');
+    }
+    static timeOutError() {
+        const error = new chargebeeError_js_1.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;
+    }
+}
+exports.HttpClient = HttpClient;
+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.');
+    }
+}
+exports.HttpClientResponse = HttpClientResponse;

package/cjs/net/FetchClient.js

@@ -0,0 +1,86 @@
+"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 {
+    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(ClientInterface_js_1.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(ClientInterface_js_1.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 ClientInterface_js_1.HttpClient.timeOutError();
+            }
+            else {
+                throw err;
+            }
+        });
+    }
+}
+exports.FetchHttpClient = FetchHttpClient;
+class FetchHttpClientResponse extends ClientInterface_js_1.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;
+    }
+}
+exports.FetchHttpClientResponse = FetchHttpClientResponse;

package/cjs/net/NodeClient.js

@@ -0,0 +1,61 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NodeHttpClientResponse = exports.NodeHttpClient = void 0;
+const ClientInterface_js_1 = require("./ClientInterface.js");
+const http = require("http");
+const https = require("https");
+class NodeHttpClient extends ClientInterface_js_1.HttpClient {
+    async makeApiRequest(props) {
+        const protocol = props.protocol === 'http' ? http : https;
+        const requestPromise = new Promise((resolve, reject) => {
+            const req = protocol.request({
+                hostname: props.host,
+                path: props.path,
+                method: props.method,
+                port: props.port,
+                headers: props.headers,
+            });
+            req.setTimeout(props.timeout, () => {
+                throw ClientInterface_js_1.HttpClient.timeOutError();
+            });
+            req.on('response', (res) => {
+                resolve(new NodeHttpClientResponse(res));
+            });
+            req.on('error', (error) => {
+                reject(error);
+            });
+            req.write(props.data);
+            req.end();
+        });
+        return requestPromise;
+    }
+}
+exports.NodeHttpClient = NodeHttpClient;
+class NodeHttpClientResponse extends ClientInterface_js_1.HttpClientResponse {
+    constructor(res) {
+        //@ts-ignore
+        super(res.statusCode, res.headers);
+        this._res = res;
+    }
+    getRawResponse() {
+        return this._res;
+    }
+    toJson() {
+        return new Promise((resolve, reject) => {
+            let response = '';
+            this._res.setEncoding('utf8');
+            this._res.on('data', (chunk) => {
+                response += chunk;
+            });
+            this._res.once('end', () => {
+                try {
+                    resolve(JSON.parse(response));
+                }
+                catch (e) {
+                    reject(e);
+                }
+            });
+        });
+    }
+}
+exports.NodeHttpClientResponse = NodeHttpClientResponse;

package/cjs/package.json

@@ -0,0 +1 @@
+{"type":"commonjs"}