Merge pull request #372 from rubennorte/promise-adapters

Changing adapter signature to receive config and return promises

README.md

@@ -247,8 +247,8 @@ These are the available config options for making requests. Only the `url` is re
   withCredentials: false, // default
 
   // `adapter` allows custom handling of requests which makes testing easier.
-  // Call `resolve` or `reject` and supply a valid response (see [response docs](#response-api)).
+  // Return a promise and supply a valid response (see [response docs](#response-api)).
-  adapter: function (resolve, reject, config) {
+  adapter: function (config) {
     /* ... */
   },
 

lib/adapters/README.md

@@ -1,13 +1,13 @@
 # axios // adapters
 
-The modules under `adapters/` are modules that handle dispatching a request and settling a `Promise` once a response is received.
+The modules under `adapters/` are modules that handle dispatching a request and settling a returned `Promise` once a response is received.
 
 ## Example
 
 ```js
 var settle = require('./../core/settle');
 
-module.exports myAdapter(resolve, reject, config) {
+module.exports myAdapter(config) {
   // At this point:
   //  - config has been merged with defaults
   //  - request transformers have already run
@@ -16,19 +16,22 @@ module.exports myAdapter(resolve, reject, config) {
   // Make the request using config provided
   // Upon response settle the Promise
 
-  var response = {
+  return new Promise(function(resolve, reject) {
-    data: responseData,
-    status: request.status,
-    statusText: request.statusText,
-    headers: responseHeaders,
-    config: config,
-    request: request
-  };
   
-  settle(resolve, reject, response);
+    var response = {
+      data: responseData,
+      status: request.status,
+      statusText: request.statusText,
+      headers: responseHeaders,
+      config: config,
+      request: request
+    };
 
-  // From here:
+    settle(resolve, reject, response);
-  //  - response transformers will run
+
-  //  - response interceptors will run
+    // From here:
+    //  - response transformers will run
+    //  - response interceptors will run
+  });
 }
 ```

lib/adapters/http.js

@@ -15,158 +15,160 @@ var createError = require('../core/createError');
 var enhanceError = require('../core/enhanceError');
 
 /*eslint consistent-return:0*/
-module.exports = function httpAdapter(resolve, reject, config) {
+module.exports = function httpAdapter(config) {
-  var data = config.data;
+  return new Promise(function dispatchHttpRequest(resolve, reject) {
-  var headers = config.headers;
+    var data = config.data;
-  var timer;
+    var headers = config.headers;
-  var aborted = false;
+    var timer;
+    var aborted = false;
 
-  // Set User-Agent (required by some servers)
+    // Set User-Agent (required by some servers)
-  // Only set header if it hasn't been set in config
+    // Only set header if it hasn't been set in config
-  // See https://github.com/mzabriskie/axios/issues/69
+    // See https://github.com/mzabriskie/axios/issues/69
-  if (!headers['User-Agent'] && !headers['user-agent']) {
+    if (!headers['User-Agent'] && !headers['user-agent']) {
-    headers['User-Agent'] = 'axios/' + pkg.version;
+      headers['User-Agent'] = 'axios/' + pkg.version;
-  }
-
-  if (data && !utils.isStream(data)) {
-    if (utils.isArrayBuffer(data)) {
-      data = new Buffer(new Uint8Array(data));
-    } else if (utils.isString(data)) {
-      data = new Buffer(data, 'utf-8');
-    } else {
-      return reject(createError(
-        'Data after transformation must be a string, an ArrayBuffer, or a Stream',
-        config
-      ));
     }
 
-    // Add Content-Length header if data exists
+    if (data && !utils.isStream(data)) {
-    headers['Content-Length'] = data.length;
+      if (utils.isArrayBuffer(data)) {
-  }
+        data = new Buffer(new Uint8Array(data));
+      } else if (utils.isString(data)) {
+        data = new Buffer(data, 'utf-8');
+      } else {
+        return reject(createError(
+          'Data after transformation must be a string, an ArrayBuffer, or a Stream',
+          config
+        ));
+      }
 
-  // HTTP basic authentication
+      // Add Content-Length header if data exists
-  var auth = undefined;
+      headers['Content-Length'] = data.length;
-  if (config.auth) {
-    var username = config.auth.username || '';
-    var password = config.auth.password || '';
-    auth = username + ':' + password;
-  }
-
-  // Parse url
-  var parsed = url.parse(config.url);
-  if (!auth && parsed.auth) {
-    var urlAuth = parsed.auth.split(':');
-    var urlUsername = urlAuth[0] || '';
-    var urlPassword = urlAuth[1] || '';
-    auth = urlUsername + ':' + urlPassword;
-  }
-  var options = {
-    hostname: parsed.hostname,
-    port: parsed.port,
-    path: buildURL(parsed.path, config.params, config.paramsSerializer).replace(/^\?/, ''),
-    method: config.method,
-    headers: headers,
-    agent: config.agent,
-    auth: auth
-  };
-
-  if (config.proxy) {
-    options.host = config.proxy.host;
-    options.port = config.proxy.port;
-    options.path = parsed.protocol + '//' + parsed.hostname + options.path;
-  }
-
-  var transport;
-  if (config.maxRedirects === 0) {
-    transport = parsed.protocol === 'https:' ? https : http;
-  } else {
-    if (config.maxRedirects) {
-      options.maxRedirects = config.maxRedirects;
-    }
-    transport = parsed.protocol === 'https:' ? httpsFollow : httpFollow;
-  }
-
-  // Create the request
-  var req = transport.request(options, function handleResponse(res) {
-    if (aborted) return;
-
-    // Response has been received so kill timer that handles request timeout
-    clearTimeout(timer);
-    timer = null;
-
-    // uncompress the response body transparently if required
-    var stream = res;
-    switch (res.headers['content-encoding']) {
-    /*eslint default-case:0*/
-    case 'gzip':
-    case 'compress':
-    case 'deflate':
-      // add the unzipper to the body stream processing pipeline
-      stream = stream.pipe(zlib.createUnzip());
-
-      // remove the content-encoding in order to not confuse downstream operations
-      delete res.headers['content-encoding'];
-      break;
     }
 
-    var response = {
+    // HTTP basic authentication
-      status: res.statusCode,
+    var auth = undefined;
-      statusText: res.statusMessage,
+    if (config.auth) {
-      headers: res.headers,
+      var username = config.auth.username || '';
-      config: config,
+      var password = config.auth.password || '';
-      request: req
+      auth = username + ':' + password;
+    }
+
+    // Parse url
+    var parsed = url.parse(config.url);
+    if (!auth && parsed.auth) {
+      var urlAuth = parsed.auth.split(':');
+      var urlUsername = urlAuth[0] || '';
+      var urlPassword = urlAuth[1] || '';
+      auth = urlUsername + ':' + urlPassword;
+    }
+    var options = {
+      hostname: parsed.hostname,
+      port: parsed.port,
+      path: buildURL(parsed.path, config.params, config.paramsSerializer).replace(/^\?/, ''),
+      method: config.method,
+      headers: headers,
+      agent: config.agent,
+      auth: auth
     };
 
-    if (config.responseType === 'stream') {
+    if (config.proxy) {
-      response.data = stream;
+      options.host = config.proxy.host;
-      settle(resolve, reject, response);
+      options.port = config.proxy.port;
+      options.path = parsed.protocol + '//' + parsed.hostname + options.path;
+    }
+
+    var transport;
+    if (config.maxRedirects === 0) {
+      transport = parsed.protocol === 'https:' ? https : http;
     } else {
-      var responseBuffer = [];
+      if (config.maxRedirects) {
-      stream.on('data', function handleStreamData(chunk) {
+        options.maxRedirects = config.maxRedirects;
-        responseBuffer.push(chunk);
+      }
+      transport = parsed.protocol === 'https:' ? httpsFollow : httpFollow;
+    }
 
-        // make sure the content length is not over the maxContentLength if specified
+    // Create the request
-        if (config.maxContentLength > -1 && Buffer.concat(responseBuffer).length > config.maxContentLength) {
+    var req = transport.request(options, function handleResponse(res) {
-          reject(createError('maxContentLength size of ' + config.maxContentLength + ' exceeded', config));
+      if (aborted) return;
-        }
-      });
 
-      stream.on('error', function handleStreamError(err) {
+      // Response has been received so kill timer that handles request timeout
-        if (aborted) return;
+      clearTimeout(timer);
-        reject(enhanceError(err, config));
+      timer = null;
-      });
 
-      stream.on('end', function handleStreamEnd() {
+      // uncompress the response body transparently if required
-        var responseData = Buffer.concat(responseBuffer);
+      var stream = res;
-        if (config.responseType !== 'arraybuffer') {
+      switch (res.headers['content-encoding']) {
-          responseData = responseData.toString('utf8');
+      /*eslint default-case:0*/
-        }
+      case 'gzip':
+      case 'compress':
+      case 'deflate':
+        // add the unzipper to the body stream processing pipeline
+        stream = stream.pipe(zlib.createUnzip());
 
-        response.data = responseData;
+        // remove the content-encoding in order to not confuse downstream operations
+        delete res.headers['content-encoding'];
+        break;
+      }
+
+      var response = {
+        status: res.statusCode,
+        statusText: res.statusMessage,
+        headers: res.headers,
+        config: config,
+        request: req
+      };
+
+      if (config.responseType === 'stream') {
+        response.data = stream;
         settle(resolve, reject, response);
-      });
+      } else {
+        var responseBuffer = [];
+        stream.on('data', function handleStreamData(chunk) {
+          responseBuffer.push(chunk);
+
+          // make sure the content length is not over the maxContentLength if specified
+          if (config.maxContentLength > -1 && Buffer.concat(responseBuffer).length > config.maxContentLength) {
+            reject(createError('maxContentLength size of ' + config.maxContentLength + ' exceeded', config));
+          }
+        });
+
+        stream.on('error', function handleStreamError(err) {
+          if (aborted) return;
+          reject(enhanceError(err, config));
+        });
+
+        stream.on('end', function handleStreamEnd() {
+          var responseData = Buffer.concat(responseBuffer);
+          if (config.responseType !== 'arraybuffer') {
+            responseData = responseData.toString('utf8');
+          }
+
+          response.data = responseData;
+          settle(resolve, reject, response);
+        });
+      }
+    });
+
+    // Handle errors
+    req.on('error', function handleRequestError(err) {
+      if (aborted) return;
+      reject(enhanceError(err, config));
+    });
+
+    // Handle request timeout
+    if (config.timeout && !timer) {
+      timer = setTimeout(function handleRequestTimeout() {
+        req.abort();
+        reject(createError('timeout of ' + config.timeout + 'ms exceeded', config, 'ECONNABORTED'));
+        aborted = true;
+      }, config.timeout);
+    }
+
+    // Send the request
+    if (utils.isStream(data)) {
+      data.pipe(req);
+    } else {
+      req.end(data);
     }
   });
-
-  // Handle errors
-  req.on('error', function handleRequestError(err) {
-    if (aborted) return;
-    reject(enhanceError(err, config));
-  });
-
-  // Handle request timeout
-  if (config.timeout && !timer) {
-    timer = setTimeout(function handleRequestTimeout() {
-      req.abort();
-      reject(createError('timeout of ' + config.timeout + 'ms exceeded', config, 'ECONNABORTED'));
-      aborted = true;
-    }, config.timeout);
-  }
-
-  // Send the request
-  if (utils.isStream(data)) {
-    data.pipe(req);
-  } else {
-    req.end(data);
-  }
 };

lib/adapters/xhr.js

@@ -8,151 +8,153 @@ var isURLSameOrigin = require('./../helpers/isURLSameOrigin');
 var createError = require('../core/createError');
 var btoa = (typeof window !== 'undefined' && window.btoa) || require('./../helpers/btoa');
 
-module.exports = function xhrAdapter(resolve, reject, config) {
+module.exports = function xhrAdapter(config) {
-  var requestData = config.data;
+  return new Promise(function dispatchXhrRequest(resolve, reject) {
-  var requestHeaders = config.headers;
+    var requestData = config.data;
+    var requestHeaders = config.headers;
 
-  if (utils.isFormData(requestData)) {
+    if (utils.isFormData(requestData)) {
-    delete requestHeaders['Content-Type']; // Let the browser set it
+      delete requestHeaders['Content-Type']; // Let the browser set it
-  }
-
-  var request = new XMLHttpRequest();
-  var loadEvent = 'onreadystatechange';
-  var xDomain = false;
-
-  // For IE 8/9 CORS support
-  // Only supports POST and GET calls and doesn't returns the response headers.
-  // DON'T do this for testing b/c XMLHttpRequest is mocked, not XDomainRequest.
-  if (process.env.NODE_ENV !== 'test' &&
-      typeof window !== 'undefined' &&
-      window.XDomainRequest && !('withCredentials' in request) &&
-      !isURLSameOrigin(config.url)) {
-    request = new window.XDomainRequest();
-    loadEvent = 'onload';
-    xDomain = true;
-    request.onprogress = function handleProgress() {};
-    request.ontimeout = function handleTimeout() {};
-  }
-
-  // HTTP basic authentication
-  if (config.auth) {
-    var username = config.auth.username || '';
-    var password = config.auth.password || '';
-    requestHeaders.Authorization = 'Basic ' + btoa(username + ':' + password);
-  }
-
-  request.open(config.method.toUpperCase(), buildURL(config.url, config.params, config.paramsSerializer), true);
-
-  // Set the request timeout in MS
-  request.timeout = config.timeout;
-
-  // Listen for ready state
-  request[loadEvent] = function handleLoad() {
-    if (!request || (request.readyState !== 4 && !xDomain)) {
-      return;
     }
 
-    // The request errored out and we didn't get a response, this will be
+    var request = new XMLHttpRequest();
-    // handled by onerror instead
+    var loadEvent = 'onreadystatechange';
-    if (request.status === 0) {
+    var xDomain = false;
-      return;
+
+    // For IE 8/9 CORS support
+    // Only supports POST and GET calls and doesn't returns the response headers.
+    // DON'T do this for testing b/c XMLHttpRequest is mocked, not XDomainRequest.
+    if (process.env.NODE_ENV !== 'test' &&
+        typeof window !== 'undefined' &&
+        window.XDomainRequest && !('withCredentials' in request) &&
+        !isURLSameOrigin(config.url)) {
+      request = new window.XDomainRequest();
+      loadEvent = 'onload';
+      xDomain = true;
+      request.onprogress = function handleProgress() {};
+      request.ontimeout = function handleTimeout() {};
     }
 
-    // Prepare the response
+    // HTTP basic authentication
-    var responseHeaders = 'getAllResponseHeaders' in request ? parseHeaders(request.getAllResponseHeaders()) : null;
+    if (config.auth) {
-    var responseData = !config.responseType || config.responseType === 'text' ? request.responseText : request.response;
+      var username = config.auth.username || '';
-    var response = {
+      var password = config.auth.password || '';
-      data: responseData,
+      requestHeaders.Authorization = 'Basic ' + btoa(username + ':' + password);
-      // IE sends 1223 instead of 204 (https://github.com/mzabriskie/axios/issues/201)
+    }
-      status: request.status === 1223 ? 204 : request.status,
+
-      statusText: request.status === 1223 ? 'No Content' : request.statusText,
+    request.open(config.method.toUpperCase(), buildURL(config.url, config.params, config.paramsSerializer), true);
-      headers: responseHeaders,
+
-      config: config,
+    // Set the request timeout in MS
-      request: request
+    request.timeout = config.timeout;
+
+    // Listen for ready state
+    request[loadEvent] = function handleLoad() {
+      if (!request || (request.readyState !== 4 && !xDomain)) {
+        return;
+      }
+
+      // The request errored out and we didn't get a response, this will be
+      // handled by onerror instead
+      if (request.status === 0) {
+        return;
+      }
+
+      // Prepare the response
+      var responseHeaders = 'getAllResponseHeaders' in request ? parseHeaders(request.getAllResponseHeaders()) : null;
+      var responseData = !config.responseType || config.responseType === 'text' ? request.responseText : request.response;
+      var response = {
+        data: responseData,
+        // IE sends 1223 instead of 204 (https://github.com/mzabriskie/axios/issues/201)
+        status: request.status === 1223 ? 204 : request.status,
+        statusText: request.status === 1223 ? 'No Content' : request.statusText,
+        headers: responseHeaders,
+        config: config,
+        request: request
+      };
+
+      settle(resolve, reject, response);
+
+      // Clean up request
+      request = null;
     };
 
-    settle(resolve, reject, response);
+    // Handle low level network errors
+    request.onerror = function handleError() {
+      // Real errors are hidden from us by the browser
+      // onerror should only fire if it's a network error
+      reject(createError('Network Error', config));
 
-    // Clean up request
+      // Clean up request
-    request = null;
+      request = null;
-  };
+    };
 
-  // Handle low level network errors
+    // Handle timeout
-  request.onerror = function handleError() {
+    request.ontimeout = function handleTimeout() {
-    // Real errors are hidden from us by the browser
+      reject(createError('timeout of ' + config.timeout + 'ms exceeded', config, 'ECONNABORTED'));
-    // onerror should only fire if it's a network error
-    reject(createError('Network Error', config));
 
-    // Clean up request
+      // Clean up request
-    request = null;
+      request = null;
-  };
+    };
-
-  // Handle timeout
-  request.ontimeout = function handleTimeout() {
-    reject(createError('timeout of ' + config.timeout + 'ms exceeded', config, 'ECONNABORTED'));
-
-    // Clean up request
-    request = null;
-  };
-
-  // Add xsrf header
-  // This is only done if running in a standard browser environment.
-  // Specifically not if we're in a web worker, or react-native.
-  if (utils.isStandardBrowserEnv()) {
-    var cookies = require('./../helpers/cookies');
 
     // Add xsrf header
-    var xsrfValue = config.withCredentials || isURLSameOrigin(config.url) ?
+    // This is only done if running in a standard browser environment.
-        cookies.read(config.xsrfCookieName) :
+    // Specifically not if we're in a web worker, or react-native.
-        undefined;
+    if (utils.isStandardBrowserEnv()) {
+      var cookies = require('./../helpers/cookies');
 
-    if (xsrfValue) {
+      // Add xsrf header
-      requestHeaders[config.xsrfHeaderName] = xsrfValue;
+      var xsrfValue = config.withCredentials || isURLSameOrigin(config.url) ?
-    }
+          cookies.read(config.xsrfCookieName) :
-  }
+          undefined;
 
-  // Add headers to the request
+      if (xsrfValue) {
-  if ('setRequestHeader' in request) {
+        requestHeaders[config.xsrfHeaderName] = xsrfValue;
-    utils.forEach(requestHeaders, function setRequestHeader(val, key) {
-      if (typeof requestData === 'undefined' && key.toLowerCase() === 'content-type') {
-        // Remove Content-Type if data is undefined
-        delete requestHeaders[key];
-      } else {
-        // Otherwise add header to the request
-        request.setRequestHeader(key, val);
-      }
-    });
-  }
-
-  // Add withCredentials to request if needed
-  if (config.withCredentials) {
-    request.withCredentials = true;
-  }
-
-  // Add responseType to request if needed
-  if (config.responseType) {
-    try {
-      request.responseType = config.responseType;
-    } catch (e) {
-      if (request.responseType !== 'json') {
-        throw e;
       }
     }
-  }
 
-  // Handle progress if needed
+    // Add headers to the request
-  if (typeof config.progress === 'function') {
+    if ('setRequestHeader' in request) {
-    if (config.method === 'post' || config.method === 'put') {
+      utils.forEach(requestHeaders, function setRequestHeader(val, key) {
-      request.upload.addEventListener('progress', config.progress);
+        if (typeof requestData === 'undefined' && key.toLowerCase() === 'content-type') {
-    } else if (config.method === 'get') {
+          // Remove Content-Type if data is undefined
-      request.addEventListener('progress', config.progress);
+          delete requestHeaders[key];
+        } else {
+          // Otherwise add header to the request
+          request.setRequestHeader(key, val);
+        }
+      });
     }
-  }
 
-  if (requestData === undefined) {
+    // Add withCredentials to request if needed
-    requestData = null;
+    if (config.withCredentials) {
-  }
+      request.withCredentials = true;
+    }
 
-  // Send the request
+    // Add responseType to request if needed
-  request.send(requestData);
+    if (config.responseType) {
+      try {
+        request.responseType = config.responseType;
+      } catch (e) {
+        if (request.responseType !== 'json') {
+          throw e;
+        }
+      }
+    }
+
+    // Handle progress if needed
+    if (typeof config.progress === 'function') {
+      if (config.method === 'post' || config.method === 'put') {
+        request.upload.addEventListener('progress', config.progress);
+      } else if (config.method === 'get') {
+        request.addEventListener('progress', config.progress);
+      }
+    }
+
+    if (requestData === undefined) {
+      requestData = null;
+    }
+
+    // Send the request
+    request.send(requestData);
+  });
 };

lib/core/dispatchRequest.js

@@ -2,7 +2,6 @@
 
 var utils = require('./../utils');
 var transformData = require('./transformData');
-var enhanceError = require('./enhanceError');
 
 /**
  * Dispatch a request to the server using whichever adapter
@@ -36,35 +35,30 @@ module.exports = function dispatchRequest(config) {
     }
   );
 
-  return new Promise(function executor(resolve, reject) {
+  var adapter;
-    try {
-      var adapter;
 
-      if (typeof config.adapter === 'function') {
+  if (typeof config.adapter === 'function') {
-        // For custom adapter support
+    // For custom adapter support
-        adapter = config.adapter;
+    adapter = config.adapter;
-      } else if (typeof XMLHttpRequest !== 'undefined') {
+  } else if (typeof XMLHttpRequest !== 'undefined') {
-        // For browsers use XHR adapter
+    // For browsers use XHR adapter
-        adapter = require('../adapters/xhr');
+    adapter = require('../adapters/xhr');
-      } else if (typeof process !== 'undefined') {
+  } else if (typeof process !== 'undefined') {
-        // For node use HTTP adapter
+    // For node use HTTP adapter
-        adapter = require('../adapters/http');
+    adapter = require('../adapters/http');
-      }
+  }
 
-      if (typeof adapter === 'function') {
+  return Promise.resolve(config)
-        adapter(resolve, reject, config);
+    // Wrap synchronous adapter errors and pass configuration
-      }
+    .then(adapter)
-    } catch (e) {
+    .then(function onFulfilled(response) {
-      reject(enhanceError(e, config));
+      // Transform response data
-    }
+      response.data = transformData(
-  }).then(function onFulfilled(response) {
+        response.data,
-    // Transform response data
+        response.headers,
-    response.data = transformData(
+        config.transformResponse
-      response.data,
+      );
-      response.headers,
-      config.transformResponse
-    );
 
-    return response;
+      return response;
-  });
+    });
 };

test/specs/requests.spec.js

@@ -36,35 +36,6 @@ describe('requests', function () {
     });
   });
 
-  it('should reject on adapter errors', function (done) {
-    // disable jasmine.Ajax since we're hitting a non-existant server anyway
-    jasmine.Ajax.uninstall();
-
-    var resolveSpy = jasmine.createSpy('resolve');
-    var rejectSpy = jasmine.createSpy('reject');
-
-    var adapterError = new Error('adapter error');
-    var adapterThatFails = function () {
-      throw adapterError;
-    };
-
-    var finish = function () {
-      expect(resolveSpy).not.toHaveBeenCalled();
-      expect(rejectSpy).toHaveBeenCalled();
-      var reason = rejectSpy.calls.first().args[0];
-      expect(reason).toBe(adapterError);
-      expect(reason.config.method).toBe('get');
-      expect(reason.config.url).toBe('/foo');
-
-      done();
-    };
-
-    axios('/foo', {
-      adapter: adapterThatFails
-    }).then(resolveSpy, rejectSpy)
-      .then(finish, finish);
-  });
-
   it('should reject on network errors', function (done) {
     // disable jasmine.Ajax since we're hitting a non-existant server anyway
     jasmine.Ajax.uninstall();