Download the PHP package geeky/request-objects without Composer

Symfony Request Objects

Note: The library is taken from this library fesor/request-objects but this library is working on symfony v5+ . with a few updates

Why?

Symfony Forms component is a very powerful tool for handling forms. But nowadays things have changed. Complex forms are handled mostly on the client side. As for simple forms symfony/forms has very large overhead.

And in some cases you just don't have forms. For example, if you are developing an HTTP API, you probably just need to interact with request payload. So why not just wrap request payload in some user defined object and validate just it? This also encourages separation of concerns and will help you in case of API versioning.

Usage

First of all, we need to install this package via composer:

And register the bundle in config/bundels.php:

Bundle doesn't require any additional configuration, but you could also specify an error response provider service in bundle config. We will come back to this in "Handle validation errors" section.

Define your request objects

All user defined requests should extend Fesor\RequestObject\RequestObject. Let's create a simple request object for user registration action:

After that we can just use it in our action:

This bundle will bind validated request object to the $request argument. Request object has very simple interface for data interaction. It is very similar to Symfony's request object but is considered immutable by default (although you can add some setters if you wish so)

Where payload comes from?

This library has default implementation of PayloadResolver interface, which acts this way:

1) If a request can have a body (i.e. it is POST, PUT, PATCH or whatever request with body) it uses union of $request->request->all() and $request->files->all() arrays as payload.

2) If request can't have a body (i.e. GET, HEAD verbs), then it uses $request->query->all().

If you wish to apply custom logic for payload extraction, you could implement PayloadResolver interface within your request object:

This will allow you to do some crazy stuff with your requests and DRY a lot of stuff.

Validating payload

As you can see from previous example, the rules method should return validation rules for symfony validator. Your request payload will be validated against it and you will get valid data in your action.

If you have some validation rules which depend on payload data, then you can handle it via validation groups.

Please note: due to limitations in Collection constraint validator it is not so handy to use groups. So instead it is recommended to use Callback validator in tricky cases with dependencies on payload data. See example for details about problem.

You may provide validation group by implementing validationGroup method:

Handling validation errors

If validated data is invalid, library will throw exception which will contain validation errors and request object.

But if you don't want to handle it via kernel.exception listener, you have several options.

First is to use your controller action to handle errors:

But this not so handy and will break DRY if you just need to return common error response. Thats why library provides you ErrorResponseProvider interface. You can implement it in your request object and move this code to getErrorResponse method:

Exception Listner Handling

If you need to handle the validaion exception from the exception itself you can take a look at this example Excetion Example

So the first thing you should create the src/EventListener/ExceptionListener.php file or anywhere you want then paste the example file in it and you can customize the response as you want,

secondly you must register the created file into services.yaml file like this:

More examples

If you're still not sure is it useful for you, please see the examples directory for more use cases. Didn't find your case? Then share your use case in issues!

Contribution

Feel free to give feedback and feature requests or post issues. PR's are welcomed!