JSON to PHP 8.2+ DTO Generator
Transform JSON payloads into modern PHP 8.2+ readonly DTO classes with constructor property promotion.
Unlike conventional calculator sites that send your financial numbers, payload data, or code snippets across remote web servers, Affi-Chain processes all mathematical derivations, algorithms, and data parsing 100% locally within your browser sandbox. No tracking cookies, no server-side retention, and zero transmission lag.
What is JSON to PHP Class Generation?
JSON to PHP Class Generation converts arbitrary JavaScript Object Notation (JSON) payloads into strongly typed, immutable Data Transfer Objects (DTOs) and entities leveraging modern PHP 8.2 and PHP 8.3 language capabilities.
Over the past decade, PHP has evolved from a dynamically typed scripting language into a strictly typed, compiled-to-opcache backend enterprise language. In modern PHP frameworks—particularly Laravel 11+, Symfony 7+, and headless WordPress architectures—relying on loose, untyped associative arrays ($data['customer']['email']) is considered an anti-pattern. Loose arrays provide zero IDE auto-completion, fail to validate datatypes at runtime, and allow subtle typos to introduce security bugs.
The Affi-Chain JSON to PHP Class Generator parses nested JSON payloads, infers strict types, and constructs modern PHP 8.2+ classes utilizing Constructor Property Promotion, Readonly Classes, and static fromArray() hydration factories directly inside your browser with 0ms latency.
Modern PHP 8+ Language Features & Architecture Matrix
The generator harnesses features introduced in PHP 8.0 through 8.3 to eliminate boilerplate:
| PHP 8 Feature | Syntax Example | Architectural Purpose |
|---|---|---|
readonly Class | readonly class OrderDto | Guarantees complete immutability; properties cannot be modified after instantiation |
| Constructor Promotion | public function __construct(public string $sku) | Combines property declaration, visibility, type, and assignment in one line |
| Nullable Types | public ?string $middleName | Permits explicit null values returned from APIs |
| Union Types | public int|float $amount | Accommodates numbers that may arrive as either integers or floating-point decimals |
Static fromArray() Factory | OrderDto::fromArray($data) | Standardized hydration method converting JSON-decoded arrays into typed objects |
JsonSerializable | implements JsonSerializable | Enables automatic native re-serialization via json_encode($dto) |
Step-by-Step Practical Transformation Example
Let us examine how a multi-tiered customer order JSON payload is transformed into production-ready PHP 8.2+ DTOs.
Raw Input JSON:
{
"orderId": "ord_99812",
"customer": {
"id": 402,
"fullName": "Clara Oswald",
"email": "clara.oswald@example.com"
},
"totalAmount": 199.95,
"isPaid": true,
"notes": null,
"items": [
{
"sku": "ITEM-101",
"quantity": 2,
"price": 49.99
}
]
}
Generated Production PHP 8.2+ Classes:
<?php
declare(strict_types=1);
namespace App\DTOs;
use JsonSerializable;
readonly class CustomerDto implements JsonSerializable
{
public function __construct(
public int $id,
public string $fullName,
public string $email,
) {}
public static function fromArray(array $data): self
{
return new self(
id: (int) ($data['id'] ?? 0),
fullName: (string) ($data['fullName'] ?? ''),
email: (string) ($data['email'] ?? ''),
);
}
public function toArray(): array
{
return [
'id' => $this->id,
'fullName' => $this->fullName,
'email' => $this->email,
];
}
public function jsonSerialize(): array
{
return $this->toArray();
}
}
readonly class OrderItemDto implements JsonSerializable
{
public function __construct(
public string $sku,
public int $quantity,
public float $price,
) {}
public static function fromArray(array $data): self
{
return new self(
sku: (string) ($data['sku'] ?? ''),
quantity: (int) ($data['quantity'] ?? 0),
price: (float) ($data['price'] ?? 0.0),
);
}
public function toArray(): array
{
return [
'sku' => $this->sku,
'quantity' => $this->quantity,
'price' => $this->price,
];
}
public function jsonSerialize(): array
{
return $this->toArray();
}
}
readonly class OrderDto implements JsonSerializable
{
/**
* @param OrderItemDto[] $items
*/
public function __construct(
public string $orderId,
public CustomerDto $customer,
public float $totalAmount,
public bool $isPaid,
public ?string $notes,
public array $items,
) {}
public static function fromArray(array $data): self
{
$items = array_map(
fn(array $item) => OrderItemDto::fromArray($item),
$data['items'] ?? []
);
return new self(
orderId: (string) ($data['orderId'] ?? ''),
customer: CustomerDto::fromArray($data['customer'] ?? []),
totalAmount: (float) ($data['totalAmount'] ?? 0.0),
isPaid: (bool) ($data['isPaid'] ?? false),
notes: isset($data['notes']) ? (string) $data['notes'] : null,
items: $items,
);
}
public function toArray(): array
{
return [
'orderId' => $this->orderId,
'customer' => $this->customer->toArray(),
'totalAmount' => $this->totalAmount,
'isPaid' => $this->isPaid,
'notes' => $this->notes,
'items' => array_map(fn(OrderItemDto $i) => $i->toArray(), $this->items),
];
}
public function jsonSerialize(): array
{
return $this->toArray();
}
}
Comparison Matrix: Data Modeling Paradigms in Modern PHP
| Modeling Paradigm | Type Safety | Boilerplate Lines | Immutability | IDE Auto-Complete |
|---|---|---|---|---|
PHP 8.2+ readonly DTOs | Strict & Complete | Minimal (Promoted properties) | Native Language Guaranteed | 100% Full IntelliSense |
| Legacy PHP 7.x Classes | Moderate | Extreme (Manual getters/setters) | Requires manual defensive coding | High |
Associative Arrays ($data[]) | Zero (Runtime traps) | Low initially | None (Mutable anywhere) | Zero |
| Spatie Laravel Data Package | Exceptional | Minimal | High | High (Requires Composer package) |
Critical Edge Cases & PHP Language Traps
1. Distinguishing Lists vs Associative Maps (array_is_list())
In PHP, arrays represent both sequential lists ([1, 2, 3]) and associative dictionaries ({"key": "value"}). In PHP 8.1+, always use the native array_is_list($data) function to determine whether an incoming array represents a collection of records or a single associative entity.
2. The Strict Types Directive (declare(strict_types=1);)
By default, PHP attempts to coerce scalar arguments (for instance, passing the string "42" to an int parameter will automatically cast it to integer 42). For production financial and mission-critical applications, always include declare(strict_types=1); at the very top of each PHP file to force the engine to throw TypeError on invalid payload inputs.
3. Reserved PHP Keyword Collisions
JSON APIs frequently use property names that collide with PHP reserved keywords, such as default, class, function, switch, or match.
- Solution: Map the incoming JSON key inside the
fromArray()factory to a safe PHP property name (e.g.,isDefault: (bool)($data['default'] ?? false)).