nexmo - npm Package Compare versions

Comparing version 2.3.0 to 2.3.1

lib/Conversations.js

 "use strict";
 
 Object.defineProperty(exports, "__esModule", {
-  value: true
+    value: true
 });
@@ -9,7 +9,7 @@
 
-var _index = require("./index");
+var _index = require('./index');
 
 var _index2 = _interopRequireDefault(_index);
 
-var _Members = require("./Members");
+var _Members = require('./Members');
 
@@ -26,131 +26,131 @@ var _Members2 = _interopRequireDefault(_Members);
 var Conversations = function () {
-  _createClass(Conversations, null, [{
-    key: "PATH",
-    get: function get() {
-      return "/beta/conversations";
-    }
+    _createClass(Conversations, null, [{
+        key: 'PATH',
+        get: function get() {
+            return '/beta/conversations';
+        }
 
-    /**
-     * @param {Credentials} credentials
-     *    credentials to be used when interacting with the API.
-     * @param {Object} options
-     *    Additional Conversations options.
-     */
+        /**
+        * @param {Credentials} credentials
+        *    credentials to be used when interacting with the API.
+        * @param {Object} options
+        *    Additional Conversations options.
+        */
 
-  }]);
+    }]);
 
-  function Conversations(credentials) {
-    var options = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
+    function Conversations(credentials) {
+        var options = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
 
-    _classCallCheck(this, Conversations);
+        _classCallCheck(this, Conversations);
 
-    this.creds = credentials;
-    this.options = options;
+        this.creds = credentials;
+        this.options = options;
 
+        /**
+         * @type Members
+         */
+        this.members = new _Members2.default(this.creds, this.options);
+
+        // Used to facilitate testing of the call to the underlying object
+        this._nexmo = this.options.nexmoOverride || _index2.default;
+    }
+
     /**
-     * @type Members
+     * Create a new conversation.
+     *
+     * @param {Object} params - Parameters used when creating the conversation. See https://ea.developer.nexmo.com/api/conversation#create-a-conversation for more information.
+     * @param {function} callback - function to be called when the request completes.
      */
-    this.members = new _Members2.default(this.creds, this.options);
 
-    // Used to facilitate testing of the call to the underlying object
-    this._nexmo = this.options.nexmoOverride || _index2.default;
-  }
 
-  /**
-   * Create a new conversation.
-   *
-   * @param {Object} params - Parameters used when creating the conversation. See https://ea.developer.nexmo.com/api/conversation#create-a-conversation for more information.
-   * @param {function} callback - function to be called when the request completes.
-   */
+    _createClass(Conversations, [{
+        key: 'create',
+        value: function create(params, callback) {
+            params = JSON.stringify(params);
 
+            var config = {
+                host: 'api.nexmo.com',
+                path: Conversations.PATH,
+                method: 'POST',
+                body: params,
+                headers: {
+                    'Content-Type': 'application/json',
+                    'Authorization': 'Bearer ' + this.creds.generateJwt()
+                }
+            };
+            this.options.httpClient.request(config, callback);
+        }
 
-  _createClass(Conversations, [{
-    key: "create",
-    value: function create(params, callback) {
-      params = JSON.stringify(params);
+        /**
+         * Get an existing conversation.
+         *
+         * @param {string|object} query - The unique identifier for the conversation to retrieve
+         *               or a set of filter parameters for the query. For more information
+         *               see https://ea.developer.nexmo.com/api/conversation#retrieve-a-conversation
+         * @param {function} callback - function to be called when the request completes.
+         */
 
-      var config = {
-        host: "api.nexmo.com",
-        path: Conversations.PATH,
-        method: "POST",
-        body: params,
-        headers: {
-          "Content-Type": "application/json",
-          Authorization: "Bearer " + this.creds.generateJwt()
+    }, {
+        key: 'get',
+        value: function get(query, callback) {
+            this._nexmo.getWithQuery(Conversations.PATH, query, this.creds, this.options, callback);
         }
-      };
-      this.options.httpClient.request(config, callback);
-    }
 
-    /**
-     * Get an existing conversation.
-     *
-     * @param {string|object} query - The unique identifier for the conversation to retrieve
-     *               or a set of filter parameters for the query. For more information
-     *               see https://ea.developer.nexmo.com/api/conversation#retrieve-a-conversation
-     * @param {function} callback - function to be called when the request completes.
-     */
+        /**
+         * Update an existing conversation.
+         *
+         * @param {string} [conversationId] - The unique identifier for the conversation to update.
+         * @param {Object} params - Parameters used when updating the conversation.
+         * @param {function} callback - function to be called when the request completes.
+         */
 
-  }, {
-    key: "get",
-    value: function get(query, callback) {
-      this._nexmo.getWithQuery(Conversations.PATH, query, this.creds, this.options, callback);
-    }
+    }, {
+        key: 'update',
+        value: function update(conversationId, params, callback) {
+            params = JSON.stringify(params);
 
-    /**
-     * Update an existing conversation.
-     *
-     * @param {string} [conversationId] - The unique identifier for the conversation to update.
-     * @param {Object} params - Parameters used when updating the conversation.
-     * @param {function} callback - function to be called when the request completes.
-     */
+            var config = {
+                host: 'api.nexmo.com',
+                path: Conversations.PATH + '/' + conversationId,
+                method: 'PUT',
+                body: params,
+                headers: {
+                    'Content-Type': 'application/json',
+                    'Authorization': 'Bearer ' + this.creds.generateJwt()
+                }
+            };
 
-  }, {
-    key: "update",
-    value: function update(conversationId, params, callback) {
-      params = JSON.stringify(params);
-
-      var config = {
-        host: "api.nexmo.com",
-        path: Conversations.PATH + "/" + conversationId,
-        method: "PUT",
-        body: params,
-        headers: {
-          "Content-Type": "application/json",
-          Authorization: "Bearer " + this.creds.generateJwt()
+            this.options.httpClient.request(config, callback);
         }
-      };
 
-      this.options.httpClient.request(config, callback);
-    }
+        /**
+         * Deleta an existing conversation.
+         *
+         * @param {string} [conversationId] - The unique identifier for the conversation to delete.
+         * @param {function} callback - function to be called when the request completes.
+         */
 
-    /**
-     * Deleta an existing conversation.
-     *
-     * @param {string} [conversationId] - The unique identifier for the conversation to delete.
-     * @param {function} callback - function to be called when the request completes.
-     */
+    }, {
+        key: 'delete',
+        value: function _delete(conversationId, callback) {
+            var config = {
+                host: 'api.nexmo.com',
+                path: Conversations.PATH + '/' + conversationId,
+                method: 'DELETE',
+                headers: {
+                    'Content-Type': 'application/json',
+                    'Authorization': 'Bearer ' + this.creds.generateJwt()
+                }
+            };
 
-  }, {
-    key: "delete",
-    value: function _delete(conversationId, callback) {
-      var config = {
-        host: "api.nexmo.com",
-        path: Conversations.PATH + "/" + conversationId,
-        method: "DELETE",
-        headers: {
-          "Content-Type": "application/json",
-          Authorization: "Bearer " + this.creds.generateJwt()
+            this.options.httpClient.request(config, callback);
         }
-      };
+    }]);
 
-      this.options.httpClient.request(config, callback);
-    }
-  }]);
-
-  return Conversations;
+    return Conversations;
 }();
 
 exports.default = Conversations;
-module.exports = exports["default"];
-//# sourceMappingURL=data:application/json;charset=utf-8;base64,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
+module.exports = exports['default'];
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,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

lib/HttpClient.js

@@ -114,5 +114,7 @@ "use strict";
         response.on("close", function (e) {
-          _this.logger.error("problem with API request detailed stacktrace below ");
-          _this.logger.error(e);
-          callback(e);
+          if (e) {
+            _this.logger.error("problem with API request detailed stacktrace below ");
+            _this.logger.error(e);
+            callback(e);
+          }
         });
@@ -347,2 +349,2 @@ });
 module.exports = exports["default"];
-//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"sources":["../src/HttpClient.js"],"names":["https","require","http","request","querystring","HttpClient","options","credentials","host","port","headers","Accept","logger","timeout","requestLib","userAgent","endpoint","method","callback","skipJsonParsing","path","Object","assign","undefined","keys","forEach","key","info","body","end","responseData","on","isBinary","response","setEncoding","push","chunk","statusCode","Buffer","concat","__parseResponse","error","e","httpResponse","data","isArrayOrBuffer","Array","Error","status","message","retryAfterMillis","join","JSON","parse","parseError","limitedAccessStatus","err","_INFO_","params","useJwt","apiKey","apiSecret","stringify","generateJwt","qs","length","joinChar","indexOf","file","formData","value","filename","url","post","Authorization"],"mappings":"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","file":"HttpClient.js","sourcesContent":["var https = require(\"https\");\nvar http = require(\"http\");\nvar request = require(\"request\");\nvar querystring = require(\"querystring\");\n\nclass HttpClient {\n  constructor(options, credentials) {\n    this.credentials = credentials;\n    this.host = options.host || \"rest.nexmo.com\";\n    this.port = options.port || 443;\n    this.https = options.https || https;\n    this.http = options.http || http;\n    this.headers = {\n      \"Content-Type\": \"application/x-www-form-urlencoded\",\n      Accept: \"application/json\"\n    };\n    this.logger = options.logger;\n    this.timeout = options.timeout;\n    this.requestLib = request;\n\n    if (options.userAgent) {\n      this.headers[\"User-Agent\"] = options.userAgent;\n    }\n  }\n\n  request(endpoint, method, callback, skipJsonParsing = false) {\n    if (typeof method === \"function\") {\n      callback = method;\n      endpoint.method = endpoint.method || \"GET\";\n    } else if (typeof method !== \"undefined\") {\n      endpoint.method = method;\n    }\n\n    if (endpoint.method === \"POST\" || endpoint.method === \"DELETE\") {\n      // TODO: verify the following fix is required\n      // Fix broken due ot 411 Content-Length error now sent by Nexmo API\n      // PL 2016-Sept-6 - commented out Content-Length 0\n      // headers['Content-Length'] = 0;\n    }\n    var options = {\n      host: endpoint.host ? endpoint.host : this.host,\n      port: this.port,\n      path: endpoint.path,\n      method: endpoint.method,\n      headers: Object.assign({}, this.headers)\n    };\n\n    if (this.timeout !== undefined) {\n      options.timeout = this.timeout;\n    }\n\n    // Allow existing headers to be overridden\n    // Allow new headers to be added\n    if (endpoint.headers) {\n      Object.keys(endpoint.headers).forEach(function(key) {\n        options.headers[key] = endpoint.headers[key];\n      });\n    }\n\n    this.logger.info(\"Request:\", options, \"\\nBody:\", endpoint.body);\n    var request;\n\n    if (options.port === 443) {\n      request = this.https.request(options);\n    } else {\n      request = this.http.request(options);\n    }\n\n    request.end(endpoint.body);\n\n    // Keep an array of String or Buffers,\n    // depending on content type (binary or JSON) of response\n    var responseData = [];\n\n    request.on(\"response\", response => {\n      var isBinary =\n        response.headers[\"content-type\"] === \"application/octet-stream\";\n      if (!isBinary) {\n        response.setEncoding(\"utf8\");\n      }\n\n      response.on(\"data\", chunk => {\n        responseData.push(chunk);\n      });\n\n      response.on(\"end\", () => {\n        this.logger.info(\"response ended:\", response.statusCode);\n        if (callback) {\n          if (isBinary) {\n            responseData = Buffer.concat(responseData);\n          }\n\n          this.__parseResponse(\n            response,\n            responseData,\n            endpoint.method,\n            callback,\n            skipJsonParsing\n          );\n        }\n      });\n      response.on(\"close\", e => {\n        this.logger.error(\n          \"problem with API request detailed stacktrace below \"\n        );\n        this.logger.error(e);\n        callback(e);\n      });\n    });\n    request.on(\"error\", e => {\n      this.logger.error(\"problem with API request detailed stacktrace below \");\n      this.logger.error(e);\n      callback(e);\n    });\n  }\n\n  __parseResponse(httpResponse, data, method, callback, skipJsonParsing) {\n    const isArrayOrBuffer = data instanceof Array || data instanceof Buffer;\n    if (!isArrayOrBuffer) {\n      throw new Error(\"data should be of type Array or Buffer\");\n    }\n\n    const status = httpResponse.statusCode;\n    const headers = httpResponse.headers;\n\n    let response = null;\n    var error = null;\n\n    try {\n      if (status >= 500) {\n        error = { message: \"Server Error\", statusCode: status };\n      } else if (\n        httpResponse.headers[\"content-type\"] === \"application/octet-stream\"\n      ) {\n        response = data;\n      } else if (status === 429) {\n        // 429 does not return a parsable body\n        if (!headers[\"retry-after\"]) {\n          // retry based on allowed per second\n          const retryAfterMillis = method === \"POST\" ? 1000 / 2 : 1000 / 5;\n          headers[\"retry-after\"] = retryAfterMillis;\n        }\n        error = { body: data.join(\"\") };\n      } else if (status === 204) {\n        response = null;\n      } else if (status >= 400 || status < 200) {\n        error = { body: JSON.parse(data.join(\"\")), headers };\n      } else if (method !== \"DELETE\") {\n        if (!!skipJsonParsing) {\n          response = data.join(\"\");\n        } else {\n          response = JSON.parse(data.join(\"\"));\n        }\n      } else {\n        response = data;\n      }\n    } catch (parseError) {\n      this.logger.error(parseError);\n      this.logger.error(\n        \"could not convert API response to JSON, above error is ignored and raw API response is returned to client\"\n      );\n      this.logger.error(\"Raw Error message from API \");\n      this.logger.error(`\"${data}\"`);\n\n      error = {\n        status: status,\n        message: \"The API response could not be parsed.\",\n        body: data.join(\"\"),\n        parseError: parseError\n      };\n    }\n\n    if (error) {\n      error.statusCode = status;\n      error.headers = headers;\n    }\n\n    if (typeof callback === \"function\") {\n      callback(error, response);\n    }\n  }\n\n  _addLimitedAccessMessageToErrors(callback, limitedAccessStatus) {\n    return function(err, data) {\n      if (err && err.status == limitedAccessStatus) {\n        err._INFO_ =\n          \"This endpoint may need activating on your account. Please email support@nexmo.com for more information\";\n      }\n\n      return callback(err, data);\n    };\n  }\n\n  get(path, params, callback, useJwt = false) {\n    if (!callback) {\n      if (typeof params == \"function\") {\n        callback = params;\n        params = {};\n      }\n    }\n\n    params = params || {};\n    if (!useJwt) {\n      params[\"api_key\"] = this.credentials.apiKey;\n      params[\"api_secret\"] = this.credentials.apiSecret;\n    }\n\n    path = path + \"?\" + querystring.stringify(params);\n\n    const headers = { \"Content-Type\": \"application/json\" };\n    if (useJwt) {\n      headers[\"Authorization\"] = `Bearer ${this.credentials.generateJwt()}`;\n    }\n\n    this.request({ path: path, headers }, \"GET\", callback);\n  }\n\n  delete(path, callback, useJwt) {\n    let params = {};\n    if (!useJwt) {\n      params[\"api_key\"] = this.credentials.apiKey;\n      params[\"api_secret\"] = this.credentials.apiSecret;\n    }\n\n    path = path + \"?\" + querystring.stringify(params);\n\n    this.request({ path: path }, \"DELETE\", callback);\n  }\n\n  postFile(path, options, callback, useJwt) {\n    let qs = {};\n    if (!useJwt) {\n      qs[\"api_key\"] = this.credentials.apiKey;\n      qs[\"api_secret\"] = this.credentials.apiSecret;\n    }\n\n    if (Object.keys(qs).length) {\n      let joinChar = \"?\";\n      if (path.indexOf(joinChar) !== -1) {\n        joinChar = \"&\";\n      }\n      path = path + joinChar + querystring.stringify(qs);\n    }\n\n    const file = options.file;\n    delete options.file; // We don't send this as metadata\n\n    const formData = {};\n\n    if (file) {\n      formData[\"filedata\"] = {\n        value: file,\n        options: {\n          filename: options.filename || null\n        }\n      };\n    }\n\n    if (options.info) {\n      formData.info = JSON.stringify(options.info);\n    }\n\n    if (options.url) {\n      formData.url = options.url;\n    }\n\n    this.requestLib.post(\n      {\n        url: \"https://\" + this.host + path,\n        formData: formData,\n        headers: {\n          Authorization: `Bearer ${this.credentials.generateJwt()}`\n        }\n      },\n      callback\n    );\n  }\n\n  post(path, params, callback, useJwt) {\n    let qs = {};\n    if (!useJwt) {\n      qs[\"api_key\"] = this.credentials.apiKey;\n      qs[\"api_secret\"] = this.credentials.apiSecret;\n    }\n\n    let joinChar = \"?\";\n    if (path.indexOf(joinChar) !== -1) {\n      joinChar = \"&\";\n    }\n\n    path = path + joinChar + querystring.stringify(qs);\n\n    this.request(\n      { path: path, body: querystring.stringify(params) },\n      \"POST\",\n      callback\n    );\n  }\n\n  postJson(path, params, callback, useJwt) {\n    let qs = {};\n    if (!useJwt) {\n      qs[\"api_key\"] = this.credentials.apiKey;\n      qs[\"api_secret\"] = this.credentials.apiSecret;\n    }\n\n    let joinChar = \"?\";\n    if (path.indexOf(joinChar) !== -1) {\n      joinChar = \"&\";\n    }\n\n    path = path + joinChar + querystring.stringify(qs);\n\n    this.request(\n      {\n        path: path,\n        body: JSON.stringify(params),\n        headers: { \"Content-Type\": \"application/json\" }\n      },\n      \"POST\",\n      callback\n    );\n  }\n\n  postUseQueryString(path, params, callback, useJwt) {\n    params = params || {};\n    if (!useJwt) {\n      params[\"api_key\"] = this.credentials.apiKey;\n      params[\"api_secret\"] = this.credentials.apiSecret;\n    }\n\n    path = path + \"?\" + querystring.stringify(params);\n\n    this.request({ path: path }, \"POST\", callback);\n  }\n}\n\nexport default HttpClient;\n"]}
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"sources":["../src/HttpClient.js"],"names":["https","require","http","request","querystring","HttpClient","options","credentials","host","port","headers","Accept","logger","timeout","requestLib","userAgent","endpoint","method","callback","skipJsonParsing","path","Object","assign","undefined","keys","forEach","key","info","body","end","responseData","on","isBinary","response","setEncoding","push","chunk","statusCode","Buffer","concat","__parseResponse","e","error","httpResponse","data","isArrayOrBuffer","Array","Error","status","message","retryAfterMillis","join","JSON","parse","parseError","limitedAccessStatus","err","_INFO_","params","useJwt","apiKey","apiSecret","stringify","generateJwt","qs","length","joinChar","indexOf","file","formData","value","filename","url","post","Authorization"],"mappings":"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","file":"HttpClient.js","sourcesContent":["var https = require(\"https\");\nvar http = require(\"http\");\nvar request = require(\"request\");\nvar querystring = require(\"querystring\");\n\nclass HttpClient {\n  constructor(options, credentials) {\n    this.credentials = credentials;\n    this.host = options.host || \"rest.nexmo.com\";\n    this.port = options.port || 443;\n    this.https = options.https || https;\n    this.http = options.http || http;\n    this.headers = {\n      \"Content-Type\": \"application/x-www-form-urlencoded\",\n      Accept: \"application/json\"\n    };\n    this.logger = options.logger;\n    this.timeout = options.timeout;\n    this.requestLib = request;\n\n    if (options.userAgent) {\n      this.headers[\"User-Agent\"] = options.userAgent;\n    }\n  }\n\n  request(endpoint, method, callback, skipJsonParsing = false) {\n    if (typeof method === \"function\") {\n      callback = method;\n      endpoint.method = endpoint.method || \"GET\";\n    } else if (typeof method !== \"undefined\") {\n      endpoint.method = method;\n    }\n\n    if (endpoint.method === \"POST\" || endpoint.method === \"DELETE\") {\n      // TODO: verify the following fix is required\n      // Fix broken due ot 411 Content-Length error now sent by Nexmo API\n      // PL 2016-Sept-6 - commented out Content-Length 0\n      // headers['Content-Length'] = 0;\n    }\n    var options = {\n      host: endpoint.host ? endpoint.host : this.host,\n      port: this.port,\n      path: endpoint.path,\n      method: endpoint.method,\n      headers: Object.assign({}, this.headers)\n    };\n\n    if (this.timeout !== undefined) {\n      options.timeout = this.timeout;\n    }\n\n    // Allow existing headers to be overridden\n    // Allow new headers to be added\n    if (endpoint.headers) {\n      Object.keys(endpoint.headers).forEach(function(key) {\n        options.headers[key] = endpoint.headers[key];\n      });\n    }\n\n    this.logger.info(\"Request:\", options, \"\\nBody:\", endpoint.body);\n    var request;\n\n    if (options.port === 443) {\n      request = this.https.request(options);\n    } else {\n      request = this.http.request(options);\n    }\n\n    request.end(endpoint.body);\n\n    // Keep an array of String or Buffers,\n    // depending on content type (binary or JSON) of response\n    var responseData = [];\n\n    request.on(\"response\", response => {\n      var isBinary =\n        response.headers[\"content-type\"] === \"application/octet-stream\";\n      if (!isBinary) {\n        response.setEncoding(\"utf8\");\n      }\n\n      response.on(\"data\", chunk => {\n        responseData.push(chunk);\n      });\n\n      response.on(\"end\", () => {\n        this.logger.info(\"response ended:\", response.statusCode);\n        if (callback) {\n          if (isBinary) {\n            responseData = Buffer.concat(responseData);\n          }\n\n          this.__parseResponse(\n            response,\n            responseData,\n            endpoint.method,\n            callback,\n            skipJsonParsing\n          );\n        }\n      });\n      response.on(\"close\", e => {\n        if (e) {\n          this.logger.error(\n            \"problem with API request detailed stacktrace below \"\n          );\n          this.logger.error(e);\n          callback(e);\n        }\n      });\n    });\n    request.on(\"error\", e => {\n      this.logger.error(\"problem with API request detailed stacktrace below \");\n      this.logger.error(e);\n      callback(e);\n    });\n  }\n\n  __parseResponse(httpResponse, data, method, callback, skipJsonParsing) {\n    const isArrayOrBuffer = data instanceof Array || data instanceof Buffer;\n    if (!isArrayOrBuffer) {\n      throw new Error(\"data should be of type Array or Buffer\");\n    }\n\n    const status = httpResponse.statusCode;\n    const headers = httpResponse.headers;\n\n    let response = null;\n    var error = null;\n\n    try {\n      if (status >= 500) {\n        error = { message: \"Server Error\", statusCode: status };\n      } else if (\n        httpResponse.headers[\"content-type\"] === \"application/octet-stream\"\n      ) {\n        response = data;\n      } else if (status === 429) {\n        // 429 does not return a parsable body\n        if (!headers[\"retry-after\"]) {\n          // retry based on allowed per second\n          const retryAfterMillis = method === \"POST\" ? 1000 / 2 : 1000 / 5;\n          headers[\"retry-after\"] = retryAfterMillis;\n        }\n        error = { body: data.join(\"\") };\n      } else if (status === 204) {\n        response = null;\n      } else if (status >= 400 || status < 200) {\n        error = { body: JSON.parse(data.join(\"\")), headers };\n      } else if (method !== \"DELETE\") {\n        if (!!skipJsonParsing) {\n          response = data.join(\"\");\n        } else {\n          response = JSON.parse(data.join(\"\"));\n        }\n      } else {\n        response = data;\n      }\n    } catch (parseError) {\n      this.logger.error(parseError);\n      this.logger.error(\n        \"could not convert API response to JSON, above error is ignored and raw API response is returned to client\"\n      );\n      this.logger.error(\"Raw Error message from API \");\n      this.logger.error(`\"${data}\"`);\n\n      error = {\n        status: status,\n        message: \"The API response could not be parsed.\",\n        body: data.join(\"\"),\n        parseError: parseError\n      };\n    }\n\n    if (error) {\n      error.statusCode = status;\n      error.headers = headers;\n    }\n\n    if (typeof callback === \"function\") {\n      callback(error, response);\n    }\n  }\n\n  _addLimitedAccessMessageToErrors(callback, limitedAccessStatus) {\n    return function(err, data) {\n      if (err && err.status == limitedAccessStatus) {\n        err._INFO_ =\n          \"This endpoint may need activating on your account. Please email support@nexmo.com for more information\";\n      }\n\n      return callback(err, data);\n    };\n  }\n\n  get(path, params, callback, useJwt = false) {\n    if (!callback) {\n      if (typeof params == \"function\") {\n        callback = params;\n        params = {};\n      }\n    }\n\n    params = params || {};\n    if (!useJwt) {\n      params[\"api_key\"] = this.credentials.apiKey;\n      params[\"api_secret\"] = this.credentials.apiSecret;\n    }\n\n    path = path + \"?\" + querystring.stringify(params);\n\n    const headers = { \"Content-Type\": \"application/json\" };\n    if (useJwt) {\n      headers[\"Authorization\"] = `Bearer ${this.credentials.generateJwt()}`;\n    }\n\n    this.request({ path: path, headers }, \"GET\", callback);\n  }\n\n  delete(path, callback, useJwt) {\n    let params = {};\n    if (!useJwt) {\n      params[\"api_key\"] = this.credentials.apiKey;\n      params[\"api_secret\"] = this.credentials.apiSecret;\n    }\n\n    path = path + \"?\" + querystring.stringify(params);\n\n    this.request({ path: path }, \"DELETE\", callback);\n  }\n\n  postFile(path, options, callback, useJwt) {\n    let qs = {};\n    if (!useJwt) {\n      qs[\"api_key\"] = this.credentials.apiKey;\n      qs[\"api_secret\"] = this.credentials.apiSecret;\n    }\n\n    if (Object.keys(qs).length) {\n      let joinChar = \"?\";\n      if (path.indexOf(joinChar) !== -1) {\n        joinChar = \"&\";\n      }\n      path = path + joinChar + querystring.stringify(qs);\n    }\n\n    const file = options.file;\n    delete options.file; // We don't send this as metadata\n\n    const formData = {};\n\n    if (file) {\n      formData[\"filedata\"] = {\n        value: file,\n        options: {\n          filename: options.filename || null\n        }\n      };\n    }\n\n    if (options.info) {\n      formData.info = JSON.stringify(options.info);\n    }\n\n    if (options.url) {\n      formData.url = options.url;\n    }\n\n    this.requestLib.post(\n      {\n        url: \"https://\" + this.host + path,\n        formData: formData,\n        headers: {\n          Authorization: `Bearer ${this.credentials.generateJwt()}`\n        }\n      },\n      callback\n    );\n  }\n\n  post(path, params, callback, useJwt) {\n    let qs = {};\n    if (!useJwt) {\n      qs[\"api_key\"] = this.credentials.apiKey;\n      qs[\"api_secret\"] = this.credentials.apiSecret;\n    }\n\n    let joinChar = \"?\";\n    if (path.indexOf(joinChar) !== -1) {\n      joinChar = \"&\";\n    }\n\n    path = path + joinChar + querystring.stringify(qs);\n\n    this.request(\n      { path: path, body: querystring.stringify(params) },\n      \"POST\",\n      callback\n    );\n  }\n\n  postJson(path, params, callback, useJwt) {\n    let qs = {};\n    if (!useJwt) {\n      qs[\"api_key\"] = this.credentials.apiKey;\n      qs[\"api_secret\"] = this.credentials.apiSecret;\n    }\n\n    let joinChar = \"?\";\n    if (path.indexOf(joinChar) !== -1) {\n      joinChar = \"&\";\n    }\n\n    path = path + joinChar + querystring.stringify(qs);\n\n    this.request(\n      {\n        path: path,\n        body: JSON.stringify(params),\n        headers: { \"Content-Type\": \"application/json\" }\n      },\n      \"POST\",\n      callback\n    );\n  }\n\n  postUseQueryString(path, params, callback, useJwt) {\n    params = params || {};\n    if (!useJwt) {\n      params[\"api_key\"] = this.credentials.apiKey;\n      params[\"api_secret\"] = this.credentials.apiSecret;\n    }\n\n    path = path + \"?\" + querystring.stringify(params);\n\n    this.request({ path: path }, \"POST\", callback);\n  }\n}\n\nexport default HttpClient;\n"]}

lib/Members.js

@@ -1,5 +0,5 @@
-"use strict";
+'use strict';
 
 Object.defineProperty(exports, "__esModule", {
-  value: true
+    value: true
 });
@@ -9,3 +9,3 @@
 
-var _index = require("./index");
+var _index = require('./index');
 
@@ -22,79 +22,80 @@ var _index2 = _interopRequireDefault(_index);
 var Members = function () {
-  _createClass(Members, null, [{
-    key: "PATH",
+    _createClass(Members, null, [{
+        key: 'PATH',
 
-    /**
-     * The path to the `members` resource.
-     */
-    get: function get() {
-      return "/beta/conversations/{conversation_uuid}/members";
-    }
 
-    /**
-     * Creates a new Members.
-     *
-     * @param {Credentials} creds - Credentials used when interacting with the Nexmo API.
-     * @param {Object} options - additional options for the class.
-     */
+        /**
+        * The path to the `members` resource.
+        */
+        get: function get() {
+            return '/beta/conversations/{conversation_uuid}/members';
+        }
 
-  }]);
+        /**
+         * Creates a new Members.
+         *
+         * @param {Credentials} creds - Credentials used when interacting with the Nexmo API.
+         * @param {Object} options - additional options for the class.
+         */
 
-  function Members(creds, options) {
-    _classCallCheck(this, Members);
+    }]);
 
-    this.creds = creds;
-    this.options = options;
+    function Members(creds, options) {
+        _classCallCheck(this, Members);
 
-    this._nexmo = this.options.nexmoOverride || _index2.default;
-  }
+        this.creds = creds;
+        this.options = options;
 
-  /**
-   * Adds a member to a conversation.
-   *
-   * @param {string} [conversationId] - The unique identifier for the conversation
-   * @param {Object} params - Parameters used when adding a member to the conversation. See https://ea.developer.nexmo.com/api/conversation#add-a-user-to-a-conversation for more information.
-   * @param {function} callback - function to be called when the request completes.
-   */
-
-
-  _createClass(Members, [{
-    key: "add",
-    value: function add(conversationId, params, callback) {
-      params = JSON.stringify(params);
-
-      var config = {
-        host: "api.nexmo.com",
-        path: Members.PATH.replace("{conversation_uuid}", conversationId),
-        method: "POST",
-        body: params,
-        headers: {
-          "Content-Type": "application/json",
-          Authorization: "Bearer " + this.creds.generateJwt()
-        }
-      };
-      this.options.httpClient.request(config, callback);
+        this._nexmo = this.options.nexmoOverride || _index2.default;
     }
 
     /**
-     * Get an existing member.
+     * Adds a member to a conversation.
      *
      * @param {string} [conversationId] - The unique identifier for the conversation
-     * @param {string|object} query - The unique identifier for the member to retrieve
-     *               or a set of filter parameters for the query. For more information
-     *               see https://ea.developer.nexmo.com/api/conversation#retrieve-members-of-a-conversation
+     * @param {Object} params - Parameters used when adding a member to the conversation. See https://ea.developer.nexmo.com/api/conversation#add-a-user-to-a-conversation for more information.
      * @param {function} callback - function to be called when the request completes.
      */
 
-  }, {
-    key: "get",
-    value: function get(conversationId, query, callback) {
-      this._nexmo.getWithQuery(Members.PATH.replace("{conversation_uuid}", conversationId), query, this.creds, this.options, callback);
-    }
-  }]);
 
-  return Members;
+    _createClass(Members, [{
+        key: 'add',
+        value: function add(conversationId, params, callback) {
+            params = JSON.stringify(params);
+
+            var config = {
+                host: 'api.nexmo.com',
+                path: Members.PATH.replace('{conversation_uuid}', conversationId),
+                method: 'POST',
+                body: params,
+                headers: {
+                    'Content-Type': 'application/json',
+                    'Authorization': 'Bearer ' + this.creds.generateJwt()
+                }
+            };
+            this.options.httpClient.request(config, callback);
+        }
+
+        /**
+         * Get an existing member.
+         *
+         * @param {string} [conversationId] - The unique identifier for the conversation
+         * @param {string|object} query - The unique identifier for the member to retrieve
+         *               or a set of filter parameters for the query. For more information
+         *               see https://ea.developer.nexmo.com/api/conversation#retrieve-members-of-a-conversation
+         * @param {function} callback - function to be called when the request completes.
+         */
+
+    }, {
+        key: 'get',
+        value: function get(conversationId, query, callback) {
+            this._nexmo.getWithQuery(Members.PATH.replace('{conversation_uuid}', conversationId), query, this.creds, this.options, callback);
+        }
+    }]);
+
+    return Members;
 }();
 
 exports.default = Members;
-module.exports = exports["default"];
-//# sourceMappingURL=data:application/json;charset=utf-8;base64,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
+module.exports = exports['default'];
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,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

lib/Users.js

 "use strict";
 
 Object.defineProperty(exports, "__esModule", {
-  value: true
+    value: true
 });
@@ -9,3 +9,3 @@
 
-var _index = require("./index");
+var _index = require('./index');
 
@@ -22,139 +22,139 @@ var _index2 = _interopRequireDefault(_index);
 var Users = function () {
-  _createClass(Users, null, [{
-    key: "PATH",
-    get: function get() {
-      return "/beta/users";
-    }
+    _createClass(Users, null, [{
+        key: 'PATH',
+        get: function get() {
+            return '/beta/users';
+        }
 
-    /**
-     * @param {Credentials} credentials
-     *    credentials to be used when interacting with the API.
-     * @param {Object} options
-     *    Additional Users options.
-     */
+        /**
+        * @param {Credentials} credentials
+        *    credentials to be used when interacting with the API.
+        * @param {Object} options
+        *    Additional Users options.
+        */
 
-  }]);
+    }]);
 
-  function Users(credentials) {
-    var options = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
+    function Users(credentials) {
+        var options = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
 
-    _classCallCheck(this, Users);
+        _classCallCheck(this, Users);
 
-    this.creds = credentials;
-    this.options = options;
+        this.creds = credentials;
+        this.options = options;
 
-    // Used to facilitate testing of the call to the underlying object
-    this._nexmo = this.options.nexmoOverride || _index2.default;
-  }
-
-  /**
-   * Create a new user.
-   *
-   * @param {Object} params - Parameters used when creating the user. See https://ea.developer.nexmo.com/api/conversation#create-a-user for more information.
-   * @param {function} callback - function to be called when the request completes.
-   */
-
-
-  _createClass(Users, [{
-    key: "create",
-    value: function create(params, callback) {
-      params = JSON.stringify(params);
-
-      var config = {
-        host: "api.nexmo.com",
-        path: Users.PATH,
-        method: "POST",
-        body: params,
-        headers: {
-          "Content-Type": "application/json",
-          Authorization: "Bearer " + this.creds.generateJwt()
-        }
-      };
-      this.options.httpClient.request(config, callback);
+        // Used to facilitate testing of the call to the underlying object
+        this._nexmo = this.options.nexmoOverride || _index2.default;
     }
 
     /**
-     * Get an existing user.
+     * Create a new user.
      *
-     * @param {string|object} query - The unique identifier for the user to retrieve
-     *               or a set of filter parameters for the query. For more information
-     *               see https://ea.developer.nexmo.com/api/conversation#retrieve-all-users
+     * @param {Object} params - Parameters used when creating the user. See https://ea.developer.nexmo.com/api/conversation#create-a-user for more information.
      * @param {function} callback - function to be called when the request completes.
      */
 
-  }, {
-    key: "get",
-    value: function get(query, callback) {
-      this._nexmo.getWithQuery(Users.PATH, query, this.creds, this.options, callback);
-    }
 
-    /**
-     * Get an conversations for an existing user.
-     *
-     * @param {string} [userId] - The unique identifier for the user to retrieve conversations for
-     * @param {function} callback - function to be called when the request completes.
-     */
+    _createClass(Users, [{
+        key: 'create',
+        value: function create(params, callback) {
+            params = JSON.stringify(params);
 
-  }, {
-    key: "getConversations",
-    value: function getConversations(userId, callback) {
-      this._nexmo.getWithQuery(Users.PATH + "/" + userId + "/conversations", {}, this.creds, this.options, callback);
-    }
+            var config = {
+                host: 'api.nexmo.com',
+                path: Users.PATH,
+                method: 'POST',
+                body: params,
+                headers: {
+                    'Content-Type': 'application/json',
+                    'Authorization': 'Bearer ' + this.creds.generateJwt()
+                }
+            };
+            this.options.httpClient.request(config, callback);
+        }
 
-    /**
-     * Update an existing user.
-     *
-     * @param {string} [userId] - The unique identifier for the user to update.
-     * @param {Object} params - Parameters used when updating the conversation.
-     * @param {function} callback - function to be called when the request completes.
-     */
+        /**
+         * Get an existing user.
+         *
+         * @param {string|object} query - The unique identifier for the user to retrieve
+         *               or a set of filter parameters for the query. For more information
+         *               see https://ea.developer.nexmo.com/api/conversation#retrieve-all-users
+         * @param {function} callback - function to be called when the request completes.
+         */
 
-  }, {
-    key: "update",
-    value: function update(userId, params, callback) {
-      params = JSON.stringify(params);
+    }, {
+        key: 'get',
+        value: function get(query, callback) {
+            this._nexmo.getWithQuery(Users.PATH, query, this.creds, this.options, callback);
+        }
 
-      var config = {
-        host: "api.nexmo.com",
-        path: Users.PATH + "/" + userId,
-        method: "PUT",
-        body: params,
-        headers: {
-          "Content-Type": "application/json",
-          Authorization: "Bearer " + this.creds.generateJwt()
+        /**
+         * Get an conversations for an existing user.
+         *
+         * @param {string} [userId] - The unique identifier for the user to retrieve conversations for
+         * @param {function} callback - function to be called when the request completes.
+         */
+
+    }, {
+        key: 'getConversations',
+        value: function getConversations(userId, callback) {
+            this._nexmo.getWithQuery(Users.PATH + '/' + userId + '/conversations', {}, this.creds, this.options, callback);
         }
-      };
 
-      this.options.httpClient.request(config, callback);
-    }
+        /**
+         * Update an existing user.
+         *
+         * @param {string} [userId] - The unique identifier for the user to update.
+         * @param {Object} params - Parameters used when updating the conversation.
+         * @param {function} callback - function to be called when the request completes.
+         */
 
-    /**
-     * Deleta an existing user.
-     *
-     * @param {string} [userId] - The unique identifier for the user to delete.
-     * @param {function} callback - function to be called when the request completes.
-     */
+    }, {
+        key: 'update',
+        value: function update(userId, params, callback) {
+            params = JSON.stringify(params);
 
-  }, {
-    key: "delete",
-    value: function _delete(userId, callback) {
-      var config = {
-        host: "api.nexmo.com",
-        path: Users.PATH + "/" + userId,
-        method: "DELETE",
-        headers: {
-          "Content-Type": "application/json",
-          Authorization: "Bearer " + this.creds.generateJwt()
+            var config = {
+                host: 'api.nexmo.com',
+                path: Users.PATH + '/' + userId,
+                method: 'PUT',
+                body: params,
+                headers: {
+                    'Content-Type': 'application/json',
+                    'Authorization': 'Bearer ' + this.creds.generateJwt()
+                }
+            };
+
+            this.options.httpClient.request(config, callback);
         }
-      };
 
-      this.options.httpClient.request(config, callback);
-    }
-  }]);
+        /**
+         * Deleta an existing user.
+         *
+         * @param {string} [userId] - The unique identifier for the user to delete.
+         * @param {function} callback - function to be called when the request completes.
+         */
 
-  return Users;
+    }, {
+        key: 'delete',
+        value: function _delete(userId, callback) {
+            var config = {
+                host: 'api.nexmo.com',
+                path: Users.PATH + '/' + userId,
+                method: 'DELETE',
+                headers: {
+                    'Content-Type': 'application/json',
+                    'Authorization': 'Bearer ' + this.creds.generateJwt()
+                }
+            };
+
+            this.options.httpClient.request(config, callback);
+        }
+    }]);
+
+    return Users;
 }();
 
 exports.default = Users;
-module.exports = exports["default"];
-//# sourceMappingURL=data:application/json;charset=utf-8;base64,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
+module.exports = exports['default'];
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,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

package.json

 {
   "name": "nexmo",
   "author": "nexmo",
-  "version": "2.3.0",
+  "version": "2.3.1",
   "main": "lib/Nexmo",
@@ -59,6 +59,6 @@ "keywords": [
     "express": "^4.14.0",
-    "mocha": "^3.2.0",
+    "mocha": "^5.2.0",
     "ngrok": "^2.2.2",
-    "nodemon": "^1.17.3",
-    "nyc": "^11.7.1",
+    "nodemon": "^1.17.5",
+    "nyc": "^13.0.0",
     "prettier": "^1.12.1",
@@ -65,0 +65,0 @@ "sinon": "^1.17.4",

New alerts

License Policy Violation

License

This package is not allowed per your license policy. Review the package's license to ensure compliance.

Found 1 instance in 1 package

Fixed alerts

License Policy Violation

License

This package is not allowed per your license policy. Review the package's license to ensure compliance.

Found 1 instance in 1 package

Improved metrics

Total package byte prevSize

772106

increased by66.85%

Lines of code

5008

increased by0.64%

Number of low supply chain risk alerts

9

decreased by-18.18%

Worsened metrics

Number of package files

66

decreased by-5.71%

No dependency changes