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') {
42
// If the use of XHR should be preferred and includes preserving the 'content-type' header
43
useFetch = false
44
preferBinary = true
45
} else if (opts.mode === 'prefer-streaming') {
46
// If streaming is a high priority but binary compatibility and
47
// the accuracy of the 'content-type' header aren't
48
preferBinary = false
49
} else if (opts.mode === 'allow-wrong-content-type') {
50
// If streaming is more important than preserving the 'content-type' header
51
preferBinary = !capability.overrideMimeType
52
} else if (!opts.mode || opts.mode === 'default' || opts.mode === 'prefer-fast') {
53
// Use binary if text streaming may corrupt data or the content-type header, or for speed
54
preferBinary = true
55
} else {
56
throw new Error('Invalid value for opts.mode')
57
}
58
self._mode = decideMode(preferBinary, useFetch)
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 self = this
84
return self._headers[name.toLowerCase()].value
85
}
86
87
ClientRequest.prototype.removeHeader = function (name) {
88
var self = this
89
delete self._headers[name.toLowerCase()]
90
}
91
92
ClientRequest.prototype._onFinish = function () {
93
var self = this
94
95
if (self._destroyed)
96
return
97
var opts = self._opts
98
99
var headersObj = self._headers
100
var body
101
if (opts.method === 'POST' || opts.method === 'PUT' || opts.method === 'PATCH') {
102
if (capability.blobConstructor) {
103
body = new global.Blob(self._body.map(function (buffer) {
104
return toArrayBuffer(buffer)
105
}), {
106
type: (headersObj['content-type'] || {}).value || ''
107
})
108
} else {
109
// get utf8 string
110
body = Buffer.concat(self._body).toString()
111
}
112
}
113
114
if (self._mode === 'fetch') {
115
var headers = Object.keys(headersObj).map(function (name) {
116
return [headersObj[name].name, headersObj[name].value]
117
})
118
119
global.fetch(self._opts.url, {
120
method: self._opts.method,
121
headers: headers,
122
body: body,
123
mode: 'cors',
124
credentials: opts.withCredentials ? 'include' : 'same-origin'
125
}).then(function (response) {
126
self._fetchResponse = response
127
self._connect()
128
}, function (reason) {
129
self.emit('error', reason)
130
})
131
} else {
132
var xhr = self._xhr = new global.XMLHttpRequest()
133
try {
134
xhr.open(self._opts.method, self._opts.url, true)
135
} catch (err) {
136
process.nextTick(function () {
137
self.emit('error', err)
138
})
139
return
140
}
141
142
// Can't set responseType on really old browsers
143
if ('responseType' in xhr)
144
xhr.responseType = self._mode.split(':')[0]
145
146
if ('withCredentials' in xhr)
147
xhr.withCredentials = !!opts.withCredentials
148
149
if (self._mode === 'text' && 'overrideMimeType' in xhr)
150
xhr.overrideMimeType('text/plain; charset=x-user-defined')
151
152
Object.keys(headersObj).forEach(function (name) {
153
xhr.setRequestHeader(headersObj[name].name, headersObj[name].value)
154
})
155
156
self._response = null
157
xhr.onreadystatechange = function () {
158
switch (xhr.readyState) {
159
case rStates.LOADING:
160
case rStates.DONE:
161
self._onXHRProgress()
162
break
163
}
164
}
165
// Necessary for streaming in Firefox, since xhr.response is ONLY defined
166
// in onprogress, not in onreadystatechange with xhr.readyState = 3
167
if (self._mode === 'moz-chunked-arraybuffer') {
168
xhr.onprogress = function () {
169
self._onXHRProgress()
170
}
171
}
173
xhr.onerror = function () {
174
if (self._destroyed)
175
return
176
self.emit('error', new Error('XHR error'))
177
}
178
179
try {
180
xhr.send(body)
181
} catch (err) {
182
process.nextTick(function () {
183
self.emit('error', err)
184
})
185
return
186
}
187
}
188
}
189
191
* Checks if xhr.status is readable and non-zero, indicating no error.
192
* Even though the spec says it should be available in readyState 3,
193
* accessing it throws an exception in IE8
194
*/
195
function statusValid (xhr) {
196
try {
197
var status = xhr.status
198
return (status !== null && status !== 0)
199
} catch (e) {
200
return false
201
}
202
}
203
204
ClientRequest.prototype._onXHRProgress = function () {
205
var self = this
206
207
if (!statusValid(self._xhr) || self._destroyed)
208
return
209
210
if (!self._response)
211
self._connect()
212
213
self._response._onXHRProgress()
214
}
215
216
ClientRequest.prototype._connect = function () {
217
var self = this
218
219
if (self._destroyed)
220
return
221
222
self._response = new IncomingMessage(self._xhr, self._fetchResponse, self._mode)
223
self.emit('response', self._response)
224
}
225
226
ClientRequest.prototype._write = function (chunk, encoding, cb) {
227
var self = this
228
229
self._body.push(chunk)
230
cb()
231
}
232
233
ClientRequest.prototype.abort = ClientRequest.prototype.destroy = function () {
234
var self = this
235
self._destroyed = true
236
if (self._response)
237
self._response._destroyed = true
238
if (self._xhr)
239
self._xhr.abort()
240
// Currently, there isn't a way to truly abort a fetch.
241
// If you like bikeshedding, see https://github.com/whatwg/fetch/issues/27
242
}
243
244
ClientRequest.prototype.end = function (data, encoding, cb) {
245
var self = this
246
if (typeof data === 'function') {
247
cb = data
248
data = undefined
249
}
250
251
stream.Writable.prototype.end.call(self, data, encoding, cb)
252
}
253
254
ClientRequest.prototype.flushHeaders = function () {}
255
ClientRequest.prototype.setTimeout = function () {}
256
ClientRequest.prototype.setNoDelay = function () {}
257
ClientRequest.prototype.setSocketKeepAlive = function () {}
258
259
// Taken from http://www.w3.org/TR/XMLHttpRequest/#the-setrequestheader%28%29-method
260
var unsafeHeaders = [
261
'accept-charset',
262
'accept-encoding',
263
'access-control-request-headers',
264
'access-control-request-method',
265
'connection',
266
'content-length',
267
'cookie',
268
'cookie2',
269
'date',
270
'dnt',
271
'expect',
272
'host',
273
'keep-alive',
274
'origin',
275
'referer',
276
'te',
277
'trailer',
278
'transfer-encoding',
279
'upgrade',
280
'user-agent',
281
'via'