request.js
1
// var Base64 = require('Base64')
2
var capability = require('./capability')
3
var foreach = require('foreach')
4
var indexOf = require('indexof')
5
var inherits = require('inherits')
6
var keys = require('object-keys')
7
var response = require('./response')
8
var stream = require('stream')
9
10
var IncomingMessage = response.IncomingMessage
11
var rStates = response.readyStates
12
13
function decideMode (preferBinary) {
14
if (capability.fetch) {
15
return 'fetch'
16
} else if (capability.mozchunkedarraybuffer) {
17
return 'moz-chunked-arraybuffer'
18
} else if (capability.msstream) {
19
return 'ms-stream'
20
} else if (capability.arraybuffer && preferBinary) {
21
return 'arraybuffer'
22
} else if (capability.vbArray && preferBinary) {
23
return 'text:vbarray'
24
} else {
25
return 'text'
26
}
27
}
28
29
var ClientRequest = module.exports = function (opts) {
30
var self = this
31
stream.Writable.call(self)
32
33
self._opts = opts
34
self._url = opts.protocol + '//' + opts.hostname + ':' + opts.port + opts.path
35
self._body = []
36
self._headers = {}
37
if (opts.auth)
38
self.setHeader('Authorization', 'Basic ' + new Buffer(opts.auth).toString('base64'))
39
foreach(keys(opts.headers), function (name) {
40
self.setHeader(name, opts.headers[name])
41
})
42
43
var preferBinary
44
if (opts.mode === 'prefer-streaming') {
45
// If streaming is a high priority but binary compatibility and
46
// the accuracy of the 'content-type' header aren't
47
preferBinary = false
48
} else if (opts.mode === 'allow-wrong-content-type') {
49
// If streaming is more important than preserving the 'content-type' header
50
preferBinary = !capability.overrideMimeType
51
} else if (!opts.mode || opts.mode === 'default' || opts.mode === 'prefer-fast') {
52
// Use binary if text streaming may corrupt data or the content-type header, or for speed
53
preferBinary = true
54
} else {
55
throw new Error('Invalid value for opts.mode')
56
}
57
self._mode = decideMode(preferBinary)
59
self.on('finish', function () {
60
self._onFinish()
61
})
62
}
63
64
inherits(ClientRequest, stream.Writable)
65
66
ClientRequest.prototype.setHeader = function (name, value) {
67
var self = this
68
var lowerName = name.toLowerCase()
69
// This check is not necessary, but it prevents warnings from browsers about setting unsafe
70
// headers. To be honest I'm not entirely sure hiding these warnings is a good thing, but
71
// http-browserify did it, so I will too.
72
if (indexOf(unsafeHeaders, lowerName) !== -1)
73
return
74
75
self._headers[lowerName] = {
76
name: name,
77
value: value
78
}
79
}
80
81
ClientRequest.prototype.getHeader = function (name) {
82
var self = this
83
return self._headers[name.toLowerCase()].value
84
}
85
86
ClientRequest.prototype.removeHeader = function (name) {
87
var self = this
88
delete self._headers[name.toLowerCase()]
89
}
90
91
ClientRequest.prototype._onFinish = function () {
92
var self = this
93
94
if (self._destroyed)
95
return
96
var opts = self._opts
97
98
var headersObj = self._headers
99
var body
100
if (opts.method === 'POST' || opts.method === 'PUT') {
101
if (capability.blobConstructor) {
102
body = new window.Blob(self._body.map(function (buffer) {
103
return buffer.toArrayBuffer()
104
}), {
105
type: (headersObj['content-type'] || {}).value || ''
106
})
107
} else {
108
// get utf8 string
109
body = Buffer.concat(self._body).toString()
110
}
111
}
112
113
if (self._mode === 'fetch') {
114
var headers = keys(headersObj).map(function (name) {
115
return [headersObj[name].name, headersObj[name].value]
116
})
117
118
window.fetch(self._url, {
119
method: self._opts.method,
120
headers: headers,
121
body: body,
122
mode: 'cors',
123
credentials: opts.withCredentials ? 'include' : 'same-origin'
124
}).then(function (response) {
125
self._fetchResponse = response
126
self._connect()
127
}).then(undefined, function (reason) {
128
self.emit('error', reason)
129
})
130
} else {
131
var xhr = self._xhr = new window.XMLHttpRequest()
132
try {
133
xhr.open(self._opts.method, self._url, true)
134
} catch (err) {
135
process.nextTick(function () {
136
self.emit('error', err)
137
})
138
return
139
}
140
141
// Can't set responseType on really old browsers
142
if ('responseType' in xhr)
143
xhr.responseType = self._mode.split(':')[0]
144
145
if ('withCredentials' in xhr)
146
xhr.withCredentials = !!opts.withCredentials
147
148
if (self._mode === 'text' && 'overrideMimeType' in xhr)
149
xhr.overrideMimeType('text/plain; charset=x-user-defined')
150
151
foreach(keys(headersObj), function (name) {
152
xhr.setRequestHeader(headersObj[name].name, headersObj[name].value)
153
})
154
155
self._response = null
156
xhr.onreadystatechange = function () {
157
switch (xhr.readyState) {
158
case rStates.LOADING:
159
case rStates.DONE:
160
self._onXHRProgress()
161
break
162
}
163
}
164
// Necessary for streaming in Firefox, since xhr.response is ONLY defined
165
// in onprogress, not in onreadystatechange with xhr.readyState = 3
166
if (self._mode === 'moz-chunked-arraybuffer') {
167
xhr.onprogress = function () {
168
self._onXHRProgress()
169
}
170
}
172
xhr.onerror = function () {
173
if (self._destroyed)
174
return
175
self.emit('error', new Error('XHR error'))
176
}
177
178
try {
179
xhr.send(body)
180
} catch (err) {
181
process.nextTick(function () {
182
self.emit('error', err)
183
})
184
return
185
}
186
}
187
}
188
189
/**
190
* Checks if xhr.status is readable. Even though the spec says it should
191
* be available in readyState 3, accessing it throws an exception in IE8
192
*/
193
function statusValid (xhr) {
194
try {
195
return (xhr.status !== null)
196
} catch (e) {
197
return false
198
}
199
}
200
201
ClientRequest.prototype._onXHRProgress = function () {
202
var self = this
203
204
if (!statusValid(self._xhr) || self._destroyed)
205
return
206
207
if (!self._response)
208
self._connect()
209
210
self._response._onXHRProgress()
211
}
212
213
ClientRequest.prototype._connect = function () {
214
var self = this
215
216
if (self._destroyed)
217
return
218
219
self._response = new IncomingMessage(self._xhr, self._fetchResponse, self._mode)
220
self.emit('response', self._response)
221
}
222
223
ClientRequest.prototype._write = function (chunk, encoding, cb) {
224
var self = this
225
226
self._body.push(chunk)
227
cb()
228
}
229
230
ClientRequest.prototype.abort = ClientRequest.prototype.destroy = function () {
231
var self = this
232
self._destroyed = true
233
if (self._response)
234
self._response._destroyed = true
235
if (self._xhr)
236
self._xhr.abort()
237
// Currently, there isn't a way to truly abort a fetch.
238
// If you like bikeshedding, see https://github.com/whatwg/fetch/issues/27
239
}
240
241
ClientRequest.prototype.end = function (data, encoding, cb) {
242
var self = this
243
if (typeof data === 'function') {
244
cb = data
245
data = undefined
246
}
247
248
stream.Writable.prototype.end.call(self, data, encoding, cb)
249
}
250
251
ClientRequest.prototype.flushHeaders = function () {}
252
ClientRequest.prototype.setTimeout = function () {}
253
ClientRequest.prototype.setNoDelay = function () {}
254
ClientRequest.prototype.setSocketKeepAlive = function () {}
255
256
// Taken from http://www.w3.org/TR/XMLHttpRequest/#the-setrequestheader%28%29-method
257
var unsafeHeaders = [
258
'accept-charset',
259
'accept-encoding',
260
'access-control-request-headers',
261
'access-control-request-method',
262
'connection',
263
'content-length',
264
'cookie',
265
'cookie2',
266
'date',
267
'dnt',
268
'expect',
269
'host',
270
'keep-alive',
271
'origin',
272
'referer',
273
'te',
274
'trailer',
275
'transfer-encoding',
276
'upgrade',
277
'user-agent',
278
'via'