Form Validation Request for a different Model / Controller

Hello,

I need some enlightenment regarding form validation. I am still a Laravel newbie.

I have a business logic that require data to be inserted into 2 tables at the same time in a transaction. So I have:

AModel, BModel
AController, BController

When calling store on AController a BModel object needs to be created too.

So, I was happy validating the post data in the Controllers themselves. The store() on AController called a validation function in BController and everything was fine.

However, as the Laravel way, separation of concerns is important, I move the validation to:

ARequest and
BRequest

The problem arouse from the fact that I just have ARequest from

    public function store(ARequest $request, A $a): JsonResponse

I had to find a way to be able to have access to BRequest to validate the data too.

The way I found out that work is:

public function store(ARequest $request, A $a): JsonResponse
{
    $validated = $request->validated();

    // Some work on post data
    $bData = $request->all();
    ...
    // Create an instance of BRequest with the data
    $bRequest = BRequest::createFrom($request);

    // Replace the request data with the trade data
    $bRequest->replace($bData);

    // Validate BRequest
    $validatedB = app('validator')->make($bRequest->all(), $bRequest->rules())->validate();
    ...
}

Without doing this way, and just creating a FormRequest object, the FormRequest->validator will be null.

All that said, it does not seems to be the best way to do this. I believe that multi-table validation within a transaction is not something rare. So, what am I missing?

Thx,

-rsd

LaryAI

1 year ago

Level 58

To handle form validation for multiple models in a Laravel application, especially when you need to validate data for two different models within a single transaction, you can follow a more structured approach. Here's a solution that adheres to Laravel's best practices:

Use Custom Form Requests: You can create custom form requests for each model. You've already done this with ARequest and BRequest.
Combine Validation Logic: Instead of trying to manually invoke the validation logic of BRequest within AController, you can create a service class that handles the combined validation and transaction logic.
Service Class: Create a service class that will handle the transaction and validation for both models.

Here's how you can implement this:

Step 1: Create a Service Class

Create a service class that will encapsulate the logic for handling the transaction and validation.

namespace App\Services;

use App\Http\Requests\ARequest;
use App\Http\Requests\BRequest;
use Illuminate\Support\Facades\DB;
use Illuminate\Support\Facades\Validator;

class ABService
{
    public function handle(ARequest $aRequest)
    {
        // Start a database transaction
        return DB::transaction(function () use ($aRequest) {
            // Validate ARequest
            $validatedA = $aRequest->validated();

            // Prepare data for BRequest
            $bData = $this->prepareBData($aRequest);

            // Validate BRequest
            $bRequest = new BRequest();
            $validator = Validator::make($bData, $bRequest->rules());
            $validatedB = $validator->validate();

            // Insert data into AModel and BModel
            $aModel = AModel::create($validatedA);
            $bModel = BModel::create($validatedB);

            return [$aModel, $bModel];
        });
    }

    private function prepareBData(ARequest $aRequest)
    {
        // Extract and prepare data for BModel from ARequest
        return [
            // Map the necessary fields
        ];
    }
}

Step 2: Use the Service in Your Controller

In your AController, use the service class to handle the request.

namespace App\Http\Controllers;

use App\Http\Requests\ARequest;
use App\Services\ABService;
use Illuminate\Http\JsonResponse;

class AController extends Controller
{
    protected $abService;

    public function __construct(ABService $abService)
    {
        $this->abService = $abService;
    }

    public function store(ARequest $request): JsonResponse
    {
        try {
            [$aModel, $bModel] = $this->abService->handle($request);

            return response()->json([
                'success' => true,
                'data' => [
                    'aModel' => $aModel,
                    'bModel' => $bModel,
                ],
            ]);
        } catch (\Exception $e) {
            return response()->json([
                'success' => false,
                'message' => $e->getMessage(),
            ], 500);
        }
    }
}

Explanation

Service Class: The ABService class handles the transaction and validation logic. It uses Laravel's DB::transaction to ensure that both model operations are atomic.
Validation: The service class uses Laravel's Validator facade to manually validate the data for BRequest.
Separation of Concerns: This approach keeps your controller clean and delegates the business logic to a dedicated service class.

This solution provides a clean and maintainable way to handle complex validation and transaction logic in Laravel.

Snapey

1 year ago

Level 122

One request goes to one controller.

That controller might not have anything to do with one specific model. It is controlling the request.

There you can validate all form data and update one, many or none models.

Please or to participate in this conversation.