JSON to Elixir Struct Generator

JSON to PHP DTO: Modern Data Handling for Scalable Web Applications

PHP has evolved significantly with the introduction of strict typing and readonly properties in recent versions. Converting JSON samples to PHP DTOs (Data Transfer Objects) allows you to move away from messy associative arrays and towards structured, type-safe objects. This approach is essential for modern frameworks like Laravel and Symfony, enabling better IDE support, easier unit testing, and more resilient business logic that handles external data with confidence.

Live Example: Mapping JSON to PHP 8.2+ Readonly DTOs

// Input JSON
{
  "user_id": 45,
  "full_name": "Maria Garcia",
  "email_verified": true,
  "roles": ["editor", "admin"]
}

// Generated PHP Code
declare(strict_types=1);

namespace App\Dto;

readonly class UserDto
{
    /**
     * @param string[] $roles
     */
    public function __construct(
        public int $userId,
        public string $fullName,
        public bool $emailVerified,
        public array $roles,
    ) {}

    public static function fromArray(array $data): self
    {
        return new self(
            userId: $data['user_id'],
            fullName: $data['full_name'],
            emailVerified: $data['email_verified'],
            roles: $data['roles'],
        );
    }
}

Step-by-Step Implementation Guide

1. Enable Strict Types: Always start your files with declare(strict_types=1); to ensure type safety.
2. Define the DTO: Map JSON keys to constructor-promoted properties. PHP prefers camelCase for property names.
3. Use Readonly Classes: In PHP 8.2+, use readonly class to ensure your DTOs are immutable once created.
4. Implement a Factory Method: Create a fromArray or fromJson static method to handle the conversion logic and any necessary data casting.

Technical Deep Dive: Constructor Promotion and Property Attributes

The introduction of **Constructor Property Promotion** in PHP 8.0 drastically reduced the boilerplate needed for DTOs. Instead of defining private fields, a constructor, and getters, you can do it all in the constructor signature. When you convert JSON to a PHP DTO, you are setting up a memory-efficient object that PHP's engine can optimize. Furthermore, you can use **Attributes** (like those in Symfony's Serializer or Laravel's Data package) to handle complex mapping rules, such as date formatting or property renaming, without cluttering your core class logic.

Comparison & Alternatives

PHP DTOs vs. Associative Arrays: Arrays are the "old way" in PHP—flexible but dangerous and difficult to document. DTOs are the modern standard for professional development. JSON Schema for PHP is an alternative for pure validation, but DTOs provide the added benefit of object-oriented data access throughout your application.

Best Practices for Production

• Keep DTOs Simple: DTOs should only contain data and factory methods. Avoid adding business logic or service dependencies to them.
• Type Everything: Use PHP's full range of type hints, including nullable (?) and mixed (sparingly), to accurately reflect the incoming JSON structure.
• Use Static Analysis: Tools like **PHPStan** or **Psalm** work best with DTOs, helping you catch potential type mismatches before they hit production.

FAQ

Q: What is the benefit of 'readonly'?
A: It prevents properties from being modified after the object is instantiated, making your data flow predictable and thread-safe (in environments where that matters).

Q: How do I handle missing optional fields?
A: Use nullable types (e.g., public ?string $bio) and provide a default value of null in your factory method if the key is missing from the JSON.

Q: Can I use this with Laravel?
A: Yes! This pattern is highly recommended for Laravel's Form Requests and Controller logic to ensure your models receive validated, structured data.