code: function invokeAndPromisify( request, callback, transform ) {
  	return new Promise( ( resolve, reject ) => {
  		// Fire off the result
  		request.end( ( err, result ) => {
  
  			// Return the results as a promise
  			if ( err || result.error ) {
  				reject( err || result.error );
  			} else {
  				resolve( result );
  			}
  		} );
  	} ).then( transform ).then( ( result ) => {
  		// If a node-style callback was provided, call it, but also return the
  		// result value for use via the returned Promise
  		if ( callback && typeof callback === 'function' ) {
  			callback( null, result );
  		}
  		return result;
  	}, ( err ) => {
  		// If the API provided an error object, it will be available within the
  		// superagent response object as response.body (containing the response
  		// JSON). If that object exists, it will have a .code property if it is
  		// truly an API error (non-API errors will not have a .code).
  		if ( err.response && err.response.body && err.response.body.code ) {
  			// Forward API error response JSON on to the calling method: omit
  			// all transport-specific (superagent-specific) properties
  			err = err.response.body;
  		}
  		// If a callback was provided, ensure it is called with the error; otherwise
  		// re-throw the error so that it can be handled by a Promise .catch or .then
  		if ( callback && typeof callback === 'function' ) {
  			callback( err );
  		} else {
  			throw err;
  		}
  	} );
  }
docs: HTTP-Related Helpers ==================== 
  Submit the provided superagent request object, invoke a callback (if it was
  provided), and return a promise to the response from the HTTP request.
  
  @private
  @param {Object} request A superagent request object
  @param {Function} callback A callback function (optional)
  @param {Function} transform A function to transform the result data
  @returns {Promise} A promise to the superagent request