Centralizing Request Transformation in Laravel: Beyond Repetitive Code

As developers working within the Laravel ecosystem, we often deal with scenarios where raw user input needs to be transformed, sanitized, or adapted before it interacts with our business logic or database. A common point of friction arises when this transformation needs to happen consistently across multiple endpoints.

You correctly identified that methods like Request::replace() exist to modify input parameters. However, as you noted, the immediate implementation often leads to a repetitive pattern: duplicating the same transformation logic in every controller action. This violates the DRY (Don't Repeat Yourself) principle and makes maintenance cumbersome.

The core question then becomes: How can we execute this critical post-validation data modification centrally, right after validation succeeds but before the specific controller method runs?

This is not something that Laravel provides with a single, dedicated "post-validation hook" function. Instead, the most robust solution involves leveraging Laravel's architectural strengths—specifically Service Classes and Middleware—to decouple the input processing from the presentation logic of your controllers.

The Problem with In-Controller Logic

Let's look at your example: transforming ISO2 language codes into legacy formats. If this logic resides in your controller, you face scaling issues:

// Bad Practice: Duplicated logic in every controller
public function updateLanguage(Request $request)
{
    $iso = $request->input('language');
    $legacy = Language::iso2ToLegacy($iso); // Business logic here
    $request->replace(['language' => $legacy]); // Modifying the request object
    
    // ... rest of the controller action
}

If you have ten routes that all need this transformation, you are duplicating the exact same data manipulation code, increasing the chance of bugs if the transformation rules change.

The Recommended Solution: Abstraction via Service Layers

The most professional way to handle complex input transformations is to abstract that logic into a dedicated service class. This shifts the responsibility of what the data should look like from the controller to a specialized layer.

Step 1: Create a Dedicated Transformer Service

Create a service responsible solely for handling the specific type of transformation required. This keeps your controllers lean and focused purely on request flow and response generation.

// app/Services/LanguageTransformer.php

namespace App\Services;

use Illuminate\Http\Request;

class LanguageTransformer
{
    public function transform(Request $request): Request
    {
        $input = $request->only('language');

        if (isset($input['language'])) {
            $isoCode = $input['language'];
            // Perform the heavy lifting transformation
            $legacyCode = \App\Models\Language::iso2ToLegacy($isoCode);
            
            // Replace the input data with the transformed value
            $request->replace(['language' => $legacyCode]);
        }

        return $request;
    }
}

Step 2: Apply Transformation via Middleware or Service Injection

Now, instead of putting this logic in the controller, we can inject this service where it makes sense. While you could force injection into controllers, a cleaner approach for request modification is often through Middleware.

Using Middleware for Global Request Modification:

You can create a custom middleware that runs before the controller executes. This allows you to intercept the request and modify it universally for specific route groups without cluttering every single method.

// app/Http/Middleware/TransformRequest.php

namespace App\Http\Middleware;

use Closure;
use Illuminate\Http\Request;
use App\Services\LanguageTransformer; // Import the service

class TransformRequest
{
    protected $transformer;

    public function __construct(LanguageTransformer $transformer)
    {
        $this->transformer = $transformer;
    }

    public function handle(Request $request, Closure $next)
    {
        // Execute the transformation logic here
        $transformedRequest = $this->transformer->transform($request);
        
        // Pass the modified request to the next layer (the controller)
        return $next($transformedRequest);
    }
}

Step 3: Register and Use the Middleware

Register this middleware in app/Http/Kernel.php and then apply it to your API routes. This cleanly separates concerns: the middleware handles how the request is prepared, and the controller handles what to do with the prepared data. As we discussed regarding best practices for building scalable APIs, keeping complex logic out of the controller is key, aligning with principles found on sites like laravelcompany.com.

Conclusion

By moving your input transformation logic into a dedicated Service class and utilizing Laravel's powerful Middleware system, you achieve significant architectural improvements. You eliminate code duplication, make your business rules easier to test and maintain, and ensure that the responsibility for data preparation is centralized. This approach results in cleaner, more scalable API endpoints where controllers focus purely on orchestrating the flow rather than managing complex input manipulation.