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