@eggjs/koa 3.1.0-beta.20 → 3.1.0-beta.21

package/dist/request.js

@@ -0,0 +1,521 @@
+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 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 ?? 'GET';
+    }
+    /**
+     * 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(pathname) {
+        const url = parse(this.req);
+        if (!url)
+            return;
+        if (url.pathname === pathname)
+            return;
+        url.pathname = pathname;
+        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 = qs.parse(str);
+            this._parsedUrlQueryCache[str] = parsedUrlQuery;
+        }
+        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)
+            return;
+        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() {
+        const querystring = this.querystring;
+        if (!querystring)
+            return '';
+        return `?${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) {
+            host = splitCommaSeparatedValues(host, 1)[0];
+        }
+        if (!host) {
+            if (this.req.httpVersionMajor >= 2) {
+                host = this.get(':authority');
+            }
+            if (!host) {
+                host = this.get('Host');
+            }
+        }
+        return host;
+    }
+    /**
+     * 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 Number.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';
+        }
+        let proto = this.get('X-Forwarded-Proto');
+        if (proto) {
+            proto = splitCommaSeparatedValues(proto, 1)[0];
+        }
+        return proto || '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 ? splitCommaSeparatedValues(val) : [];
+        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;
+    }
+    accepts(args, ...others) {
+        return this.accept.types(args, ...others);
+    }
+    acceptsEncodings(encodings, ...others) {
+        if (!encodings) {
+            return this.accept.encodings();
+        }
+        if (Array.isArray(encodings)) {
+            encodings = [...encodings, ...others];
+        }
+        else {
+            encodings = [encodings, ...others];
+        }
+        return this.accept.encodings(...encodings);
+    }
+    acceptsCharsets(charsets, ...others) {
+        if (!charsets) {
+            return this.accept.charsets();
+        }
+        if (Array.isArray(charsets)) {
+            charsets = [...charsets, ...others];
+        }
+        else {
+            charsets = [charsets, ...others];
+        }
+        return this.accept.charsets(...charsets);
+    }
+    acceptsLanguages(languages, ...others) {
+        if (!languages) {
+            return this.accept.languages();
+        }
+        if (Array.isArray(languages)) {
+            languages = [...languages, ...others];
+        }
+        else {
+            languages = [languages, ...others];
+        }
+        return this.accept.languages(...languages);
+    }
+    /**
+     * 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) {
+        let testTypes = [];
+        if (type) {
+            testTypes = Array.isArray(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,
+        };
+    }
+}
+/**
+ * Split a comma-separated value string into an array of values, with an optional limit.
+ * All the values are trimmed of whitespace and filtered out empty values.
+ *
+ * @param {string} value - The comma-separated value string to split.
+ * @param {number} [limit] - The maximum number of values to return.
+ * @returns {string[]} An array of values from the comma-separated string.
+ */
+function splitCommaSeparatedValues(value, limit) {
+    return value
+        .split(',', limit)
+        .map(v => v.trim())
+        .filter(v => v.length > 0);
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"request.js","sourceRoot":"","sources":["../src/request.ts"],"names":[],"mappings":"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"}