chargebee 2.40.0 → 3.0.0-beta.1

package/CHANGELOG.md

@@ -1,3 +1,12 @@
+### v3.0.0-beta.1 (2024-08-26)
+* * *
+
+* Names of the resources, operations etc. have been changed from snake_case to camelCase. For example, configuration option api_key is now apiKey.
+* Minimum Node.js version is 18
+* Class based models are replaced with TypeScript types.
+* Response will contain headers instead of responseHeaders.
+* Response will contain isIdempotencyReplayed field instead of isIdempotencyReplayed() method.
+
 ### v2.40.0 (2024-08-14)
 * * *
 
@@ -2543,4 +2552,4 @@ Support for deleting the plans & addons. See our API documentation on [Delete a
 
 ### v1.0.0  (2014-02-02)
 * * *
-Initial version of ChargeBee NodeJS binding.
+Initial version of ChargeBee NodeJS binding.

package/LICENSE

@@ -1,6 +1,6 @@
 The MIT License
 
-Copyright (c) 2011-2024 ChargeBee, Inc.
+Copyright (c) 2011-2024 Chargebee, Inc.
 
 Permission is hereby granted, free of charge, to any person
 obtaining a copy of this software and associated documentation

package/README.md

@@ -1,229 +1,147 @@
-# Chargebee Node.js Client Library
+# Chargebee Node.js / TypeScript client library (Beta)
 
-[![npm](https://img.shields.io/npm/v/chargebee.svg?maxAge=3)](https://www.npmjs.com/package/chargebee)
-[![npm](https://img.shields.io/npm/dt/chargebee.svg?maxAge=3)](https://www.npmjs.com/package/chargebee)
-
-This is the [node.js](http://nodejs.org/) library for integrating with Chargebee. Sign up for a Chargebee account [here](https://www.chargebee.com).
-
-> **Note**
-> If you’re using [API V1](https://apidocs.chargebee.com/docs/api/v1), head to [chargebee-v1 branch](https://github.com/chargebee/chargebee-node/tree/chargebee-v1).
+This is the [Node.js](http://nodejs.org/) library for integrating with Chargebee. Sign up for a Chargebee account [here](https://www.chargebee.com).
 
 ## Requirements
 
-Node 0.6 or higher.
+Node.js 18 or higher.
 
 ## Installation
 
-Install the latest version of the library with:
+Install the beta version of the library with npm:
 
 ```sh
-npm install chargebee
-# or
-yarn add chargebee
-# or
-pnpm install chargebee
+npm install chargebee@beta
+```
+With pnpm:
+```sh
+pnpm add chargebee@beta
 ```
 
-## Usage
+With yarn:
+```sh
+yarn add chargebee@beta
+```
 
-The package needs to be configured with your site's API key, which is available under Configure Chargebee Section. Refer [here](https://www.chargebee.com/docs/2.0/api_keys.html) for more details. 
+## Usage
 
-The full documentation can be found on the Chargebee API Docs: [https://apidocs.chargebee.com/docs/api?lang=node](https://apidocs.chargebee.com/docs/api?lang=node)
+The package needs to be configured with your site's API key, which is available under Configure Chargebee Section. Refer [here](https://www.chargebee.com/docs/2.0/api_keys.html) for more details.
 
+If you're using ESM / TypeScript:
 
-```js
-const chargebee = require('chargebee');
+```typescript
+import Chargebee from 'chargebee';
 
-chargebee.configure({
-  site: '<YOUR_SITE_NAME>',
-  api_key: '<YOUR_API_KEY>',
+const chargebee = new Chargebee({
+  site: "{{site}}",
+  apiKey: "{{api-key}}",
 });
 ```
 
-Or using ES modules,
+Or using Common JS module system:
 
-```js
-import chargebee from 'chargebee';
+```javascript
+const Chargebee = require('chargebee');
 
-chargebee.configure({
-  site: '<YOUR_SITE_NAME>',
-  api_key: '<YOUR_API_KEY>',
+const chargebee = new Chargebee({
+  site: "{{site}}",
+  apiKey: "{{api-key}}",
 });
-
 ```
 
 ### Using Async / Await
 
-```js
+```typescript
 try {
-  const result = await chargebee.customer
-    .create({
-      email: 'john@test.com',
-      // other params
-    })
-    .request();
-    // access customer as result.customer;
+  const { customer } = await chargebee.customer.create({
+    email: "john@test.com"
+    // other params
+  });
 } catch (err) {
   // handle error
 }
 ```
 
-### Using Promises
-
-```js
-chargebee.customer
-  .create({
-    email: 'john@test.com',
-    // other params
-  })
-  .request()
-  .then((result) => {
-    // handle result
-    // access customer as result.customer;
-  })
-  .catch((err) => {
-    // handle error
-  });
-```
-
-### Using callbacks
-
-```js
-chargebee.customer
-  .create({
-    email: 'john@test.com',
-    // other params
-  })
-  .request(function (error, result) {
-    if (error) {
-      // handle error
-    } else {
-      // handle result
-     // access customer as result.customer;
-    }
-  });
-```
-
-### Usage with TypeScript
-
-You can import the types as shown below.
-
-```ts
-import chargebee, { Customer } from 'chargebee';
-
-chargebee.configure({
-  site: '<YOUR_SITE_NAME>',
-  api_key: '<YOUR_API_KEY>',
-});
-
-const createCustomer = async () => {
-  const inputParams: Customer.CreateInputParam = {
-    email: 'john@test.com',
-    first_name: 'John',
-    last_name: 'Doe',
-  };
-
-  const { customer } = await chargebee.customer.create(inputParams).request();
-  console.log(customer);
-};
-
-createCustomer();
-```
-
 ### Using filters in the List API
 
-For pagination: `offset` is the parameter that is being used. The value used for this parameter must be the value returned for `next_offset` parameter in the previous API call.
+For pagination, `offset` is the parameter that is being used. The value used for this parameter must be the value returned for `next_offset` parameter in the previous API call.
 
-```js
-const fetchCustomers = async (offset) => {
-    const result = await chargebee.customer.list({
+```typescript
+async function getAllCustomers() {
+  const allCustomers: Customer[] = [];
+  let offset: string | undefined = undefined;
+
+  do {
+    const listCustomersReponse = await chargebee.customer.list({
       limit: 2,
-      offset: offset,
-      first_name: { is: 'John' },
-    }).request();
-
-    return {
-      customers: result.list.map((obj) => obj.customer),
-      next_offset: result.next_offset,
-    };
-  };
-
-  const getCustomers = async () => {
-    const { customers, next_offset } = await fetchCustomers();
-    console.log('Offset:', next_offset); // Print the offset value
-
-    // Fetching next set of customers
-    await fetchCustomers(next_offset);
-  };
-
-  getCustomers().catch((err) => {
-    console.log(err);
-  });
+      offset,
+      first_name: {
+        is: "John"
+      }
+    });
+
+    const customers = listCustomersReponse.list.map(
+      (object) => object.customer
+    );
+    
+    allCustomers.push(...customers);
+    offset = listCustomersReponse.next_offset;
+  } while (offset);
+
+  console.log(allCustomers);
+}
 ```
 
-### Using custom headers and custom fields:
-
-```js
-const result = await chargebee.customer
-.create({ email: 'john@test.com', cf_host_url: 'http://xyz.com' }) //Add custom field in payload
-.headers({
-  'chargebee-event-email': 'all-disabled', // To disable webhooks
-  'chargebee-request-origin-ip': '192.168.1.2',
-})
-.setIdempotencyKey("safeKey")
-.request();
+### Using custom headers and custom fields
 
-const customer = result.customer;
-console.log(customer.cf_host_url);
+```typescript
+const { customer } = await chargebee.customer.create(
+  {
+    email: "john@test.com",
+    cf_host_url: "http://xyz.com" // `cf_host_url` is a custom field in Customer object
+  },
+  {
+    "chargebee-event-email": "all-disabled" // To disable webhooks
+  }
+);
 ```
 
 ### Creating an idempotent request
 
 [Idempotency keys](https://apidocs.chargebee.com/docs/api/idempotency?prod_cat_ver=2) are passed along with request headers to allow a safe retry of POST requests.
 
-```js
-const result = await chargebee.customer
-    .create({ email: 'john@test.com' })
-    .setIdempotencyKey("safeKey")
-    .request();
-const customer = result.customer;
-const headers = result.headers;
-const isIdempotencyReplayed = result.isIdempotencyReplayed;
-```
-
-OR
-
-```js
-chargebee.customer.create({ email: 'john@test.com', cf_host_url: 'http://xyz.com' })
-.setIdempotencyKey("safeKey")
-.request(function(error,result) {
-  if(error){
-    //handle error
-  }else{
-    const customer = result.customer;
-    const headers = result.headers;
-    const isIdempotencyReplayed = result.isIdempotencyReplayed;
+```typescript
+const { customer, isIdempotencyReplayed } = await chargebee.customer.create(
+  { email: "john@test.com" },
+  {
+    "chargebee-idempotency-key": "eBs7iOFQuR7asUKHfddyxDDerOuF1JtFrLmDI" // Add idempotency key
   }
-});
+);
+console.log("isIdempotencyReplayed: ", isIdempotencyReplayed);
 ```
 
-### Passing API Keys at request level
+### Creating multiple instances of Chargebee for different sites
+
+```typescript
+const chargebeeSiteUS = new Chargebee({
+  apiKey: "{api-key}",
+  site: "my-site-us"
+});
 
-```js
-const newCust = await chargebee.customer.create({
-  email: 'john@test.com',
-  first_name: 'John',
-  last_name: 'Doe'
-}).request({
-  site: '<YOUR_SITE_NAME>',
-  api_key: '<YOUR_API_KEY>',
+const chargebeeSiteEU = new Chargebee({
+  apiKey: "{api-key}",
+  site: "my-site-eu"
 });
 ```
 
 ### Processing Webhooks - API Version Check
 
-An attribute, <b>api_version</b>, 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.
+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.
+
+## Feedback
+
+If you find any bugs or have any feedback, open an issue in this repository or email it to dx@chargebee.com
 
 ## License
 
-See the [LICENSE](./LICENSE) file.
+See the [LICENSE](./LICENSE) file.

package/cjs/RequestWrapper.js

@@ -0,0 +1,81 @@
+"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 node_buffer_1 = require("node:buffer");
+const IDEMPOTENCY_HEADER = 'chargebee-idempotency-key';
+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 = {};
+        (0, util_js_1.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 = (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 = {};
+            }
+            let data = (0, util_js_1.encodeParams)(params);
+            (0, util_js_1.extend)(true, this.httpHeaders, {
+                Authorization: 'Basic ' + node_buffer_1.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: (0, util_js_1.getHost)(env),
+                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 (0, util_js_1.callbackifyPromise)(promise);
+    }
+}
+exports.RequestWrapper = RequestWrapper;

package/cjs/asyncApiSupport.js

@@ -0,0 +1,39 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.waitForProcessToComplete = void 0;
+const util_js_1 = require("./util.js");
+const waitForProcessToComplete = (retrieveHandling, env) => {
+    if (typeof retrieveHandling == 'undefined' || !(0, util_js_1.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') {
+            (0, util_js_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);
+            callBack = undefined;
+        }
+        if (typeof callBack !== 'undefined' && !(0, util_js_1.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 (0, util_js_1.callbackifyPromise)(promise, callBack);
+    };
+    return new DummyRequestWrapper();
+};
+exports.waitForProcessToComplete = waitForProcessToComplete;

package/cjs/chargebee.cjs.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const createChargebee_js_1 = require("./createChargebee.js");
+const NodeClient_js_1 = require("./net/NodeClient.js");
+const FetchClient_js_1 = require("./net/FetchClient.js");
+//@ts-ignore
+const httpClient = globalThis.fetch
+    ? new NodeClient_js_1.NodeHttpClient()
+    : new FetchClient_js_1.FetchHttpClient();
+const Chargebee = (0, createChargebee_js_1.CreateChargebee)(httpClient);
+module.exports = Chargebee;
+module.exports.Chargebee = Chargebee;
+module.exports.default = Chargebee;

package/cjs/chargebee.cjs.worker.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const createChargebee_js_1 = require("./createChargebee.js");
+const FetchClient_js_1 = require("./net/FetchClient.js");
+const httpClient = new FetchClient_js_1.FetchHttpClient();
+const Chargebee = (0, createChargebee_js_1.CreateChargebee)(httpClient);
+module.exports = Chargebee;
+module.exports.Chargebee = Chargebee;
+module.exports.default = Chargebee;

package/cjs/chargebeeError.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ChargebeeError = void 0;
+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;
+    }
+}
+exports.ChargebeeError = ChargebeeError;

package/cjs/coreCommon.js

@@ -0,0 +1,72 @@
+"use strict";
+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 IDEMPOTENCY_REPLAYED_HEADER = 'chargebee-idempotency-replayed';
+function throwError(callBack, rawError, headers) {
+    const error = new chargebeeError_js_1.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);
+}
+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 ((0, util_js_1.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);
+        }
+    }
+};
+exports.handleResponse = handleResponse;

package/cjs/createChargebee.js

@@ -0,0 +1,92 @@
+"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 CreateChargebee = (httpClient) => {
+    const Chargebee = function (conf) {
+        this._env = Object.assign({}, environment_js_1.Environment);
+        (0, util_js_1.extend)(true, this._env, conf);
+        // @ts-ignore
+        this._env.httpClient = httpClient;
+        this._buildResources();
+        this._endpoints = api_endpoints_js_1.Endpoints;
+    };
+    Chargebee.prototype = {
+        _createApiFunc(apiCall, env) {
+            return async function () {
+                const rw = new RequestWrapper_js_1.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 (0, util_js_1.sleep)(this._env.exportWaitInMillis);
+                        continue;
+                    }
+                    else {
+                        return result;
+                    }
+                }
+                throw new Error('Export is taking too long');
+            };
+            return (0, asyncApiSupport_js_1.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 (0, util_js_1.sleep)(this._env.timemachineWaitInMillis);
+                        continue;
+                    }
+                    else {
+                        return result;
+                    }
+                }
+                throw new Error('The time travel is taking too much time');
+            };
+            return (0, asyncApiSupport_js_1.waitForProcessToComplete)(retrieve);
+        },
+        _buildResources() {
+            for (const res in api_endpoints_js_1.Endpoints) {
+                this[res] = {};
+                // @ts-ignore
+                const apiCalls = api_endpoints_js_1.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;
+};
+exports.CreateChargebee = CreateChargebee;