Reusable DTO Parse Methods in PHP

The Problem

You’re working with DTOs (Data Transfer Objects) that need to be deserialized from JSON or arrays. Every time you need to deserialize, you’re copy-pasting the same serializer setup code:

$serializer = SerializerBuilder::create()->build();
$config = $serializer->deserialize($jsonString, ConfigDTO::class, 'json');

This gets old fast. Let’s fix it.

The Solution: Static parse() Methods

Encapsulate the serialization logic inside the DTO itself with a static parse() method:

class ConfigDTO
{
    public string $apiKey;
    public int $timeout;
    public bool $enableDebug;

    public static function parse(array $data): self
    {
        $serializer = SerializerBuilder::create()->build();
        $jsonString = json_encode($data);
        return $serializer->deserialize($jsonString, self::class, 'json');
    }
}

Now instead of:

$serializer = SerializerBuilder::create()->build();
$config = $serializer->deserialize(
    json_encode($requestData),
    ConfigDTO::class,
    'json'
);

You write:

$config = ConfigDTO::parse($requestData);

Why This is Better

1. Single Source of Truth

Your DTO knows how to deserialize itself. If you need to change serializer configuration (add normalizers, change naming strategy, etc.), you change it in one place.

2. Cleaner Call Sites

Controllers, services, and tests become dramatically cleaner:

// Before
public function store(Request $request, SerializerInterface $serializer)
{
    $config = $serializer->deserialize(
        json_encode($request->all()),
        ConfigDTO::class,
        'json'
    );
    // ...
}

// After
public function store(Request $request)
{
    $config = ConfigDTO::parse($request->all());
    // ...
}

3. Easier to Test

Testing becomes straightforward because the DTO handles its own deserialization:

public function test_config_parsing()
{
    $config = ConfigDTO::parse([
        'api_key' => 'test-key',
        'timeout' => 30,
        'enable_debug' => true
    ]);

    $this->assertEquals('test-key', $config->apiKey);
    $this->assertEquals(30, $config->timeout);
    $this->assertTrue($config->enableDebug);
}

4. Validation in One Place

You can add validation logic to the parse() method:

public static function parse(array $data): self
{
    if (empty($data['api_key'])) {
        throw new InvalidArgumentException('API key is required');
    }

    $serializer = SerializerBuilder::create()->build();
    $jsonString = json_encode($data);
    return $serializer->deserialize($jsonString, self::class, 'json');
}

Real-World Example: API Response DTO

class ApiResponseDTO
{
    public bool $success;
    public string $message;
    public ?array $data;
    public ?int $errorCode;

    public static function parse(array $responseData): self
    {
        // Custom validation before deserialization
        if (!isset($responseData['success'])) {
            throw new MalformedResponseException('Missing success field');
        }

        $serializer = SerializerBuilder::create()
            ->setPropertyNamingStrategy(
                new SerializedNameAnnotationStrategy(
                    new CamelCaseNamingStrategy()
                )
            )
            ->build();

        return $serializer->deserialize(
            json_encode($responseData),
            self::class,
            'json'
        );
    }
}

// Usage in an API client
$response = $client->get('/api/users');
$dto = ApiResponseDTO::parse($response->json());

if ($dto->success) {
    return $dto->data;
}

throw new ApiException($dto->message, $dto->errorCode);

Bonus: Support Multiple Formats

You can add format-specific parse methods:

class ConfigDTO
{
    // ... properties ...

    public static function parse(array $data): self
    {
        // Same as before
    }

    public static function fromJson(string $json): self
    {
        $serializer = SerializerBuilder::create()->build();
        return $serializer->deserialize($json, self::class, 'json');
    }

    public static function fromXml(string $xml): self
    {
        $serializer = SerializerBuilder::create()->build();
        return $serializer->deserialize($xml, self::class, 'xml');
    }
}

When NOT to Use This Pattern

This pattern works great for JMS Serializer or Symfony Serializer. If you’re using Laravel’s native JSON casting or Eloquent models, stick with Laravel’s conventions instead.

The Takeaway

Don’t scatter serializer instantiation across your codebase. Put it in the DTO where it belongs. Your future self will thank you when you need to change how deserialization works.