Module

x/opine/src/request.ts>WrappedRequest

Fast, minimalist web framework for Deno ported from ExpressJS.
Go to Latest
class WrappedRequest
implements OpineRequest
import { WrappedRequest } from "https://dotland.deno.dev/x/opine@2.2.0/src/request.ts";

Constructors

new
WrappedRequest(request: Request, connInfo: ConnInfo)

Properties

optional
_parsedBody: boolean | undefined
optional
_parsedOriginalUrl: ParsedURL | undefined
optional
_parsedUrl: ParsedURL | undefined
baseUrl: string
body: unknown
readonly
conn
readonly
finalResponse

Returns a promise that resolves to the response to the request.

readonly
fresh

Check if the request is fresh, aka Last-Modified and/or the ETag still match.

headers: Headers
readonly
hostname: string | undefined

Parse the "Host" header field to a hostname.

When the "trust proxy" setting trusts the socket address, the "X-Forwarded-Host" header field will be trusted.

readonly
ip: string

Return the remote address from the trusted proxy.

The is the remote address on the socket unless "trust proxy" is set.

readonly
ips

When "trust proxy" is set, trusted proxy addresses + client.

For example if the value were "client, proxy1, proxy2" you would receive the array ["client", "proxy1", "proxy2"] where "proxy2" is the furthest down-stream and "proxy1" and "proxy2" were trusted.

method: string
optional
next: NextFunction | undefined
originalUrl: string
param: (name: string, defaultValue?: string | undefined) => string | undefined
optional
parsedBody: unknown
readonly
path: string

Returns the pathname of the URL.

proto: string
readonly
protocol

Return the protocol string "http" or "https" when requested with TLS. When the "trust proxy" setting trusts the socket address, the "X-Forwarded-Proto" header field will be trusted and used if present.

If you're running behind a reverse proxy that supplies https for you this may be enabled.

query: unknown
readonly
raw
route: unknown
readonly
secure

Short-hand for:

req.protocol === 'https'

readonly
stale: boolean

Check if the request is stale, aka "Last-Modified" and / or the "ETag" for the resource has changed.

readonly
subdomains

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 "subdomain offset".

For example, if the domain is "deno.dinosaurs.example.com": If "subdomain offset" is not set, req.subdomains is ["dinosaurs", "deno"]. If "subdomain offset" is 3, req.subdomains is ["deno"].

url: string
readonly
xhr

Check if the request was an XMLHttpRequest.

Methods

accepts(this: OpineRequest, ...args: [string[]] | string[])

Check if the given type(s) is acceptable, returning the best match when true, otherwise undefined, in which case you should respond with 406 "Not Acceptable".

The type value may be a single MIME type string such as "application/json", an extension name such as "json", a comma-delimited list such as "json, html, text/plain", an argument list such as "json", "html", "text/plain", 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
req.accepts('html');
// => "html"

// Accept: text/*, application/json
req.accepts('html');
// => "html"
req.accepts('text/html');
// => "text/html"
req.accepts('json, text');
// => "json"
req.accepts('application/json');
// => "application/json"

// Accept: text/*, application/json
req.accepts('image/png');
req.accepts('png');
// => undefined

// Accept: text/*;q=.5, application/json
req.accepts(['html', 'json']);
req.accepts('html', 'json');
req.accepts('html, json');
// => "json"
acceptsCharsets(this: OpineRequest, ...args: [string[]] | string[])

Check if the given charsets are acceptable, otherwise you should respond with 406 "Not Acceptable".

acceptsEncodings(this: OpineRequest, ...args: [string[]] | string[])

Check if the given encodings are accepted.

acceptsLanguages(this: OpineRequest, ...args: [string[]] | string[])

Check if the given langs are acceptable, otherwise you should respond with 406 "Not Acceptable".

get(name: string): string | undefined

Return request header.

The Referrer header field is special-cased, both Referrer and Referer are interchangeable.

Examples:

req.get('Content-Type');
// => "text/plain"

req.get('content-type');
// => "text/plain"

req.get('Something');
// => undefined

Aliased as req.header().

is(this: OpineRequest, types: string | string[])

Check if the incoming request contains the "Content-Type" header field, and it contains the give mime type.

Examples:

 // With Content-Type: text/html; charset=utf-8
 req.is('html');
 req.is('text/html');
 req.is('text/*');
 // => true

 // When Content-Type is application/json
 req.is('json');
 req.is('application/json');
 req.is('application/*');
 // => true

 req.is('html');
 // => false
range(size: number, options?: RangeParserOptions): RangeParserRanges | RangeParserResult | undefined

Parse Range header field, capping to the given size.

Unspecified ranges such as "0-" require knowledge of your resource length. In the case of a byte range this is of course the total number of bytes. If the Range header field is not given undefined is returned, -1 when unsatisfiable, and -2 when syntactically invalid.

When ranges are returned, the array has a "type" property which is the type of range that is required (most commonly, "bytes"). Each array element is an object with a "start" and "end" property for the portion of the range.

The "combine" option can be set to true and overlapping & adjacent ranges will be combined into a single range.

NOTE: remember that ranges are inclusive, so for example "Range: users=0-3" should respond with 4 users when available, not 3.