github-api
Version:
A higher-level wrapper around the Github API.
395 lines (324 loc) • 43 kB
JavaScript
;
var _typeof = typeof Symbol === "function" && typeof Symbol.iterator === "symbol" ? function (obj) { return typeof obj; } : function (obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; };
var _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }();
var _axios = require('axios');
var _axios2 = _interopRequireDefault(_axios);
var _debug = require('debug');
var _debug2 = _interopRequireDefault(_debug);
var _jsBase = require('js-base64');
function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
function _toConsumableArray(arr) { if (Array.isArray(arr)) { for (var i = 0, arr2 = Array(arr.length); i < arr.length; i++) { arr2[i] = arr[i]; } return arr2; } else { return Array.from(arr); } }
function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
function _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return call && (typeof call === "object" || typeof call === "function") ? call : self; }
function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function, not " + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; } /**
* @file
* @copyright 2016 Yahoo Inc.
* @license Licensed under {@link https://spdx.org/licenses/BSD-3-Clause-Clear.html BSD-3-Clause-Clear}.
* Github.js is freely distributable.
*/
var log = (0, _debug2.default)('github:request');
/**
* The error structure returned when a network call fails
*/
var ResponseError = function (_Error) {
_inherits(ResponseError, _Error);
/**
* Construct a new ResponseError
* @param {string} message - an message to return instead of the the default error message
* @param {string} path - the requested path
* @param {Object} response - the object returned by Axios
*/
function ResponseError(message, path, response) {
_classCallCheck(this, ResponseError);
var _this = _possibleConstructorReturn(this, (ResponseError.__proto__ || Object.getPrototypeOf(ResponseError)).call(this, message));
_this.path = path;
_this.request = response.config;
_this.response = (response || {}).response || response;
_this.status = response.status;
return _this;
}
return ResponseError;
}(Error);
/**
* Requestable wraps the logic for making http requests to the API
*/
var Requestable = function () {
/**
* Either a username and password or an oauth token for Github
* @typedef {Object} Requestable.auth
* @prop {string} [username] - the Github username
* @prop {string} [password] - the user's password
* @prop {token} [token] - an OAuth token
*/
/**
* Initialize the http internals.
* @param {Requestable.auth} [auth] - the credentials to authenticate to Github. If auth is
* not provided request will be made unauthenticated
* @param {string} [apiBase=https://api.github.com] - the base Github API URL
* @param {string} [AcceptHeader=v3] - the accept header for the requests
*/
function Requestable(auth, apiBase, AcceptHeader) {
_classCallCheck(this, Requestable);
this.__apiBase = apiBase || 'https://api.github.com';
this.__auth = {
token: auth.token,
username: auth.username,
password: auth.password
};
this.__AcceptHeader = AcceptHeader || 'v3';
if (auth.token) {
this.__authorizationHeader = 'token ' + auth.token;
} else if (auth.username && auth.password) {
this.__authorizationHeader = 'Basic ' + _jsBase.Base64.encode(auth.username + ':' + auth.password);
}
}
/**
* Compute the URL to use to make a request.
* @private
* @param {string} path - either a URL relative to the API base or an absolute URL
* @return {string} - the URL to use
*/
_createClass(Requestable, [{
key: '__getURL',
value: function __getURL(path) {
var url = path;
if (path.indexOf('//') === -1) {
url = this.__apiBase + path;
}
var newCacheBuster = 'timestamp=' + new Date().getTime();
return url.replace(/(timestamp=\d+)/, newCacheBuster);
}
/**
* Compute the headers required for an API request.
* @private
* @param {boolean} raw - if the request should be treated as JSON or as a raw request
* @param {string} AcceptHeader - the accept header for the request
* @return {Object} - the headers to use in the request
*/
}, {
key: '__getRequestHeaders',
value: function __getRequestHeaders(raw, AcceptHeader) {
var headers = {
'Content-Type': 'application/json;charset=UTF-8',
'Accept': 'application/vnd.github.' + (AcceptHeader || this.__AcceptHeader)
};
if (raw) {
headers.Accept += '.raw';
}
headers.Accept += '+json';
if (this.__authorizationHeader) {
headers.Authorization = this.__authorizationHeader;
}
return headers;
}
/**
* Sets the default options for API requests
* @protected
* @param {Object} [requestOptions={}] - the current options for the request
* @return {Object} - the options to pass to the request
*/
}, {
key: '_getOptionsWithDefaults',
value: function _getOptionsWithDefaults() {
var requestOptions = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
if (!(requestOptions.visibility || requestOptions.affiliation)) {
requestOptions.type = requestOptions.type || 'all';
}
requestOptions.sort = requestOptions.sort || 'updated';
requestOptions.per_page = requestOptions.per_page || '100'; // eslint-disable-line
return requestOptions;
}
/**
* if a `Date` is passed to this function it will be converted to an ISO string
* @param {*} date - the object to attempt to coerce into an ISO date string
* @return {string} - the ISO representation of `date` or whatever was passed in if it was not a date
*/
}, {
key: '_dateToISO',
value: function _dateToISO(date) {
if (date && date instanceof Date) {
date = date.toISOString();
}
return date;
}
/**
* A function that receives the result of the API request.
* @callback Requestable.callback
* @param {Requestable.Error} error - the error returned by the API or `null`
* @param {(Object|true)} result - the data returned by the API or `true` if the API returns `204 No Content`
* @param {Object} request - the raw {@linkcode https://github.com/mzabriskie/axios#response-schema Response}
*/
/**
* Make a request.
* @param {string} method - the method for the request (GET, PUT, POST, DELETE)
* @param {string} path - the path for the request
* @param {*} [data] - the data to send to the server. For HTTP methods that don't have a body the data
* will be sent as query parameters
* @param {Requestable.callback} [cb] - the callback for the request
* @param {boolean} [raw=false] - if the request should be sent as raw. If this is a falsy value then the
* request will be made as JSON
* @return {Promise} - the Promise for the http request
*/
}, {
key: '_request',
value: function _request(method, path, data, cb, raw) {
var url = this.__getURL(path);
var AcceptHeader = (data || {}).AcceptHeader;
if (AcceptHeader) {
delete data.AcceptHeader;
}
var headers = this.__getRequestHeaders(raw, AcceptHeader);
var queryParams = {};
var shouldUseDataAsParams = data && (typeof data === 'undefined' ? 'undefined' : _typeof(data)) === 'object' && methodHasNoBody(method);
if (shouldUseDataAsParams) {
queryParams = data;
data = undefined;
}
var config = {
url: url,
method: method,
headers: headers,
params: queryParams,
data: data,
responseType: raw ? 'text' : 'json'
};
log(config.method + ' to ' + config.url);
var requestPromise = (0, _axios2.default)(config).catch(callbackErrorOrThrow(cb, path));
if (cb) {
requestPromise.then(function (response) {
if (response.data && Object.keys(response.data).length > 0) {
// When data has results
cb(null, response.data, response);
} else if (config.method !== 'GET' && Object.keys(response.data).length < 1) {
// True when successful submit a request and receive a empty object
cb(null, response.status < 300, response);
} else {
cb(null, response.data, response);
}
});
}
return requestPromise;
}
/**
* Make a request to an endpoint the returns 204 when true and 404 when false
* @param {string} path - the path to request
* @param {Object} data - any query parameters for the request
* @param {Requestable.callback} cb - the callback that will receive `true` or `false`
* @param {method} [method=GET] - HTTP Method to use
* @return {Promise} - the promise for the http request
*/
}, {
key: '_request204or404',
value: function _request204or404(path, data, cb) {
var method = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : 'GET';
return this._request(method, path, data).then(function success(response) {
if (cb) {
cb(null, true, response);
}
return true;
}, function failure(response) {
if (response.response.status === 404) {
if (cb) {
cb(null, false, response);
}
return false;
}
if (cb) {
cb(response);
}
throw response;
});
}
/**
* Make a request and fetch all the available data. Github will paginate responses so for queries
* that might span multiple pages this method is preferred to {@link Requestable#request}
* @param {string} path - the path to request
* @param {Object} options - the query parameters to include
* @param {Requestable.callback} [cb] - the function to receive the data. The returned data will always be an array.
* @param {Object[]} results - the partial results. This argument is intended for internal use only.
* @return {Promise} - a promise which will resolve when all pages have been fetched
* @deprecated This will be folded into {@link Requestable#_request} in the 2.0 release.
*/
}, {
key: '_requestAllPages',
value: function _requestAllPages(path, options, cb, results) {
var _this2 = this;
results = results || [];
return this._request('GET', path, options).then(function (response) {
var _results;
var thisGroup = void 0;
if (response.data instanceof Array) {
thisGroup = response.data;
} else if (response.data.items instanceof Array) {
thisGroup = response.data.items;
} else {
var message = 'cannot figure out how to append ' + response.data + ' to the result set';
throw new ResponseError(message, path, response);
}
(_results = results).push.apply(_results, _toConsumableArray(thisGroup));
var nextUrl = getNextPage(response.headers.link);
if (nextUrl) {
if (!options) {
options = {};
}
options.page = parseInt(nextUrl.match(/([&\?]page=[0-9]*)/g).shift().split('=').pop());
if (!(options && typeof options.page !== 'number')) {
log('getting next page: ' + nextUrl);
return _this2._requestAllPages(nextUrl, options, cb, results);
}
}
if (cb) {
cb(null, results, response);
}
response.data = results;
return response;
}).catch(callbackErrorOrThrow(cb, path));
}
}]);
return Requestable;
}();
module.exports = Requestable;
// ////////////////////////// //
// Private helper functions //
// ////////////////////////// //
var METHODS_WITH_NO_BODY = ['GET', 'HEAD', 'DELETE'];
function methodHasNoBody(method) {
return METHODS_WITH_NO_BODY.indexOf(method) !== -1;
}
function getNextPage() {
var linksHeader = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : '';
var links = linksHeader.split(/\s*,\s*/); // splits and strips the urls
return links.reduce(function (nextUrl, link) {
if (link.search(/rel="next"/) !== -1) {
return (link.match(/<(.*)>/) || [])[1];
}
return nextUrl;
}, undefined);
}
function callbackErrorOrThrow(cb, path) {
return function handler(object) {
var error = void 0;
if (object.hasOwnProperty('config')) {
var _object$response = object.response,
status = _object$response.status,
statusText = _object$response.statusText,
_object$config = object.config,
method = _object$config.method,
url = _object$config.url;
var message = status + ' error making request ' + method + ' ' + url + ': "' + statusText + '"';
error = new ResponseError(message, path, object);
log(message + ' ' + JSON.stringify(object.data));
} else {
error = object;
}
if (cb) {
log('going to error callback');
cb(error);
} else {
log('throwing error');
throw error;
}
};
}
//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"sources":["Requestable.js"],"names":["log","ResponseError","message","path","response","request","config","status","Error","Requestable","auth","apiBase","AcceptHeader","__apiBase","__auth","token","username","password","__AcceptHeader","__authorizationHeader","Base64","encode","url","indexOf","newCacheBuster","Date","getTime","replace","raw","headers","Accept","Authorization","requestOptions","visibility","affiliation","type","sort","per_page","date","toISOString","method","data","cb","__getURL","__getRequestHeaders","queryParams","shouldUseDataAsParams","methodHasNoBody","undefined","params","responseType","requestPromise","catch","callbackErrorOrThrow","then","Object","keys","length","_request","success","failure","options","results","thisGroup","Array","items","push","nextUrl","getNextPage","link","page","parseInt","match","shift","split","pop","_requestAllPages","module","exports","METHODS_WITH_NO_BODY","linksHeader","links","reduce","search","handler","object","error","hasOwnProperty","statusText","JSON","stringify"],"mappings":"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","file":"Requestable.js","sourcesContent":["/**\n * @file\n * @copyright  2016 Yahoo Inc.\n * @license    Licensed under {@link https://spdx.org/licenses/BSD-3-Clause-Clear.html BSD-3-Clause-Clear}.\n *             Github.js is freely distributable.\n */\n\nimport axios from 'axios';\nimport debug from 'debug';\nimport {Base64} from 'js-base64';\n\nconst log = debug('github:request');\n\n/**\n * The error structure returned when a network call fails\n */\nclass ResponseError extends Error {\n   /**\n    * Construct a new ResponseError\n    * @param {string} message - an message to return instead of the the default error message\n    * @param {string} path - the requested path\n    * @param {Object} response - the object returned by Axios\n    */\n   constructor(message, path, response) {\n      super(message);\n      this.path = path;\n      this.request = response.config;\n      this.response = (response || {}).response || response;\n      this.status = response.status;\n   }\n}\n\n/**\n * Requestable wraps the logic for making http requests to the API\n */\nclass Requestable {\n   /**\n    * Either a username and password or an oauth token for Github\n    * @typedef {Object} Requestable.auth\n    * @prop {string} [username] - the Github username\n    * @prop {string} [password] - the user's password\n    * @prop {token} [token] - an OAuth token\n    */\n   /**\n    * Initialize the http internals.\n    * @param {Requestable.auth} [auth] - the credentials to authenticate to Github. If auth is\n    *                                  not provided request will be made unauthenticated\n    * @param {string} [apiBase=https://api.github.com] - the base Github API URL\n    * @param {string} [AcceptHeader=v3] - the accept header for the requests\n    */\n   constructor(auth, apiBase, AcceptHeader) {\n      this.__apiBase = apiBase || 'https://api.github.com';\n      this.__auth = {\n         token: auth.token,\n         username: auth.username,\n         password: auth.password,\n      };\n      this.__AcceptHeader = AcceptHeader || 'v3';\n\n      if (auth.token) {\n         this.__authorizationHeader = 'token ' + auth.token;\n      } else if (auth.username && auth.password) {\n         this.__authorizationHeader = 'Basic ' + Base64.encode(auth.username + ':' + auth.password);\n      }\n   }\n\n   /**\n    * Compute the URL to use to make a request.\n    * @private\n    * @param {string} path - either a URL relative to the API base or an absolute URL\n    * @return {string} - the URL to use\n    */\n   __getURL(path) {\n      let url = path;\n\n      if (path.indexOf('//') === -1) {\n         url = this.__apiBase + path;\n      }\n\n      let newCacheBuster = 'timestamp=' + new Date().getTime();\n      return url.replace(/(timestamp=\\d+)/, newCacheBuster);\n   }\n\n   /**\n    * Compute the headers required for an API request.\n    * @private\n    * @param {boolean} raw - if the request should be treated as JSON or as a raw request\n    * @param {string} AcceptHeader - the accept header for the request\n    * @return {Object} - the headers to use in the request\n    */\n   __getRequestHeaders(raw, AcceptHeader) {\n      let headers = {\n         'Content-Type': 'application/json;charset=UTF-8',\n         'Accept': 'application/vnd.github.' + (AcceptHeader || this.__AcceptHeader),\n      };\n\n      if (raw) {\n         headers.Accept += '.raw';\n      }\n      headers.Accept += '+json';\n\n      if (this.__authorizationHeader) {\n         headers.Authorization = this.__authorizationHeader;\n      }\n\n      return headers;\n   }\n\n   /**\n    * Sets the default options for API requests\n    * @protected\n    * @param {Object} [requestOptions={}] - the current options for the request\n    * @return {Object} - the options to pass to the request\n    */\n   _getOptionsWithDefaults(requestOptions = {}) {\n      if (!(requestOptions.visibility || requestOptions.affiliation)) {\n         requestOptions.type = requestOptions.type || 'all';\n      }\n      requestOptions.sort = requestOptions.sort || 'updated';\n      requestOptions.per_page = requestOptions.per_page || '100'; // eslint-disable-line\n\n      return requestOptions;\n   }\n\n   /**\n    * if a `Date` is passed to this function it will be converted to an ISO string\n    * @param {*} date - the object to attempt to coerce into an ISO date string\n    * @return {string} - the ISO representation of `date` or whatever was passed in if it was not a date\n    */\n   _dateToISO(date) {\n      if (date && (date instanceof Date)) {\n         date = date.toISOString();\n      }\n\n      return date;\n   }\n\n   /**\n    * A function that receives the result of the API request.\n    * @callback Requestable.callback\n    * @param {Requestable.Error} error - the error returned by the API or `null`\n    * @param {(Object|true)} result - the data returned by the API or `true` if the API returns `204 No Content`\n    * @param {Object} request - the raw {@linkcode https://github.com/mzabriskie/axios#response-schema Response}\n    */\n   /**\n    * Make a request.\n    * @param {string} method - the method for the request (GET, PUT, POST, DELETE)\n    * @param {string} path - the path for the request\n    * @param {*} [data] - the data to send to the server. For HTTP methods that don't have a body the data\n    *                   will be sent as query parameters\n    * @param {Requestable.callback} [cb] - the callback for the request\n    * @param {boolean} [raw=false] - if the request should be sent as raw. If this is a falsy value then the\n    *                              request will be made as JSON\n    * @return {Promise} - the Promise for the http request\n    */\n   _request(method, path, data, cb, raw) {\n      const url = this.__getURL(path);\n\n      const AcceptHeader = (data || {}).AcceptHeader;\n      if (AcceptHeader) {\n         delete data.AcceptHeader;\n      }\n      const headers = this.__getRequestHeaders(raw, AcceptHeader);\n\n      let queryParams = {};\n\n      const shouldUseDataAsParams = data && (typeof data === 'object') && methodHasNoBody(method);\n      if (shouldUseDataAsParams) {\n         queryParams = data;\n         data = undefined;\n      }\n\n      const config = {\n         url: url,\n         method: method,\n         headers: headers,\n         params: queryParams,\n         data: data,\n         responseType: raw ? 'text' : 'json',\n      };\n\n      log(`${config.method} to ${config.url}`);\n      const requestPromise = axios(config).catch(callbackErrorOrThrow(cb, path));\n\n      if (cb) {\n         requestPromise.then((response) => {\n            if (response.data && Object.keys(response.data).length > 0) {\n               // When data has results\n               cb(null, response.data, response);\n            } else if (config.method !== 'GET' && Object.keys(response.data).length < 1) {\n               // True when successful submit a request and receive a empty object\n               cb(null, (response.status < 300), response);\n            } else {\n               cb(null, response.data, response);\n            }\n         });\n      }\n\n      return requestPromise;\n   }\n\n   /**\n    * Make a request to an endpoint the returns 204 when true and 404 when false\n    * @param {string} path - the path to request\n    * @param {Object} data - any query parameters for the request\n    * @param {Requestable.callback} cb - the callback that will receive `true` or `false`\n    * @param {method} [method=GET] - HTTP Method to use\n    * @return {Promise} - the promise for the http request\n    */\n   _request204or404(path, data, cb, method = 'GET') {\n      return this._request(method, path, data)\n         .then(function success(response) {\n            if (cb) {\n               cb(null, true, response);\n            }\n            return true;\n         }, function failure(response) {\n            if (response.response.status === 404) {\n               if (cb) {\n                  cb(null, false, response);\n               }\n               return false;\n            }\n\n            if (cb) {\n               cb(response);\n            }\n            throw response;\n         });\n   }\n\n   /**\n    * Make a request and fetch all the available data. Github will paginate responses so for queries\n    * that might span multiple pages this method is preferred to {@link Requestable#request}\n    * @param {string} path - the path to request\n    * @param {Object} options - the query parameters to include\n    * @param {Requestable.callback} [cb] - the function to receive the data. The returned data will always be an array.\n    * @param {Object[]} results - the partial results. This argument is intended for internal use only.\n    * @return {Promise} - a promise which will resolve when all pages have been fetched\n    * @deprecated This will be folded into {@link Requestable#_request} in the 2.0 release.\n    */\n   _requestAllPages(path, options, cb, results) {\n      results = results || [];\n\n      return this._request('GET', path, options)\n         .then((response) => {\n            let thisGroup;\n            if (response.data instanceof Array) {\n               thisGroup = response.data;\n            } else if (response.data.items instanceof Array) {\n               thisGroup = response.data.items;\n            } else {\n               let message = `cannot figure out how to append ${response.data} to the result set`;\n               throw new ResponseError(message, path, response);\n            }\n            results.push(...thisGroup);\n\n            const nextUrl = getNextPage(response.headers.link);\n            if(nextUrl) {\n               if (!options) {\n                  options = {};\n               }\n               options.page = parseInt(\n                 nextUrl.match(/([&\\?]page=[0-9]*)/g)\n                   .shift()\n                   .split('=')\n                   .pop()\n               );\n               if (!(options && typeof options.page !== 'number')) {\n                  log(`getting next page: ${nextUrl}`);\n                  return this._requestAllPages(nextUrl, options, cb, results);\n               }\n            }\n\n            if (cb) {\n               cb(null, results, response);\n            }\n\n            response.data = results;\n            return response;\n         }).catch(callbackErrorOrThrow(cb, path));\n   }\n}\n\nmodule.exports = Requestable;\n\n// ////////////////////////// //\n//  Private helper functions  //\n// ////////////////////////// //\nconst METHODS_WITH_NO_BODY = ['GET', 'HEAD', 'DELETE'];\nfunction methodHasNoBody(method) {\n   return METHODS_WITH_NO_BODY.indexOf(method) !== -1;\n}\n\nfunction getNextPage(linksHeader = '') {\n   const links = linksHeader.split(/\\s*,\\s*/); // splits and strips the urls\n   return links.reduce(function(nextUrl, link) {\n      if (link.search(/rel=\"next\"/) !== -1) {\n         return (link.match(/<(.*)>/) || [])[1];\n      }\n\n      return nextUrl;\n   }, undefined);\n}\n\nfunction callbackErrorOrThrow(cb, path) {\n   return function handler(object) {\n      let error;\n      if (object.hasOwnProperty('config')) {\n         const {response: {status, statusText}, config: {method, url}} = object;\n         let message = (`${status} error making request ${method} ${url}: \"${statusText}\"`);\n         error = new ResponseError(message, path, object);\n         log(`${message} ${JSON.stringify(object.data)}`);\n      } else {\n         error = object;\n      }\n      if (cb) {\n         log('going to error callback');\n         cb(error);\n      } else {\n         log('throwing error');\n         throw error;\n      }\n   };\n}\n"]}
//# sourceMappingURL=Requestable.js.map