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

package/dist/request.d.ts

@@ -0,0 +1,338 @@
+import { type Socket } from 'node:net';
+import { type ParsedUrlQuery } from 'node:querystring';
+import util from 'node:util';
+import type { IncomingMessage, ServerResponse } from 'node:http';
+import { type Accepts } from 'accepts';
+import type { Application } from './application.ts';
+import type { Context } from './context.ts';
+import type { Response } from './response.ts';
+export interface RequestSocket extends Socket {
+    encrypted: boolean;
+}
+export declare class Request {
+    [key: symbol]: unknown;
+    app: Application;
+    req: IncomingMessage;
+    res: ServerResponse;
+    ctx: Context;
+    response: Response;
+    originalUrl: string;
+    constructor(app: Application, ctx: Context, req: IncomingMessage, res: ServerResponse);
+    /**
+     * Return request header.
+     */
+    get header(): import("http").IncomingHttpHeaders;
+    /**
+     * Set request header.
+     */
+    set header(val: import("http").IncomingHttpHeaders);
+    /**
+     * Return request header, alias as request.header
+     */
+    get headers(): import("http").IncomingHttpHeaders;
+    /**
+     * Set request header, alias as request.header
+     */
+    set headers(val: import("http").IncomingHttpHeaders);
+    /**
+     * Get request URL.
+     */
+    get url(): string;
+    /**
+     * Set request URL.
+     */
+    set url(val: string);
+    /**
+     * Get origin of URL.
+     */
+    get origin(): string;
+    /**
+     * Get full request URL.
+     */
+    get href(): string;
+    /**
+     * Get request method.
+     */
+    get method(): string;
+    /**
+     * Set request method.
+     */
+    set method(val: string);
+    /**
+     * Get request pathname.
+     */
+    get path(): string;
+    /**
+     * Set pathname, retaining the query string when present.
+     */
+    set path(pathname: string);
+    protected _parsedUrlQueryCache: Record<string, ParsedUrlQuery> | undefined;
+    /**
+     * Get parsed query string.
+     */
+    get query(): ParsedUrlQuery;
+    /**
+     * Set query string as an object.
+     */
+    set query(obj: ParsedUrlQuery);
+    /**
+     * Get query string.
+     */
+    get querystring(): string;
+    /**
+     * Set query string.
+     */
+    set querystring(str: string);
+    /**
+     * Get the search string. Same as the query string
+     * except it includes the leading ?.
+     */
+    get search(): string;
+    /**
+     * Set the search string. Same as
+     * request.querystring= but included for ubiquity.
+     */
+    set search(str: string);
+    /**
+     * Parse the "Host" header field host
+     * and support X-Forwarded-Host when a
+     * proxy is enabled.
+     * return `hostname:port` format
+     */
+    get host(): string;
+    /**
+     * Parse the "Host" header field hostname
+     * and support X-Forwarded-Host when a
+     * proxy is enabled.
+     */
+    get hostname(): string;
+    protected _memoizedURL: URL | undefined;
+    /**
+     * Get WHATWG parsed URL.
+     * Lazily memoized.
+     */
+    get URL(): URL;
+    /**
+     * Check if the request is fresh, aka
+     * Last-Modified and/or the ETag
+     * still match.
+     */
+    get fresh(): boolean;
+    /**
+     * Check if the request is stale, aka
+     * "Last-Modified" and / or the "ETag" for the
+     * resource has changed.
+     */
+    get stale(): boolean;
+    /**
+     * Check if the request is idempotent.
+     */
+    get idempotent(): boolean;
+    /**
+     * Return the request socket.
+     */
+    get socket(): RequestSocket;
+    /**
+     * Get the charset when present or undefined.
+     */
+    get charset(): string;
+    /**
+     * Return parsed Content-Length when present.
+     */
+    get length(): number | undefined;
+    /**
+     * 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(): string;
+    /**
+     * Shorthand for:
+     *
+     *    this.protocol == 'https'
+     */
+    get secure(): boolean;
+    /**
+     * 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(): string[];
+    protected _ip: string;
+    /**
+     * 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(): string;
+    set ip(ip: string);
+    /**
+     * 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(): string[];
+    protected _accept: Accepts;
+    /**
+     * Get accept object.
+     * Lazily memoized.
+     */
+    get accept(): Accepts;
+    /**
+     * Set accept object.
+     */
+    set accept(obj: Accepts);
+    /**
+     * 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: string[]): string | string[] | false;
+    accepts(...args: string[]): string | string[] | false;
+    /**
+     * Return accepted encodings or best fit based on `encodings`.
+     *
+     * Given `Accept-Encoding: gzip, deflate`
+     * an array sorted by quality is returned:
+     *
+     *     ['gzip', 'deflate']
+     */
+    acceptsEncodings(): string[];
+    acceptsEncodings(encodings: string[]): string | false;
+    acceptsEncodings(...encodings: string[]): string | false;
+    /**
+     * 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(): string[];
+    acceptsCharsets(charsets: string[]): string | false;
+    acceptsCharsets(...charsets: string[]): string | false;
+    /**
+     * 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(): string[];
+    acceptsLanguages(languages: string[]): string | false;
+    acceptsLanguages(...languages: string[]): string | false;
+    /**
+     * 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?: string | string[], ...types: string[]): string | false | null;
+    /**
+     * Return the request mime type void of
+     * parameters such as "charset".
+     */
+    get type(): string;
+    /**
+     * 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<T = string | string[]>(field: string): T;
+    /**
+     * Inspect implementation.
+     */
+    inspect(): {
+        method: string;
+        url: string;
+        header: import("http").IncomingHttpHeaders;
+    } | undefined;
+    /**
+     * Custom inspection implementation for newer Node.js versions.
+     */
+    [util.inspect.custom](): {
+        method: string;
+        url: string;
+        header: import("http").IncomingHttpHeaders;
+    } | undefined;
+    /**
+     * Return JSON representation.
+     */
+    toJSON(): {
+        method: string;
+        url: string;
+        header: import("http").IncomingHttpHeaders;
+    };
+}