1 | ;
|
2 |
|
3 | 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; };
|
4 |
|
5 | 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; }; }();
|
6 |
|
7 | var _axios = require('axios');
|
8 |
|
9 | var _axios2 = _interopRequireDefault(_axios);
|
10 |
|
11 | var _debug = require('debug');
|
12 |
|
13 | var _debug2 = _interopRequireDefault(_debug);
|
14 |
|
15 | var _jsBase = require('js-base64');
|
16 |
|
17 | function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
|
18 |
|
19 | 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); } }
|
20 |
|
21 | function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
|
22 |
|
23 | 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; }
|
24 |
|
25 | 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; } /**
|
26 | * @file
|
27 | * @copyright 2016 Yahoo Inc.
|
28 | * @license Licensed under {@link https://spdx.org/licenses/BSD-3-Clause-Clear.html BSD-3-Clause-Clear}.
|
29 | * Github.js is freely distributable.
|
30 | */
|
31 |
|
32 | var log = (0, _debug2.default)('github:request');
|
33 |
|
34 | /**
|
35 | * The error structure returned when a network call fails
|
36 | */
|
37 |
|
38 | var ResponseError = function (_Error) {
|
39 | _inherits(ResponseError, _Error);
|
40 |
|
41 | /**
|
42 | * Construct a new ResponseError
|
43 | * @param {string} message - an message to return instead of the the default error message
|
44 | * @param {string} path - the requested path
|
45 | * @param {Object} response - the object returned by Axios
|
46 | */
|
47 | function ResponseError(message, path, response) {
|
48 | _classCallCheck(this, ResponseError);
|
49 |
|
50 | var _this = _possibleConstructorReturn(this, (ResponseError.__proto__ || Object.getPrototypeOf(ResponseError)).call(this, message));
|
51 |
|
52 | _this.path = path;
|
53 | _this.request = response.config;
|
54 | _this.response = (response || {}).response || response;
|
55 | _this.status = response.status;
|
56 | return _this;
|
57 | }
|
58 |
|
59 | return ResponseError;
|
60 | }(Error);
|
61 |
|
62 | /**
|
63 | * Requestable wraps the logic for making http requests to the API
|
64 | */
|
65 |
|
66 |
|
67 | var Requestable = function () {
|
68 | /**
|
69 | * Either a username and password or an oauth token for Github
|
70 | * @typedef {Object} Requestable.auth
|
71 | * @prop {string} [username] - the Github username
|
72 | * @prop {string} [password] - the user's password
|
73 | * @prop {token} [token] - an OAuth token
|
74 | */
|
75 | /**
|
76 | * Initialize the http internals.
|
77 | * @param {Requestable.auth} [auth] - the credentials to authenticate to Github. If auth is
|
78 | * not provided request will be made unauthenticated
|
79 | * @param {string} [apiBase=https://api.github.com] - the base Github API URL
|
80 | * @param {string} [AcceptHeader=v3] - the accept header for the requests
|
81 | */
|
82 | function Requestable(auth, apiBase, AcceptHeader) {
|
83 | _classCallCheck(this, Requestable);
|
84 |
|
85 | this.__apiBase = apiBase || 'https://api.github.com';
|
86 | this.__auth = {
|
87 | token: auth.token,
|
88 | username: auth.username,
|
89 | password: auth.password
|
90 | };
|
91 | this.__AcceptHeader = AcceptHeader || 'v3';
|
92 |
|
93 | if (auth.token) {
|
94 | this.__authorizationHeader = 'token ' + auth.token;
|
95 | } else if (auth.username && auth.password) {
|
96 | this.__authorizationHeader = 'Basic ' + _jsBase.Base64.encode(auth.username + ':' + auth.password);
|
97 | }
|
98 | }
|
99 |
|
100 | /**
|
101 | * Compute the URL to use to make a request.
|
102 | * @private
|
103 | * @param {string} path - either a URL relative to the API base or an absolute URL
|
104 | * @return {string} - the URL to use
|
105 | */
|
106 |
|
107 |
|
108 | _createClass(Requestable, [{
|
109 | key: '__getURL',
|
110 | value: function __getURL(path) {
|
111 | var url = path;
|
112 |
|
113 | if (path.indexOf('//') === -1) {
|
114 | url = this.__apiBase + path;
|
115 | }
|
116 |
|
117 | var newCacheBuster = 'timestamp=' + new Date().getTime();
|
118 | return url.replace(/(timestamp=\d+)/, newCacheBuster);
|
119 | }
|
120 |
|
121 | /**
|
122 | * Compute the headers required for an API request.
|
123 | * @private
|
124 | * @param {boolean} raw - if the request should be treated as JSON or as a raw request
|
125 | * @param {string} AcceptHeader - the accept header for the request
|
126 | * @return {Object} - the headers to use in the request
|
127 | */
|
128 |
|
129 | }, {
|
130 | key: '__getRequestHeaders',
|
131 | value: function __getRequestHeaders(raw, AcceptHeader) {
|
132 | var headers = {
|
133 | 'Content-Type': 'application/json;charset=UTF-8',
|
134 | 'Accept': 'application/vnd.github.' + (AcceptHeader || this.__AcceptHeader)
|
135 | };
|
136 |
|
137 | if (raw) {
|
138 | headers.Accept += '.raw';
|
139 | }
|
140 | headers.Accept += '+json';
|
141 |
|
142 | if (this.__authorizationHeader) {
|
143 | headers.Authorization = this.__authorizationHeader;
|
144 | }
|
145 |
|
146 | return headers;
|
147 | }
|
148 |
|
149 | /**
|
150 | * Sets the default options for API requests
|
151 | * @protected
|
152 | * @param {Object} [requestOptions={}] - the current options for the request
|
153 | * @return {Object} - the options to pass to the request
|
154 | */
|
155 |
|
156 | }, {
|
157 | key: '_getOptionsWithDefaults',
|
158 | value: function _getOptionsWithDefaults() {
|
159 | var requestOptions = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
|
160 |
|
161 | if (!(requestOptions.visibility || requestOptions.affiliation)) {
|
162 | requestOptions.type = requestOptions.type || 'all';
|
163 | }
|
164 | requestOptions.sort = requestOptions.sort || 'updated';
|
165 | requestOptions.per_page = requestOptions.per_page || '100'; // eslint-disable-line
|
166 |
|
167 | return requestOptions;
|
168 | }
|
169 |
|
170 | /**
|
171 | * if a `Date` is passed to this function it will be converted to an ISO string
|
172 | * @param {*} date - the object to attempt to coerce into an ISO date string
|
173 | * @return {string} - the ISO representation of `date` or whatever was passed in if it was not a date
|
174 | */
|
175 |
|
176 | }, {
|
177 | key: '_dateToISO',
|
178 | value: function _dateToISO(date) {
|
179 | if (date && date instanceof Date) {
|
180 | date = date.toISOString();
|
181 | }
|
182 |
|
183 | return date;
|
184 | }
|
185 |
|
186 | /**
|
187 | * A function that receives the result of the API request.
|
188 | * @callback Requestable.callback
|
189 | * @param {Requestable.Error} error - the error returned by the API or `null`
|
190 | * @param {(Object|true)} result - the data returned by the API or `true` if the API returns `204 No Content`
|
191 | * @param {Object} request - the raw {@linkcode https://github.com/mzabriskie/axios#response-schema Response}
|
192 | */
|
193 | /**
|
194 | * Make a request.
|
195 | * @param {string} method - the method for the request (GET, PUT, POST, DELETE)
|
196 | * @param {string} path - the path for the request
|
197 | * @param {*} [data] - the data to send to the server. For HTTP methods that don't have a body the data
|
198 | * will be sent as query parameters
|
199 | * @param {Requestable.callback} [cb] - the callback for the request
|
200 | * @param {boolean} [raw=false] - if the request should be sent as raw. If this is a falsy value then the
|
201 | * request will be made as JSON
|
202 | * @return {Promise} - the Promise for the http request
|
203 | */
|
204 |
|
205 | }, {
|
206 | key: '_request',
|
207 | value: function _request(method, path, data, cb, raw) {
|
208 | var url = this.__getURL(path);
|
209 |
|
210 | var AcceptHeader = (data || {}).AcceptHeader;
|
211 | if (AcceptHeader) {
|
212 | delete data.AcceptHeader;
|
213 | }
|
214 | var headers = this.__getRequestHeaders(raw, AcceptHeader);
|
215 |
|
216 | var queryParams = {};
|
217 |
|
218 | var shouldUseDataAsParams = data && (typeof data === 'undefined' ? 'undefined' : _typeof(data)) === 'object' && methodHasNoBody(method);
|
219 | if (shouldUseDataAsParams) {
|
220 | queryParams = data;
|
221 | data = undefined;
|
222 | }
|
223 |
|
224 | var config = {
|
225 | url: url,
|
226 | method: method,
|
227 | headers: headers,
|
228 | params: queryParams,
|
229 | data: data,
|
230 | responseType: raw ? 'text' : 'json'
|
231 | };
|
232 |
|
233 | log(config.method + ' to ' + config.url);
|
234 | var requestPromise = (0, _axios2.default)(config).catch(callbackErrorOrThrow(cb, path));
|
235 |
|
236 | if (cb) {
|
237 | requestPromise.then(function (response) {
|
238 | if (response.data && Object.keys(response.data).length > 0) {
|
239 | // When data has results
|
240 | cb(null, response.data, response);
|
241 | } else if (config.method !== 'GET' && Object.keys(response.data).length < 1) {
|
242 | // True when successful submit a request and receive a empty object
|
243 | cb(null, response.status < 300, response);
|
244 | } else {
|
245 | cb(null, response.data, response);
|
246 | }
|
247 | });
|
248 | }
|
249 |
|
250 | return requestPromise;
|
251 | }
|
252 |
|
253 | /**
|
254 | * Make a request to an endpoint the returns 204 when true and 404 when false
|
255 | * @param {string} path - the path to request
|
256 | * @param {Object} data - any query parameters for the request
|
257 | * @param {Requestable.callback} cb - the callback that will receive `true` or `false`
|
258 | * @param {method} [method=GET] - HTTP Method to use
|
259 | * @return {Promise} - the promise for the http request
|
260 | */
|
261 |
|
262 | }, {
|
263 | key: '_request204or404',
|
264 | value: function _request204or404(path, data, cb) {
|
265 | var method = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : 'GET';
|
266 |
|
267 | return this._request(method, path, data).then(function success(response) {
|
268 | if (cb) {
|
269 | cb(null, true, response);
|
270 | }
|
271 | return true;
|
272 | }, function failure(response) {
|
273 | if (response.response.status === 404) {
|
274 | if (cb) {
|
275 | cb(null, false, response);
|
276 | }
|
277 | return false;
|
278 | }
|
279 |
|
280 | if (cb) {
|
281 | cb(response);
|
282 | }
|
283 | throw response;
|
284 | });
|
285 | }
|
286 |
|
287 | /**
|
288 | * Make a request and fetch all the available data. Github will paginate responses so for queries
|
289 | * that might span multiple pages this method is preferred to {@link Requestable#request}
|
290 | * @param {string} path - the path to request
|
291 | * @param {Object} options - the query parameters to include
|
292 | * @param {Requestable.callback} [cb] - the function to receive the data. The returned data will always be an array.
|
293 | * @param {Object[]} results - the partial results. This argument is intended for internal use only.
|
294 | * @return {Promise} - a promise which will resolve when all pages have been fetched
|
295 | * @deprecated This will be folded into {@link Requestable#_request} in the 2.0 release.
|
296 | */
|
297 |
|
298 | }, {
|
299 | key: '_requestAllPages',
|
300 | value: function _requestAllPages(path, options, cb, results) {
|
301 | var _this2 = this;
|
302 |
|
303 | results = results || [];
|
304 |
|
305 | return this._request('GET', path, options).then(function (response) {
|
306 | var _results;
|
307 |
|
308 | var thisGroup = void 0;
|
309 | if (response.data instanceof Array) {
|
310 | thisGroup = response.data;
|
311 | } else if (response.data.items instanceof Array) {
|
312 | thisGroup = response.data.items;
|
313 | } else {
|
314 | var message = 'cannot figure out how to append ' + response.data + ' to the result set';
|
315 | throw new ResponseError(message, path, response);
|
316 | }
|
317 | (_results = results).push.apply(_results, _toConsumableArray(thisGroup));
|
318 |
|
319 | var nextUrl = getNextPage(response.headers.link);
|
320 | if (nextUrl) {
|
321 | if (!options) {
|
322 | options = {};
|
323 | }
|
324 | options.page = parseInt(nextUrl.match(/([&\?]page=[0-9]*)/g).shift().split('=').pop());
|
325 | if (!(options && typeof options.page !== 'number')) {
|
326 | log('getting next page: ' + nextUrl);
|
327 | return _this2._requestAllPages(nextUrl, options, cb, results);
|
328 | }
|
329 | }
|
330 |
|
331 | if (cb) {
|
332 | cb(null, results, response);
|
333 | }
|
334 |
|
335 | response.data = results;
|
336 | return response;
|
337 | }).catch(callbackErrorOrThrow(cb, path));
|
338 | }
|
339 | }]);
|
340 |
|
341 | return Requestable;
|
342 | }();
|
343 |
|
344 | module.exports = Requestable;
|
345 |
|
346 | // ////////////////////////// //
|
347 | // Private helper functions //
|
348 | // ////////////////////////// //
|
349 | var METHODS_WITH_NO_BODY = ['GET', 'HEAD', 'DELETE'];
|
350 | function methodHasNoBody(method) {
|
351 | return METHODS_WITH_NO_BODY.indexOf(method) !== -1;
|
352 | }
|
353 |
|
354 | function getNextPage() {
|
355 | var linksHeader = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : '';
|
356 |
|
357 | var links = linksHeader.split(/\s*,\s*/); // splits and strips the urls
|
358 | return links.reduce(function (nextUrl, link) {
|
359 | if (link.search(/rel="next"/) !== -1) {
|
360 | return (link.match(/<(.*)>/) || [])[1];
|
361 | }
|
362 |
|
363 | return nextUrl;
|
364 | }, undefined);
|
365 | }
|
366 |
|
367 | function callbackErrorOrThrow(cb, path) {
|
368 | return function handler(object) {
|
369 | var error = void 0;
|
370 | if (object.hasOwnProperty('config')) {
|
371 | var _object$response = object.response,
|
372 | status = _object$response.status,
|
373 | statusText = _object$response.statusText,
|
374 | _object$config = object.config,
|
375 | method = _object$config.method,
|
376 | url = _object$config.url;
|
377 |
|
378 | var message = status + ' error making request ' + method + ' ' + url + ': "' + statusText + '"';
|
379 | error = new ResponseError(message, path, object);
|
380 | log(message + ' ' + JSON.stringify(object.data));
|
381 | } else {
|
382 | error = object;
|
383 | }
|
384 | if (cb) {
|
385 | log('going to error callback');
|
386 | cb(error);
|
387 | } else {
|
388 | log('throwing error');
|
389 | throw error;
|
390 | }
|
391 | };
|
392 | }
|
393 | //# 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"]}
|
394 | //# sourceMappingURL=Requestable.js.map
|