Server : Apache System : Linux server2.corals.io 4.18.0-348.2.1.el8_5.x86_64 #1 SMP Mon Nov 15 09:17:08 EST 2021 x86_64 User : corals ( 1002) PHP Version : 7.4.33 Disable Function : exec,passthru,shell_exec,system Directory : /home/corals/vreg/node_modules/node-res/ |
'use strict'
/*
* node-res
*
* (c) Harminder Virk <[email protected]>
*
* For the full copyright and license information, please view the LICENSE
* file that was distributed with this source code.
*/
const mime = require('mime-types')
const etag = require('etag')
const vary = require('vary')
const onFinished = require('on-finished')
const destroy = require('destroy')
const methods = require('./methods')
const returnContentAndType = function (body) {
/**
* Return the body and it's type when
* body is a string.
*/
if (typeof (body) === 'string') {
return {
body,
type: /^\s*</.test(body) ? 'text/html' : 'text/plain'
}
}
/**
* If body is a buffer, return the exact copy
* and type as bin.
*/
if (Buffer.isBuffer(body)) {
return { body, type: 'application/octet-stream' }
}
/**
* If body is a number or boolean. Convert it to
* a string and return the type as text.
*/
if (typeof (body) === 'number' || typeof (body) === 'boolean') {
return { body: String(body), type: 'text/plain' }
}
/**
* Otherwise check whether body is an object or not. If yes
* stringify it and otherwise return the exact copy.
*/
return typeof (body) === 'object'
? { body: JSON.stringify(body), type: 'application/json' }
: { body }
}
/**
* A simple IO module to make consistent HTTP response, without
* worrying about underlying details.
*
* @module Response
*/
const Response = exports = module.exports = {}
/**
* Copying all the descriptive methods to the response object.
*/
Response.descriptiveMethods = Object.keys(methods).map((method) => {
Response[method] = function (req, res, body) {
Response.status(res, methods[method])
Response.send(req, res, body)
}
return method
})
/**
* Returns the value of an existing header on
* the response object
*
* @method getHeader
*
* @param {ServerResponse} res
* @param {String} key
*
* @return {Array|String} Return type depends upon the header existing value
*
* @example
* ```js
* nodeRes.getHeader(res, 'Content-type')
* ```
*/
Response.getHeader = function (res, key) {
return res.getHeader(key)
}
/**
* Sets header on the response object. This method will wipe off
* existing values. To append to existing values, use `append`.
*
* @method header
*
* @param {http.ServerResponse} res
* @param {String} key
* @param {String|Array} value
*
* @return {void}
*
* @example
* ```js
* nodeRes.header(res, 'Content-type', 'application/json')
*
* // or set an array of headers
* nodeRes.header(res, 'Link', ['<http://localhost/>', '<http://localhost:3000/>'])
* ```
*/
Response.header = function (res, key, value) {
const values = Array.isArray(value) ? value.map(String) : value
res.setHeader(key, values)
}
/**
* Appends value to the header existing values.
*
* @method append
*
* @param {http.ServerResponse} res
* @param {String} key
* @param {String|Array} value
*
* @return {void}
*
* @example
* ```js
* nodeRes.append(res, 'Content-type', 'application/json')
*
* // or append an array of headers
* nodeRes.append(res, 'Link', ['<http://localhost/>', '<http://localhost:3000/>'])
* ```
*/
Response.append = function (res, key, value) {
const previousValue = Response.getHeader(res, key)
const headers = previousValue
? (Array.isArray(previousValue) ? previousValue.concat(value) : [previousValue].concat(value))
: value
Response.header(res, key, headers)
}
/**
* Set status on the HTTP res object
*
* @method status
*
* @param {http.ServerResponse} res
* @param {Number} code
*
* @return {void}
*
* @example
* ```js
* nodeRes.status(res, 200)
* ```
*/
Response.status = function (res, code) {
res.statusCode = code
}
/**
* Sets the header on response object, only if it
* does not exists.
*
* @method safeHeader
*
* @param {http.ServerResponse} res
* @param {String} key
* @param {String|Array} value
*
* @return {void}
*
* @example
* ```js
* nodeRes.safeHeader(res, 'Content-type', 'application/json')
* ```
*/
Response.safeHeader = function (res, key, value) {
if (!res.getHeader(key)) {
Response.header(res, key, value)
}
}
/**
* Removes the header from response
*
* @method removeHeader
*
* @param {http.ServerResponse} res
* @param {String} key
*
* @return {void}
*
* @example
* ```js
* nodeRes.removeHeader(res, 'Content-type')
* ```
*/
Response.removeHeader = function (res, key) {
res.removeHeader(key)
}
/**
* Write string or buffer to the response object.
*
* @method write
*
* @param {http.ServerResponse} res
* @param {String|Buffer} body
*
* @return {void}
*
* @example
* ```js
* nodeRes.write(res, 'Hello world')
* ```
*/
Response.write = function (res, body) {
res.write(body)
}
/**
* Explictly end HTTP response
*
* @method end
*
* @param {http.ServerResponse} res
* @param {String|Buffer} [payload]
*
* @return {void}
*
* @example
* ```js
* nodeRes.end(res, 'Hello world')
* ```
*/
Response.end = function (res, payload) {
res.end(payload)
}
/**
* Send body as the HTTP response and end it. Also
* this method will set the appropriate `Content-type`
* and `Content-length`.
*
* If body is set to null, this method will end the response
* as 204.
*
* @method send
*
* @param {http.ServerRequest} req
* @param {http.ServerResponse} res
* @param {String|Buffer|Object|Stream} body
* @param {Boolean} [generateEtag = true]
*
* @return {void}
*
* @example
* ```js
* nodeRes.send(req, res, 'Hello world')
*
* // or html
* nodeRes.send(req, res, '<h2> Hello world </h2>')
*
* // or JSON
* nodeRes.send(req, res, { greeting: 'Hello world' })
*
* // or Buffer
* nodeRes.send(req, res, Buffer.from('Hello world', 'utf-8'))
*
* // Ignore etag
* nodeRes.send(req, res, 'Hello world', false)
* ```
*/
Response.send = function (req, res, body = null, generateEtag = true) {
/**
* Handle streams
*/
if (body && typeof (body.pipe) === 'function') {
Response
.stream(res, body)
.catch((error) => {
Response.status(res, error.code === 'ENOENT' ? 404 : 500)
Response.send(req, res, error.message, generateEtag)
})
return
}
const chunk = Response.prepare(res, body)
if (chunk === null || req.method === 'HEAD') {
Response.end(res)
return
}
/**
* Generate etag when instructured for
*/
if (generateEtag) {
Response.etag(res, chunk)
}
Response.end(res, chunk)
}
/**
* Sets the Etag header for a given body chunk
*
* @method etag
*
* @param {http.ServerResponse} res
* @param {String|Buffer} body
*
* @return {void}
*
* @example
* ```js
* nodeRes.etag(res, 'Hello world')
* ```
*/
Response.etag = function (res, body) {
Response.header(res, 'ETag', etag(body))
}
/**
* Prepares the response body by encoding it properly. Also
* sets appropriate headers based upon the body content type.
*
* This method is used internally by `send`, so you should
* never use it when calling `send`.
*
* It is helpful when you want to get the final payload and end the
* response at a later stage.
*
* @method prepare
*
* @param {http.ServerResponse} res
* @param {Mixed} body
*
* @return {String}
*
* @example
* ```js
* const chunk = nodeRes.prepare(res, '<h2> Hello </h2>')
*
* if (chunk) {
* nodeRes.etag(res, chunk)
*
* if (nodeReq.fresh(req, res)) {
* chunk = null
* nodeRes.status(304)
* }
*
* nodeRes.end(chunk)
* }
* ```
*/
Response.prepare = function (res, body) {
if (body === null) {
Response.status(res, 204)
Response.removeHeader(res, 'Content-Type')
Response.removeHeader(res, 'Content-Length')
Response.removeHeader(res, 'Transfer-Encoding')
return null
}
let { body: chunk, type } = returnContentAndType(body)
/**
* Remove unwanted headers when statuscode is 204 or 304
*/
if (res.statusCode === 204 || res.statusCode === 304) {
Response.removeHeader(res, 'Content-Type')
Response.removeHeader(res, 'Content-Length')
Response.removeHeader(res, 'Transfer-Encoding')
return chunk
}
const headers = typeof res.getHeaders === 'function' ? res.getHeaders() : (res._headers || {})
/**
* Setting content type. Ideally we can use `Response.type`, which
* sets the right charset too. But we will be doing extra
* processing for no reasons.
*/
if (type && !headers['content-type']) {
Response.header(res, 'Content-Type', `${type}; charset=utf-8`)
}
/**
* setting up content length as response header
*/
if (chunk && !headers['content-length']) {
Response.header(res, 'Content-Length', Buffer.byteLength(chunk))
}
return chunk
}
/**
* Prepares response for JSONP
*
* @method prepareJsonp
*
* @param {http.ServerResponse} res
* @param {Object} body
* @param {String} callbackFn
*
* @return {String}
*
* @example
* ```js
* const chunk = nodeRes.prepareJsonp(res, '<h2> Hello </h2>', 'callback')
*
* if (chunk) {
* nodeRes.etag(res, chunk)
*
* if (nodeReq.fresh(req, res)) {
* chunk = null
* nodeRes.status(304)
* }
*
* nodeRes.end(chunk)
* }
* ```
*/
Response.prepareJsonp = function (res, body, callbackFn) {
Response.header(res, 'X-Content-Type-Options', 'nosniff')
Response.safeHeader(res, 'Content-Type', 'text/javascript; charset=utf-8')
const parsedBody = JSON
.stringify(body)
.replace(/\u2028/g, '\\u2028')
.replace(/\u2029/g, '\\u2029')
/**
* setting up callbackFn on response body , typeof will make
* sure not to throw error of client if callbackFn is not
* a function
*/
return '/**/ typeof ' + callbackFn + " === 'function' && " + callbackFn + '(' + parsedBody + ');'
}
/**
* Returns the HTTP response with `Content-type`
* set to `application/json`.
*
* @method json
*
* @param {http.IncomingMessage} req
* @param {http.ServerResponse} res
* @param {Object} body
* @param {Boolean} [generateEtag = true]
*
* @return {void}
*
* @example
* ```js
* nodeRes.json(req, res, { name: 'virk' })
* nodeRes.json(req, res, [ 'virk', 'joe' ])
* ```
*/
Response.json = function (req, res, body, generateEtag) {
Response.safeHeader(res, 'Content-Type', 'application/json; charset=utf-8')
Response.send(req, res, body, generateEtag)
}
/**
* Make JSONP response with `Content-type` set to
* `text/javascript`.
*
* @method jsonp
*
* @param {http.IncomingMessage} req
* @param {http.ServerResponse} res
* @param {Object} body
* @param {String} [callbackFn = 'callback']
* @param {Boolean} [generateEtag = true]
*
* @return {void}
*
* @example
* ```js
* nodeRes.jsonp(req, res, { name: 'virk' }, 'callback')
* ```
*/
Response.jsonp = function (req, res, body, callbackFn = 'callback', generateEtag) {
Response.send(req, res, Response.prepareJsonp(res, body, callbackFn), generateEtag)
}
/**
* Set `Location` header on the HTTP response.
*
* @method location
*
* @param {http.ServerResponse} res
* @param {String} url
*
* @return {void}
*/
Response.location = function (res, url) {
Response.header(res, 'Location', url)
}
/**
* Redirect the HTTP request to the given url.
*
* @method redirect
*
* @param {http.IncomingMessage} req
* @param {http.ServerResponse} res
* @param {String} url
* @param {Number} [status = 302]
*
* @return {void}
*
* @example
* ```js
* nodeRes.redirect(req, res, '/')
* ```
*/
Response.redirect = function (req, res, url, status = 302) {
const body = ''
Response.status(res, status)
Response.location(res, url)
Response.send(req, res, body)
}
/**
* Add vary header to the HTTP response.
*
* @method vary
*
* @param {http.ServerResponse} res
* @param {String} field
*
* @return {void}
*/
Response.vary = function (res, field) {
vary(res, field)
}
/**
* Set content type header by looking up the actual
* type and setting charset to utf8.
*
* ### Note
* When defining custom charset, you must set pass the complete
* content type, otherwise `false` will be set as the
* content-type header.
*
* @method type
*
* @param {http.IncomingMessage} req
* @param {http.ServerResponse} res
* @param {String} [charset]
* @return {void}
*
* @example
* ```js
* nodeRes.type(res, 'html')
*
* nodeRes.type(res, 'json')
*
* nodeRes.type(res, 'text/html', 'ascii')
* ```
*/
Response.type = function (res, type, charset) {
type = charset ? `${type}; charset=${charset}` : type
Response.safeHeader(res, 'Content-Type', mime.contentType(type))
}
/**
* Pipe stream to the response. Also this method will make sure
* to destroy the stream, if request gets cancelled.
*
* The promise resolve when response finishes and rejects, when
* stream raises errors.
*
* @method stream
*
* @param {Object} res
* @param {Stream} body
*
* @returns {Promise}
*
* @example
* ```js
* Response.stream(res, fs.createReadStream('foo.txt'))
*
* // handle stream errors
* Response
* .stream(res, fs.createReadStream('foo.txt'))
* .catch((error) => {
* })
* ```
*/
Response.stream = function (res, body) {
return new Promise((resolve, reject) => {
if (typeof (body.pipe) !== 'function') {
reject(new Error('Body is not a valid stream'))
return
}
let finished = false
/**
* Error in stream
*/
body.on('error', (error) => {
if (finished) {
return
}
finished = true
destroy(body)
reject(error)
})
/**
* Consumed stream
*/
body.on('end', resolve)
/**
* Written response
*/
onFinished(res, function () {
finished = true
destroy(body)
})
/**
* Pipe to res
*/
body.pipe(res)
})
}