Laravel Validated DTO

https://github.com/wendelladriel/laravel-validated-dto
Admin
A Laravel package that provides validated Data Transfer Objects (DTOs) for transferring and...
Tokens:11,667
Snippets:58
Trust Score:10
License:MIT
Update:7 months ago
Show doc for...
Tokens:
Raw
### Install Dev Dependencies with Make

Source: https://github.com/wendelladriel/laravel-validated-dto/blob/main/CONTRIBUTING.md

Installs the development dependencies for the project using a Makefile. This is an alternative to using Composer for setup.

```bash
make install
```

--------------------------------

### Install Dev Dependencies with Composer

Source: https://github.com/wendelladriel/laravel-validated-dto/blob/main/CONTRIBUTING.md

Installs the development dependencies required for contributing to the project using Composer. This is a prerequisite for linting and testing.

```bash
composer install
```

--------------------------------

### Install Laravel Validated DTO via Composer

Source: https://github.com/wendelladriel/laravel-validated-dto/blob/main/README.md

The installation process involves using the Composer package manager to add the library to your Laravel project dependencies.

```bash
composer require wendelladriel/laravel-validated-dto
```

--------------------------------

### Instantiate DTOs from Data Sources

Source: https://context7.com/wendelladriel/laravel-validated-dto/llms.txt

Demonstrates how to create DTO instances using static factory methods such as fromRequest, fromArray, fromJson, fromModel, and fromCommand. These methods simplify the process of mapping external data inputs into structured DTO objects.

```php
<?php

use App\DTOs\CreateUserDTO;
use App\Models\User;
use Illuminate\Http\Request;
use Illuminate\Console\Command;

// From HTTP Request
class UserController extends Controller
{
    public function store(Request $request)
    {
        $dto = CreateUserDTO::fromRequest($request);
        $user = User::create($dto->toArray());
        return response()->json($user);
    }
}

// From Array
$dto = CreateUserDTO::fromArray(['name' => 'John Doe', 'email' => 'john@example.com', 'age' => 30]);

// From JSON string
$json = '{"name":"Jane Doe","email":"jane@example.com","age":25}';
$dto = CreateUserDTO::fromJson($json);

// From Eloquent Model
$user = User::find(1);
$dto = CreateUserDTO::fromModel($user);

// From Artisan Command
class CreateUserCommand extends Command
{
    protected $signature = 'user:create {name} {email} {--age=}';
    public function handle()
    {
        $dto = CreateUserDTO::fromCommand($this);
        User::create($dto->toArray());
    }
}
```

--------------------------------

### Create DTOs from runtime sources in PHP

Source: https://github.com/wendelladriel/laravel-validated-dto/blob/main/resources/boost/skills/laravel-validated-dto-development/SKILL.md

Demonstrates how to instantiate DTOs from various data sources including arrays, JSON, HTTP requests, Eloquent models, and console commands.

```php
$dto = UserDTO::fromArray($data);
$dto = UserDTO::fromJson($json);
$dto = UserDTO::fromRequest($request);
$dto = UserDTO::fromModel($user);
$dto = UserDTO::fromCommandArguments($this);
$dto = UserDTO::fromCommandOptions($this);
$dto = UserDTO::fromCommand($this);
```

--------------------------------

### Run All Tests with Make

Source: https://github.com/wendelladriel/laravel-validated-dto/blob/main/CONTRIBUTING.md

Executes all tests within the project using a Makefile. This command is used to verify the overall integrity of the codebase after changes.

```bash
make test
```

--------------------------------

### Lint Code with Make

Source: https://github.com/wendelladriel/laravel-validated-dto/blob/main/CONTRIBUTING.md

Runs the code linting process using a Makefile. This command ensures the code adheres to the project's established coding standards.

```bash
make lint
```

--------------------------------

### Publish Custom DTO Stubs

Source: https://github.com/wendelladriel/laravel-validated-dto/blob/main/resources/boost/skills/laravel-validated-dto-development/SKILL.md

Publish the package stubs to the local project directory to allow for custom template modifications.

```bash
php artisan dto:stubs
```

--------------------------------

### Configure Package Settings and Strict Casting

Source: https://context7.com/wendelladriel/laravel-validated-dto/llms.txt

Shows how to publish and modify the package configuration file. It also demonstrates the 'require_casting' setting, which enforces explicit cast definitions for all DTO properties.

```php
return [
    'namespace' => 'App\\DTOs',
    'require_casting' => true,
];

// Strict DTO implementation
class StrictDTO extends ValidatedDTO {
    public string $name;
    protected function rules(): array {
        return ['name' => ['required']];
    }
    protected function casts(): array {
        return ['name' => new StringCast()];
    }
}
```

--------------------------------

### SimpleDTO: Data Casting and Transformation in PHP

Source: https://context7.com/wendelladriel/laravel-validated-dto/llms.txt

Demonstrates how to use SimpleDTO for data casting and transformation without explicit validation rules. It shows defining properties, default values, and casting rules using various cast types. Useful when data source is trusted or simpler DTOs are needed.

```php
<?php

namespace App\DTOs;

use WendellAdriel\ValidatedDTO\SimpleDTO;
use WendellAdriel\ValidatedDTO\Casting\IntegerCast;
use WendellAdriel\ValidatedDTO\Casting\StringCast;
use WendellAdriel\ValidatedDTO\Casting\CollectionCast;
use WendellAdriel\ValidatedDTO\Casting\DTOCast;
use Illuminate\Support\Collection;

class ProfileDTO extends SimpleDTO
{
    public string $username;
    public ?int $followers;
    public ?Collection $posts;

    protected function defaults(): array
    {
        return [
            'followers' => 0,
        ];
    }

    protected function casts(): array
    {
        return [
            'username'  => new StringCast(),
            'followers' => new IntegerCast(),
            'posts'     => new CollectionCast(new DTOCast(PostDTO::class)),
        ];
    }
}

// Usage - No validation, just casting
$profile = new ProfileDTO([
    'username'  => 'johndoe',
    'followers' => '1500', // Will be cast to integer
    'posts'     => [
        ['title' => 'First Post', 'content' => 'Hello World'],
        ['title' => 'Second Post', 'content' => 'Another post'],
    ],
]);

echo $profile->username;           // "johndoe"
echo $profile->followers;          // 1500 (integer)
echo $profile->posts->count();     // 2
echo $profile->posts->first()->title; // "First Post"

```

--------------------------------

### Livewire Integration with Wireable Trait in PHP

Source: https://context7.com/wendelladriel/laravel-validated-dto/llms.txt

Shows how to make DTOs compatible with Livewire components using the `Wireable` trait and implementing the `Livewire\Wireable` interface. This enables seamless data binding and automatic hydration/dehydration of DTO properties within Livewire components. It utilizes `SimpleDTO` as a base and includes casting for properties.

```php
<?php

namespace App\DTOs;

use WendellAdriel\ValidatedDTO\SimpleDTO;
use WendellAdriel\ValidatedDTO\Concerns\Wireable;
use WendellAdriel\ValidatedDTO\Casting\IntegerCast;
use WendellAdriel\ValidatedDTO\Casting\StringCast;
use Livewire\Wireable as LivewireWireable;

class ContactFormDTO extends SimpleDTO implements LivewireWireable
{
    use Wireable;

    public ?string $name;
    public ?string $email;
    public ?string $message;
    public ?int $priority;

    protected function defaults(): array
    {
        return [
            'priority' => 1,
        ];
    }

    protected function casts(): array
    {
        return [
            'name'     => new StringCast(),
            'email'    => new StringCast(),
            'message'  => new StringCast(),
            'priority' => new IntegerCast(),
        ];
    }
}

// In a Livewire Component
namespace App\Livewire;

use Livewire\Component;
use App\DTOs\ContactFormDTO;

class ContactForm extends Component
{
    public ContactFormDTO $form;

    public function mount()
    {
        $this->form = new ContactFormDTO([]);
    }

    public function submit()
    {
        // The DTO is automatically hydrated/dehydrated by Livewire
        $data = $this->form->toArray();

        // Process the form data
        Contact::create($data);

        $this->reset('form');
    }

    public function render()
    {
        return view('livewire.contact-form');
    }
}

// In Blade template (livewire/contact-form.blade.php)
// <input type="text" wire:model="form.name">
// <input type="email" wire:model="form.email">
// <textarea wire:model="form.message"></textarea>
// <select wire:model="form.priority">...</select>
// <button wire:click="submit">Send</button>

```

--------------------------------

### Run Unit Tests with Make

Source: https://github.com/wendelladriel/laravel-validated-dto/blob/main/CONTRIBUTING.md

Executes only the unit tests using a Makefile. This provides a focused test run for individual components of the application.

```bash
make test-unit
```

--------------------------------

### Lint Code with Composer

Source: https://github.com/wendelladriel/laravel-validated-dto/blob/main/CONTRIBUTING.md

Runs the code linting process using Composer to ensure adherence to coding style guidelines. This command helps maintain code quality and consistency.

```bash
composer lint
```

--------------------------------

### Run All Tests with Composer

Source: https://github.com/wendelladriel/laravel-validated-dto/blob/main/CONTRIBUTING.md

Executes all tests defined in the project using Composer. This is crucial for verifying that new changes do not introduce regressions.

```bash
composer test
```

--------------------------------

### Run Unit Tests with Composer

Source: https://github.com/wendelladriel/laravel-validated-dto/blob/main/CONTRIBUTING.md

Executes only the unit tests using Composer. This allows for faster feedback on the correctness of individual components.

```bash
composer test:unit
```

--------------------------------

### Generate DTO Classes via Artisan

Source: https://github.com/wendelladriel/laravel-validated-dto/blob/main/resources/boost/skills/laravel-validated-dto-development/SKILL.md

Use artisan commands to scaffold different types of DTOs. This ensures consistent directory structure and namespace configuration.

```bash
php artisan make:dto UserDTO
php artisan make:dto CheckoutInputDTO --simple
php artisan make:dto UserResourceDTO --resource
```

--------------------------------

### Implementing Type Casting in ValidatedDTO

Source: https://context7.com/wendelladriel/laravel-validated-dto/llms.txt

Demonstrates the implementation of a DTO class using various built-in casters such as StringCast, IntegerCast, CarbonCast, and ModelCast. It shows how to define rules, defaults, and the mapping of input keys to specific caster instances.

```php
<?php

namespace App\DTOs;

use WendellAdriel\ValidatedDTO\ValidatedDTO;
use WendellAdriel\ValidatedDTO\Casting\ArrayCast;
use WendellAdriel\ValidatedDTO\Casting\BooleanCast;
use WendellAdriel\ValidatedDTO\Casting\CarbonCast;
use WendellAdriel\ValidatedDTO\Casting\CarbonImmutableCast;
use WendellAdriel\ValidatedDTO\Casting\CollectionCast;
use WendellAdriel\ValidatedDTO\Casting\DTOCast;
use WendellAdriel\ValidatedDTO\Casting\EnumCast;
use WendellAdriel\ValidatedDTO\Casting\FloatCast;
use WendellAdriel\ValidatedDTO\Casting\IntegerCast;
use WendellAdriel\ValidatedDTO\Casting\ModelCast;
use WendellAdriel\ValidatedDTO\Casting\ObjectCast;
use WendellAdriel\ValidatedDTO\Casting\StringCast;
use Carbon\Carbon;
use Carbon\CarbonImmutable;
use Illuminate\Support\Collection;
use App\Enums\UserStatus;
use App\Models\User;

class FullExampleDTO extends ValidatedDTO
{
    public string $name;
    public int $count;
    public float $price;
    public bool $isActive;
    public array $tags;
    public object $metadata;
    public Collection $items;
    public Carbon $publishedAt;
    public CarbonImmutable $createdAt;
    public UserStatus $status;
    public AddressDTO $address;
    public User $author;

    protected function rules(): array
    {
        return [
            'name'        => ['required', 'string'],
            'count'       => ['required'],
            'price'       => ['required'],
            'isActive'    => ['required'],
            'tags'        => ['required', 'array'],
            'metadata'    => ['required'],
            'items'       => ['required'],
            'publishedAt' => ['required'],
            'createdAt'   => ['required'],
            'status'      => ['required'],
            'address'     => ['required'],
            'author'      => ['required'],
        ];
    }

    protected function casts(): array
    {
        return [
            'name'     => new StringCast(),
            'count'    => new IntegerCast(),
            'price'    => new FloatCast(),
            'isActive' => new BooleanCast(),
            'tags'     => new ArrayCast(),
            'metadata' => new ObjectCast(),
            'items'    => new CollectionCast(),
            'publishedAt' => new CarbonCast('UTC'),
            'createdAt'   => new CarbonImmutableCast('America/New_York', 'Y-m-d H:i:s'),
            'status'   => new EnumCast(UserStatus::class),
            'address'  => new DTOCast(AddressDTO::class),
            'author'   => new ModelCast(User::class),
        ];
    }
}

$dto = new FullExampleDTO([
    'name'        => 'Product',
    'count'       => '100',
    'price'       => '29.99',
    'isActive'    => 'true',
    'tags'        => '["php","laravel"]',
    'metadata'    => ['key' => 'value'],
    'items'       => [1, 2, 3],
    'publishedAt' => '2024-01-15',
    'createdAt'   => '2024-01-15 10:30:00',
    'status'      => 'active',
    'address'     => ['street' => '123 Main St', 'city' => 'NYC'],
    'author'      => ['id' => 1, 'name' => 'Author'],
]);
```

--------------------------------

### Automatic Property Case Conversion with Attributes - PHP

Source: https://context7.com/wendelladriel/laravel-validated-dto/llms.txt

Illustrates using `#[Receive]` and `#[Provide]` attributes to automatically convert property cases (e.g., snake_case to PascalCase) when receiving and providing data. This simplifies handling data from external sources with different naming conventions.

```php
<?php

namespace App\DTOs;

use WendellAdriel\ValidatedDTO\ValidatedDTO;
use WendellAdriel\ValidatedDTO\Attributes\Provide;
use WendellAdriel\ValidatedDTO\Attributes\Receive;
use WendellAdriel\ValidatedDTO\Attributes\Rules;
use WendellAdriel\ValidatedDTO\Concerns\EmptyCasts;
use WendellAdriel\ValidatedDTO\Concerns\EmptyDefaults;
use WendellAdriel\ValidatedDTO\Concerns\EmptyRules;
use WendellAdriel\ValidatedDTO\Enums\PropertyCase;

// Receive snake_case input, provide PascalCase output
#[Receive(PropertyCase::SnakeCase)]
#[Provide(PropertyCase::PascalCase)]
class ApiUserDTO extends ValidatedDTO
{
    use EmptyCasts, EmptyDefaults, EmptyRules;

    #[Rules(['required', 'string'])]
    public string $firstName;

    #[Rules(['required', 'string'])]
    public string $lastName;

    #[Rules(['required', 'email'])]
    public string $emailAddress;

    #[Rules(['required', 'integer'])]
    public int $accountId;
}

// Input: snake_case (from external API)
$dto = new ApiUserDTO([
    'first_name'    => 'John',     // Mapped to firstName
    'last_name'     => 'Doe',      // Mapped to lastName
    'email_address' => 'john@example.com', // Mapped to emailAddress
    'account_id'    => 123,        // Mapped to accountId
]);

echo $dto->firstName;    // "John"
echo $dto->emailAddress; // "john@example.com"

// Output: PascalCase
$output = $dto->toArray();
// [
//     'FirstName'    => 'John',
//     'LastName'     => 'Doe',
//     'EmailAddress' => 'john@example.com',
//     'AccountId'    => 123,
// ]

// Available PropertyCase options:
// PropertyCase::SnakeCase  - converts to/from snake_case
// PropertyCase::PascalCase - converts to/from PascalCase

```

--------------------------------

### Transform DTOs to Output Formats

Source: https://context7.com/wendelladriel/laravel-validated-dto/llms.txt

Shows how to convert DTO instances into arrays, JSON strings, or Eloquent model instances. These methods respect property mappings defined in the DTO's mapToTransform method.

```php
<?php

use App\DTOs\CreateUserDTO;
use App\Models\User;

$dto = CreateUserDTO::fromArray(['name' => 'John Doe', 'email' => 'john@example.com', 'age' => 30, 'active' => true]);

// Convert to array
$array = $dto->toArray();

// Convert to JSON
$json = $dto->toJson();

// Convert to pretty JSON
$prettyJson = $dto->toPrettyJson();

// Convert to Eloquent Model instance
$user = $dto->toModel(User::class);
$user->save();
```

--------------------------------

### Map DTO Property Names for Input and Output - PHP

Source: https://context7.com/wendelladriel/laravel-validated-dto/llms.txt

Demonstrates how to use `mapData` to rename incoming properties and `mapToTransform` to rename properties for output. This is useful for integrating with APIs that use different naming conventions. It shows mapping flat and nested properties.

```php
<?php

namespace App\DTOs;

use WendellAdriel\ValidatedDTO\ValidatedDTO;
use WendellAdriel\ValidatedDTO\Casting\DTOCast;

class NameDTO extends ValidatedDTO
{
    public string $firstName;
    public string $lastName;

    protected function rules(): array
    {
        return [
            'firstName' => ['required', 'string'],
            'lastName'  => ['required', 'string'],
        ];
    }

    protected function defaults(): array
    {
        return [];
    }

    protected function casts(): array
    {
        return [];
    }
}

class UserDTO extends ValidatedDTO
{
    public string $email;
    public NameDTO $name;

    protected function rules(): array
    {
        return [
            'email' => ['required', 'email'],
            'name'  => ['required', 'array'],
        ];
    }

    protected function defaults(): array
    {
        return [];
    }

    protected function casts(): array
    {
        return [
            'name' => new DTOCast(NameDTO::class),
        ];
    }

    // Map incoming data property names to DTO properties
    protected function mapData(): array
    {
        return [
            'email_address' => 'email',         // Map 'email_address' -> 'email'
            'user_name'     => 'name',          // Map 'user_name' -> 'name'
        ];
    }

    // Map DTO properties to export names
    protected function mapToTransform(): array
    {
        return [
            'email' => 'contact_email',         // Export as 'contact_email'
            // Flatten nested DTO properties
            'name.firstName' => 'first_name',   // Export nested as flat keys
            'name.lastName'  => 'last_name',
        ];
    }
}

// Input uses mapped names
$dto = UserDTO::fromArray([
    'email_address' => 'john@example.com',  // Mapped to 'email'
    'user_name' => [                        // Mapped to 'name'
        'firstName' => 'John',
        'lastName'  => 'Doe',
    ],
]);

echo $dto->email;           // "john@example.com"
echo $dto->name->firstName; // "John"

// Output uses transformed names
$output = $dto->toArray();
// [
//     'contact_email' => 'john@example.com',
//     'first_name'    => 'John',
//     'last_name'     => 'Doe',
// ]

```

--------------------------------

### Generate DTO Classes using Artisan

Source: https://context7.com/wendelladriel/laravel-validated-dto/llms.txt

The make:dto Artisan command allows for the rapid scaffolding of DTO classes. It supports flags for standard ValidatedDTOs, SimpleDTOs, and ResourceDTOs.

```bash
# Create a ValidatedDTO (with validation rules)
php artisan make:dto UserDTO

# Create a SimpleDTO (without validation)
php artisan make:dto UserDTO --simple

# Create a ResourceDTO (for API responses)
php artisan make:dto UserResourceDTO --resource

# Force overwrite existing DTO
php artisan make:dto UserDTO --force
```

--------------------------------

### Define and Instantiate a ValidatedDTO

Source: https://context7.com/wendelladriel/laravel-validated-dto/llms.txt

Create a DTO by extending the ValidatedDTO class and implementing rules, defaults, and casts. The DTO automatically validates input upon instantiation and throws a ValidationException if rules are violated.

```php
<?php

namespace App\DTOs;

use WendellAdriel\ValidatedDTO\ValidatedDTO;
use WendellAdriel\ValidatedDTO\Casting\IntegerCast;
use WendellAdriel\ValidatedDTO\Casting\StringCast;

class CreateUserDTO extends ValidatedDTO
{
    public string $name;
    public string $email;
    public ?int $age;
    public bool $active;

    protected function rules(): array
    {
        return [
            'name'   => ['required', 'string', 'min:3', 'max:255'],
            'email'  => ['required', 'email', 'max:255'],
            'age'    => ['nullable', 'integer', 'min:0'],
            'active' => ['sometimes', 'boolean'],
        ];
    }

    protected function defaults(): array
    {
        return [
            'active' => true,
        ];
    }

    protected function casts(): array
    {
        return [
            'name'   => new StringCast(),
            'email'  => new StringCast(),
            'age'    => new IntegerCast(),
        ];
    }

    public function messages(): array
    {
        return ['email.email' => 'Please provide a valid email address.'];
    }

    public function attributes(): array
    {
        return ['email' => 'email address'];
    }
}

try {
    $dto = new CreateUserDTO([
        'name'  => 'John Doe',
        'email' => 'john@example.com',
        'age'   => 30,
    ]);

    echo $dto->name;
    echo $dto->email;
    echo $dto->age;
    echo $dto->active;
} catch (\Illuminate\Validation\ValidationException $e) {
    $errors = $e->errors();
}
```

--------------------------------

### Define DTOs using PHP 8 Attributes

Source: https://context7.com/wendelladriel/laravel-validated-dto/llms.txt

Demonstrates the use of PHP 8 attributes for defining validation rules, default values, type casting, and property mapping. This declarative approach reduces boilerplate code when combined with the EmptyRules, EmptyCasts, and EmptyDefaults traits.

```php
<?php

namespace AppDTOs;

use WendellAdrielValidatedDTOValidatedDTO;
use WendellAdrielValidatedDTOAttributes\Cast;
use WendellAdrielValidatedDTOAttributes\DefaultValue;
use WendellAdrielValidatedDTOAttributes\Map;
use WendellAdrielValidatedDTOAttributes\Rules;
use WendellAdrielValidatedDTOCasting\ArrayCast;
use WendellAdrielValidatedDTOCasting\BooleanCast;
use WendellAdrielValidatedDTOCasting\FloatCast;
use WendellAdrielValidatedDTOCasting\IntegerCast;
use WendellAdrielValidatedDTOConcerns\EmptyCasts;
use WendellAdrielValidatedDTOConcerns\EmptyDefaults;
use WendellAdrielValidatedDTOConcerns\EmptyRules;

class ProductDTO extends ValidatedDTO
{
    use EmptyCasts, EmptyDefaults, EmptyRules;

    #[Rules(['required', 'string', 'min:3', 'max:255'])]
    public string $name;

    #[Rules(
        rules: ['required', 'email', 'max:255'],
        messages: ['email.email' => 'Invalid email format']
    )]
    public string $contactEmail;

    #[Rules(['sometimes', 'boolean'])]
    #[DefaultValue(true)]
    #[Cast(BooleanCast::class)]
    public bool $isActive;

    #[Rules(['sometimes', 'integer', 'min:0'])]
    #[Cast(IntegerCast::class)]
    public ?int $stock;

    #[Rules(['sometimes', 'array'])]
    #[Cast(type: ArrayCast::class, param: FloatCast::class)]
    public ?array $prices;

    #[Rules(['required', 'string'])]
    #[Map(data: 'product_code', transform: 'sku')]
    public string $code;
}
```

--------------------------------

### Create Custom Casters with Castable Interface

Source: https://context7.com/wendelladriel/laravel-validated-dto/llms.txt

Implements the Castable interface to define reusable custom logic for data transformation. This approach allows complex casting, such as converting strings or numbers into Money objects, and integrates directly into the DTO's cast configuration.

```php
<?php

namespace AppCasters;

use WendellAdrielValidatedDTOCastingCastable;
use WendellAdrielValidatedDTOExceptionsCastException;
use BrickMoneyMoney;

class MoneyCast implements Castable
{
    public function __construct(
        private string $currency = 'USD'
    ) {}

    public function cast(string $property, mixed $value): Money
    {
        try {
            if ($value instanceof Money) {
                return $value;
            }

            if (is_numeric($value)) {
                return Money::of($value, $this->currency);
            }

            if (is_string($value) && preg_match('/^[\d.,]+$/', $value)) {
                $cleaned = str_replace(',', '', $value);
                return Money::of($cleaned, $this->currency);
            }

            throw new CastException($property);
        } catch (\Throwable $e) {
            throw new CastException($property);
        }
    }
}
```

--------------------------------

### Inject DTOs into Laravel Controllers

Source: https://github.com/wendelladriel/laravel-validated-dto/blob/main/resources/boost/skills/laravel-validated-dto-development/SKILL.md

Shows the preferred method of type-hinting DTOs directly in controller methods for automatic resolution.

```php
public function store(UserDTO $dto)
{
    // ...
}
```

--------------------------------

### Cast Nested DTOs and Collections with Laravel Validated DTO

Source: https://context7.com/wendelladriel/laravel-validated-dto/llms.txt

Demonstrates how to cast nested objects to DTOs and collections of DTOs using `DTOCast`, `ArrayCast`, and `CollectionCast`. This allows for structured data handling within your DTOs, including arrays and collections of other DTOs.

```php
<?php

namespace App\DTOs;

use WendellAdriel\ValidatedDTO\ValidatedDTO;
use WendellAdriel\ValidatedDTO\Casting\ArrayCast;
use WendellAdriel\ValidatedDTO\Casting\CollectionCast;
use WendellAdriel\ValidatedDTO\Casting\DTOCast;
use Illuminate\Support\Collection;

class AddressDTO extends ValidatedDTO
{
    public string $street;
    public string $city;
    public string $country;

    protected function rules(): array
    {
        return [
            'street'  => ['required', 'string'],
            'city'    => ['required', 'string'],
            'country' => ['required', 'string'],
        ];
    }

    protected function defaults(): array
    {
        return ['country' => 'USA'];
    }

    protected function casts(): array
    {
        return [];
    }
}

class OrderItemDTO extends ValidatedDTO
{
    public string $product;
    public int $quantity;
    public float $price;

    protected function rules(): array
    {
        return [
            'product'  => ['required', 'string'],
            'quantity' => ['required', 'integer', 'min:1'],
            'price'    => ['required', 'numeric', 'min:0'],
        ];
    }

    protected function defaults(): array
    {
        return [];
    }

    protected function casts(): array
    {
        return [];
    }
}

class OrderDTO extends ValidatedDTO
{
    public string $orderNumber;
    public AddressDTO $shippingAddress;
    public AddressDTO $billingAddress;
    public array $itemsArray;
    public Collection $itemsCollection;

    protected function rules(): array
    {
        return [
            'orderNumber'     => ['required', 'string'],
            'shippingAddress' => ['required', 'array'],
            'billingAddress'  => ['required', 'array'],
            'itemsArray'      => ['required', 'array'],
            'itemsCollection' => ['required', 'array'],
        ];
    }

    protected function defaults(): array
    {
        return [];
    }

    protected function casts(): array
    {
        return [
            // Single nested DTO
            'shippingAddress' => new DTOCast(AddressDTO::class),
            'billingAddress'  => new DTOCast(AddressDTO::class),

            // Array of DTOs
            'itemsArray'      => new ArrayCast(new DTOCast(OrderItemDTO::class)),

            // Collection of DTOs
            'itemsCollection' => new CollectionCast(new DTOCast(OrderItemDTO::class)),
        ];
    }
}

// Usage
$order = new OrderDTO([
    'orderNumber' => 'ORD-001',
    'shippingAddress' => [
        'street'  => '123 Main St',
        'city'    => 'New York',
        'country' => 'USA',
    ],
    'billingAddress' => [
        'street'  => '456 Oak Ave',
        'city'    => 'Boston',
        'country' => 'USA',
    ],
    'itemsArray' => [
        ['product' => 'Widget', 'quantity' => 2, 'price' => 19.99],
        ['product' => 'Gadget', 'quantity' => 1, 'price' => 49.99],
    ],
    'itemsCollection' => [
        ['product' => 'Widget', 'quantity' => 2, 'price' => 19.99],
        ['product' => 'Gadget', 'quantity' => 1, 'price' => 49.99],
    ],
]);

// Access nested DTOs
echo $order->shippingAddress->city;    // "New York"
echo $order->itemsArray[0]->product;   // "Widget"
echo $order->itemsCollection->first()->quantity; // 2

```

--------------------------------

### ResourceDTO: API Response DTOs in PHP

Source: https://context7.com/wendelladriel/laravel-validated-dto/llms.txt

Illustrates the use of ResourceDTO for creating API response DTOs that implement Laravel's `Responsable` interface. It shows how to define DTOs for single resources, collections, and how to customize HTTP status codes and headers. This DTO type can be directly returned from controllers.

```php
<?php

namespace App\DTOs;

use WendellAdriel\ValidatedDTO\ResourceDTO;
use WendellAdriel\ValidatedDTO\Casting\IntegerCast;
use WendellAdriel\ValidatedDTO\Casting\StringCast;

class UserResourceDTO extends ResourceDTO
{
    public string $name;
    public string $email;
    public int $age;

    protected function defaults(): array
    {
        return [];
    }

    protected function casts(): array
    {
        return [
            'name'  => new StringCast(),
            'email' => new StringCast(),
            'age'   => new IntegerCast(),
        ];
    }
}

// In a Controller - Single resource
class UserController extends Controller
{
    public function show(User $user)
    {
        // Returns JSON response automatically
        return new UserResourceDTO([
            'name'  => $user->name,
            'email' => $user->email,
            'age'   => $user->age,
        ]);
        // Response: {"name":"John Doe","email":"john@example.com","age":30}
    }

    // With custom status and headers
    public function created(Request $request)
    {
        $user = User::create($request->validated());

        return new UserResourceDTO(
            ['name' => $user->name, 'email' => $user->email, 'age' => $user->age],
            201,  // HTTP status code
            ['X-Custom-Header' => 'value']  // Custom headers
        );
    }

    // Collection of resources
    public function index()
    {
        $users = User::all()->map(fn($u) => [
            'name'  => $u->name,
            'email' => $u->email,
            'age'   => $u->age,
        ])->toArray();

        return UserResourceDTO::collection($users);
        // Response: [{"name":"John","email":"john@example.com","age":30},...]
    }
}

```

--------------------------------

### Implement Eloquent Model Casting with DTOs

Source: https://context7.com/wendelladriel/laravel-validated-dto/llms.txt

Demonstrates how to define DTO classes extending ValidatedDTO and map them to Eloquent model attributes using the $casts property. This enables automatic transformation of JSON database columns into DTO objects upon retrieval and saving.

```php
namespace App\DTOs;

use WendellAdriel\ValidatedDTO\ValidatedDTO;

class AddressDTO extends ValidatedDTO {
    public string $street;
    public string $city;
    public string $state;
    public string $zipCode;
    public string $country;

    protected function rules(): array {
        return [
            'street'  => ['required', 'string'],
            'city'    => ['required', 'string'],
            'state'   => ['required', 'string'],
            'zipCode' => ['required', 'string'],
            'country' => ['required', 'string'],
        ];
    }

    protected function defaults(): array {
        return ['country' => 'USA'];
    }

    protected function casts(): array {
        return [];
    }
}

// In Eloquent Model
namespace App\Models;

use Illuminate\Database\Eloquent\Model;
use App\DTOs\AddressDTO;

class User extends Model {
    protected $fillable = ['name', 'email', 'address'];
    protected $casts = [
        'address' => AddressDTO::class,
    ];
}
```

--------------------------------

### Custom Callable Casters for Data Transformation in Laravel Validated DTO

Source: https://context7.com/wendelladriel/laravel-validated-dto/llms.txt

Illustrates how to use custom callable functions for data casting logic within Laravel Validated DTO. This approach offers flexibility for transforming property values directly using closures.

```php
<?php

namespace App\DTOs;

use WendellAdriel\ValidatedDTO\ValidatedDTO;

class ProductDTO extends ValidatedDTO
{
    public string $name;
    public string $sku;
    public float $price;

    protected function rules(): array
    {
        return [
            'name'  => ['required', 'string'],
            'sku'   => ['required', 'string'],
            'price' => ['required', 'numeric'],
        ];
    }

    protected function defaults(): array
    {
        return [];
    }

    protected function casts(): array
    {
        return [
            // Callable cast - receives property name and value
            'name' => fn(string $property, mixed $value) => ucwords(strtolower($value)),

            // Transform SKU to uppercase
            'sku' => fn(string $property, mixed $value) => strtoupper($value),

            // Round price to 2 decimals
            'price' => fn(string $property, mixed $value) => round((float) $value, 2),
        ];
    }
}

// Usage
$dto = new ProductDTO([
    'name'  => 'WIRELESS MOUSE',  // Cast to: "Wireless Mouse"
    'sku'   => 'wm-001',          // Cast to: "WM-001"
    'price' => '29.999',          // Cast to: 29.99
]);

```

--------------------------------

### Custom Validation with after() Hook in PHP

Source: https://context7.com/wendelladriel/laravel-validated-dto/llms.txt

Demonstrates how to add custom validation logic to a DTO that runs after standard validation rules. It checks for password confirmation match, ensures the new password differs from the current one, and validates password strength using a private helper method. This requires the `ValidatedDTO` base class and `IlluminateValidationValidator`.

```php
<?php

namespace App\DTOs;

use WendellAdriel\ValidatedDTO\ValidatedDTO;
use Illuminate\Validation\Validator;

class PasswordResetDTO extends ValidatedDTO
{
    public string $password;
    public string $passwordConfirmation;
    public string $currentPassword;

    protected function rules(): array
    {
        return [
            'password'             => ['required', 'string', 'min:8'],
            'passwordConfirmation' => ['required', 'string'],
            'currentPassword'      => ['required', 'string'],
        ];
    }

    protected function defaults(): array
    {
        return [];
    }

    protected function casts(): array
    {
        return [];
    }

    // Custom validation logic
    protected function after(Validator $validator): void
    {
        // Check password confirmation matches
        if ($this->password !== $this->passwordConfirmation) {
            $validator->errors()->add(
                'passwordConfirmation',
                'The password confirmation does not match.'
            );
        }

        // Ensure new password is different from current
        if ($this->password === $this->currentPassword) {
            $validator->errors()->add(
                'password',
                'The new password must be different from your current password.'
            );
        }

        // Complex business rule validation
        if (!$this->isPasswordStrong($this->password)) {
            $validator->errors()->add(
                'password',
                'Password must contain uppercase, lowercase, number, and special character.'
            );
        }
    }

    private function isPasswordStrong(string $password): bool
    {
        return preg_match('/[A-Z]/', $password) &&
               preg_match('/[a-z]/', $password) &&
               preg_match('/[0-9]/', $password) &&
               preg_match('/[^A-Za-z0-9]/', $password);
    }
}

try {
    $dto = new PasswordResetDTO([
        'password'             => 'NewP@ss123',
        'passwordConfirmation' => 'NewP@ss123',
        'currentPassword'      => 'OldPass123',
    ]);
} catch (\Illuminate\Validation\ValidationException $e) {
    $errors = $e->errors();
}

```

--------------------------------

### Enable Lazy Validation in PHP

Source: https://context7.com/wendelladriel/laravel-validated-dto/llms.txt

Lazy validation defers casting and validation until the `validate()` method is explicitly called. This can be enabled using the #[Lazy] attribute on the DTO class or by setting the `$lazyValidation` property to `true`. It's useful for building DTOs incrementally and controlling when validation occurs.

```php
<?php

namespace App\DTOs;

use WendellAdriel\ValidatedDTO\ValidatedDTO;
use WendellAdriel\ValidatedDTO\Attributes\Lazy;
use WendellAdriel\ValidatedDTO\Attributes\Rules;
use WendellAdriel\ValidatedDTO\Casting\IntegerCast;
use WendellAdriel\ValidatedDTO\Casting\StringCast;
use WendellAdriel\ValidatedDTO\Concerns\EmptyCasts;
use WendellAdriel\ValidatedDTO\Concerns\EmptyDefaults;
use WendellAdriel\ValidatedDTO\Concerns\EmptyRules;

// Method 1: Using #[Lazy] attribute
#[Lazy]
class LazyUserDTO extends ValidatedDTO
{
    use EmptyCasts, EmptyDefaults, EmptyRules;

    #[Rules(['required', 'string'])]
    public string $name;

    #[Rules(['required', 'integer'])]
    public int $age;
}

// Method 2: Using property
class LazyProductDTO extends ValidatedDTO
{
    public bool $lazyValidation = true;

    public ?string $name;
    public ?int $quantity;

    protected function rules(): array
    {
        return [
            'name'     => ['required', 'string'],
            'quantity' => ['required', 'integer', 'min:0'],
        ];
    }

    protected function defaults(): array
    {
        return [];
    }

    protected function casts(): array
    {
        return [
            'name'     => new StringCast(),
            'quantity' => new IntegerCast(),
        ];
    }
}

// Usage - No validation on construction
$dto = new LazyProductDTO([
    'name'     => 'Widget',
    'quantity' => '100',
]);

// Values stored but NOT cast yet
echo $dto->quantity; // "100" (string, not cast)

// Explicitly validate and cast
$dto->validate();

echo $dto->quantity; // 100 (integer, now cast)

// Validation errors are thrown on validate() call
$invalidDto = new LazyProductDTO([
    'name' => '', // Invalid - required
]);

try {
    $invalidDto->validate();
} catch (\Illuminate\Validation\ValidationException $e) {
    $errors = $e->errors();
    // ['name' => ['The name field is required.']]
}

```

--------------------------------

### Exclude Properties with SkipOnTransform Attribute in PHP

Source: https://context7.com/wendelladriel/laravel-validated-dto/llms.txt

The #[SkipOnTransform] attribute in PHP allows specific properties of a ValidatedDTO to be excluded from array and JSON output. This is useful for sensitive data like passwords or API secrets. Properties are still accessible directly from the DTO instance.

```php
<?php

namespace App\DTOs;

use WendellAdriel\ValidatedDTO\ValidatedDTO;
use WendellAdriel\ValidatedDTO\Attributes\Rules;
use WendellAdriel\ValidatedDTO\Attributes\SkipOnTransform;
use WendellAdriel\ValidatedDTO\Concerns\EmptyCasts;
use WendellAdriel\ValidatedDTO\Concerns\EmptyDefaults;
use WendellAdriel\ValidatedDTO\Concerns\EmptyRules;

class UserCredentialsDTO extends ValidatedDTO
{
    use EmptyCasts, EmptyDefaults, EmptyRules;

    #[Rules(['required', 'string'])]
    public string $username;

    #[Rules(['required', 'email'])]
    public string $email;

    // This property will NOT be included in toArray()/toJson() output
    #[Rules(['required', 'string', 'min:8'])]
    #[SkipOnTransform]
    public string $password;

    // Sensitive data excluded from exports
    #[Rules(['sometimes', 'string'])]
    #[SkipOnTransform]
    public ?string $apiSecret;
}

$dto = new UserCredentialsDTO([
    'username'  => 'johndoe',
    'email'     => 'john@example.com',
    'password'  => 'secureP@ss123',
    'apiSecret' => 'secret-key-123',
]);

// Properties are accessible
echo $dto->password;  // "secureP@ss123"
echo $dto->apiSecret; // "secret-key-123"

// But excluded from exports
$array = $dto->toArray();
// [
//     'username' => 'johndoe',
//     'email'    => 'john@example.com',
//     // 'password' and 'apiSecret' are NOT included
// ]

```
Tokens:
Raw