@eggjs/koa 2.17.0 → 2.18.1

package/dist/esm/request.js

@@ -0,0 +1,522 @@
+import net from 'node:net';
+import { format as stringify } from 'node:url';
+import qs from 'node:querystring';
+import util from 'node:util';
+import accepts from 'accepts';
+import contentType from 'content-type';
+import parse from 'parseurl';
+import typeis from 'type-is';
+import fresh from 'fresh';
+export default class Request {
+    app;
+    req;
+    res;
+    ctx;
+    response;
+    originalUrl;
+    constructor(app, ctx, req, res) {
+        this.app = app;
+        this.req = req;
+        this.res = res;
+        this.ctx = ctx;
+        this.originalUrl = req.url;
+    }
+    /**
+     * Return request header.
+     */
+    get header() {
+        return this.req.headers;
+    }
+    /**
+     * Set request header.
+     */
+    set header(val) {
+        this.req.headers = val;
+    }
+    /**
+     * Return request header, alias as request.header
+     */
+    get headers() {
+        return this.req.headers;
+    }
+    /**
+     * Set request header, alias as request.header
+     */
+    set headers(val) {
+        this.req.headers = val;
+    }
+    /**
+     * Get request URL.
+     */
+    get url() {
+        return this.req.url;
+    }
+    /**
+     * Set request URL.
+     */
+    set url(val) {
+        this.req.url = val;
+    }
+    /**
+     * Get origin of URL.
+     */
+    get origin() {
+        return `${this.protocol}://${this.host}`;
+    }
+    /**
+     * Get full request URL.
+     */
+    get href() {
+        // support: `GET http://example.com/foo`
+        if (/^https?:\/\//i.test(this.originalUrl))
+            return this.originalUrl;
+        return this.origin + this.originalUrl;
+    }
+    /**
+     * Get request method.
+     */
+    get method() {
+        return this.req.method;
+    }
+    /**
+     * Set request method.
+     */
+    set method(val) {
+        this.req.method = val;
+    }
+    /**
+     * Get request pathname.
+     */
+    get path() {
+        return parse(this.req).pathname;
+    }
+    /**
+     * Set pathname, retaining the query string when present.
+     */
+    set path(path) {
+        const url = parse(this.req);
+        if (url.pathname === path)
+            return;
+        url.pathname = path;
+        url.path = null;
+        this.url = stringify(url);
+    }
+    #parsedUrlQueryCache;
+    /**
+     * Get parsed query string.
+     */
+    get query() {
+        const str = this.querystring;
+        if (!this.#parsedUrlQueryCache) {
+            this.#parsedUrlQueryCache = {};
+        }
+        let parsedUrlQuery = this.#parsedUrlQueryCache[str];
+        if (!parsedUrlQuery) {
+            parsedUrlQuery = this.#parsedUrlQueryCache[str] = qs.parse(str);
+        }
+        return parsedUrlQuery;
+    }
+    /**
+     * Set query string as an object.
+     */
+    set query(obj) {
+        this.querystring = qs.stringify(obj);
+    }
+    /**
+     * Get query string.
+     */
+    get querystring() {
+        if (!this.req)
+            return '';
+        return parse(this.req).query || '';
+    }
+    /**
+     * Set query string.
+     */
+    set querystring(str) {
+        const url = parse(this.req);
+        if (url.search === `?${str}`)
+            return;
+        url.search = str;
+        url.path = null;
+        this.url = stringify(url);
+    }
+    /**
+     * Get the search string. Same as the query string
+     * except it includes the leading ?.
+     */
+    get search() {
+        if (!this.querystring)
+            return '';
+        return `?${this.querystring}`;
+    }
+    /**
+     * Set the search string. Same as
+     * request.querystring= but included for ubiquity.
+     */
+    set search(str) {
+        this.querystring = str;
+    }
+    /**
+     * Parse the "Host" header field host
+     * and support X-Forwarded-Host when a
+     * proxy is enabled.
+     * return `hostname:port` format
+     */
+    get host() {
+        const proxy = this.app.proxy;
+        let host = proxy ? this.get('X-Forwarded-Host') : '';
+        if (!host) {
+            if (this.req.httpVersionMajor >= 2)
+                host = this.get(':authority');
+            if (!host)
+                host = this.get('Host');
+        }
+        if (!host)
+            return '';
+        return host.split(/\s*,\s*/, 1)[0];
+    }
+    /**
+     * Parse the "Host" header field hostname
+     * and support X-Forwarded-Host when a
+     * proxy is enabled.
+     */
+    get hostname() {
+        const host = this.host;
+        if (!host)
+            return '';
+        if (host[0] === '[')
+            return this.URL.hostname || ''; // IPv6
+        return host.split(':', 1)[0];
+    }
+    #memoizedURL;
+    /**
+     * Get WHATWG parsed URL.
+     * Lazily memoized.
+     */
+    get URL() {
+        if (!this.#memoizedURL) {
+            const originalUrl = this.originalUrl || ''; // avoid undefined in template string
+            try {
+                this.#memoizedURL = new URL(`${this.origin}${originalUrl}`);
+            }
+            catch {
+                this.#memoizedURL = Object.create(null);
+            }
+        }
+        return this.#memoizedURL;
+    }
+    /**
+     * Check if the request is fresh, aka
+     * Last-Modified and/or the ETag
+     * still match.
+     */
+    get fresh() {
+        const method = this.method;
+        const status = this.response.status;
+        // GET or HEAD for weak freshness validation only
+        if (method !== 'GET' && method !== 'HEAD')
+            return false;
+        // 2xx or 304 as per rfc2616 14.26
+        if ((status >= 200 && status < 300) || status === 304) {
+            return fresh(this.header, this.response.header);
+        }
+        return false;
+    }
+    /**
+     * Check if the request is stale, aka
+     * "Last-Modified" and / or the "ETag" for the
+     * resource has changed.
+     */
+    get stale() {
+        return !this.fresh;
+    }
+    /**
+     * Check if the request is idempotent.
+     */
+    get idempotent() {
+        const methods = ['GET', 'HEAD', 'PUT', 'DELETE', 'OPTIONS', 'TRACE'];
+        return methods.includes(this.method);
+    }
+    /**
+     * Return the request socket.
+     */
+    get socket() {
+        return this.req.socket;
+    }
+    /**
+     * Get the charset when present or undefined.
+     */
+    get charset() {
+        try {
+            const { parameters } = contentType.parse(this.req);
+            return parameters.charset || '';
+        }
+        catch {
+            return '';
+        }
+    }
+    /**
+     * Return parsed Content-Length when present.
+     */
+    get length() {
+        const len = this.get('Content-Length');
+        if (len === '')
+            return;
+        return parseInt(len);
+    }
+    /**
+     * Return the protocol string "http" or "https"
+     * when requested with TLS. When the proxy setting
+     * is enabled the "X-Forwarded-Proto" header
+     * field will be trusted. If you're running behind
+     * a reverse proxy that supplies https for you this
+     * may be enabled.
+     */
+    get protocol() {
+        if (this.socket.encrypted)
+            return 'https';
+        if (!this.app.proxy)
+            return 'http';
+        const proto = this.get('X-Forwarded-Proto');
+        return proto ? proto.split(/\s*,\s*/, 1)[0] : 'http';
+    }
+    /**
+     * Shorthand for:
+     *
+     *    this.protocol == 'https'
+     */
+    get secure() {
+        return this.protocol === 'https';
+    }
+    /**
+     * When `app.proxy` is `true`, parse
+     * the "X-Forwarded-For" ip address list.
+     *
+     * For example if the value was "client, proxy1, proxy2"
+     * you would receive the array `["client", "proxy1", "proxy2"]`
+     * where "proxy2" is the furthest down-stream.
+     */
+    get ips() {
+        const proxy = this.app.proxy;
+        const val = this.get(this.app.proxyIpHeader);
+        let ips = proxy && val
+            ? val.split(/\s*,\s*/)
+            : [];
+        if (this.app.maxIpsCount > 0) {
+            ips = ips.slice(-this.app.maxIpsCount);
+        }
+        return ips;
+    }
+    #ip;
+    /**
+     * Return request's remote address
+     * When `app.proxy` is `true`, parse
+     * the "X-Forwarded-For" ip address list and return the first one
+     */
+    get ip() {
+        if (!this.#ip) {
+            this.#ip = this.ips[0] || this.socket.remoteAddress || '';
+        }
+        return this.#ip;
+    }
+    set ip(ip) {
+        this.#ip = ip;
+    }
+    /**
+     * Return subdomains as an array.
+     *
+     * Subdomains are the dot-separated parts of the host before the main domain
+     * of the app. By default, the domain of the app is assumed to be the last two
+     * parts of the host. This can be changed by setting `app.subdomainOffset`.
+     *
+     * For example, if the domain is "tobi.ferrets.example.com":
+     * If `app.subdomainOffset` is not set, this.subdomains is
+     * `["ferrets", "tobi"]`.
+     * If `app.subdomainOffset` is 3, this.subdomains is `["tobi"]`.
+     */
+    get subdomains() {
+        const offset = this.app.subdomainOffset;
+        const hostname = this.hostname;
+        if (net.isIP(hostname))
+            return [];
+        return hostname
+            .split('.')
+            .reverse()
+            .slice(offset);
+    }
+    #accept;
+    /**
+     * Get accept object.
+     * Lazily memoized.
+     */
+    get accept() {
+        return this.#accept || (this.#accept = accepts(this.req));
+    }
+    /**
+     * Set accept object.
+     */
+    set accept(obj) {
+        this.#accept = obj;
+    }
+    /**
+     * Check if the given `type(s)` is acceptable, returning
+     * the best match when true, otherwise `false`, in which
+     * case you should respond with 406 "Not Acceptable".
+     *
+     * The `type` value may be a single mime type string
+     * such as "application/json", the extension name
+     * such as "json" or an array `["json", "html", "text/plain"]`. When a list
+     * or array is given the _best_ match, if any is returned.
+     *
+     * Examples:
+     *
+     *     // Accept: text/html
+     *     this.accepts('html');
+     *     // => "html"
+     *
+     *     // Accept: text/*, application/json
+     *     this.accepts('html');
+     *     // => "html"
+     *     this.accepts('text/html');
+     *     // => "text/html"
+     *     this.accepts('json', 'text');
+     *     // => "json"
+     *     this.accepts('application/json');
+     *     // => "application/json"
+     *
+     *     // Accept: text/*, application/json
+     *     this.accepts('image/png');
+     *     this.accepts('png');
+     *     // => false
+     *
+     *     // Accept: text/*;q=.5, application/json
+     *     this.accepts(['html', 'json']);
+     *     this.accepts('html', 'json');
+     *     // => "json"
+     */
+    accepts(...args) {
+        return this.accept.types(...args);
+    }
+    /**
+     * Return accepted encodings or best fit based on `encodings`.
+     *
+     * Given `Accept-Encoding: gzip, deflate`
+     * an array sorted by quality is returned:
+     *
+     *     ['gzip', 'deflate']
+     */
+    acceptsEncodings(...args) {
+        return this.accept.encodings(...args);
+    }
+    /**
+     * Return accepted charsets or best fit based on `charsets`.
+     *
+     * Given `Accept-Charset: utf-8, iso-8859-1;q=0.2, utf-7;q=0.5`
+     * an array sorted by quality is returned:
+     *
+     *     ['utf-8', 'utf-7', 'iso-8859-1']
+     */
+    acceptsCharsets(...args) {
+        return this.accept.charsets(...args);
+    }
+    /**
+     * Return accepted languages or best fit based on `langs`.
+     *
+     * Given `Accept-Language: en;q=0.8, es, pt`
+     * an array sorted by quality is returned:
+     *
+     *     ['es', 'pt', 'en']
+     */
+    acceptsLanguages(...args) {
+        return this.accept.languages(...args);
+    }
+    /**
+     * Check if the incoming request contains the "Content-Type"
+     * header field and if it contains any of the given mime `type`s.
+     * If there is no request body, `null` is returned.
+     * If there is no content type, `false` is returned.
+     * Otherwise, it returns the first `type` that matches.
+     *
+     * Examples:
+     *
+     *     // With Content-Type: text/html; charset=utf-8
+     *     this.is('html'); // => 'html'
+     *     this.is('text/html'); // => 'text/html'
+     *     this.is('text/*', 'application/json'); // => 'text/html'
+     *
+     *     // When Content-Type is application/json
+     *     this.is('json', 'urlencoded'); // => 'json'
+     *     this.is('application/json'); // => 'application/json'
+     *     this.is('html', 'application/*'); // => 'application/json'
+     *
+     *     this.is('html'); // => false
+     */
+    is(type, ...types) {
+        const testTypes = Array.isArray(type) ? type :
+            (type ? [type] : []);
+        return typeis(this.req, [...testTypes, ...types]);
+    }
+    /**
+     * Return the request mime type void of
+     * parameters such as "charset".
+     */
+    get type() {
+        const type = this.get('Content-Type');
+        if (!type)
+            return '';
+        return type.split(';')[0];
+    }
+    /**
+     * Return request header.
+     *
+     * The `Referrer` header field is special-cased,
+     * both `Referrer` and `Referer` are interchangeable.
+     *
+     * Examples:
+     *
+     *     this.get('Content-Type');
+     *     // => "text/plain"
+     *
+     *     this.get('content-type');
+     *     // => "text/plain"
+     *
+     *     this.get('Something');
+     *     // => ''
+     */
+    get(field) {
+        const req = this.req;
+        switch (field = field.toLowerCase()) {
+            case 'referer':
+            case 'referrer':
+                return (req.headers.referrer || req.headers.referer || '');
+            default:
+                return (req.headers[field] || '');
+        }
+    }
+    /**
+     * Inspect implementation.
+     */
+    inspect() {
+        if (!this.req)
+            return;
+        return this.toJSON();
+    }
+    /**
+     * Custom inspection implementation for newer Node.js versions.
+     */
+    [util.inspect.custom]() {
+        return this.inspect();
+    }
+    /**
+     * Return JSON representation.
+     */
+    toJSON() {
+        return {
+            method: this.method,
+            url: this.url,
+            header: this.header,
+        };
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"request.js","sourceRoot":"","sources":["../../src/request.ts"],"names":[],"mappings":"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"}