@h3ravel/http 11.4.3 → 11.5.0

package/dist/index.js

@@ -1,4 +1,6 @@
 import { i as __toESM, r as __require, t as __commonJS } from "./chunk-BLWcukCW.js";
+import { writeFile } from "fs/promises";
+import { Arr, Obj, Str, data_get, data_set, safeDot } from "@h3ravel/support";
 import { Command } from "@h3ravel/musket";
 import { HttpContext, Logger } from "@h3ravel/shared";
 import { fileURLToPath } from "node:url";
@@ -16,9 +18,697 @@ import { appendFileSync, createReadStream, createWriteStream, readFileSync, stat
 import { finished } from "node:stream/promises";
 import { Duplex, PassThrough, Readable, Transform, Writable, getDefaultHighWaterMark } from "node:stream";
 import { Buffer as Buffer$1 } from "node:buffer";
-import { H3, getQuery, getRouterParams, html, readBody, redirect, serve } from "h3";
-import { safeDot } from "@h3ravel/support";
+import { H3, getQuery, getRequestIP, getRequestURL, getRouterParams, html, parseCookies, redirect, serve } from "h3";
 
+//#region src/Exceptions/BadRequestException.ts
+var BadRequestException = class extends Error {
+	constructor(message) {
+		super(message);
+		this.name = "BadRequestException";
+	}
+};
+
+//#endregion
+//#region src/Exceptions/UnexpectedValueException.ts
+var UnexpectedValueException = class extends Error {
+	constructor(message) {
+		super(message);
+		this.name = "UnexpectedValueException";
+	}
+};
+
+//#endregion
+//#region src/Bags/ParamBag.ts
+/**
+* ParamBag is a container for key/value pairs
+* for Node/H3 environments.
+*/
+var ParamBag = class {
+	constructor(parameters = {}, event) {
+		this.parameters = parameters;
+		this.event = event;
+		this.parameters = { ...parameters };
+	}
+	/**
+	* Returns the parameters.
+	* @
+	* @param key The name of the parameter to return or null to get them all
+	*
+	* @throws BadRequestException if the value is not an array
+	*/
+	all(key) {
+		if (key === null) return { ...this.parameters };
+		const value = key ? this.parameters[key] : void 0;
+		if (value && typeof value !== "object") throw new BadRequestException(`Unexpected value for parameter "${key}": expected object, got ${typeof value}`);
+		return value || {};
+	}
+	get(key, defaultValue) {
+		return key in this.parameters ? this.parameters[key] : defaultValue;
+	}
+	set(key, value) {
+		this.parameters[key] = value;
+	}
+	/**
+	* Returns true if the parameter is defined.
+	* 
+	* @param key  
+	*/
+	has(key) {
+		return Object.prototype.hasOwnProperty.call(this.parameters, key);
+	}
+	/**
+	* Removes a parameter.
+	* 
+	* @param key  
+	*/
+	remove(key) {
+		delete this.parameters[key];
+	}
+	/**
+	* 
+	* Returns the parameter as string.
+	*
+	* @param key 
+	* @param defaultValue 
+	* @throws UnexpectedValueException if the value cannot be converted to string
+	* @returns 
+	*/
+	getString(key, defaultValue = "") {
+		const value = this.get(key, defaultValue);
+		if (typeof value === "string" || typeof value === "number" || typeof value === "boolean") return String(value);
+		throw new UnexpectedValueException(`Parameter "${key}" cannot be converted to string`);
+	}
+	/**
+	* Returns the parameter value converted to integer.
+	*
+	* @param key 
+	* @param defaultValue 
+	* @throws UnexpectedValueException if the value cannot be converted to integer
+	*/
+	getInt(key, defaultValue = 0) {
+		const value = parseInt(this.get(key, defaultValue), 10);
+		if (isNaN(value)) throw new Error(`Parameter "${key}" is not an integer`);
+		return value;
+	}
+	/**
+	* Returns the parameter value converted to boolean.
+	*
+	* @param key 
+	* @param defaultValue 
+	* @throws UnexpectedValueException if the value cannot be converted to a boolean
+	*/
+	getBoolean(key, defaultValue = false) {
+		const value = this.get(key, defaultValue);
+		if (typeof value === "boolean") return value;
+		if ([
+			"1",
+			"true",
+			"yes"
+		].includes(String(value).toLowerCase())) return true;
+		if ([
+			"0",
+			"false",
+			"no"
+		].includes(String(value).toLowerCase())) return false;
+		throw new Error(`Parameter "${key}" cannot be converted to boolean`);
+	}
+	/**
+	* Returns the alphabetic characters of the parameter value.
+	*
+	* @param key 
+	* @param defaultValue 
+	* @throws UnexpectedValueException if the value cannot be converted to string
+	*/
+	getAlpha(key, defaultValue = "") {
+		return this.getString(key, defaultValue).replace(/[^a-z]/gi, "");
+	}
+	/**
+	* Returns the alphabetic characters and digits of the parameter value.
+	*
+	* @param key 
+	* @param defaultValue 
+	* @throws UnexpectedValueException if the value cannot be converted to string
+	*/
+	getAlnum(key, defaultValue = "") {
+		return this.getString(key, defaultValue).replace(/[^a-z0-9]/gi, "");
+	}
+	/**
+	* Returns the digits of the parameter value.
+	* 
+	* @param key 
+	* @param defaultValue 
+	* @throws UnexpectedValueException if the value cannot be converted to string
+	* @returns 
+	**/
+	getDigits(key, defaultValue = "") {
+		return this.getString(key, defaultValue).replace(/\D/g, "");
+	}
+	/**
+	* Returns the parameter keys.
+	*/
+	keys() {
+		return Object.keys(this.parameters);
+	}
+	/**
+	* Replaces the current parameters by a new set.
+	*/
+	replace(parameters = {}) {
+		this.parameters = { ...parameters };
+	}
+	/**
+	* Adds parameters.
+	*/
+	add(parameters = {}) {
+		this.parameters = {
+			...this.parameters,
+			...parameters
+		};
+	}
+	/**
+	* Returns the number of parameters.
+	*/
+	count() {
+		return Object.keys(this.parameters).length;
+	}
+	/**
+	* Returns an iterator for parameters.
+	*
+	* @returns 
+	*/
+	[Symbol.iterator]() {
+		return Object.entries(this.parameters)[Symbol.iterator]();
+	}
+};
+
+//#endregion
+//#region src/UploadedFile.ts
+var UploadedFile = class UploadedFile {
+	constructor(originalName, mimeType, size, content) {
+		this.originalName = originalName;
+		this.mimeType = mimeType;
+		this.size = size;
+		this.content = content;
+	}
+	static createFromBase(file) {
+		return new UploadedFile(file.name, file.type, file.size, file);
+	}
+	/**
+	* Save to disk (Node environment only)
+	*/
+	async moveTo(destination) {
+		await writeFile(destination, Buffer.from(await this.content.arrayBuffer()));
+	}
+};
+
+//#endregion
+//#region src/Bags/FileBag.ts
+/**
+* FileBag is a container for uploaded files
+* for Node/H3 environments.
+*/
+var FileBag = class extends ParamBag {
+	parameters = {};
+	constructor(parameters = {}, event) {
+		super(parameters, event);
+		this.replace(parameters);
+	}
+	/**
+	* Replace all stored files.
+	*/
+	replace(files = {}) {
+		this.parameters = {};
+		this.add(files);
+	}
+	/**
+	* Set a file or array of files.
+	*/
+	set(key, value) {
+		if (Array.isArray(value)) this.parameters[key] = value.map((v) => v ? this.convertFileInformation(v) : null).filter(Boolean);
+		else if (value) this.parameters[key] = this.convertFileInformation(value);
+		else this.parameters[key] = null;
+	}
+	/**
+	* Add multiple files.
+	*/
+	add(files = {}) {
+		for (const [key, file] of Object.entries(files)) this.set(key, file);
+	}
+	/**
+	* Get all stored files.
+	*/
+	all() {
+		return this.parameters;
+	}
+	/**
+	* Normalize file input into UploadedFile instances.
+	*/
+	convertFileInformation(file) {
+		if (!file) return null;
+		if (file instanceof UploadedFile) return file;
+		if (file instanceof File) return UploadedFile.createFromBase(file);
+		throw new TypeError("Invalid file input — expected File or UploadedFile instance.");
+	}
+};
+
+//#endregion
+//#region src/Bags/HeaderBag.ts
+/**
+* HeaderBag — A container for HTTP headers
+* for Node/H3 environments.
+*/
+var HeaderBag = class HeaderBag {
+	static UPPER = "_ABCDEFGHIJKLMNOPQRSTUVWXYZ";
+	static LOWER = "-abcdefghijklmnopqrstuvwxyz";
+	headers = {};
+	cacheControl = {};
+	constructor(headers = {}) {
+		for (const [key, values] of Object.entries(headers)) this.set(key, values);
+	}
+	/**
+	* Returns all headers as string (for debugging / toString) 
+	* 
+	* @returns 
+	*/
+	toString() {
+		const headers = this.all();
+		if (!Object.keys(headers).length) return "";
+		const sortedKeys = Object.keys(headers).sort();
+		const max = Math.max(...sortedKeys.map((k) => k.length)) + 1;
+		let content = "";
+		for (const name of sortedKeys) {
+			const values = headers[name] ?? [];
+			const displayName = name.split("-").map((p) => p.charAt(0).toUpperCase() + p.slice(1)).join("-");
+			for (const value of values) content += `${displayName + ":"}`.padEnd(max + 1, " ") + `${value ?? ""}\r\n`;
+		}
+		return content;
+	}
+	/**
+	* Returns all headers or specific header list
+	* 
+	* @param key 
+	* @returns 
+	*/
+	all(key) {
+		if (key !== void 0) return this.headers[this.normalizeKey(key)] ?? [];
+		return this.headers;
+	}
+	/**
+	* Returns header keys
+	* 
+	* @returns 
+	*/
+	keys() {
+		return Object.keys(this.headers);
+	}
+	/**
+	* Replace all headers with new set
+	* 
+	* @param headers 
+	*/
+	replace(headers = {}) {
+		this.headers = {};
+		this.add(headers);
+	}
+	/**
+	* Add multiple headers
+	* 
+	* @param headers 
+	*/
+	add(headers) {
+		for (const [key, values] of Object.entries(headers)) this.set(key, values);
+	}
+	/**
+	* Returns first header value by name or default
+	* 
+	* @param key 
+	* @param defaultValue 
+	* @returns 
+	*/
+	get(key, defaultValue = null) {
+		const headers = this.all(key);
+		if (!headers.length) return defaultValue;
+		return headers[0];
+	}
+	/**
+	* Sets a header by name.
+	* 
+	* @param replace Whether to replace existing values (default true)
+	*/
+	set(key, values, replace = true) {
+		const normalized = this.normalizeKey(key);
+		if (Array.isArray(values)) {
+			const valList = values.map((v) => v === void 0 ? null : v);
+			if (replace || !this.headers[normalized]) this.headers[normalized] = valList;
+			else this.headers[normalized].push(...valList);
+		} else {
+			const val = values === void 0 ? null : values;
+			if (replace || !this.headers[normalized]) this.headers[normalized] = [val];
+			else this.headers[normalized].push(val);
+		}
+		if (normalized === "cache-control") this.cacheControl = this.parseCacheControl((this.headers[normalized] ?? []).join(", "));
+	}
+	/**
+	* Returns true if header exists
+	* 
+	* @param key 
+	* @returns 
+	*/
+	has(key) {
+		return Object.prototype.hasOwnProperty.call(this.headers, this.normalizeKey(key));
+	}
+	/**
+	* Returns true if header contains value
+	* 
+	* @param key 
+	* @param value 
+	* @returns 
+	*/
+	contains(key, value) {
+		return this.all(key).includes(value);
+	}
+	/**
+	* Removes a header
+	* 
+	* @param key 
+	*/
+	remove(key) {
+		const normalized = this.normalizeKey(key);
+		delete this.headers[normalized];
+		if (normalized === "cache-control") this.cacheControl = {};
+	}
+	/**
+	* Returns parsed date from header
+	* 
+	* @param key 
+	* @param defaultValue 
+	* @returns 
+	*/
+	getDate(key, defaultValue = null) {
+		const value = this.get(key);
+		if (!value) return defaultValue ? new Date(defaultValue) : null;
+		const parsed = new Date(value);
+		if (isNaN(parsed.getTime())) throw new Error(`The "${key}" HTTP header is not parseable (${value}).`);
+		return parsed;
+	}
+	/**
+	* Adds a Cache-Control directive
+	* 
+	* @param key 
+	* @param value 
+	*/
+	addCacheControlDirective(key, value = true) {
+		this.cacheControl[key] = value;
+		this.set("Cache-Control", this.getCacheControlHeader());
+	}
+	/**
+	* Returns true if Cache-Control directive is defined
+	* 
+	* @param key 
+	* @returns 
+	*/
+	hasCacheControlDirective(key) {
+		return Object.prototype.hasOwnProperty.call(this.cacheControl, key);
+	}
+	/**
+	* Returns a Cache-Control directive value by name
+	* 
+	* @param key 
+	* @returns 
+	*/
+	getCacheControlDirective(key) {
+		return this.cacheControl[key] ?? null;
+	}
+	/**
+	* Removes a Cache-Control directive
+	* 
+	* @param key 
+	* @returns 
+	*/
+	removeCacheControlDirective(key) {
+		delete this.cacheControl[key];
+		this.set("Cache-Control", this.getCacheControlHeader());
+	}
+	/**
+	* Number of headers
+	* 
+	* @param key 
+	* @returns 
+	*/
+	count() {
+		return Object.keys(this.headers).length;
+	}
+	/**
+	* Normalize header name to lowercase with hyphens
+	* 
+	* @param key 
+	* @returns 
+	*/
+	normalizeKey(key) {
+		return key.replace(/[A-Z_]/g, (ch) => {
+			const idx = HeaderBag.UPPER.indexOf(ch);
+			return idx === -1 ? ch : HeaderBag.LOWER[idx];
+		}).toLowerCase();
+	}
+	/**
+	* Generates Cache-Control header string
+	* 
+	* @param header 
+	* @returns 
+	*/
+	getCacheControlHeader() {
+		return Object.entries(this.cacheControl).sort(([a$1], [b]) => a$1.localeCompare(b)).map(([k, v]) => v === true ? k : v === false ? "" : `${k}=${v}`).filter(Boolean).join(", ");
+	}
+	/**
+	* Parses Cache-Control header
+	* 
+	* @param header 
+	* @returns 
+	*/
+	parseCacheControl(header) {
+		const directives = {};
+		const parts = header.split(",").map((p) => p.trim()).filter(Boolean);
+		for (const part of parts) {
+			const [key, val] = part.split("=", 2);
+			directives[key.trim()] = val !== void 0 ? val.trim() : true;
+		}
+		return directives;
+	}
+	/**
+	* Iterator support
+	* @returns 
+	*/
+	[Symbol.iterator]() {
+		return Object.entries(this.headers)[Symbol.iterator]();
+	}
+};
+
+//#endregion
+//#region src/Bags/InputBag.ts
+/**
+* InputBag is a container for user input values
+* (e.g., query params, body, cookies)
+* for Node/H3 environments.
+*/
+var InputBag = class extends ParamBag {
+	constructor(inputs = {}, event) {
+		super(inputs, event);
+		this.add(inputs);
+	}
+	/**
+	* Returns a scalar input value by name.
+	*
+	* @param key 
+	* @param defaultValue 
+	* @throws BadRequestException if the input contains a non-scalar value
+	* @returns 
+	*/
+	get(key, defaultValue = null) {
+		if (defaultValue !== null && typeof defaultValue !== "string" && typeof defaultValue !== "number" && typeof defaultValue !== "boolean") throw new TypeError(`Expected a scalar value as 2nd argument to get(), got ${typeof defaultValue}`);
+		const value = Obj.get(this.parameters, key, defaultValue);
+		if (value !== null && typeof value !== "string" && typeof value !== "number" && typeof value !== "boolean") throw new BadRequestException(`Input value "${key}" contains a non-scalar value.`);
+		return value;
+	}
+	/**
+	* Replaces all current input values.
+	* 
+	* @param inputs 
+	* @returns
+	*/
+	replace(inputs = {}) {
+		this.parameters = {};
+		this.add(inputs);
+	}
+	/**
+	* Adds multiple input values.
+	* 
+	* @param inputs 
+	* @returns
+	*/
+	add(inputs = {}) {
+		Object.entries(inputs).forEach(([key, value]) => this.set(key, value));
+	}
+	/**
+	* Sets an input by name.
+	*
+	* @param key 
+	* @param value 
+	* @throws TypeError if value is not scalar or array
+	* @returns
+	*/
+	set(key, value) {
+		if (value !== null && typeof value !== "string" && typeof value !== "number" && typeof value !== "boolean" && !Array.isArray(value) && typeof value !== "object") throw new TypeError(`Expected scalar, array, object, or null as value for set(), got ${typeof value}`);
+		this.parameters[key] = value;
+	}
+	/**
+	* Returns true if a key exists.
+	* 
+	* @param key 
+	* @returns
+	*/
+	has(key) {
+		return Object.prototype.hasOwnProperty.call(this.parameters, key);
+	}
+	/**
+	* Returns all parameters.
+	* 
+	* @returns
+	*/
+	all() {
+		return { ...this.parameters };
+	}
+	/**
+	* Converts a parameter value to string.
+	*
+	* @param key 
+	* @param defaultValue 
+	* @throws BadRequestException if input contains a non-scalar value
+	* @returns
+	*/
+	getString(key, defaultValue = "") {
+		const value = this.get(key, defaultValue);
+		return String(value ?? "");
+	}
+	/**
+	* Filters input value with a predicate.
+	* Mimics PHP’s filter_var() in spirit, but simpler.
+	*
+	* @param key 
+	* @param defaultValue 
+	* @param filterFn 
+	* @throws BadRequestException if validation fails
+	* @returns 
+	*/
+	filter(key, defaultValue = null, filterFn) {
+		const value = this.has(key) ? this.parameters[key] : defaultValue;
+		if (Array.isArray(value)) throw new BadRequestException(`Input value "${key}" contains an array, but array filtering not allowed.`);
+		if (filterFn && !filterFn(value)) throw new BadRequestException(`Input value "${key}" is invalid and did not pass filter.`);
+		return value;
+	}
+	/**
+	* Returns an enum value by key.
+	*
+	* @param key 
+	* @param EnumClass 
+	* @param defaultValue 
+	* @throws BadRequestException if conversion fails
+	* @returns 
+	*/
+	getEnum(key, EnumClass, defaultValue = null) {
+		const value = this.get(key, defaultValue);
+		if (value === null) return defaultValue;
+		if (!Object.values(EnumClass).includes(value)) throw new BadRequestException(`Input "${key}" cannot be converted to enum.`);
+		return value;
+	}
+	/**
+	* Removes a key.
+	*
+	* @param key 
+	*/
+	remove(key) {
+		delete this.parameters[key];
+	}
+	/**
+	* Returns all keys.
+	* 
+	* @returns
+	*/
+	keys() {
+		return Object.keys(this.parameters);
+	}
+	/**
+	* Returns number of parameters.
+	* 
+	* @returns
+	*/
+	count() {
+		return this.keys().length;
+	}
+};
+
+//#endregion
+//#region src/Bags/ServerBag.ts
+/**
+* ServerBag — a simplified version of Symfony's ServerBag
+* for Node/H3 environments.
+*
+* Responsible for extracting and normalizing HTTP headers
+* from the incoming request.
+*/
+var ServerBag = class extends ParamBag {
+	constructor(parameters = {}, event) {
+		super(Object.fromEntries(Object.entries(parameters).map(([k, v]) => [k.toLowerCase(), v])), event);
+	}
+	/**
+	* Returns all request headers, normalized to uppercase with underscores.
+	* Example: content-type → CONTENT_TYPE
+	*/
+	getHeaders() {
+		const headers = {};
+		for (const [key, value] of Object.entries(this.parameters)) {
+			if (value === void 0 || value === "") continue;
+			switch (key) {
+				case "accept":
+				case "content-type":
+				case "content-length":
+				case "content-md5":
+				case "authorization":
+					headers[key.toUpperCase().replace(/-/g, "_")] = value;
+					break;
+				default: headers[`HTTP_${key.toUpperCase().replace(/-/g, "_")}`] = value;
+			}
+		}
+		if (headers["HTTP_AUTHORIZATION"] || headers["AUTHORIZATION"]) {
+			const auth = headers["HTTP_AUTHORIZATION"] || headers["AUTHORIZATION"] || "";
+			if (auth.toLowerCase().startsWith("basic ")) {
+				const [user, pass] = Buffer.from(auth.slice(6), "base64").toString().split(":", 2);
+				headers["AUTH_TYPE"] = "Basic";
+				headers["AUTH_USER"] = user;
+				headers["AUTH_PASS"] = pass;
+			} else if (auth.toLowerCase().startsWith("bearer ")) {
+				headers["AUTH_TYPE"] = "Bearer";
+				headers["AUTH_TOKEN"] = auth.slice(7);
+			} else if (auth.toLowerCase().startsWith("digest ")) {
+				headers["AUTH_TYPE"] = "Digest";
+				headers["AUTH_DIGEST"] = auth;
+			}
+		}
+		return headers;
+	}
+	/**
+	* Returns a specific header by name, case-insensitive.
+	*/
+	get(name) {
+		return this.parameters[name.toLowerCase()];
+	}
+	/**
+	* Returns true if a header exists.
+	*/
+	has(name) {
+		return name.toLowerCase() in this.parameters;
+	}
+};
+
+//#endregion
 //#region ../../node_modules/.pnpm/is-plain-obj@4.1.0/node_modules/is-plain-obj/index.js
 function isPlainObject(value) {
 	if (typeof value !== "object" || value === null) return false;
@@ -10227,8 +10917,8 @@ var require_graceful_fs = /* @__PURE__ */ __commonJS({ "../../node_modules/.pnpm
 			}
 		}
 		var fs$writeFile = fs$9.writeFile;
-		fs$9.writeFile = writeFile;
-		function writeFile(path$12, data, options, cb) {
+		fs$9.writeFile = writeFile$1;
+		function writeFile$1(path$12, data, options, cb) {
 			if (typeof options === "function") cb = options, options = null;
 			return go$writeFile(path$12, data, options, cb);
 			function go$writeFile(path$13, data$1, options$1, cb$1, startTime) {
@@ -18039,7 +18729,7 @@ var require_dumper = /* @__PURE__ */ __commonJS({ "../../node_modules/.pnpm/js-y
 			}
 		}
 	}
-	function dump(input, options) {
+	function dump$1(input, options) {
 		options = options || {};
 		var state = new State(options);
 		if (!state.noRefs) getDuplicateReferences(input, state);
@@ -18047,9 +18737,9 @@ var require_dumper = /* @__PURE__ */ __commonJS({ "../../node_modules/.pnpm/js-y
 		return "";
 	}
 	function safeDump(input, options) {
-		return dump(input, common.extend({ schema: DEFAULT_SAFE_SCHEMA }, options));
+		return dump$1(input, common.extend({ schema: DEFAULT_SAFE_SCHEMA }, options));
 	}
-	module.exports.dump = dump;
+	module.exports.dump = dump$1;
 	module.exports.safeDump = safeDump;
 }) });
 
@@ -18260,6 +18950,68 @@ var FireCommand = class extends Command {
 	}
 };
 
+//#endregion
+//#region src/Exceptions/SuspiciousOperationException.ts
+var SuspiciousOperationException = class extends Error {
+	constructor(message) {
+		super(message);
+		this.name = "SuspiciousOperationException";
+	}
+};
+
+//#endregion
+//#region src/FormRequest.ts
+var FormRequest = class {
+	dataset;
+	constructor(data) {
+		this.initialize(data);
+	}
+	/**
+	* Initialize the data
+	* @param data 
+	*/
+	initialize(data) {
+		this.dataset = {
+			files: {},
+			input: {}
+		};
+		for (const [rawKey, value] of data.entries()) {
+			const key = rawKey.endsWith("[]") ? rawKey.slice(0, -2) : rawKey;
+			if (value instanceof File) {
+				const uploaded = value instanceof UploadedFile ? value : UploadedFile.createFromBase(value);
+				if (this.dataset.files[key]) {
+					const existing = this.dataset.files[key];
+					if (Array.isArray(existing)) existing.push(uploaded);
+					else this.dataset.files[key] = [existing, uploaded];
+				} else this.dataset.files[key] = uploaded;
+			} else if (this.dataset.input[key]) {
+				const existing = this.dataset.input[key];
+				if (Array.isArray(existing)) existing.push(value);
+				else this.dataset.input[key] = [existing, value];
+			} else this.dataset.input[key] = value;
+		}
+	}
+	/**
+	* Get all uploaded files
+	*/
+	files() {
+		return this.dataset.files;
+	}
+	/**
+	* Get all input fields
+	*/
+	input() {
+		return this.dataset.input;
+	}
+	/**
+	* Get combined input and files
+	* File entries take precedence if names overlap.
+	*/
+	all() {
+		return Object.assign({}, this.dataset.input, this.dataset.files);
+	}
+};
+
 //#endregion
 //#region src/Middleware.ts
 var Middleware = class {};
@@ -18306,50 +19058,586 @@ var HttpServiceProvider = class {
 
 //#endregion
 //#region src/Request.ts
-var Request = class {
+var Request = class Request {
+	/**
+	* Parsed request body
+	*/
+	body;
+	/**
+	* The decoded JSON content for the request.
+	*/
+	#json;
+	#uri;
+	#method = void 0;
 	/**
 	* Gets route parameters.
 	* @returns An object containing route parameters.
 	*/
 	params;
 	/**
-	* Gets query parameters.
-	* @returns An object containing query parameters.
+	* All of the converted files for the request.
+	*/
+	convertedFiles;
+	/**
+	* Form data from incoming request.
+	* @returns The FormRequest object.
+	*/
+	formData;
+	/**
+	* Request body parameters (POST).
+	*
+	* @see getPayload() for portability between content types
+	*/
+	request;
+	/**
+	* Query string parameters (GET).
 	*/
 	query;
 	/**
+	* Uploaded files (FILES).
+	*/
+	files;
+	/**
+	* Server and execution environment parameters
+	*/
+	server;
+	/**
+	* Cookies
+	*/
+	cookies;
+	/**
+	* The request attributes (parameters parsed from the PATH_INFO, ...).
+	*/
+	attributes;
+	/**
 	* Gets the request headers.
 	* @returns An object containing request headers.
 	*/
 	headers;
+	content = void 0;
+	static formats = void 0;
+	static httpMethodParameterOverride = false;
 	/**
-	* The current H3 H3Event instance
+	* List of Acceptable Content Types
 	*/
-	event;
+	acceptableContentTypes = [];
 	constructor(event, app) {
-		this.app = app;
 		this.event = event;
-		this.query = getQuery(this.event);
+		this.app = app;
+	}
+	/**
+	* Factory method to create a Request instance from an H3Event.
+	*/
+	static async create(event, app) {
+		const instance = new Request(event, app);
+		await instance.setBody();
+		await instance.initialize();
+		globalThis.request = () => instance;
+		return instance;
+	}
+	/**
+	* Sets the parameters for this request.
+	*
+	* This method also re-initializes all properties.
+	*
+	* @param attributes 
+	* @param cookies    The COOKIE parameters
+	* @param files      The FILES parameters
+	* @param server     The SERVER parameters
+	* @param content    The raw body data
+	*/
+	async initialize() {
 		this.params = getRouterParams(this.event);
-		this.headers = this.event.req.headers;
+		this.request = new InputBag(this.formData ? this.formData.input() : {}, this.event);
+		this.query = new InputBag(getQuery(this.event), this.event);
+		this.attributes = new ParamBag(getRouterParams(this.event), this.event);
+		this.cookies = new InputBag(parseCookies(this.event), this.event);
+		this.files = new FileBag(this.formData ? this.formData.files() : {}, this.event);
+		this.server = new ServerBag(Object.fromEntries(this.event.req.headers.entries()), this.event);
+		this.headers = new HeaderBag(this.server.getHeaders());
+		this.acceptableContentTypes = [];
+		this.#method = void 0;
+		this.#uri = (await import(String("@h3ravel/url"))).Url.of(getRequestURL(this.event).toString(), this.app);
+	}
+	async setBody() {
+		const type = this.event.req.headers.get("content-type") || "";
+		if (this.body) return;
+		if (type.includes("application/json")) {
+			this.body = await this.event.req.json().catch(() => ({}));
+			this.content = this.body;
+		} else if (type.includes("form-data") || type.includes("x-www-form-urlencoded")) {
+			this.formData = new FormRequest(await this.event.req.formData());
+			this.body = this.formData.all();
+			this.content = JSON.stringify(this.formData.input());
+		} else if (type.startsWith("text/")) {
+			this.body = await this.event.req.text();
+			this.content = this.body;
+		} else {
+			const content = this.event.req.body;
+			this.content = content;
+			if (content instanceof ReadableStream) {
+				const reader = content.getReader();
+				const chunks = [];
+				let done = false;
+				while (!done) {
+					const { value, done: isDone } = await reader.read();
+					if (value) chunks.push(value);
+					done = isDone;
+				}
+				this.body = new TextDecoder().decode(new Uint8Array(chunks.flatMap((chunk) => Array.from(chunk))));
+			} else this.body = content;
+		}
+	}
+	/**
+	* Retrieve all data from the instance (query + body).
+	*/
+	all(keys) {
+		const input = Obj.deepMerge({}, this.input(), this.allFiles());
+		if (!keys) return input;
+		const results = {};
+		const list = Array.isArray(keys) ? keys : [keys];
+		for (const key of list) data_set(results, key, Obj.get(input, key));
+		return results;
 	}
 	/**
-	* Get all input data (query + body).
+	* Retrieve an input item from the request.
+	* 
+	* @param key 
+	* @param defaultValue 
+	* @returns 
 	*/
-	async all() {
-		let data = {
-			...getRouterParams(this.event),
-			...getQuery(this.event)
+	input(key, defaultValue) {
+		const source = {
+			...this.getInputSource().all(),
+			...this.query.all()
 		};
-		if (this.event.req.method === "POST") data = Object.assign({}, data, Object.fromEntries((await this.event.req.formData()).entries()));
-		else if (this.event.req.method === "PUT") data = Object.fromEntries(Object.entries(await readBody(this.event)));
-		return data;
+		return key ? data_get(source, key, defaultValue) : Arr.except(source, ["_method"]);
+	}
+	/**
+	* Retrieve a file from the request.
+	*
+	* @param key
+	* @param defaultValue
+	* @returns
+	*/
+	file(key, defaultValue) {
+		const source = this.allFiles();
+		return key ? data_get(source, key, defaultValue) : source;
+	}
+	/**
+	* Get an array of all of the files on the request.
+	*/
+	allFiles() {
+		if (this.convertedFiles) return this.convertedFiles;
+		const entries = Object.entries(this.files.all()).filter((e) => e[1] != null);
+		const files = Object.fromEntries(entries);
+		this.convertedFiles = this.convertUploadedFiles(files);
+		return this.convertedFiles;
+	}
+	/**
+	* Extract and convert uploaded files from FormData.
+	*/
+	convertUploadedFiles(files) {
+		if (!this.formData) return files;
+		for (const [key, value] of Object.entries(this.formData.files())) {
+			if (!(value instanceof File)) continue;
+			if (key.endsWith("[]")) {
+				const normalizedKey = key.slice(0, -2);
+				if (!files[normalizedKey]) files[normalizedKey] = [];
+				files[normalizedKey].push(UploadedFile.createFromBase(value));
+			} else files[key] = UploadedFile.createFromBase(value);
+		}
+		return files;
+	}
+	/**
+	* Determine if the data contains a given key.
+	* 
+	* @param keys 
+	* @returns 
+	*/
+	has(keys) {
+		return Obj.has(this.all(), keys);
+	}
+	/**
+	* Determine if the instance is missing a given key.
+	*/
+	missing(key) {
+		const keys = Array.isArray(key) ? key : [key];
+		return !this.has(keys);
+	}
+	/**
+	* Get a subset containing the provided keys with values from the instance data.
+	* 
+	* @param keys 
+	* @returns 
+	*/
+	only(keys) {
+		const data = Object.entries(this.all()).filter(([key]) => keys.includes(key));
+		return Object.fromEntries(data);
+	}
+	/**
+	* Get all of the data except for a specified array of items.
+	* 
+	* @param keys 
+	* @returns 
+	*/
+	except(keys) {
+		const data = Object.entries(this.all()).filter(([key]) => !keys.includes(key));
+		return Object.fromEntries(data);
 	}
 	/**
-	* Get a single input field from query or body.
+	* Merges new input data into the current request's input source.
+	*
+	* @param input - An object containing key-value pairs to merge.
+	* @returns this - For fluent chaining.
 	*/
-	async input(key, defaultValue) {
-		return (await this.all())[key] ?? defaultValue;
+	merge(input) {
+		const source = this.getInputSource();
+		for (const [key, value] of Object.entries(input)) source.set(key, value);
+		return this;
+	}
+	/**
+	* Merge new input into the request's input, but only when that key is missing from the request.
+	*
+	* @param input
+	*/
+	mergeIfMissing(input) {
+		return this.merge(Object.fromEntries(Object.entries(input).filter(([key]) => this.missing(key))));
+	}
+	/**
+	* Get the keys for all of the input and files.
+	*/
+	keys() {
+		return [...Object.keys(this.input()), ...this.files.keys()];
+	}
+	/**
+	* Determine if the request is sending JSON.
+	*
+	* @return bool
+	*/
+	isJson() {
+		return Str.contains(this.getHeader("CONTENT_TYPE") ?? "", ["/json", "+json"]);
+	}
+	/**
+	* Determine if the current request probably expects a JSON response.
+	* 
+	* @returns 
+	*/
+	expectsJson() {
+		return Str.contains(this.getHeader("Accept") ?? "", "application/json");
+	}
+	/**
+	* Determine if the current request is asking for JSON.
+	* 
+	* @returns 
+	*/
+	wantsJson() {
+		const acceptable = this.getAcceptableContentTypes();
+		return !!acceptable[0] && Str.contains(acceptable[0].toLowerCase(), ["/json", "+json"]);
+	}
+	/**
+	* Gets a list of content types acceptable by the client browser in preferable order.
+	* @returns {string[]}
+	*/
+	getAcceptableContentTypes() {
+		if (this.acceptableContentTypes.length > 0) return this.acceptableContentTypes;
+		const accept = this.getHeader("accept");
+		if (!accept) return [];
+		return this.acceptableContentTypes = accept.split(",").map((type) => type.trim()).map((type) => type.split(";")[0]).filter(Boolean);
+	}
+	/**
+	* Determine if the request is the result of a PJAX call.
+	*
+	* @return bool
+	*/
+	pjax() {
+		return this.headers.get("X-PJAX") == true;
+	}
+	/**
+	* Returns true if the request is an XMLHttpRequest (AJAX).
+	* 
+	* @alias isXmlHttpRequest()
+	* @returns {boolean}
+	*/
+	ajax() {
+		return this.isXmlHttpRequest();
+	}
+	/**
+	* Returns true if the request is an XMLHttpRequest (AJAX).
+	*/
+	isXmlHttpRequest() {
+		return "XMLHttpRequest" === this.getHeader("X-Requested-With");
+	}
+	/**
+	* Returns the value of the requested header.
+	*/
+	getHeader(name) {
+		return this.headers.get(name);
+	}
+	/**
+	* Checks if the request method is of specified type.
+	*
+	* @param method Uppercase request method (GET, POST etc)
+	*/
+	isMethod(method) {
+		return this.getMethod() === method.toUpperCase();
+	}
+	/**
+	* Checks whether or not the method is safe.
+	*
+	* @see https://tools.ietf.org/html/rfc7231#section-4.2.1
+	*/
+	isMethodSafe() {
+		return [
+			"GET",
+			"HEAD",
+			"OPTIONS",
+			"TRACE"
+		].includes(this.getMethod());
+	}
+	/**
+	* Checks whether or not the method is idempotent.
+	*/
+	isMethodIdempotent() {
+		return [
+			"HEAD",
+			"GET",
+			"PUT",
+			"DELETE",
+			"TRACE",
+			"OPTIONS",
+			"PURGE"
+		].includes(this.getMethod());
+	}
+	/**
+	* Checks whether the method is cacheable or not.
+	*
+	* @see https://tools.ietf.org/html/rfc7231#section-4.2.3
+	*/
+	isMethodCacheable() {
+		return ["GET", "HEAD"].includes(this.getMethod());
+	}
+	/**
+	* Initializes HTTP request formats.
+	*/
+	static initializeFormats() {
+		this.formats = {
+			html: ["text/html", "application/xhtml+xml"],
+			txt: ["text/plain"],
+			js: [
+				"application/javascript",
+				"application/x-javascript",
+				"text/javascript"
+			],
+			css: ["text/css"],
+			json: ["application/json", "application/x-json"],
+			jsonld: ["application/ld+json"],
+			xml: [
+				"text/xml",
+				"application/xml",
+				"application/x-xml"
+			],
+			rdf: ["application/rdf+xml"],
+			atom: ["application/atom+xml"],
+			rss: ["application/rss+xml"],
+			form: ["application/x-www-form-urlencoded", "multipart/form-data"]
+		};
+	}
+	/**
+	* Gets the request "intended" method.
+	*
+	* If the X-HTTP-Method-Override header is set, and if the method is a POST,
+	* then it is used to determine the "real" intended HTTP method.
+	*
+	* The _method request parameter can also be used to determine the HTTP method,
+	* but only if enableHttpMethodParameterOverride() has been called.
+	*
+	* The method is always an uppercased string.
+	*
+	* @see getRealMethod()
+	*/
+	getMethod() {
+		if (this.#method) return this.#method;
+		this.#method = this.getRealMethod();
+		if ("POST" !== this.#method) return this.#method;
+		let method = this.event.req.headers.get("X-HTTP-METHOD-OVERRIDE");
+		if (!method && Request.httpMethodParameterOverride) method = this.request.get("_method", this.query.get("_method", "POST"));
+		if (typeof method !== "string") return this.#method;
+		method = method.toUpperCase();
+		if ([
+			"GET",
+			"HEAD",
+			"POST",
+			"PUT",
+			"DELETE",
+			"CONNECT",
+			"OPTIONS",
+			"PATCH",
+			"PURGE",
+			"TRACE"
+		].includes(method)) {
+			this.#method = method;
+			return this.#method;
+		}
+		if (!/^[A-Z]+$/.test(method)) throw new SuspiciousOperationException("Invalid HTTP method override.");
+		this.#method = method;
+		return this.#method;
+	}
+	/**
+	* Gets the "real" request method.
+	*
+	* @see getMethod()
+	*/
+	getRealMethod() {
+		return this.event.req.method.toUpperCase();
+	}
+	/**
+	* Get the client IP address.
+	*/
+	ip() {
+		return getRequestIP(this.event);
+	}
+	/**
+	* Get a URI instance for the request.
+	*/
+	uri() {
+		return this.#uri;
+	}
+	/**
+	* Get the full URL for the request. 
+	*/
+	fullUrl() {
+		return this.event.req.url;
+	}
+	/**
+	* Return the Request instance.
+	*/
+	instance() {
+		return this;
+	}
+	/**
+	* Get the request method.
+	*/
+	method() {
+		return this.getMethod();
+	}
+	/**
+	* Get the JSON payload for the request.
+	*
+	* @param  key
+	* @param  defaultValue
+	* @return {InputBag}
+	*/
+	json(key, defaultValue) {
+		if (!this.#json) {
+			let json = this.getContent();
+			if (typeof json == "string") json = JSON.parse(json || "{}");
+			this.#json = new InputBag(json, this.event);
+		}
+		if (!key) return this.#json;
+		return Obj.get(this.#json.all(), key, defaultValue);
+	}
+	/**
+	* Get the input source for the request.
+	*
+	* @return {InputBag}
+	*/
+	getInputSource() {
+		if (this.isJson()) return this.json();
+		return ["GET", "HEAD"].includes(this.getRealMethod()) ? this.query : this.request;
+	}
+	/**
+	* Returns the request body content.
+	*
+	* @param asStream If true, returns a ReadableStream instead of the parsed string
+	* @return {string | ReadableStream | Promise<string | ReadableStream>}
+	*/
+	getContent(asStream = false) {
+		let content = this.body;
+		if (content !== void 0 && content !== null) {
+			if (asStream) {
+				if (content instanceof ReadableStream) return content;
+				const encoder = new TextEncoder();
+				return new ReadableStream({ start(controller) {
+					controller.enqueue(encoder.encode(String(content)));
+					controller.close();
+				} });
+			}
+			if (typeof content === "string") return content;
+		}
+		if (asStream) return this.content;
+		content = this.content;
+		this.body = content;
+		return content;
+	}
+	/**
+	* Determine if the uploaded data contains a file.
+	*
+	* @param  key
+	* @return boolean
+	*/
+	hasFile(key) {
+		let files = this.file(key);
+		if (!Array.isArray(files)) files = [files];
+		return files.some((e) => this.isValidFile(e));
+	}
+	/**
+	* Check that the given file is a valid file instance.
+	*
+	* @param file
+	* @return boolean
+	*/
+	isValidFile(file) {
+		return file.content instanceof File && file.size > 0;
+	}
+	/**
+	* Gets a "parameter" value from any bag.
+	*
+	* This method is mainly useful for libraries that want to provide some flexibility. If you don't need the
+	* flexibility in controllers, it is better to explicitly get request parameters from the appropriate
+	* public property instead (attributes, query, request).
+	*
+	* Order of precedence: PATH (routing placeholders or custom attributes), GET, POST
+	*
+	* @internal use explicit input sources instead
+	*/
+	get(key, defaultValue) {
+		const result = this.attributes.get(key, this);
+		if (this !== result) return result;
+		if (this.query.has(key)) return this.query.all()[key];
+		if (this.request.has(key)) return this.request.all()[key];
+		return defaultValue;
+	}
+	/**
+	* Enables support for the _method request parameter to determine the intended HTTP method.
+	*
+	* Be warned that enabling this feature might lead to CSRF issues in your code.
+	* Check that you are using CSRF tokens when required.
+	* If the HTTP method parameter override is enabled, an html-form with method "POST" can be altered
+	* and used to send a "PUT" or "DELETE" request via the _method request parameter.
+	* If these methods are not protected against CSRF, this presents a possible vulnerability.
+	*
+	* The HTTP method can only be overridden when the real HTTP method is POST.
+	*/
+	static enableHttpMethodParameterOverride() {
+		this.httpMethodParameterOverride = true;
+	}
+	/**
+	* Checks whether support for the _method request parameter is enabled.
+	*/
+	static getHttpMethodParameterOverride() {
+		return this.httpMethodParameterOverride;
+	}
+	/**
+	* Dump the items.
+	*
+	* @param  keys
+	* @return this
+	*/
+	dump(...keys) {
+		if (keys.length > 0) this.only(keys).then(dump);
+		else this.all().then(dump);
+		return this;
 	}
 	getEvent(key) {
 		return safeDot(this.event, key);
@@ -18534,7 +19822,7 @@ var Response = class {
 	}
 	html(content) {
 		this.applyHeaders();
-		return html(this.event, content);
+		return html(content);
 	}
 	/**
 	* Send a JSON response.
@@ -18555,9 +19843,9 @@ var Response = class {
 	/**
 	* Redirect to another URL.
 	*/
-	redirect(url, status = 302) {
+	redirect(location, status = 302, statusText) {
 		this.setStatusCode(status);
-		return redirect(this.event, url, this.statusCode);
+		return redirect(location, this.statusCode, statusText);
 	}
 	/**
 	* Apply headers before sending response.
@@ -18573,4 +19861,4 @@ var Response = class {
 };
 
 //#endregion
-export { ApiResource, FireCommand, HttpContext, HttpServiceProvider, JsonResource, LogRequests, Middleware, Request, Response };
+export { ApiResource, BadRequestException, FileBag, FireCommand, FormRequest, HeaderBag, HttpContext, HttpServiceProvider, InputBag, JsonResource, LogRequests, Middleware, ParamBag, Request, Response, ServerBag, SuspiciousOperationException, UnexpectedValueException, UploadedFile };