aRequest

MMO\core\classes · 1 symbol · generated 30 Sep 2026

class

aRequest

Base implementation of PSR-7's (Server)RequestInterface (Request /

abstract class MMO\core\classes\aRequest extends MMO\core\classes\aMessage implements MMO\core\interfaces\iRequest, JsonSerializable, Stringable

Namespace: MMO\core\classes
Extends: aMessage
Implements: iRequest, JsonSerializable, Stringable
See: ShellRequest extend this) -- generic enough to represent an HTTP request or a CLI invocation ("request" in the framework's routing sense, either way). Immutable like aMessage: every with*() method returns a clone, leaving the original untouched.

$req = new Request('GET', 'https://example.com/foo'); $req2 = $req->withUri(Uri::Immutable('https://other.com/bar')); // $req2 !== $req; Host header synced to 'other.com'

Index

	attributes
	body
	target
	uri
	debugName()
	getAttribute($name, $default)	Retrieve a single derived request attribute.
	getAttributes()	Retrieve attributes derived from the request.
	getHeader($name)
	getParsedBody()	Retrieve any parameters provided in the request body.
	getRequestTarget()	Retrieves the message's request target.
	getServerParams()	Retrieve server parameters.
	getUri($mutable)	Retrieves the URI instance.
	hasHeader($name)
	HeaderName($name) static	The name of the header php's `$_SERVER` calls $name -- the way a web server hands php a request's headers: `HTTP_X_CSRF_TOKEN` is `X-Csrf-Token`, `CONTENT_TYPE` is `Content-Type`.
	setHeader($name, $value)
	setUri($uri, $preserveHost)
	unsetHeader($name)
	withAttribute($name, $value)	Return an instance with the specified derived request attribute.
	withAttributes($attrs)	Return an instance with several derived request attributes set at once (merged via
	withoutAttribute($name)	Return an instance that removes the specified derived request attribute.
	withParsedBody($data)	Return an instance with the specified body parameters.
	withRequestTarget($requestTarget)	Return an instance with the specific request-target.
	withUri($uri, $preserveHost)	Returns an instance with the provided URI.
	__clone()
	__construct($uri, $headers)
	__toString()

Properties4

attributes

protected array $attributes = []

Type: array

body

protected MMO\core\interfaces\iArray|array|null $body

Type: iArray | array | null

target

protected ?string $target = null

Type: null | string

uri

protected MMO\core\helpers\Uri $uri

Type: Uri

Methods22

debugName()

aRequest.php:40

function debugName()

returns

a short identifier for logs, e.g. '(Request)GET|https://example.com/foo'

getAttribute($name, $default)

aRequest.php:301

Retrieve a single derived request attribute.

function getAttribute(string $name, mixed $default = null): mixed

Retrieves a single derived request attribute as described in getAttributes(). If the attribute has not been previously set, returns the default value as provided. This method obviates the need for a hasAttribute() method, as it allows specifying a default value to return if the attribute is not found.

See: getAttributes()

$name	string	The attribute name.
$default = null	mixed	Default value to return if the attribute does not exist.
returns	mixed

$req->getAttribute('user', null);

getAttributes()

aRequest.php:281

Retrieve attributes derived from the request.

function getAttributes(): array

The request "attributes" may be used to allow injection of any parameters derived from the request: e.g., the results of path match operations; the results of decrypting cookies; the results of deserializing non-form-encoded message bodies; etc. Attributes will be application and request specific, and CAN be mutable.

returns

array

Attributes derived from the request.

$req->getAttributes(); // e.g. ['controller' => $controller, 'user' => $user]

getHeader($name)

aRequest.php:106

function getHeader(string $name): array

See: tWithHeaders::getHeader, by php's name of the header too (HeaderName)

$name	string
returns	array

$request->getHeader('If-None-Match'); // what `$_SERVER['HTTP_IF_NONE_MATCH']` has, on a request of the server

getParsedBody()

aRequest.php:228

Retrieve any parameters provided in the request body.

function getParsedBody(): ArrayAccess|array|null

If the request Content-Type is either application/x-www-form-urlencoded or multipart/form-data, and the request method is POST, this method MUST return the contents of $_POST. Otherwise, this method may return any results of deserializing the request body content; as parsing returns structured content, the potential types MUST be arrays or objects only. A null value indicates the absence of body content.

returns

ArrayAccess | array | null

The deserialized body parameters, if any. These will typically be an array or object.

$req->getParsedBody(); // e.g. ['name' => 'value'], or null if nothing was parsed

getRequestTarget()

aRequest.php:129

Retrieves the message's request target.

function getRequestTarget(): string

Retrieves the message's request-target either as it will appear (for clients), as it appeared at request (for servers), or as it was specified for the instance (see withRequestTarget()). In most cases, this will be the origin-form of the composed URI, unless a value was provided to the concrete implementation (see withRequestTarget() below). If no URI is available, and no request-target has been specifically provided, this method MUST return the string "/".

returns

string

$req->getRequestTarget(); // e.g. '/foo?x=1', derived from the URI, unless withRequestTarget() was used

getServerParams()

aRequest.php:374

Retrieve server parameters.

function getServerParams(): array

Retrieves data related to the incoming request environment, typically derived from PHP's $_SERVER superglobal. The data IS NOT REQUIRED to originate from $_SERVER.

returns

array

$req->getServerParams(); // $_SERVER

getUri($mutable)

aRequest.php:168

Retrieves the URI instance.

function getUri(bool $mutable = false): Psr\Http\Message\UriInterface

This method MUST return a UriInterface instance.

$mutable = false	bool	if true, return a mutable clone of the URI instead of the shared immutable one
returns	`UriInterface`	Returns a UriInterface instance representing the URI of the request.

$req->getUri(); // the request's Uri instance

hasHeader($name)

aRequest.php:98

function hasHeader(string $name): bool

See: tWithHeaders::hasHeader, by php's name of the header too (HeaderName)

$name	string
returns	bool

HeaderName($name)

staticaRequest.php:78

The name of the header php's $_SERVER calls $name -- the way a web server hands php a request's headers: HTTP_X_CSRF_TOKEN is X-Csrf-Token, CONTENT_TYPE is Content-Type. Any other name is returned as it is.

static function HeaderName(string $name): string

A request sets and reads its headers through it: a header given as `$_SERVER` has it is kept under its own name, and `getHeaderLine('HTTP_RANGE')` still finds the `Range` header.

$name	string
returns	string

Request::HeaderName('HTTP_IF_NONE_MATCH'); // 'If-None-Match'

Request::HeaderName('DOCUMENT_ROOT'); // 'DOCUMENT_ROOT': not a header

setHeader($name, $value)

aRequest.php:86

protected function setHeader(string $name, array|string $value): self

See: tWithHeaders::setHeader, under the header's own name when $name is php's (HeaderName)

$name	string
$value	array \| string
returns	self

setUri($uri, $preserveHost)

aRequest.php:54

protected function setUri($uri, bool $preserveHost = true)

$uri
$preserveHost = true	bool	see `withUri` for the exact semantics
returns

unsetHeader($name)

aRequest.php:92

protected function unsetHeader(string $name): self

See: tWithHeaders::unsetHeader, by php's name of the header too (HeaderName)

$name	string
returns	self

withAttribute($name, $value)

aRequest.php:321

Return an instance with the specified derived request attribute.

function withAttribute(string $name, mixed $value): self

This method allows setting a single derived request attribute as described in getAttributes(). This method MUST be implemented in such a way as to retain the immutability of the message, and MUST return an instance that has the updated attribute.

See: getAttributes()

$name	string	The attribute name.
$value	mixed	The value of the attribute.
returns	self

$req->withAttribute('user', $user);

withAttributes($attrs)

aRequest.php:334

Return an instance with several derived request attributes set at once (merged via

function withAttributes(array $attrs): self

See: merge, so an existing attribute not present in $attrs is kept).

$attrs	array	name => value
returns	self

$req->withAttributes(['user' => $user, 'role' => 'admin']);

withoutAttribute($name)

aRequest.php:355

Return an instance that removes the specified derived request attribute.

function withoutAttribute(string $name): self

This method allows removing a single derived request attribute as described in getAttributes(). This method MUST be implemented in such a way as to retain the immutability of the message, and MUST return an instance that removes the attribute.

See: getAttributes()

$name	string	The attribute name.
returns	self	a clone without $name; or $this unchanged (no clone) if $name was never set to begin with

$req->withoutAttribute('user');

withParsedBody($data)

aRequest.php:262

Return an instance with the specified body parameters.

function withParsedBody(ArrayAccess|array|null $data): self

These MAY be injected during instantiation. If the request Content-Type is either application/x-www-form-urlencoded or multipart/form-data, and the request method is POST, use this method ONLY to inject the contents of $_POST. The data IS NOT REQUIRED to come from $_POST, but MUST be the results of deserializing the request body content. Deserialization/parsing returns structured data, and, as such, this method ONLY accepts arrays or objects, or a null value if nothing was available to parse. As an example, if content negotiation determines that the request data is a JSON payload, this method could be used to create a request instance with the deserialized parameters. This method MUST be implemented in such a way as to retain the immutability of the message, and MUST return an instance that has the updated body parameters.

$data	ArrayAccess \| array \| null	The deserialized body data. This will typically be in an array or object.
returns	self
throws		if an unsupported argument type is provided.

$req->withParsedBody(['name' => 'value']);

$req->withParsedBody(null); // explicitly "nothing was available to parse"

withRequestTarget($requestTarget)

aRequest.php:151

Return an instance with the specific request-target.

function withRequestTarget(string $requestTarget): self

If the request needs a non-origin-form request-target — e.g., for specifying an absolute-form, authority-form, or asterisk-form — this method may be used to create an instance with the specified request-target, verbatim. This method MUST be implemented in such a way as to retain the immutability of the message, and MUST return an instance that has the changed request target.

$requestTarget	string
returns	self

$req->withRequestTarget('*'); // e.g. for an OPTIONS * request

withUri($uri, $preserveHost)

aRequest.php:204

Returns an instance with the provided URI.

function withUri(Psr\Http\Message\UriInterface $uri, $preserveHost = false): self

This method MUST update the Host header of the returned request by default if the URI contains a host component. If the URI does not contain a host component, any pre-existing Host header MUST be carried over to the returned request. You can opt-in to preserving the original state of the Host header by setting `$preserveHost` to `true`. When `$preserveHost` is set to `true`, this method interacts with the Host header in the following ways: - If the Host header is missing or empty, and the new URI contains a host component, this method MUST update the Host header in the returned request. - If the Host header is missing or empty, and the new URI does not contain a host component, this method MUST NOT update the Host header in the returned request. - If a Host header is present and non-empty, this method MUST NOT update the Host header in the returned request. This method MUST be implemented in such a way as to retain the immutability of the message, and MUST return an instance that has the new UriInterface instance.

$uri	`UriInterface`	New request URI to use.
$preserveHost = false		Preserve the original state of the Host header.
returns	self

$req->withUri(Uri::Immutable('https://other.com/bar')); // Host header updated to 'other.com'

$req->withUri(Uri::Immutable('https://other.com/bar'), true); // Host header left as-is, if already set

__clone()

aRequest.php:35

function __clone()

__construct($uri, $headers)

aRequest.php:30

function __construct($uri, array $headers = [])

$uri
$headers = []	array

__toString()

aRequest.php:45

function __toString(): string

returns

string

e.g. 'GET|https://example.com/foo'

Inherited members (51)

	Properties	Declared by	Description
	`headers`	aMessage
	`ikeys`	aMessage
	`Listeners`	aMessage
	`protocol`	aMessage

Methods	Declared by	Description
`addHeader($name, $value)`	aMessage	Append a value to a header, keeping any value(s) already set (as opposed to `setHeader`, which replaces).
`AddListener($handler, $order)`	aMessage	Register a listener directly (as opposed to `ConnectListeners`'s attribute-based discovery).
`ConnectListeners($obj)`	aMessage	Scan $obj's methods for #[Listen(EventClass::class)] attributes and register each one as a listener on the matching event class.
`DisconnectListeners($obj)`	aMessage	Undo a previous `ConnectListeners`: removes every listener that `connect` had registered for $obj on this event class.
`dispatch()`	aMessage	Invoke every `GetListeners` listener with $this.
`getBody()`	`MessageInterface`	Gets the body of the message.
`getCharset()`	aMessage
`getContentExtension()`	aMessage
`getContentType($single)`	aMessage
`getCookieParams()`	`ServerRequestInterface`	Retrieve cookies.
`getHeaderLine($name)`	aMessage	Retrieves a comma-separated string of the values for a single header.
`getHeaders()`	aMessage	Retrieves all message header values.
`GetListeners()`	aMessage	Collect every listener for this class, including those registered on its parent classes (so a subclass event is also caught by listeners of its parent event), sorted by ascending $order (ties keep …
`getMethod()`	`RequestInterface`	Retrieves the HTTP method of the request.
`getOrigin()`	aMessage	Get origin of the request by looking at 'Origin', then 'Referer', then 'Sender' in the request's headers.
`getProtocolVersion()`	aMessage	Retrieves the HTTP protocol version as a string.
`getQueryParams()`	`ServerRequestInterface`	Retrieve query string arguments.
`getUploadedFiles()`	`ServerRequestInterface`	Retrieve normalized file upload data.
`getUserAgent()`	aMessage
`HasListener($handler)`	aMessage
`isHTML()`	aMessage
`isIe()`	aMessage
`isIphone()`	aMessage
`isJSON()`	aMessage
`isMac()`	aMessage
`isMobile()`	aMessage
`isWindows()`	aMessage
`jsonSerialize()`	JsonSerializable
`RemoveListener($handler)`	aMessage	Remove the last added handler from the listeners.
`Send($args)`	aMessage	Construct a new instance of this class with $args, then `dispatch` it to every listener.
`setCacheControl($cache, $pragma)`	aMessage	Set the Cache-Control header (and, optionally, the legacy Pragma header alongside it).
`setContentType($type, $charset)`	aMessage	Set the Content-Type header, appending a charset parameter (unless $charset is null/empty).
`setExpires($time)`	aMessage	Set the Expires header from a unix timestamp, formatted as an RFC 7231 HTTP-date.
`SetListenerOrder($handler, $order)`	aMessage	Change the order of an already-registered listener, whether added directly via `AddListener` or indirectly via `ConnectListeners` (which also stores its `[$obj, $methodName]` callables here).
`withAddedHeader($name, $value)`	aMessage	Return an instance with the specified header appended with the given value.
`withBody($body)`	`MessageInterface`	Return an instance with the specified message body.
`withCacheControl($cache, $pragma)`	aMessage	Set cache control of a clone.
`withContentType($type, $charset)`	aMessage	Set content type of a clone.
`withCookieParams($cookies)`	`ServerRequestInterface`	Return an instance with the specified cookies.
`withExpires($time)`	aMessage	Set cache expire date of a clone.
`withHeader($name, $value)`	aMessage	Return an instance with the provided value replacing the specified header.
`withHeaders($headers, $reset)`	aMessage	Return a clone with every header in $headers set (through `tWithHeaders::setHeader`, so each value replaces any existing one for the same header name).
`withMethod($method)`	`RequestInterface`	Return an instance with the provided HTTP method.
`withoutHeader($name)`	aMessage	Return an instance without the specified header.
`withProtocolVersion($version)`	aMessage	Return an instance with the specified HTTP protocol version.
`withQueryParams($query)`	`ServerRequestInterface`	Return an instance with the specified query string arguments.
`withUploadedFiles($uploadedFiles)`	`ServerRequestInterface`	Create a new instance with the specified uploaded files.