@adonisjs/http-server 6.8.2-1 → 6.8.2-10

package/build/src/response.js

@@ -1,3 +1,11 @@
+/*
+ * @adonisjs/http-server
+ *
+ * (c) AdonisJS
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
 import etag from 'etag';
 import vary from 'vary';
 import fresh from 'fresh';
@@ -5,44 +13,92 @@ import mime from 'mime-types';
 import destroy from 'destroy';
 import { extname } from 'node:path';
 import onFinished from 'on-finished';
-import { promisify } from 'node:util';
 import json from '@poppinss/utils/json';
 import Macroable from '@poppinss/macroable';
-import { createReadStream, stat } from 'node:fs';
+import { createReadStream } from 'node:fs';
+import { stat } from 'node:fs/promises';
 import { RuntimeException } from '@poppinss/utils';
 import contentDisposition from 'content-disposition';
 import { Redirect } from './redirect.js';
 import { CookieSerializer } from './cookies/serializer.js';
 import { E_HTTP_REQUEST_ABORTED } from './exceptions.js';
-const statFn = promisify(stat);
 const CACHEABLE_HTTP_METHODS = ['GET', 'HEAD'];
+/**
+ * The response is a wrapper over [ServerResponse](https://nodejs.org/api/http.html#http_class_http_serverresponse)
+ * streamlining the process of writing response body and automatically setting up appropriate headers.
+ */
 export class Response extends Macroable {
     request;
     response;
+    /**
+     * Query string parser
+     */
     #qs;
+    /**
+     * Outgoing headers
+     */
     #headers = {};
+    /**
+     * Has explicit status been set
+     */
     #hasExplicitStatus = false;
+    /**
+     * Cookies serializer to serialize the outgoing cookies
+     */
     #cookieSerializer;
+    /**
+     * Router is used to make the redirect URLs from routes
+     */
     #router;
+    /**
+     * Response config
+     */
     #config;
+    /**
+     * Does response has body set that will written to the
+     * response socket at the end of the request
+     */
     get hasLazyBody() {
         return !!(this.lazyBody.content || this.lazyBody.fileToStream || this.lazyBody.stream);
     }
+    /**
+     * Find if the response has non-stream content
+     */
     get hasContent() {
         return !!this.lazyBody.content;
     }
+    /**
+     * Returns true when response body is set using "response.stream"
+     * method
+     */
     get hasStream() {
         return !!this.lazyBody.stream;
     }
+    /**
+     * Returns true when response body is set using "response.download"
+     * or "response.attachment" methods
+     */
     get hasFileToStream() {
         return !!this.lazyBody.fileToStream;
     }
+    /**
+     * Returns the response content. Check if the response
+     * has content using the "hasContent" method
+     */
     get content() {
         return this.lazyBody.content;
     }
+    /**
+     * Returns reference to the stream set using "response.stream"
+     * method
+     */
     get outgoingStream() {
         return this.lazyBody.stream?.[0];
     }
+    /**
+     * Returns reference to the file path set using "response.stream"
+     * method.
+     */
     get fileToStream() {
         return this.lazyBody.fileToStream
             ? {
@@ -51,7 +107,16 @@ export class Response extends Macroable {
             }
             : undefined;
     }
+    /**
+     * Lazy body is used to set the response body. However, do not
+     * write it on the socket immediately unless `response.finish`
+     * is called.
+     */
     lazyBody = {};
+    /**
+     * The ctx will be set by the context itself. It creates a circular
+     * reference
+     */
     ctx;
     constructor(request, response, encryption, config, router, qs) {
         super();
@@ -62,30 +127,68 @@ export class Response extends Macroable {
         this.#router = router;
         this.#cookieSerializer = new CookieSerializer(encryption);
     }
+    /**
+     * Returns a boolean telling if response is finished or not.
+     * Any more attempts to update headers or body will result
+     * in raised exceptions.
+     */
     get finished() {
         return this.response.writableFinished;
     }
+    /**
+     * Returns a boolean telling if response headers has been sent or not.
+     * Any more attempts to update headers will result in raised
+     * exceptions.
+     */
     get headersSent() {
         return this.response.headersSent;
     }
+    /**
+     * Returns a boolean telling if response headers and body is written
+     * or not. When value is `true`, you can feel free to write headers
+     * and body.
+     */
     get isPending() {
         return !this.headersSent && !this.finished;
     }
+    /**
+     * Normalizes header value to a string or an array of string
+     */
     #castHeaderValue(value) {
         return Array.isArray(value) ? value.map(String) : String(value);
     }
+    /**
+     * Ends the response by flushing headers and writing body
+     */
     #endResponse(body, statusCode) {
-        this.flushHeaders(statusCode);
+        this.writeHead(statusCode);
+        // avoid ArgumentsAdaptorTrampoline from V8 (inspired by fastify)
         const res = this.response;
         res.end(body, null, null);
     }
+    /**
+     * Returns type for the content body. Only following types are allowed
+     *
+     * - Dates
+     * - Arrays
+     * - Booleans
+     * - Objects
+     * - Strings
+     * - Buffer
+     */
     #getDataType(content) {
         if (Buffer.isBuffer(content)) {
             return 'buffer';
         }
+        /**
+         * Date instance
+         */
         if (content instanceof Date) {
             return 'date';
         }
+        /**
+         * Regular expression
+         */
         if (content instanceof RegExp) {
             return 'regexp';
         }
@@ -96,17 +199,34 @@ export class Response extends Macroable {
             dataType === 'bigint') {
             return dataType;
         }
+        /**
+         * Object
+         */
         if (dataType === 'object') {
             return 'object';
         }
         throw new RuntimeException(`Cannot serialize "${dataType}" to HTTP response`);
     }
+    /**
+     * Writes the body with appropriate response headers. Etag header is set
+     * when `generateEtag` is set to `true`.
+     *
+     * Empty body results in `204`.
+     */
     writeBody(content, generateEtag, jsonpCallbackName) {
         const hasEmptyBody = content === null || content === undefined || content === '';
+        /**
+         * Set status to "204" when body is empty. The `safeStatus` method only
+         * sets the status when no explicit status has been set already
+         */
         if (hasEmptyBody) {
             this.safeStatus(204);
         }
         const statusCode = this.response.statusCode;
+        /**
+         * Do not process body when status code is less than 200 or is 204 or 304. As per
+         * https://tools.ietf.org/html/rfc7230#section-3.3.2
+         */
         if (statusCode && (statusCode < 200 || statusCode === 204 || statusCode === 304)) {
             this.removeHeader('Content-Type');
             this.removeHeader('Content-Length');
@@ -114,12 +234,27 @@ export class Response extends Macroable {
             this.#endResponse();
             return;
         }
+        /**
+         * Body is empty and status code is not "204", "304" and neither under 200.
+         */
         if (hasEmptyBody) {
             this.removeHeader('Content-Length');
             this.#endResponse();
             return;
         }
+        /**
+         * Javascript data type for the content. We only handle a subset
+         * of data types. Check [[this.getDataType]] method for more
+         * info
+         */
         const dataType = this.#getDataType(content);
+        /**
+         * ----------------------------------------
+         * SERIALIZE CONTENT TO A STRING
+         * ----------------------------------------
+         *
+         * Transforming date, number, boolean and object to a string
+         */
         if (dataType === 'object') {
             content = json.safeStringify(content);
         }
@@ -132,13 +267,39 @@ export class Response extends Macroable {
         else if (dataType === 'date') {
             content = content.toISOString();
         }
+        /*
+         * ----------------------------------------
+         * MORE MODIFICATIONS FOR JSONP BODY
+         * ----------------------------------------
+         *
+         * If JSONP callback exists, then update the body to be a
+         * valid JSONP response
+         */
         if (jsonpCallbackName) {
+            /*
+             * replace chars not allowed in JavaScript that are in JSON
+             * https://github.com/rack/rack-contrib/pull/37
+             */
             content = content.replace(/\u2028/g, '\\u2028').replace(/\u2029/g, '\\u2029');
+            // the /**/ is a specific security mitigation for "Rosetta Flash JSONP abuse"
+            // https://web.nvd.nist.gov/view/vuln/detail?vulnId=CVE-2014-4671
+            // http://miki.it/blog/2014/7/8/abusing-jsonp-with-rosetta-flash/
+            // http://drops.wooyun.org/tips/2554
             content = `/**/ typeof ${jsonpCallbackName} === 'function' && ${jsonpCallbackName}(${content});`;
         }
+        /*
+         * ----------------------------------------
+         * FINALY GENERATE AN ETAG
+         * ----------------------------------------
+         *
+         * Generate etag if instructed.
+         */
         if (generateEtag) {
             this.setEtag(content);
         }
+        /**
+         * End response when cache is fresh
+         */
         if (generateEtag && this.fresh()) {
             this.removeHeader('Content-Type');
             this.removeHeader('Content-Length');
@@ -146,7 +307,29 @@ export class Response extends Macroable {
             this.#endResponse(null, 304);
             return;
         }
+        /*
+         * ----------------------------------------
+         * SET CONTENT-LENGTH HEADER
+         * ----------------------------------------
+         */
         this.header('Content-Length', Buffer.byteLength(content));
+        /**
+         * ----------------------------------------
+         * SET CONTENT-TYPE HEADER
+         * ----------------------------------------
+         *
+         * - If it is a JSONP response, then we always set the content type
+         *   to "text/javascript"
+         *
+         * - String are checked for HTML and "text/plain" or "text/html" is set
+         *   accordingly.
+         *
+         * - "text/plain"  is set for "numbers" and "booleans" and "dates"
+         *
+         * - "application/octet-stream" is set for buffers
+         *
+         * - "application/json" is set for objects and arrays
+         */
         if (jsonpCallbackName) {
             this.header('X-Content-Type-Options', 'nosniff');
             this.safeHeader('Content-Type', 'text/javascript; charset=utf-8');
@@ -174,53 +357,110 @@ export class Response extends Macroable {
         }
         this.#endResponse(content);
     }
+    /**
+     * Stream the body to the response and handles cleaning up the stream
+     */
     streamBody(body, errorCallback) {
         return new Promise((resolve) => {
             let finished = false;
+            /*
+             * Listen for errors on the stream and properly destroy
+             * stream
+             */
             body.on('error', (error) => {
+                /* c8 ignore next 3 */
                 if (finished) {
                     return;
                 }
                 finished = true;
                 destroy(body);
                 this.type('text');
-                if (typeof errorCallback === 'function') {
-                    this.#endResponse(...errorCallback(error));
+                if (!this.headersSent) {
+                    if (typeof errorCallback === 'function') {
+                        this.#endResponse(...errorCallback(error));
+                    }
+                    else {
+                        this.#endResponse(error.code === 'ENOENT' ? 'File not found' : 'Cannot process file', error.code === 'ENOENT' ? 404 : 500);
+                    }
                 }
                 else {
-                    this.#endResponse(error.code === 'ENOENT' ? 'File not found' : 'Cannot process file', error.code === 'ENOENT' ? 404 : 500);
-                    resolve();
+                    this.response.destroy();
                 }
+                resolve();
             });
-            body.on('end', resolve);
+            /*
+             * Listen for end and resolve the promise
+             */
+            body.on('end', () => {
+                if (!this.headersSent) {
+                    this.#endResponse();
+                }
+                resolve();
+            });
+            /*
+             * Cleanup stream when finishing response
+             */
             onFinished(this.response, () => {
                 finished = true;
                 destroy(body);
             });
+            /*
+             * Pipe stream
+             */
             this.flushHeaders();
             body.pipe(this.response);
         });
     }
+    /**
+     * Downloads a file by streaming it to the response
+     */
     async streamFileForDownload(filePath, generateEtag, errorCallback) {
         try {
-            const stats = await statFn(filePath);
+            const stats = await stat(filePath);
             if (!stats || !stats.isFile()) {
                 throw new TypeError('response.download only accepts path to a file');
             }
+            /*
+             * Set appropriate headers
+             */
             this.header('Last-Modified', stats.mtime.toUTCString());
             this.type(extname(filePath));
+            /*
+             * Set the etag when instructed.
+             */
             if (generateEtag) {
                 this.setEtag(stats, true);
             }
+            /*
+             * Do not stream files for HEAD request, but set the appropriate
+             * status code.
+             *
+             * 200: When not using etags or cache is not fresh. This forces browser
+             *      to always make a GET request
+             *
+             * 304: When etags are used and cache is fresh
+             */
             if (this.request.method === 'HEAD') {
                 this.#endResponse(null, generateEtag && this.fresh() ? 304 : 200);
                 return;
             }
+            /*
+             * Regardless of request method, if we are using etags and
+             * cache is fresh, then we must respond with 304
+             */
             if (generateEtag && this.fresh()) {
                 this.#endResponse(null, 304);
                 return;
             }
+            /*
+             * Fix for https://tools.ietf.org/html/rfc7232#section-4.1. It is
+             * recommended to ignore headers other than Cache-Control,
+             * Content-Location, Date, ETag, Expires, and Vary.
+             */
             this.header('Content-length', stats.size);
+            /*
+             * Finally stream the file
+             */
             return this.streamBody(createReadStream(filePath), errorCallback);
         }
         catch (error) {
@@ -234,20 +474,55 @@ export class Response extends Macroable {
             }
         }
     }
-    flushHeaders(statusCode) {
+    /**
+     * Writes headers with the Node.js res object using the
+     * response.setHeader method
+     */
+    flushHeaders() {
+        if (!this.headersSent) {
+            for (let key in this.#headers) {
+                const value = this.#headers[key];
+                if (value) {
+                    this.response.setHeader(key, value);
+                }
+            }
+        }
+    }
+    /**
+     * Calls res.writeHead on the Node.js res object.
+     */
+    writeHead(statusCode) {
         this.response.writeHead(statusCode || this.response.statusCode, this.#headers);
         return this;
     }
+    /**
+     * Returns the existing value for a given HTTP response
+     * header.
+     */
     getHeader(key) {
         const value = this.#headers[key.toLowerCase()];
         return value === undefined ? this.response.getHeader(key) : value;
     }
+    /**
+     * Get response headers
+     */
     getHeaders() {
         return {
             ...this.response.getHeaders(),
             ...this.#headers,
         };
     }
+    /**
+     * Set header on the response. To `append` values to the existing header, we suggest
+     * using [[append]] method.
+     *
+     * If `value` is non existy, then header won't be set.
+     *
+     * @example
+     * ```js
+     * response.header('content-type', 'application/json')
+     * ```
+     */
     header(key, value) {
         if (value === null || value === undefined) {
             return this;
@@ -255,6 +530,17 @@ export class Response extends Macroable {
         this.#headers[key.toLowerCase()] = this.#castHeaderValue(value);
         return this;
     }
+    /**
+     * Append value to an existing header. To replace the value, we suggest using
+     * [[header]] method.
+     *
+     * If `value` is not existy, then header won't be set.
+     *
+     * @example
+     * ```js
+     * response.append('set-cookie', 'username=virk')
+     * ```
+     */
     append(key, value) {
         if (value === null || value === undefined) {
             return this;
@@ -262,6 +548,10 @@ export class Response extends Macroable {
         key = key.toLowerCase();
         let existingHeader = this.getHeader(key);
         let casted = this.#castHeaderValue(value);
+        /**
+         * If there isn't any header, then setHeader right
+         * away
+         */
         if (!existingHeader) {
             this.#headers[key] = casted;
             return this;
@@ -273,12 +563,18 @@ export class Response extends Macroable {
         this.#headers[key] = casted;
         return this;
     }
+    /**
+     * Adds HTTP response header, when it doesn't exists already.
+     */
     safeHeader(key, value) {
         if (!this.getHeader(key)) {
             this.header(key, value);
         }
         return this;
     }
+    /**
+     * Removes the existing response header from being sent.
+     */
     removeHeader(key) {
         key = key.toLowerCase();
         this.response.removeHeader(key);
@@ -287,14 +583,24 @@ export class Response extends Macroable {
         }
         return this;
     }
+    /**
+     * Returns the status code for the response
+     */
     getStatus() {
         return this.response.statusCode;
     }
+    /**
+     * Set HTTP status code
+     */
     status(code) {
         this.#hasExplicitStatus = true;
         this.response.statusCode = code;
         return this;
     }
+    /**
+     * Set's status code only when it's not explictly
+     * set
+     */
     safeStatus(code) {
         if (this.#hasExplicitStatus) {
             return this;
@@ -302,19 +608,65 @@ export class Response extends Macroable {
         this.response.statusCode = code;
         return this;
     }
+    /**
+     * Set response type by looking up for the mime-type using
+     * partial types like file extensions.
+     *
+     * Make sure to read [mime-types](https://www.npmjs.com/package/mime-types) docs
+     * too.
+     *
+     * @example
+     * ```js
+     * response.type('.json') // Content-type: application/json
+     * ```
+     */
     type(type, charset) {
         type = charset ? `${type}; charset=${charset}` : type;
         this.header('Content-Type', mime.contentType(type));
         return this;
     }
+    /**
+     * Set the Vary HTTP header
+     */
     vary(field) {
         vary(this.response, field);
         return this;
     }
+    /**
+     * Set etag by computing hash from the body. This class will set the etag automatically
+     * when `etag = true` in the defined config object.
+     *
+     * Use this function, when you want to compute etag manually for some other resons.
+     */
     setEtag(body, weak = false) {
         this.header('Etag', etag(body, { weak }));
         return this;
     }
+    /**
+     * Returns a boolean telling if the new response etag evaluates same
+     * as the request header `if-none-match`. In case of `true`, the
+     * server must return `304` response, telling the browser to
+     * use the client cache.
+     *
+     * You won't have to deal with this method directly, since AdonisJs will
+     * handle this for you when `http.etag = true` inside `config/app.js` file.
+     *
+     * However, this is how you can use it manually.
+     *
+     * @example
+     * ```js
+     * const responseBody = view.render('some-view')
+     *
+     * // sets the HTTP etag header for response
+     * response.setEtag(responseBody)
+     *
+     * if (response.fresh()) {
+     *   response.sendStatus(304)
+     * } else {
+     *   response.send(responseBody)
+     * }
+     * ```
+     */
     fresh() {
         if (this.request.method && !CACHEABLE_HTTP_METHODS.includes(this.request.method)) {
             return false;
@@ -325,35 +677,124 @@ export class Response extends Macroable {
         }
         return false;
     }
+    /**
+     * Returns the response body. Returns null when response
+     * body is a stream
+     */
     getBody() {
         if (this.lazyBody.content) {
             return this.lazyBody.content[0];
         }
         return null;
     }
+    /**
+     * Send the body as response and optionally generate etag. The default value
+     * is read from `config/app.js` file, using `http.etag` property.
+     *
+     * This method buffers the body if `explicitEnd = true`, which is the default
+     * behavior and do not change, unless you know what you are doing.
+     */
     send(body, generateEtag = this.#config.etag) {
         this.lazyBody.content = [body, generateEtag];
     }
+    /**
+     * Alias of [[send]]
+     */
     json(body, generateEtag = this.#config.etag) {
         return this.send(body, generateEtag);
     }
+    /**
+     * Writes response as JSONP. The callback name is resolved as follows, with priority
+     * from top to bottom.
+     *
+     * 1. Explicitly defined as 2nd Param.
+     * 2. Fetch from request query string.
+     * 3. Use the config value `http.jsonpCallbackName` from `config/app.js`.
+     * 4. Fallback to `callback`.
+     *
+     * This method buffers the body if `explicitEnd = true`, which is the default
+     * behavior and do not change, unless you know what you are doing.
+     */
     jsonp(body, callbackName = this.#config.jsonpCallbackName, generateEtag = this.#config.etag) {
         this.lazyBody.content = [body, generateEtag, callbackName];
     }
+    /**
+     * Pipe stream to the response. This method will gracefully destroy
+     * the stream, avoiding memory leaks.
+     *
+     * If `raiseErrors=false`, then this method will self handle all the exceptions by
+     * writing a generic HTTP response. To have more control over the error, it is
+     * recommended to set `raiseErrors=true` and wrap this function inside a
+     * `try/catch` statement.
+     *
+     * Streaming a file from the disk and showing 404 when file is missing.
+     *
+     * @example
+     * ```js
+     * // Errors handled automatically with generic HTTP response
+     * response.stream(fs.createReadStream('file.txt'))
+     *
+     * // Manually handle (note the await call)
+     * try {
+     *   await response.stream(fs.createReadStream('file.txt'))
+     * } catch () {
+     *   response.status(404).send('File not found')
+     * }
+     * ```
+     */
     stream(body, errorCallback) {
         if (typeof body.pipe !== 'function' || !body.readable || typeof body.read !== 'function') {
             throw new TypeError('response.stream accepts a readable stream only');
         }
         this.lazyBody.stream = [body, errorCallback];
     }
+    /**
+     * Download file by streaming it from the file path. This method will setup
+     * appropriate `Content-type`, `Content-type` and `Last-modified` headers.
+     *
+     * Unexpected stream errors are handled gracefully to avoid memory leaks.
+     *
+     * If `raiseErrors=false`, then this method will self handle all the exceptions by
+     * writing a generic HTTP response. To have more control over the error, it is
+     * recommended to set `raiseErrors=true` and wrap this function inside a
+     * `try/catch` statement.
+     *
+     * @example
+     * ```js
+     * // Errors handled automatically with generic HTTP response
+     * response.download('somefile.jpg')
+     *
+     * // Manually handle (note the await call)
+     * try {
+     *   await response.download('somefile.jpg')
+     * } catch (error) {
+     *   response.status(error.code === 'ENOENT' ? 404 : 500)
+     *   response.send('Cannot process file')
+     * }
+     * ```
+     */
     download(filePath, generateEtag = this.#config.etag, errorCallback) {
         this.lazyBody.fileToStream = [filePath, generateEtag, errorCallback];
     }
+    /**
+     * Download the file by forcing the user to save the file vs displaying it
+     * within the browser.
+     *
+     * Internally calls [[download]]
+     */
     attachment(filePath, name, disposition, generateEtag, errorCallback) {
         name = name || filePath;
         this.header('Content-Disposition', contentDisposition(name, { type: disposition }));
         return this.download(filePath, generateEtag, errorCallback);
     }
+    /**
+     * Set the location header.
+     *
+     * @example
+     * ```js
+     * response.location('/login')
+     * ```
+     */
     location(url) {
         this.header('Location', url);
         return this;
@@ -371,19 +812,35 @@ export class Response extends Macroable {
         }
         return handler;
     }
+    /**
+     * Abort the request with custom body and a status code. 400 is
+     * used when status is not defined
+     */
     abort(body, status) {
         throw E_HTTP_REQUEST_ABORTED.invoke(body, status || 400);
     }
+    /**
+     * Abort the request with custom body and a status code when
+     * passed condition returns `true`
+     */
     abortIf(condition, body, status) {
         if (condition) {
             this.abort(body, status);
         }
     }
+    /**
+     * Abort the request with custom body and a status code when
+     * passed condition returns `false`
+     */
     abortUnless(condition, body, status) {
         if (!condition) {
             this.abort(body, status);
         }
     }
+    /**
+     * Set signed cookie as the response header. The inline options overrides
+     * all options from the config.
+     */
     cookie(key, value, options) {
         options = Object.assign({}, this.#config.cookie, options);
         const serialized = this.#cookieSerializer.sign(key, value, options);
@@ -393,6 +850,10 @@ export class Response extends Macroable {
         this.append('set-cookie', serialized);
         return this;
     }
+    /**
+     * Set encrypted cookie as the response header. The inline options overrides
+     * all options from the config.
+     */
     encryptedCookie(key, value, options) {
         options = Object.assign({}, this.#config.cookie, options);
         const serialized = this.#cookieSerializer.encrypt(key, value, options);
@@ -402,6 +863,10 @@ export class Response extends Macroable {
         this.append('set-cookie', serialized);
         return this;
     }
+    /**
+     * Set unsigned cookie as the response header. The inline options overrides
+     * all options from the config.
+     */
     plainCookie(key, value, options) {
         options = Object.assign({}, this.#config.cookie, options);
         const serialized = this.#cookieSerializer.encode(key, value, options);
@@ -411,6 +876,9 @@ export class Response extends Macroable {
         this.append('set-cookie', serialized);
         return this;
     }
+    /**
+     * Clear existing cookie.
+     */
     clearCookie(key, options) {
         options = Object.assign({}, this.#config.cookie, options);
         options.expires = new Date(1);
@@ -419,6 +887,12 @@ export class Response extends Macroable {
         this.append('set-cookie', serialized);
         return this;
     }
+    /**
+     * Finishes the response by writing the lazy body, when `explicitEnd = true`
+     * and response is already pending.
+     *
+     * Calling this method twice or when `explicitEnd = false` is noop.
+     */
     finish() {
         if (!this.isPending) {
             return;
@@ -437,170 +911,296 @@ export class Response extends Macroable {
         }
         this.#endResponse();
     }
+    /**
+     * Shorthand method to finish request with "100" status code
+     */
     continue() {
         this.status(100);
         return this.send(null, false);
     }
+    /**
+     * Shorthand method to finish request with "101" status code
+     */
     switchingProtocols() {
         this.status(101);
         return this.send(null, false);
     }
+    /**
+     * Shorthand method to finish request with "200" status code
+     */
     ok(body, generateEtag) {
         this.status(200);
         return this.send(body, generateEtag);
     }
+    /**
+     * Shorthand method to finish request with "201" status code
+     */
     created(body, generateEtag) {
         this.status(201);
         return this.send(body, generateEtag);
     }
+    /**
+     * Shorthand method to finish request with "202" status code
+     */
     accepted(body, generateEtag) {
         this.status(202);
         return this.send(body, generateEtag);
     }
+    /**
+     * Shorthand method to finish request with "203" status code
+     */
     nonAuthoritativeInformation(body, generateEtag) {
         this.status(203);
         return this.send(body, generateEtag);
     }
+    /**
+     * Shorthand method to finish request with "204" status code
+     */
     noContent() {
         this.status(204);
         return this.send(null, false);
     }
+    /**
+     * Shorthand method to finish request with "205" status code
+     */
     resetContent() {
         this.status(205);
         return this.send(null, false);
     }
+    /**
+     * Shorthand method to finish request with "206" status code
+     */
     partialContent(body, generateEtag) {
         this.status(206);
         return this.send(body, generateEtag);
     }
+    /**
+     * Shorthand method to finish request with "300" status code
+     */
     multipleChoices(body, generateEtag) {
         this.status(300);
         return this.send(body, generateEtag);
     }
+    /**
+     * Shorthand method to finish request with "301" status code
+     */
     movedPermanently(body, generateEtag) {
         this.status(301);
         return this.send(body, generateEtag);
     }
+    /**
+     * Shorthand method to finish request with "302" status code
+     */
     movedTemporarily(body, generateEtag) {
         this.status(302);
         return this.send(body, generateEtag);
     }
+    /**
+     * Shorthand method to finish request with "303" status code
+     */
     seeOther(body, generateEtag) {
         this.status(303);
         return this.send(body, generateEtag);
     }
+    /**
+     * Shorthand method to finish request with "304" status code
+     */
     notModified(body, generateEtag) {
         this.status(304);
         return this.send(body, generateEtag);
     }
+    /**
+     * Shorthand method to finish request with "305" status code
+     */
     useProxy(body, generateEtag) {
         this.status(305);
         return this.send(body, generateEtag);
     }
+    /**
+     * Shorthand method to finish request with "307" status code
+     */
     temporaryRedirect(body, generateEtag) {
         this.status(307);
         return this.send(body, generateEtag);
     }
+    /**
+     * Shorthand method to finish request with "400" status code
+     */
     badRequest(body, generateEtag) {
         this.status(400);
         return this.send(body, generateEtag);
     }
+    /**
+     * Shorthand method to finish request with "401" status code
+     */
     unauthorized(body, generateEtag) {
         this.status(401);
         return this.send(body, generateEtag);
     }
+    /**
+     * Shorthand method to finish request with "402" status code
+     */
     paymentRequired(body, generateEtag) {
         this.status(402);
         return this.send(body, generateEtag);
     }
+    /**
+     * Shorthand method to finish request with "403" status code
+     */
     forbidden(body, generateEtag) {
         this.status(403);
         return this.send(body, generateEtag);
     }
+    /**
+     * Shorthand method to finish request with "404" status code
+     */
     notFound(body, generateEtag) {
         this.status(404);
         return this.send(body, generateEtag);
     }
+    /**
+     * Shorthand method to finish request with "405" status code
+     */
     methodNotAllowed(body, generateEtag) {
         this.status(405);
         return this.send(body, generateEtag);
     }
+    /**
+     * Shorthand method to finish request with "406" status code
+     */
     notAcceptable(body, generateEtag) {
         this.status(406);
         return this.send(body, generateEtag);
     }
+    /**
+     * Shorthand method to finish request with "407" status code
+     */
     proxyAuthenticationRequired(body, generateEtag) {
         this.status(407);
         return this.send(body, generateEtag);
     }
+    /**
+     * Shorthand method to finish request with "408" status code
+     */
     requestTimeout(body, generateEtag) {
         this.status(408);
         return this.send(body, generateEtag);
     }
+    /**
+     * Shorthand method to finish request with "409" status code
+     */
     conflict(body, generateEtag) {
         this.status(409);
         return this.send(body, generateEtag);
     }
+    /**
+     * Shorthand method to finish request with "401" status code
+     */
     gone(body, generateEtag) {
         this.status(410);
         return this.send(body, generateEtag);
     }
+    /**
+     * Shorthand method to finish request with "411" status code
+     */
     lengthRequired(body, generateEtag) {
         this.status(411);
         return this.send(body, generateEtag);
     }
+    /**
+     * Shorthand method to finish request with "412" status code
+     */
     preconditionFailed(body, generateEtag) {
         this.status(412);
         return this.send(body, generateEtag);
     }
+    /**
+     * Shorthand method to finish request with "413" status code
+     */
     requestEntityTooLarge(body, generateEtag) {
         this.status(413);
         return this.send(body, generateEtag);
     }
+    /**
+     * Shorthand method to finish request with "414" status code
+     */
     requestUriTooLong(body, generateEtag) {
         this.status(414);
         return this.send(body, generateEtag);
     }
+    /**
+     * Shorthand method to finish request with "415" status code
+     */
     unsupportedMediaType(body, generateEtag) {
         this.status(415);
         return this.send(body, generateEtag);
     }
+    /**
+     * Shorthand method to finish request with "416" status code
+     */
     requestedRangeNotSatisfiable(body, generateEtag) {
         this.status(416);
         return this.send(body, generateEtag);
     }
+    /**
+     * Shorthand method to finish request with "417" status code
+     */
     expectationFailed(body, generateEtag) {
         this.status(417);
         return this.send(body, generateEtag);
     }
+    /**
+     * Shorthand method to finish request with "422" status code
+     */
     unprocessableEntity(body, generateEtag) {
         this.status(422);
         return this.send(body, generateEtag);
     }
+    /**
+     * Shorthand method to finish request with "429" status code
+     */
     tooManyRequests(body, generateEtag) {
         this.status(429);
         return this.send(body, generateEtag);
     }
+    /**
+     * Shorthand method to finish request with "500" status code
+     */
     internalServerError(body, generateEtag) {
         this.status(500);
         return this.send(body, generateEtag);
     }
+    /**
+     * Shorthand method to finish request with "501" status code
+     */
     notImplemented(body, generateEtag) {
         this.status(501);
         return this.send(body, generateEtag);
     }
+    /**
+     * Shorthand method to finish request with "502" status code
+     */
     badGateway(body, generateEtag) {
         this.status(502);
         return this.send(body, generateEtag);
     }
+    /**
+     * Shorthand method to finish request with "503" status code
+     */
     serviceUnavailable(body, generateEtag) {
         this.status(503);
         return this.send(body, generateEtag);
     }
+    /**
+     * Shorthand method to finish request with "504" status code
+     */
     gatewayTimeout(body, generateEtag) {
         this.status(504);
         return this.send(body, generateEtag);
     }
+    /**
+     * Shorthand method to finish request with "505" status code
+     */
     httpVersionNotSupported(body, generateEtag) {
         this.status(505);
         return this.send(body, generateEtag);