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