superagent 3.7.0 → 3.8.2

package/lib/node/index.js

@@ -4,30 +4,29 @@
  * Module dependencies.
  */
 
-var debug = require('debug')('superagent');
-var formidable = require('formidable');
-var FormData = require('form-data');
-var Response = require('./response');
-var parse = require('url').parse;
-var format = require('url').format;
-var resolve = require('url').resolve;
-var methods = require('methods');
-var Stream = require('stream');
-var utils = require('../utils');
-var unzip = require('./unzip').unzip;
-var extend = require('extend');
-var mime = require('mime');
-var https = require('https');
-var http = require('http');
-var fs = require('fs');
-var qs = require('qs');
-var zlib = require('zlib');
-var util = require('util');
-var pkg = require('../../package.json');
-var RequestBase = require('../request-base');
-var shouldRetry = require('../should-retry');
-
-var request = exports = module.exports = function(method, url) {
+const debug = require('debug')('superagent');
+const formidable = require('formidable');
+const FormData = require('form-data');
+const Response = require('./response');
+const parse = require('url').parse;
+const format = require('url').format;
+const resolve = require('url').resolve;
+let methods = require('methods');
+const Stream = require('stream');
+const utils = require('../utils');
+const unzip = require('./unzip').unzip;
+const extend = require('extend');
+const mime = require('mime');
+const https = require('https');
+const http = require('http');
+const fs = require('fs');
+const qs = require('qs');
+const zlib = require('zlib');
+const util = require('util');
+const pkg = require('../../package.json');
+const RequestBase = require('../request-base');
+
+function request(method, url) {
   // callback
   if ('function' == typeof url) {
     return new exports.Request('GET', method).end(url);
@@ -40,6 +39,7 @@ var request = exports = module.exports = function(method, url) {
 
   return new exports.Request(method, url);
 }
+exports = module.exports = request;
 
 /**
  * Expose `Request`.
@@ -79,7 +79,7 @@ mime.define({
 
 exports.protocols = {
   'http:': http,
-  'https:': https
+  'https:': https,
 };
 
 /**
@@ -93,7 +93,7 @@ exports.protocols = {
 
 exports.serialize = {
   'application/x-www-form-urlencoded': qs.stringify,
-  'application/json': JSON.stringify
+  'application/json': JSON.stringify,
 };
 
 /**
@@ -114,7 +114,7 @@ exports.parse = require('./parsers');
  * @api private
  */
 function _initHeaders(req) {
-  var ua = 'node-superagent/' + pkg.version;
+  const ua = `node-superagent/${pkg.version}`;
   req._header = { // coerces header names to lowercase
     'user-agent': ua
   };
@@ -164,7 +164,7 @@ RequestBase(Request.prototype);
  *
  * ``` js
  * request.post('http://localhost/upload')
- *   .attach(new Buffer('<b>Hello world</b>'), 'hello.html')
+ *   .attach('field', Buffer.from('<b>Hello world</b>'), 'hello.html')
  *   .end(callback);
  * ```
  *
@@ -189,7 +189,7 @@ Request.prototype.attach = function(field, file, options){
       throw Error("superagent can't mix .send() and .attach()");
     }
 
-    var o = options || {};
+    let o = options || {};
     if ('string' == typeof options) {
       o = { filename: options };
     }
@@ -210,10 +210,9 @@ Request.prototype.attach = function(field, file, options){
 Request.prototype._getFormData = function() {
   if (!this._formData) {
     this._formData = new FormData();
-    var that = this;
-    this._formData.on('error', function(err) {
-      that.emit('error', err);
-      that.abort();
+    this._formData.on('error', err => {
+      this.emit('error', err);
+      this.abort();
     });
   }
   return this._formData;
@@ -259,10 +258,11 @@ Request.prototype.agent = function(agent){
  * @api public
  */
 
-Request.prototype.type = function(type){
-  return this.set('Content-Type', ~type.indexOf('/')
-    ? type
-    : mime.lookup(type));
+Request.prototype.type = function(type) {
+  return this.set(
+    'Content-Type',
+    ~type.indexOf('/') ? type : mime.lookup(type)
+  );
 };
 
 /**
@@ -324,7 +324,7 @@ Request.prototype.query = function(val){
  */
 
 Request.prototype.write = function(data, encoding){
-  var req = this.request();
+  const req = this.request();
   if (!this._streamRequest) {
     this._streamRequest = true;
   }
@@ -348,25 +348,32 @@ Request.prototype.pipe = function(stream, options){
 };
 
 Request.prototype._pipeContinue = function(stream, options){
-  var self = this;
-  this.req.once('response', function(res){
+  this.req.once('response', res => {
     // redirect
-    var redirect = isRedirect(res.statusCode);
-    if (redirect && self._redirects++ != self._maxRedirects) {
-      return self._redirect(res)._pipeContinue(stream, options);
+    const redirect = isRedirect(res.statusCode);
+    if (redirect && this._redirects++ != this._maxRedirects) {
+      return this._redirect(res)._pipeContinue(stream, options);
     }
 
-    self.res = res;
-    self._emitResponse();
-    if (self._aborted) return;
+    this.res = res;
+    this._emitResponse();
+    if (this._aborted) return;
 
-    if (self._shouldUnzip(res)) {
-      res.pipe(zlib.createUnzip()).pipe(stream, options);
+    if (this._shouldUnzip(res)) {
+      const unzipObj = zlib.createUnzip();
+      unzipObj.on('error', err => {
+        if (err && err.code === 'Z_BUF_ERROR') { // unexpected end of file is ignored by browsers and curl
+          stream.emit('end');
+          return;
+        }
+        stream.emit('error', err);
+      });
+      res.pipe(unzipObj).pipe(stream, options);
     } else {
       res.pipe(stream, options);
     }
-    res.once('end', function(){
-      self.emit('end');
+    res.once('end', () => {
+      this.emit('end');
     });
   });
   return stream;
@@ -394,7 +401,7 @@ Request.prototype.buffer = function(val){
  */
 
 Request.prototype._redirect = function(res){
-  var url = res.headers.location;
+  let url = res.headers.location;
   if (!url) {
     return this.callback(new Error('No location header for redirect'), res);
   }
@@ -408,15 +415,15 @@ Request.prototype._redirect = function(res){
   // this is required for Node v0.10+
   res.resume();
 
-  var headers = this.req._headers;
+  let headers = this.req._headers;
 
-  var shouldStripCookie = parse(url).host !== parse(this.url).host;
+  const changesOrigin = parse(url).host !== parse(this.url).host;
 
   // implementation of 302 following defacto standard
   if (res.statusCode == 301 || res.statusCode == 302){
     // strip Content-* related fields
     // in case of POST etc
-    headers = utils.cleanHeader(this.req._headers, shouldStripCookie);
+    headers = utils.cleanHeader(this.req._headers, changesOrigin);
 
     // force GET
     this.method = 'HEAD' == this.method
@@ -430,7 +437,7 @@ Request.prototype._redirect = function(res){
   if (res.statusCode == 303) {
     // strip Content-* related fields
     // in case of POST etc
-    headers = utils.cleanHeader(this.req._headers, shouldStripCookie);
+    headers = utils.cleanHeader(this.req._headers, changesOrigin);
 
     // force method
     this.method = 'GET';
@@ -446,7 +453,7 @@ Request.prototype._redirect = function(res){
   delete this._formData;
 
   // remove all add header except User-Agent
-  _initHeaders(this)
+  _initHeaders(this);
 
   // redirect
   this._endCalled = false;
@@ -479,19 +486,19 @@ Request.prototype._redirect = function(res){
 
 Request.prototype.auth = function(user, pass, options){
   if (1 === arguments.length) pass = '';
-  if (2 === arguments.length && typeof pass === 'object') options = pass;
+  if (typeof pass === 'object' && pass !== null) { // pass is optional and can be replaced with options
+    options = pass;
+    pass = '';
+  }
   if (!options) {
     options = { type: 'basic' };
   }
-  switch (options.type) {
-    case 'bearer':
-      return this.set('Authorization', 'Bearer ' + user);
-
-    default: // 'basic'
-      if (!~user.indexOf(':')) user = user + ':';
-      var str = new Buffer(user + pass).toString('base64');
-      return this.set('Authorization', 'Basic ' + str);
-  }
+
+  var encoder = function(string) {
+    return new Buffer(string).toString('base64');
+  };
+
+  return this._auth(user, pass, options, encoder);
 };
 
 /**
@@ -528,8 +535,8 @@ Request.prototype.key = function(cert){
  * @api public
  */
 
-Request.prototype.pfx = function(cert){
-  if(typeof cert === 'object' && !Buffer.isBuffer(cert)){
+Request.prototype.pfx = function(cert) {
+  if (typeof cert === 'object' && !Buffer.isBuffer(cert)) {
     this._pfx = cert.pfx;
     this._passphrase = cert.passphrase;
   } else {
@@ -561,11 +568,13 @@ Request.prototype.cert = function(cert){
 Request.prototype.request = function(){
   if (this.req) return this.req;
 
-  var self = this;
-  var options = {};
+  const options = {};
 
   try {
-    var query = qs.stringify(this.qs, { indices: false, strictNullHandling: true });
+    const query = qs.stringify(this.qs, {
+      indices: false,
+      strictNullHandling: true,
+    });
     if (query) {
       this.qs = {};
       this._query.push(query);
@@ -575,20 +584,20 @@ Request.prototype.request = function(){
     return this.emit('error', e);
   }
 
-  var url = this.url;
-  var retries = this._retries;
+  let url = this.url;
+  const retries = this._retries;
 
   // default to http://
-  if (0 != url.indexOf('http')) url = 'http://' + url;
+  if (0 != url.indexOf('http')) url = `http://${url}`;
   url = parse(url);
 
   // support unix sockets
   if (/^https?\+unix:/.test(url.protocol) === true) {
     // get the protocol
-    url.protocol = url.protocol.split('+')[0] + ':';
+    url.protocol = `${url.protocol.split('+')[0]}:`;
 
     // get the socket, path
-    var unixParts = url.path.match(/^([^/]+)(.+)$/);
+    const unixParts = url.path.match(/^([^/]+)(.+)$/);
     options.socketPath = unixParts[1].replace(/%2F/g, '/');
     url.path = unixParts[2];
   }
@@ -606,10 +615,10 @@ Request.prototype.request = function(){
   options.agent = this._agent;
 
   // initiate request
-  var mod = exports.protocols[url.protocol];
+  const mod = exports.protocols[url.protocol];
 
   // request
-  var req = this.req = mod.request(options);
+  const req = (this.req = mod.request(options));
 
   // set tcp no delay
   req.setNoDelay(true);
@@ -621,32 +630,35 @@ Request.prototype.request = function(){
   this.host = url.host;
 
   // expose events
-  req.once('drain', function(){ self.emit('drain'); });
+  req.once('drain', () => { this.emit('drain'); });
 
-  req.once('error', function(err){
+  req.once('error', err => {
     // flag abortion here for out timeouts
     // because node will emit a faux-error "socket hang up"
     // when request is aborted before a connection is made
-    if (self._aborted) return;
+    if (this._aborted) return;
     // if not the same, we are in the **old** (cancelled) request,
     // so need to continue (same as for above)
-    if (self._retries !== retries) return;
+    if (this._retries !== retries) return;
     // if we've received a response then we don't want to let
     // an error in the request blow up the response
-    if (self.response) return;
-    self.callback(err);
+    if (this.response) return;
+    this.callback(err);
   });
 
   // auth
   if (url.auth) {
-    var auth = url.auth.split(':');
+    const auth = url.auth.split(':');
     this.auth(auth[0], auth[1]);
   }
+  if (this.username && this.password) {
+    this.auth(this.username, this.password);
+  }
 
   // add cookies
   if (this.cookies) req.setHeader('Cookie', this.cookies);
 
-  for (var key in this.header) {
+  for (const key in this.header) {
     if (this.header.hasOwnProperty(key))
       req.setHeader(key, this.header[key]);
   }
@@ -664,33 +676,35 @@ Request.prototype.request = function(){
  */
 
 Request.prototype.callback = function(err, res){
-  // console.log(this._retries, this._maxRetries)
-  if (this._maxRetries && this._retries++ < this._maxRetries && shouldRetry(err, res)) {
+  if (this._shouldRetry(err, res)) {
     return this._retry();
   }
 
   // Avoid the error which is emitted from 'socket hang up' to cause the fn undefined error on JS runtime.
-  var fn = this._callback || noop;
+  const fn = this._callback || noop;
   this.clearTimeout();
   if (this.called) return console.warn('superagent: double callback bug');
   this.called = true;
 
   if (!err) {
     try {
-      if (this._isResponseOK(res)) {
-        return fn(err, res);
-      }
-
-      var msg = 'Unsuccessful HTTP response';
-      if (res) {
-        msg = http.STATUS_CODES[res.status] || msg;
+      if (!this._isResponseOK(res)) {
+        let msg = 'Unsuccessful HTTP response';
+        if (res) {
+          msg = http.STATUS_CODES[res.status] || msg;
+        }
+        err = new Error(msg);
+        err.status = res ? res.status : undefined;
       }
-      err = new Error(msg);
-      err.status = res ? res.status : undefined;
     } catch (new_err) {
       err = new_err;
     }
   }
+  // It's important that the callback is called outside try/catch
+  // to avoid double callback
+  if (!err) {
+    return fn(null, res);
+  }
 
   err.response = res;
   if (this._maxRetries) err.retries = this._retries - 1;
@@ -724,24 +738,26 @@ Request.prototype._isHost = function _isHost(obj) {
  * @api public
  */
 
-Request.prototype._emitResponse = function(body, files){
-    var response = new Response(this);
-    this.response = response;
-    response.redirects = this._redirectList;
-    if (undefined !== body) {
-      response.body = body;
-    }
-    response.files = files;
-    this.emit('response', response);
-    return response;
+Request.prototype._emitResponse = function(body, files) {
+  const response = new Response(this);
+  this.response = response;
+  response.redirects = this._redirectList;
+  if (undefined !== body) {
+    response.body = body;
+  }
+  response.files = files;
+  this.emit('response', response);
+  return response;
 };
 
-Request.prototype.end = function(fn){
+Request.prototype.end = function(fn) {
   this.request();
   debug('%s %s', this.method, this.url);
 
   if (this._endCalled) {
-    console.warn("Warning: .end() was called twice. This is not supported in superagent");
+    console.warn(
+      'Warning: .end() was called twice. This is not supported in superagent'
+    );
   }
   this._endCalled = true;
 
@@ -752,11 +768,10 @@ Request.prototype.end = function(fn){
 };
 
 Request.prototype._end = function() {
-  var self = this;
-  var data = this._data;
-  var req = this.req;
-  var buffer = this._buffer;
-  var method = this.method;
+  let data = this._data;
+  const req = this.req;
+  let buffer = this._buffer;
+  const method = this.method;
 
   this._setTimeouts();
 
@@ -764,10 +779,10 @@ Request.prototype._end = function() {
   if ('HEAD' != method && !req._headerSent) {
     // serialize stuff
     if ('string' != typeof data) {
-      var contentType = req.getHeader('Content-Type')
+      let contentType = req.getHeader('Content-Type');
       // Parse out just the content type from the header (ignore the charset)
-      if (contentType) contentType = contentType.split(';')[0]
-      var serialize = exports.serialize[contentType];
+      if (contentType) contentType = contentType.split(';')[0];
+      let serialize = exports.serialize[contentType];
       if (!serialize && isJSON(contentType)) {
         serialize = exports.serialize['application/json'];
       }
@@ -781,40 +796,40 @@ Request.prototype._end = function() {
   }
 
   // response
-  req.once('response', function(res){
-    debug('%s %s -> %s', self.method, self.url, res.statusCode);
+  req.once('response', res => {
+    debug('%s %s -> %s', this.method, this.url, res.statusCode);
 
-    if (self._responseTimeoutTimer) {
-      clearTimeout(self._responseTimeoutTimer);
+    if (this._responseTimeoutTimer) {
+      clearTimeout(this._responseTimeoutTimer);
     }
 
-    if (self.piped) {
+    if (this.piped) {
       return;
     }
 
-    var max = self._maxRedirects;
-    var mime = utils.type(res.headers['content-type'] || '') || 'text/plain';
-    var type = mime.split('/')[0];
-    var multipart = 'multipart' == type;
-    var redirect = isRedirect(res.statusCode);
-    var parser = self._parser;
-    var responseType = self._responseType;
+    const max = this._maxRedirects;
+    const mime = utils.type(res.headers['content-type'] || '') || 'text/plain';
+    const type = mime.split('/')[0];
+    const multipart = 'multipart' == type;
+    const redirect = isRedirect(res.statusCode);
+    let parser = this._parser;
+    const responseType = this._responseType;
 
-    self.res = res;
+    this.res = res;
 
     // redirect
-    if (redirect && self._redirects++ != max) {
-      return self._redirect(res);
+    if (redirect && this._redirects++ != max) {
+      return this._redirect(res);
     }
 
-    if ('HEAD' == self.method) {
-      self.emit('end');
-      self.callback(null, self._emitResponse());
+    if ('HEAD' == this.method) {
+      this.emit('end');
+      this.callback(null, this._emitResponse());
       return;
     }
 
     // zlib support
-    if (self._shouldUnzip(res)) {
+    if (this._shouldUnzip(res)) {
       unzip(req, res);
     }
 
@@ -823,7 +838,7 @@ Request.prototype._end = function() {
         parser = exports.parse.image; // It's actually a generic Buffer
         buffer = true;
       } else if (multipart) {
-        var form = new formidable.IncomingForm();
+        const form = new formidable.IncomingForm();
         parser = form.parse.bind(form);
         buffer = true;
       } else if (isImageOrVideo(mime)) {
@@ -845,15 +860,15 @@ Request.prototype._end = function() {
     }
 
     // by default only buffer text/*, json and messed up thing from hell
-    if (undefined === buffer && isText(mime) || isJSON(mime)) {
+    if ((undefined === buffer && isText(mime)) || isJSON(mime)) {
       buffer = true;
     }
 
-    var parserHandlesEnd = false;
+    let parserHandlesEnd = false;
     if (buffer) {
       // Protectiona against zip bombs and other nuisance
-      let responseBytesLeft = self._maxResponseSize || 200000000;
-      res.on('data', function(buf) {
+      let responseBytesLeft = this._maxResponseSize || 200000000;
+      res.on('data', buf => {
         responseBytesLeft -= buf.byteLength || buf.length;
         if (responseBytesLeft < 0) {
           // This will propagate through error event
@@ -874,71 +889,72 @@ Request.prototype._end = function() {
         // which is weird BTW, because response.body won't be there.
         parserHandlesEnd = buffer;
 
-        parser(res, function(err, obj, files) {
-          if (self.timedout) {
+        parser(res, (err, obj, files) => {
+          if (this.timedout) {
             // Timeout has already handled all callbacks
             return;
           }
 
           // Intentional (non-timeout) abort is supposed to preserve partial response,
           // even if it doesn't parse.
-          if (err && !self._aborted) {
-            return self.callback(err);
+          if (err && !this._aborted) {
+            return this.callback(err);
           }
 
           if (parserHandlesEnd) {
-            self.emit('end');
-            self.callback(null, self._emitResponse(obj, files));
+            this.emit('end');
+            this.callback(null, this._emitResponse(obj, files));
           }
         });
       } catch (err) {
-        self.callback(err);
+        this.callback(err);
         return;
       }
     }
 
-    self.res = res;
+    this.res = res;
 
     // unbuffered
     if (!buffer) {
-      debug('unbuffered %s %s', self.method, self.url);
-      self.callback(null, self._emitResponse());
-      if (multipart) return // allow multipart to handle end event
-      res.once('end', function(){
-        debug('end %s %s', self.method, self.url);
-        self.emit('end');
-      })
+      debug('unbuffered %s %s', this.method, this.url);
+      this.callback(null, this._emitResponse());
+      if (multipart) return; // allow multipart to handle end event
+      res.once('end', () => {
+        debug('end %s %s', this.method, this.url);
+        this.emit('end');
+      });
       return;
     }
 
     // terminating events
-    res.once('error', function(err){
+    res.once('error', err => {
       parserHandlesEnd = false;
-      self.callback(err, null);
-    });
-    if (!parserHandlesEnd) res.once('end', function(){
-      debug('end %s %s', self.method, self.url);
-      // TODO: unless buffering emit earlier to stream
-      self.emit('end');
-      self.callback(null, self._emitResponse());
+      this.callback(err, null);
     });
+    if (!parserHandlesEnd)
+      res.once('end', () => {
+        debug('end %s %s', this.method, this.url);
+        // TODO: unless buffering emit earlier to stream
+        this.emit('end');
+        this.callback(null, this._emitResponse());
+      });
   });
 
   this.emit('request', this);
 
   // if a FormData instance got created, then we send that as the request body
-  var formData = this._formData;
+  const formData = this._formData;
   if (formData) {
 
     // set headers
-    var headers = formData.getHeaders();
-    for (var i in headers) {
+    const headers = formData.getHeaders();
+    for (const i in headers) {
       debug('setting FormData header: "%s: %s"', i, headers[i]);
       req.setHeader(i, headers[i]);
     }
 
     // attempt to get "Content-Length" header
-    formData.getLength(function(err, length) {
+    formData.getLength((err, length) => {
       // TODO: Add chunked encoding when no length (if err)
 
       debug('got FormData Content-Length: %s', length);
@@ -946,19 +962,19 @@ Request.prototype._end = function() {
         req.setHeader('Content-Length', length);
       }
 
-      var getProgressMonitor = function () {
-        var lengthComputable = true;
-        var total = req.getHeader('Content-Length');
-        var loaded = 0;
+      const getProgressMonitor = () => {
+        const lengthComputable = true;
+        const total = req.getHeader('Content-Length');
+        let loaded = 0;
 
-        var progress = new Stream.Transform();
-        progress._transform = function (chunk, encoding, cb) {
+        const progress = new Stream.Transform();
+        progress._transform = (chunk, encoding, cb) => {
           loaded += chunk.length;
-          self.emit('progress', {
+          this.emit('progress', {
             direction: 'upload',
-            lengthComputable: lengthComputable,
-            loaded: loaded,
-            total: total
+            lengthComputable,
+            loaded,
+            total,
           });
           cb(null, chunk);
         };
@@ -976,7 +992,7 @@ Request.prototype._end = function() {
 /**
  * Check whether response has a non-0-sized gzip-encoded body
  */
-Request.prototype._shouldUnzip = function(res){
+Request.prototype._shouldUnzip = res => {
   if (res.statusCode === 204 || res.statusCode === 304) {
     // These aren't supposed to have any body
     return false;
@@ -1000,14 +1016,14 @@ if (methods.indexOf('del') == -1) {
   methods = methods.slice(0);
   methods.push('del');
 }
-methods.forEach(function(method){
-  var name = method;
+methods.forEach(method => {
+  const name = method;
   method = 'del' == method ? 'delete' : method;
 
   method = method.toUpperCase();
-  request[name] = function(url, data, fn){
-    var req = request(method, url);
-    if ('function' == typeof data) fn = data, data = null;
+  request[name] = (url, data, fn) => {
+    const req = request(method, url);
+    if ('function' == typeof data) (fn = data), (data = null);
     if (data) {
       if (method === 'GET' || method === 'HEAD') {
         req.query(data);
@@ -1029,16 +1045,15 @@ methods.forEach(function(method){
  */
 
 function isText(mime) {
-  var parts = mime.split('/');
-  var type = parts[0];
-  var subtype = parts[1];
+  const parts = mime.split('/');
+  const type = parts[0];
+  const subtype = parts[1];
 
-  return 'text' == type
-    || 'x-www-form-urlencoded' == subtype;
+  return 'text' == type || 'x-www-form-urlencoded' == subtype;
 }
 
 function isImageOrVideo(mime) {
-  var type = mime.split('/')[0];
+  const type = mime.split('/')[0];
 
   return 'image' == type || 'video' == type;
 }
@@ -1052,7 +1067,9 @@ function isImageOrVideo(mime) {
  */
 
 function isJSON(mime) {
-  return /[\/+]json\b/.test(mime);
+  // should match /json or +json
+  // but not /json-seq
+  return /[\/+]json($|[^-\w])/.test(mime);
 }
 
 /**