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