0 follower

Final Class Yiisoft\Request\Body\RequestBodyParser

All Classes | Methods
InheritanceYiisoft\Request\Body\RequestBodyParser
ImplementsPsr\Http\Server\MiddlewareInterface

The package is a PSR-15 middleware that allows parsing PSR-7 server request body selecting the parser according to the server request mime type.

See also:

Public Methods

Hide inherited methods

Method Description Defined By
__construct() Yiisoft\Request\Body\RequestBodyParser
ignoreBadRequestBody() Makes the middleware to simple skip requests it cannot parse. Yiisoft\Request\Body\RequestBodyParser
process() Yiisoft\Request\Body\RequestBodyParser
withParser() Registers a request parser for a mime type specified. Yiisoft\Request\Body\RequestBodyParser
withoutParsers() Returns new instance with parsers un-registered for mime types specified. Yiisoft\Request\Body\RequestBodyParser

Method Details

Hide inherited methods

__construct() public method

public mixed __construct ( \Psr\Http\Message\ResponseFactoryInterface $responseFactory, \Psr\Container\ContainerInterface $container, Yiisoft\Request\Body\BadRequestHandlerInterface|null $badRequestHandler = null )
$responseFactory \Psr\Http\Message\ResponseFactoryInterface
$container \Psr\Container\ContainerInterface
$badRequestHandler Yiisoft\Request\Body\BadRequestHandlerInterface|null 

                public function __construct(
    ResponseFactoryInterface $responseFactory,
    private readonly ContainerInterface $container,
    BadRequestHandlerInterface|null $badRequestHandler = null
) {
    $this->badRequestHandler = $badRequestHandler ?? new BadRequestHandler($responseFactory);
}
ignoreBadRequestBody() public method

Makes the middleware to simple skip requests it cannot parse.

public self ignoreBadRequestBody ( )

                public function ignoreBadRequestBody(): self
{
    $new = clone $this;
    $new->ignoreBadRequestBody = true;
    return $new;
}
process() public method

public \Psr\Http\Message\ResponseInterface process ( \Psr\Http\Message\ServerRequestInterface $request, \Psr\Http\Server\RequestHandlerInterface $handler )
$request \Psr\Http\Message\ServerRequestInterface
$handler \Psr\Http\Server\RequestHandlerInterface 

                public function process(ServerRequestInterface $request, RequestHandlerInterface $handler): ResponseInterface
{
    $parser = $this->getParser($this->getContentType($request));
    if ($parser !== null) {
        try {
            /** @var mixed $parsed */
            $parsed = $parser->parse((string)$request->getBody());
            if ($parsed !== null && !is_object($parsed) && !is_array($parsed)) {
                $parserClass = $parser::class;
                throw new RuntimeException(
                    "$parserClass::parse() return value must be an array, an object, or null."
                );
            }
            $request = $request->withParsedBody($parsed);
        } catch (ParserException $e) {
            if (!$this->ignoreBadRequestBody) {
                return $this->badRequestHandler
                    ->withParserException($e)
                    ->handle($request);
            }
        }
    }
    return $handler->handle($request);
}
withParser() public method

Registers a request parser for a mime type specified.

public self withParser ( string $mimeType, string $parserClass )
$mimeType string

Mime type to register parser for.
$parserClass string

Parser fully qualified name.

 

                public function withParser(string $mimeType, string $parserClass): self
{
    $this->validateMimeType($mimeType);
    if ($parserClass === '') {
        throw new InvalidArgumentException('The parser class cannot be an empty string.');
    }
    if ($this->container->has($parserClass) === false) {
        throw new InvalidArgumentException("The parser \"$parserClass\" cannot be found.");
    }
    $new = clone $this;
    $new->parsers[$this->normalizeMimeType($mimeType)] = $parserClass;
    return $new;
}
withoutParsers() public method

Returns new instance with parsers un-registered for mime types specified.

public self withoutParsers ( string $mimeTypes )
$mimeTypes string

Mime types to unregister parsers for.

 

                public function withoutParsers(string ...$mimeTypes): self
{
    $new = clone $this;
    if (count($mimeTypes) === 0) {
        $new->parsers = [];
        return $new;
    }
    foreach ($mimeTypes as $mimeType) {
        $this->validateMimeType($mimeType);
        unset($new->parsers[$this->normalizeMimeType($mimeType)]);
    }
    return $new;
}