Reuse Form Requests (Composite Form Requests)

[vopolonc]

I've noticed that there are a lot of reusable Form Requests across my projects (I don't think I'm alone in this).
For example, on a project, you use some kind of form in several places, let's say ContactInformationRequest consisting of some basic contact info:

    public function rules(): array
    {
        return [
            'email' => 'required|email',
            'country_id' => 'required|exists:countries,id',
            'phone_number' => 'required_with:dial_code|digits_between:3,15',
            'dial_code' => 'required_with:phone_number|max:3',
        ];
    }

You use this form to get in touch, or to leave some feedback, and so on. Occasionally, you notice that the registration request, profile update request, etc.. also contain these rules (maybe with slight changes, for example, in such forms, we should take into account that the email is unique or country is nullable).

Why is it not possible to create a composite form by assembling rules from multiple smaller forms:

    public function rules(): array
    {
        return [
            'name' => ['string', 'min:2', 'max:50', 'regex:/^[a-z ,.\'-]+$/i'],
            'password' => 'required|min:5|max:128|regex:/^[^\s]+$/',

            ...$this->mergeRules(ContactInformationRequest::class)
        ];
    }

Or if we'd like to adjust the email rule:

...$this->mergeRules(ContactInformationRequest::class, merge: ['email' => 'string|email|unique:users,email'])

Also we can add condition to it and return default on failure:

...$this->mergeRules(
    class: ContactInformationRequest::class, 
    merge: ['email' => 'string|email|unique:users,email']),
    condition: $this->user()->isCustomer(),
    default: []
)

I've come up with a simple solution that does not solve the problem of resolving Form Requests, but it's pretty handy:

/**
 * @mixin FormRequest
 */
trait MergesRules
{
    /**
     * @param string $class
     * @param string $prefix
     * @param bool $condition
     * @param array $default
     * @param array $merge
     *
     * @see FormRequest::createFromGlobals()
     * 
     * @return array
     */
    protected function mergeRules(string $class, string $prefix = '', bool $condition = true, array $default = [], array $merge = []): array
    {
        if (!$condition) {
            return $default;
        }

        $rules = array_merge($class::createFromGlobals()->rules(), $merge);

        return Arr::mapWithKeys($rules, fn ($value, $key) => [$prefix . $key => $value]);
    }
}

What do you think, maybe there is already a similar trait\method in Laravel? Or it's a bad practice? I will be glad to hear your opinion.

[TheBlckbird]

I always use traits for this, but I think a native method would be very useful. I always have two Form Requests for a resource: UpdatePostRequest and StoreResourceRequest. Those two don't always have the exact same validation rules so I can't just use a PostRequest for updating and storing.

I could implement this feature if it should be added.

[rojtjo]

Why construct a full request object when you could just place the rules in it's own class (or function even)? The rules method even allows for dependency injection from the container.

class AccountInformationRules
{
    public function __construct(
        private bool $includePassword = true,
    )
    {
    }

    public function withoutPassword(): self
    {
        $this->includePassword = false;
        
        return $this;
    }

    public function rules(): array
    {
        return [
            'email' => ['required', 'email'],
            'password' => $this->includePassword ? ['required'] : [],
        ];
    }
}

class ContactInformationRules
{
    public function rules(): array
    {
        return [
            'phone' => ['required'],
        ];
    }
}

class SomeFormRequest extends FormRequest
{
    public function rules(AccountInformationRules $accountInformation, ContactInformationRules $contactInformation)
    {
        return [
            ...$accountInformation->withoutPassword()->rules(),
            ...$contactInformation->rules(),
        ];
    }
}

[vopolonc]

@rojtjo Maybe I'm wrong, but if we inject form request it will resolve it immediately, and trigger validation process of injected class, that's what we should avoid.

In 90% of use cases you're injecting Form Request inside the controller so you're unable to pass includePassword coz FormRequests are resolved and immediately apply validation process. That's the reason why I instantiate Form Request using ::createFromGlobals method in the code above.

[rojtjo]

You would be totally correct if I was injecting FormRequests, except my suggestion was to place the rules on a plain object and to compose them in your FormRequest class.

[vopolonc]

@rojtjo The main point of the topic is to reuse already used FormRequests and provide clear and straightforward interface to do that. Not just move it to a separate class with rules() method.

[rojtjo]

Yes I realized that, I was just questioning the initialization of multiple FormRequests just to grab their validation rules and wanted to provide an alternative.