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