### Install spatie/laravel-data Package Source: https://spatie.be/docs/laravel-data/v3/installation-setup Installs the spatie/laravel-data package using Composer. This is the primary step to integrate the package into your Laravel project. ```bash composer require spatie/laravel-data ``` -------------------------------- ### Creating Validated Data Object Without Request Source: https://spatie.be/docs/laravel-data/v3/getting-started/quickstart This example demonstrates how to create a data object with validation enabled, even when not originating from an HTTP request. The `::validateAndCreate()` method ensures that all provided values are validated against the data object's rules before instantiation. ```php $post = PostData::validateAndCreate([ // Before creating the object, each value will be validated ]); ``` -------------------------------- ### Instantiate a Data Object Directly - PHP Source: https://spatie.be/docs/laravel-data/v3/getting-started/quickstart Demonstrates how to create an instance of the `PostData` object by directly calling its constructor with the required arguments. This is a straightforward way to instantiate data objects when all values are known. ```PHP $post = new PostData( 'Hello laravel-data', 'This is an introduction post for the new package', PostStatus::published, CarbonImmutable::now() ); ``` -------------------------------- ### Include Specific Post Properties in JSON Output Source: https://spatie.be/docs/laravel-data/v3/getting-started/quickstart Demonstrates how to selectively include specific properties of a related 'posts' collection when converting a data object to JSON. This allows for fine-grained control over the serialized output. ```php $postData->include('posts.{title,status}')->toJson(); ``` -------------------------------- ### Publish Laravel Data Configuration File Source: https://spatie.be/docs/laravel-data/v3/installation-setup Publishes the configuration file for the spatie/laravel-data package using the Artisan command. This allows for customization of package behavior. ```bash php artisan vendor:publish --provider="Spatie\LaravelData\LaravelDataServiceProvider" --tag="data-config" ``` -------------------------------- ### Generate Empty Data Blueprint with Defaults Source: https://spatie.be/docs/laravel-data/v3/getting-started/quickstart This PHP code demonstrates how to generate an empty blueprint for `PostData` while providing default values for specific fields. Here, the `status` is set to `PostStatus::draft` by default. ```php PostData::empty([ 'status' => PostStatus::draft; ]); ``` -------------------------------- ### Include All Post Properties in JSON Output Source: https://spatie.be/docs/laravel-data/v3/getting-started/quickstart Shows how to include all properties of a related 'posts' collection when serializing a data object to JSON. This is a convenient way to ensure all data within the related posts is present in the output. ```php $postData->include('posts.*')->toJson(); ``` -------------------------------- ### Default Laravel Data Configuration Source: https://spatie.be/docs/laravel-data/v3/installation-setup The default configuration file for spatie/laravel-data, which defines settings for date formatting, global transformers, casts, rule inferrers, normalizers, and data wrapping. ```php return [ /* * The package will use this format when working with dates. If this option * is an array, it will try to convert from the first format that works, * and will serialize dates using the first format from the array. */ 'date_format' => DATE_ATOM, /* * Global transformers will take complex types and transform them into simple * types. */ 'transformers' => [ DateTimeInterface::class => \Spatie\LaravelData\Transformers\DateTimeInterfaceTransformer::class, \Illuminate\Contracts\Support\Arrayable::class => \Spatie\LaravelData\Transformers\ArrayableTransformer::class, BackedEnum::class => Spatie\LaravelData\Transformers\EnumTransformer::class, ], /* * Global casts will cast values into complex types when creating a data * object from simple types. */ 'casts' => [ DateTimeInterface::class => Spatie\LaravelData\Casts\DateTimeInterfaceCast::class, BackedEnum::class => Spatie\LaravelData\Casts\EnumCast::class, ], /* * Rule inferrers can be configured here. They will automatically add * validation rules to properties of a data object based upon * the type of the property. */ 'rule_inferrers' => [ Spatie\LaravelData\RuleInferrers\SometimesRuleInferrer::class, Spatie\LaravelData\RuleInferrers\NullableRuleInferrer::class, Spatie\LaravelData\RuleInferrers\RequiredRuleInferrer::class, Spatie\LaravelData\RuleInferrers\BuiltInTypesRuleInferrer::class, Spatie\LaravelData\RuleInferrers\AttributesRuleInferrer::class, ], /** * Normalizers return an array representation of the payload, or null if * it cannot normalize the payload. The normalizers below are used for * every data object, unless overridden in a specific data object class. */ 'normalizers' => [ Spatie\LaravelData\Normalizers\ModelNormalizer::class, Spatie\LaravelData\Normalizers\ArrayableNormalizer::class, Spatie\LaravelData\Normalizers\ObjectNormalizer::class, Spatie\LaravelData\Normalizers\ArrayNormalizer::class, Spatie\LaravelData\Normalizers\JsonNormalizer::class, ], /* * Data objects can be wrapped into a key like 'data' when used as a resource, * this key can be set globally here for all data objects. You can pass in * `null` if you want to disable wrapping. */ 'wrap' => null, /** * Adds a specific caster to the Symphony VarDumper component which hides * some properties from data objects and collections when being dumped * by `dump` or `dd`. Can be 'enabled', 'disabled' or 'development' * which will only enable the caster locally. */ 'var_dumper_caster_mode' => 'development', ]; ``` -------------------------------- ### Create a Data Object from an Array - PHP Source: https://spatie.be/docs/laravel-data/v3/getting-started/quickstart Shows how to create a `PostData` object from an associative array using the `from` method. This is useful when data is received in an array format, such as from API requests or database results. ```PHP $post = PostData::from([ 'title' => 'Hello laravel-data', 'content' => 'This is an introduction post for the new package', 'status' => PostStatus::published, 'published_at' => CarbonImmutable::now(), ]); ``` -------------------------------- ### Data Object with Custom Validation Attribute Source: https://spatie.be/docs/laravel-data/v3/getting-started/quickstart This example shows how to enhance a `PostData` object by adding custom validation attributes. The `#[Date]` attribute is applied to the `published_at` property, ensuring that the date format is validated automatically by Laravel Data. ```php class PostData extends Data { public function __construct( public string $title, public string $content, public PostStatus $status, #[Date] public ?CarbonImmutable $published_at ) { } } ``` -------------------------------- ### Controller with Laravel Data for Automatic Validation and Creation Source: https://spatie.be/docs/laravel-data/v3/getting-started/quickstart This controller showcases the simplified approach using Laravel Data. By injecting the `PostData` object directly, the package automatically handles request validation and data object creation, significantly reducing boilerplate code. ```php class DataController { public function __invoke(PostData $postData) { Post::create($postData->toArray()); return redirect()->back(); } } ``` -------------------------------- ### Configure Transformers in Laravel Data Source: https://spatie.be/docs/laravel-data/v3/getting-started/quickstart This configuration snippet shows how to register transformers for specific classes. It maps `DateTimeInterface` to `DateTimeInterfaceTransformer` and `Arrayable` to `ArrayableTransformer`, enabling automatic transformation of these types when needed. ```php 'transformers' => [ DateTimeInterface::class => \Spatie\LaravelData\Transformers\DateTimeInterfaceTransformer::class, \Illuminate\Contracts\Support\Arrayable::class => \Spatie\LaravelData\Transformers\ArrayableTransformer::class, ] ``` -------------------------------- ### Transform Eloquent Model to Data Object - PHP Source: https://spatie.be/docs/laravel-data/v3/getting-started/quickstart Illustrates how to convert an Eloquent `Post` model instance into a `PostData` object using the `from` method. This is a common pattern for API responses or when you need to structure model data. ```PHP PostData::from(Post::findOrFail($id)); ``` -------------------------------- ### Controller with Manual Validation and Data Population Source: https://spatie.be/docs/laravel-data/v3/getting-started/quickstart This controller demonstrates the traditional Laravel approach to handling requests, including manual validation and populating a data object from request inputs. It requires explicit mapping of request data to the data object's properties and manual date parsing. ```php class DataController { public function __invoke(Request $request) { $request->validate($this->rules()); $postData = PostData::from([ 'title' => $request->input('title'), 'content' => $request->input('content'), 'status' => $request->enum('status', PostStatus::class), 'published_at' => $request->has('published_at') ? CarbonImmutable::createFromFormat(DATE_ATOM, $request->input('published_at')) : null, ]); Post::create($postData->toArray()); return redirect()->back(); } private function rules(): array { return [ 'title' => ['required', 'string'], 'content' => ['required', 'string'], 'status' => ['required', new Enum(PostStatus::class)], 'published_at' => ['nullable', 'date'], ]; } } ``` -------------------------------- ### Generate Empty Data Blueprint Source: https://spatie.be/docs/laravel-data/v3/getting-started/quickstart This PHP code shows how to generate an empty blueprint for the `PostData` object using the `empty()` method. This is useful for creating forms or initial data structures where all fields are initially null. ```php PostData::empty(); ``` -------------------------------- ### Instantiate AuthorData with PostData Collection (PHP) Source: https://spatie.be/docs/laravel-data/v3/getting-started/quickstart Demonstrates two methods for creating an AuthorData object. The first method uses direct instantiation with a manually created DataCollection of PostData. The second method utilizes the `from` method, which automatically converts an array of post data into the desired nested structure, simplifying data mapping. ```php new AuthorData( 'Ruben Van Assche', PostData::collection([ new PostData('Hello laravel-data', 'This is an introduction post for the new package,' PostStatus::draft, null, null), new PostData('What is a data object', 'How does it work?', PostStatus::draft, null, null), ]) ); ``` ```php AuthorData::from([ 'name' => 'Ruben Van Assche', 'posts' => [ [ 'title' => 'Hello laravel-data', 'content' => 'This is an introduction post for the new package', 'status' => PostStatus::draft, ], [ 'title' => 'What is a data object', 'content' => 'How does it work', 'status' => PostStatus::published, ], ], ]); ``` -------------------------------- ### Define a Data Object with Constructor - PHP Source: https://spatie.be/docs/laravel-data/v3/getting-started/quickstart Defines a data object `PostData` by extending the base `Data` class. It uses a constructor with public properties for title, content, status, and an optional published date. This is the fundamental way to structure data for the package. ```PHP use Spatie\LaravelData\Data; class PostData extends Data { public function __construct( public string $title, public string $content, public PostStatus $status, public ?CarbonImmutable $published_at ) { } } ``` -------------------------------- ### Create Data Object from Array Source: https://spatie.be/docs/laravel-data/v3/getting-started/quickstart This PHP code demonstrates how to create a `PostData` object from an associative array. It populates the `title`, `content`, `status`, `image` (with filename and size), and `published_at` properties. The `ImageTransformer` will automatically process the image data. ```php public function __invoke() { return PostData::from([ 'title' => 'Hello laravel-data', 'content' => 'This is an introduction post for the new package', 'status' => PostStatus::published, 'image' => [ 'filename' => 'images/8JQtgd0XaPtt9CqkPJ3eWFVV4BAp6JR9ltYAIKqX.png', 'size' => 16524 ], 'published_at' => CarbonImmutable::create(2020, 05, 16), ]); } ``` -------------------------------- ### Creating Data Object Without Validation (Non-Request Context) Source: https://spatie.be/docs/laravel-data/v3/getting-started/quickstart This code snippet illustrates how to create a data object using the `::from()` method in a context where request validation is not automatically applied. As long as the provided values are compatible with the property types, the object will be instantiated without validation checks. ```php $post = PostData::from([ // As long as PHP accepts the values for the properties, the object will be created ]); ``` -------------------------------- ### Generating Validation Rules from Data Object Source: https://spatie.be/docs/laravel-data/v3/getting-started/quickstart This snippet demonstrates how to programmatically retrieve the validation rules that Laravel Data will generate for a given data object. It takes the request's array data and passes it to `PostData::getValidationRules` to inspect the generated rules. ```php class DataController { public function __invoke(Request $request) { dd(PostData::getValidationRules($request->toArray())); } } ``` -------------------------------- ### Implement a Custom Image Transformer Source: https://spatie.be/docs/laravel-data/v3/getting-started/quickstart This PHP code defines a custom transformer for an `Image` object. It takes an `Image` object as input and returns a URL string by accessing the `filename` property. This allows for transforming complex image objects into simple URL strings. ```php class ImageTransformer implements Transformer { public function transform(DataProperty $property, mixed $value): string { if (! $value instanceof Image) { throw new Exception("Not an image"); } return url($value->filename); } } ``` -------------------------------- ### Install spatie/laravel-typescript-transformer Source: https://spatie.be/docs/laravel-data/v3/advanced-usage/typescript Installs the necessary package for transforming data objects to TypeScript. This is a prerequisite for using the TypeScript generation features. ```bash composer require spatie/laravel-typescript-transformer ``` -------------------------------- ### Custom Data Object Creation from String Source: https://spatie.be/docs/laravel-data/v3/getting-started/quickstart This PHP code defines a static magic creation method, fromString, within a Laravel Data object. This method allows the PostData object to be created from a pipe-separated string, parsing the title, status, and content accordingly. It demonstrates a flexible way to instantiate data objects from custom formats. ```php use Spatie\LaravelData\Data; use Spatie\LaravelData\Attributes\WithCast; use Carbon\CarbonImmutable; class PostData extends Data { public function __construct( public string $title, public string $content, public PostStatus $status, #[WithCast(ImageCast::class)] public ?Image $image, #[Date] public ?CarbonImmutable $published_at ) { } public static function fromString(string $post): PostData { $fields = explode('|', $post); return new self( $fields[0], $fields[2], PostStatus::from($fields[1]), null, null ); } } ``` -------------------------------- ### Define AuthorData with Lazy Posts in PHP Source: https://spatie.be/docs/laravel-data/v3/getting-started/quickstart This snippet defines an AuthorData class that uses lazy properties for its 'posts' attribute. The posts are loaded only when explicitly requested, optimizing performance by avoiding unnecessary data transfer. It includes a static method `fromModel` to create AuthorData instances from an Author Eloquent model. ```php class AuthorData extends DataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataDataData ``` -------------------------------- ### Custom Image Casting Implementation Source: https://spatie.be/docs/laravel-data/v3/getting-started/quickstart This PHP code defines a custom cast for an Image object. It handles two scenarios: creating an Image from an UploadedFile (saving it and getting the filename) or from an array containing 'filename' and 'size'. If neither scenario matches, it throws an Uncastable exception. ```php use Illuminate\Http\UploadedFile; use Spatie\LaravelData\Casts\Cast; use Spatie\LaravelData\Casts\Uncastable; use Spatie\LaravelData\Support\DataProperty; use Str; class ImageCast implements Cast { public function cast(DataProperty $property, mixed $value, array $context): Image { // Scenario A if ($value instanceof UploadedFile) { $filename = $value->store('images', 'public'); return new Image( $filename, $value->getSize(), ); } // Scenario B if (is_array($value)) { return new Image( $value['filename'], $value['size'], ); } throw Uncastable::create(); } } ``` -------------------------------- ### Get All Rules from Collection - PHP Source: https://spatie.be/docs/laravel-data/v3/advanced-usage/creating-a-rule-inferrer This example shows how to retrieve all the validation rules currently stored within the `RulesCollection` object. The `all()` method returns an array of `ValidationRule` objects. ```php $rules->all(); ```