Module
A microframework for Deno's HTTP server with zero third-party dependencies
123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344import { getCookies } from "../../deps.ts";import { Errors } from "../../mod.ts";import type { ConnInfo } from "../../deps.ts";import { BodyFile } from "../types.ts";
export type ParsedBody = | Record<string, string | BodyFile | BodyFile[]> | undefined | string;
/** * A class that holds the representation of an incoming request */export class DrashRequest extends Request { public conn_info: ConnInfo;
#end_lifecycle = false; #original: Request; #parsed_body?: ParsedBody; readonly #path_params: Map<string, string>; #search_params!: URLSearchParams;
////////////////////////////////////////////////////////////////////////////// // FILE MARKER - CONSTRUCTOR ///////////////////////////////////////////////// //////////////////////////////////////////////////////////////////////////////
/** * Construct an object of this class. * * This class is just a wrapper around the native Request object. The only * reason we wrap around the native Request object is so we can add more * methods to interact with the native Request object (e.g., req.bodyParam()). * * @param originalRequest - The original request coming. * @param pathParams - The path params to match the request's URL to. The path * params come from a resource's path(s). * @param connInfo - The connection information for the current request */ constructor( originalRequest: Request, pathParams: Map<string, string>, connInfo: ConnInfo, ) { super(originalRequest); this.#path_params = pathParams; this.conn_info = connInfo; this.#original = originalRequest.clone(); }
////////////////////////////////////////////////////////////////////////////// // GETTERS / SETTERS ///////////////////////////////////////////////////////// //////////////////////////////////////////////////////////////////////////////
get end_lifecycle(): boolean { return this.#end_lifecycle; }
get original(): Request { return this.#original; }
////////////////////////////////////////////////////////////////////////////// // FILE MARKER - METHODS - STATIC //////////////////////////////////////////// //////////////////////////////////////////////////////////////////////////////
/** * Create a Drash request object. We use this method to create request objects * because we need to use `async-await` and cannot use them in constructor * methods. This is the only reason for this abstraction. * * @param request - The original request. * @param pathParams - The path params to match the request's URL to. The path * params come from a resource's path(s). * @param connInfo - The connection info Deno provides on a new request * * @returns A Drash request object. */ static async create( request: Request, pathParams: Map<string, string>, connInfo: ConnInfo, ) { const req = new DrashRequest(request, pathParams, connInfo); // This is here because `parseBody` is async. We can't parse the request // body on the fly as we dont want users to have to use await when getting a // body param. const contentLength = req.headers.get("content-length") ?? "0"; if (req.body && req.bodyUsed === false && contentLength !== "0") { req.#parsed_body = await req.#parseBody(); } return req; }
////////////////////////////////////////////////////////////////////////////// // FILE MARKER - METHODS - PUBLIC //////////////////////////////////////////// //////////////////////////////////////////////////////////////////////////////
/** * Check if the content type in question are accepted by the request. * * @param contentType - A proper MIME type. See /src/dictionaries/mime_db.ts for proper MIME types * that Drash can handle. * * @returns True if yes, false if no. */ public accepts(contentType: string): boolean { const acceptHeader = this.headers.get("Accept"); if (!acceptHeader) { return false; } return acceptHeader.includes(contentType); }
/** * Set this request to end early? Calling this will tell the request to stop * where it is at in the request-resource-response lifecycle and immediately * return a response. */ public end(): void { this.#end_lifecycle = true; }
/** * Get a cookie value by the name that is sent in with the request. * * @param name - The name of the cookie to retrieve * * @returns The cookie value associated with the cookie name or `undefined` if * a cookie with that name doesn't exist */ public getCookie(name: string): string { const cookies = getCookies( this.headers, ); return cookies[name]; }
/** * Get a body parameter of the request by the name * * @example * ```js * // Assume you've sent a fetch request with: * // { * // user: { * // name: "Drash" * // } * // } * const user = request.bodyParam<{ name: string }>("user") // { name: "Drash" } * // More examples: * request.bodyParam<BodyFile[]>('uploads') * ``` * * @param name The body parameter name * * @returns The value of the parameter if found, or `undefined` if not found. */ public bodyParam<T>(name: string): T | undefined { if (this.#parsed_body === undefined) { return undefined; }
if (typeof this.#parsed_body !== "object") { return undefined; }
if (this.#parsed_body[name] === undefined) { return undefined; }
return this.#parsed_body[name] as unknown as T; }
/** * Get all body params. * * @returns All params contained in the body or an empty body if no params * exist. */ public bodyAll<T>(): ParsedBody | T { if (this.#parsed_body === undefined) { return {}; }
if (typeof this.#parsed_body !== "object") { return {}; }
return this.#parsed_body; }
/** * Parse the request body. * * @returns A parsed body based on the content type of the request body. */ async #parseBody(): Promise<ParsedBody> { const contentLength = this.headers.get("content-length");
// The Content-Length header indicates that the client is sending a body. // Some clients send a Content-Length header of "0", which indicates that // there is in fact no body present with the request. We need to check for // this or else we try to parse a body for no reason. if (!contentLength || contentLength === "0") { return undefined; }
// If we get to this point, then that means there is a body (since the // Content-Length header is greater than 0). In order for us to parse the // body, we need to know the Content-Type of the body. Otherwise, we have // no way of knowing how to parse it. We can assume, but let's just tell the // client to modify their request to include the Content-Type header. const contentType = this.headers.get("content-type");
if (!contentType) { throw new Errors.HttpError( 400, "Bad Request. The request body cannot be parsed due to the Content-Type header missing.", ); }
try { if (contentType.includes("multipart/form-data")) { return await this.#constructFormDataUsingBody(); } if (contentType.includes("application/json")) { return await this.json(); } if (contentType.includes("application/x-www-form-urlencoded")) { return await this.#constructFormDataUsingBody(); } if (contentType.includes("text/plain")) { return await this.text(); }
// If all else fails, then try to parse the body using FormData return await this.#constructFormDataUsingBody(); } catch (_e) { throw new Errors.HttpError( 422, "Unprocessable Entity. The request body seems to be invalid as there was an error parsing it.", ); } }
/** * Get a path parameter from the request based on the request's URL and the * resource path it matched to. * * @example * ```js * // Assume a path for your resource is "/users/:id/:city?", and the request * // is "/users/2/". * const id = this.paramParam("id") // Returns 2 * const city = this.queryParam("city") // Returns undefined * ``` * * @param name - The parameter name in the resource path. * * @returns The value for the parameter if found, or undefined if not set. */ public pathParam(name: string): string | undefined { const param = this.#path_params.get(name); if (!param) { return undefined; } return this.#decodeValue(param); }
/** * Find a query string parameter. * * @example * ```js * // Assume url is "http://localhost:1336/users?city=London&country=England" * const city = this.queryParam("city") // Returns "London" * const country = this.queryParam("country") // Returns "England" * ``` * * @param name - The name of the query string. * * @returns The value of the param if found, or undefined if not. */ public queryParam(name: string): string | undefined { if (!this.#search_params) { this.#search_params = new URL(this.url).searchParams; } const param = this.#search_params.get(name); if (!param) { return undefined; } return this.#decodeValue(param); }
////////////////////////////////////////////////////////////////////////////// // FILE MARKER - METHODS - PRIVATE /////////////////////////////////////////// //////////////////////////////////////////////////////////////////////////////
/** * Construct the form data of a request body. * * @returns The form data body as a key-value pair object. */ async #constructFormDataUsingBody(): Promise<ParsedBody> { const formData = await this.formData(); const formDataJSON: ParsedBody = {}; for (const [key, value] of formData.entries()) { if (value instanceof File) { const content = new Uint8Array(await value.arrayBuffer()); const file = { size: value.size, type: value.type, content, filename: value.name, }; if (key.endsWith("[]")) { const name = key.slice(0, -2); if (!formDataJSON[name]) { formDataJSON[name] = []; } (formDataJSON[name] as BodyFile[]).push(file); } else { formDataJSON[key] = file; } continue; } formDataJSON[key] = value as string; } return formDataJSON; }
/** * Decode a URI component -- netrualizing the string by replacing characters * not required. * * @param value - The string to decode. * * @returns The neutralized string. */ #decodeValue(value: string): string { return decodeURIComponent(value.replace(/\+/g, " ")); }}