You can install the package via composer:
composer require spatie/data-transfer-object- Note: v3 of this package only supports
php:^8.0. If you're looking for the older version, check out v2.
We invest a lot of resources into creating best in class open source packages. You can support us by buying one of our paid products.
We highly appreciate you sending us a postcard from your hometown, mentioning which of our package(s) you are using. You'll find our address on our contact page. We publish all received postcards on our virtual postcard wall.
The goal of this package is to make constructing objects from arrays of (serialized) data as easy as possible. Here's what a DTO looks like:
use Spatie\DataTransferObject\DataTransferObject;
class MyDTO extends DataTransferObject
{
public OtherDTO $otherDTO;
public OtherDTOCollection $collection;
#[CastWith(ComplexObjectCaster::class)]
public ComplexObject $complexObject;
public ComplexObjectWithCast $complexObjectWithCast;
#[NumberBetween(1, 100)]
public int $a;
}You could construct this DTO like so:
$dto = new MyDTO(
a: 5,
collection: [
['id' => 1],
['id' => 2],
['id' => 3],
],
complexObject: [
'name' => 'test',
],
complexObjectWithCast: [
'name' => 'test',
],
otherDTO: ['id' => 5],
);Let's discuss all possibilities one by one.
Constructing a DTO can be done with named arguments. It's also possible to still use the old array notation. This example is equivalent to the one above.
$dto = new MyDTO([
'a' => 5,
'collection' => [
['id' => 1],
['id' => 2],
['id' => 3],
],
'complexObject' => [
'name' => 'test',
],
'complexObjectWithCast' => [
'name' => 'test',
],
'otherDTO' => ['id' => 5],
]);If a DTO has a property that is another DTO or a DTO collection, the package will take care of automatically casting arrays of data to those DTOs:
$dto = new MyDTO(
collection: [ // This will become an object of class OtherDTOCollection
['id' => 1],
['id' => 2], // Each item will be an instance of OtherDTO
['id' => 3],
],
otherDTO: ['id' => 5], // This data will be cast to OtherDTO
);You can build your own caster classes, which will take whatever input they are given, and will cast that input to the desired result.
Take a look at the ComplexObject:
class ComplexObject
{
public string $name;
}And its caster ComplexObjectCaster:
use Spatie\DataTransferObject\Caster;
class ComplexObjectCaster implements Caster
{
/**
* @param array|mixed $value
*
* @return mixed
*/
public function cast(mixed $value): ComplexObject
{
return new ComplexObject(
name: $value['name']
);
}
}Instead of specifying which caster should be used for each property, you can also define that caster on the target class itself:
class MyDTO extends DataTransferObject
{
public ComplexObjectWithCast $complexObjectWithCast;
}#[CastWith(ComplexObjectWithCastCaster::class)]
class ComplexObjectWithCast
{
public string $name;
}It's possible to define default casters on a DTO class itself. These casters will be used whenever a property with a given type is encountered within the DTO class.
#[
DefaultCast(DateTimeImmutable::class, DateTimeImmutableCaster::class),
DefaultCast(Enum::class, EnumCaster::class),
]
abstract class BaseDataTransferObject extends DataTransferObject
{
public MyEnum $status; // EnumCaster will be used
public DateTimeImmutable $date; // DateTimeImmutableCaster will be used
}This package doesn't offer any specific validation functionality, but it does give you a way to build your own validation attributes. For example, NumberBetween is a user-implemented validation attribute:
class MyDTO extends DataTransferObject
{
#[NumberBetween(1, 100)]
public int $a;
}It works like this under the hood:
#[Attribute(Attribute::TARGET_PROPERTY | Attribute::IS_REPEATABLE)]
class NumberBetween implements Validator
{
public function __construct(
private int $min,
private int $max
) {
}
public function validate(mixed $value): ValidationResult
{
if ($value < $this->min) {
return ValidationResult::invalid("Value should be greater than or equal to {$this->min}");
}
if ($value > $this->max) {
return ValidationResult::invalid("Value should be less than or equal to {$this->max}");
}
return ValidationResult::valid();
}
}The previous version of this package added the FlexibleDataTransferObject class which allowed you to ignore properties that didn't exist on the DTO. This behaviour has been changed, all DTOs are flexible now by default, but you can make them strict by using the #[Strict] attribute:
class NonStrictDto extends DataTransferObject
{
public string $name;
}
// This works
new NonStrictDto(
name: 'name',
unknown: 'unknown'
);use \Spatie\DataTransferObject\Attributes\Strict;
#[Strict]
class StrictDto extends DataTransferObject
{
public string $name;
}
// This throws a \Spatie\DataTransferObject\Exceptions\UnknownProperties exception
new StrictDto(
name: 'name',
unknown: 'unknown'
);There are also some helper functions provided for working with multiple properties at once.
$postData->all();
$postData
->only('title', 'body')
->toArray();
$postData
->except('author')
->toArray();Note that all() will simply return all properties, while toArray() will cast nested DTOs to arrays as well.
You can chain the except() and only() methods:
$postData
->except('title')
->except('body')
->toArray();It's important to note that except() and only() are immutable, they won't change the original data transfer object.
composer testPlease see CHANGELOG for more information on what has changed recently.
Please see CONTRIBUTING for details.
If you discover any security related issues, please email freek@spatie.be instead of using the issue tracker.
You're free to use this package, but if it makes it to your production environment we highly appreciate you sending us a postcard from your hometown, mentioning which of our package(s) you are using.
Our address is: Spatie, Kruikstraat 22, 2018 Antwerp, Belgium.
We publish all received postcards on our company website.
- json2dto: a GUI to convert JSON objects to DTO classes (with nesting support). Also provides a CLI tool for local usage.
- Data Transfer Object Factory: generates a DTO instance or collection with fake data based on its definition. Supports type casting and doc blocks.
Our Arr class contains functions copied from Laravels Arr helper.
The MIT License (MIT). Please see License File for more information.