Support true computed properties?

[ragulka]

I noticed v3.5.0 introduced Computed properties, however these seem to be very limited in their usage:

• they won't automatically recalculate when an underlying property changes
• they can be manually overridden at any point
• there's no easy way to exclude all computed properties from the data object

Ideally, we could provide Closure for the computed property, and when the property is accessed, the closure is evaluated and the result is returned - pretty much the same as Laravel model accessors.

Perhaps something like the example below. The implementation could also be totally different - this just illustrates the idea:

use Spatie\LaravelData\Data;
use Spatie\LaravelData\Attributes\Computed;

class SongData extends Data
{
    #[Computed('getFullName')] // the argument indicates the closure/getter for the computed prop
    public string $full_name; // accessing this property will call the closure

    public function __construct(
        public string $first_name,
        public string $last_name,
    ) {
    }

    protected function getFullName(): string
    {
        return "{$this->first_name} {$this->last_name}";
    }
}

$data = SongData::from(['first_name' => 'Ruben', 'last_name' => 'Van Assche']);

echo $data->full_name; // "Ruben Van Assche"

$data->first_name = 'Sir Ruben';

echo $data->full_name; // "Sir Ruben Van Assche"

$data->excludeComputed(); // automatically excludes all properties with #[Computed]

[rubenvanassche]

I think computed properties in Laravel are kinda of an anti-pattern, your IDE doesn't have any idea what's happening and it relies on a lot of magic.

Adding computed properties like you describe also seems a lot of work I'm not willing to do at the moment, if it can be done by including a trait (which should I think be possible) maybe I'll add it in to the package as an optional feature which can be added. But this is a huge effort if you want to get the details right (transformation, validation, name mapping, ....)

[ragulka]

I see what you mean, and I can definitely understand the pain point of lack of IDE support for Laravel's computed properties/attributes.

For anyone interested, though, here's how I ended up implementing quasi-computed properties for my data objects. I ended up combining Computed with Lazy, so that the computed property is evaluated when the data object is converted to an array (usually happens when sending data to the frontend, in my case):

#[TypeScript]
class ProductData extends Data
{
    use FormatsMoney;
    
    #[Computed]
    public string|Lazy $price_for_humans;

    public function __construct(
        public string $name,
        public float $price,
    ) {
        $this->price_for_humans = Lazy::create(fn () => $this->formatMoney($this->price));
    }

    public function getComputedProperties(): array
    {
        return app(DataConfig::class)
            ->getDataClass($this instanceof DataCollectable ? $this->dataClass : static::class)
            ->properties
            ->filter(fn ($property) => $property->computed)
            ->keys()
            ->toArray();
    }

    public function exceptComputed(): static
    {
        return $this->except(...$this->getComputedProperties());
    }

    public function includeComputed(): static
    {
        return $this->include(...$this->getComputedProperties());
    }    
}

Usage:

$data = ProductData::from(['name' => 'Foo', 'price' => 20]);

$data->includeComputed()->toArray(); // will resolve and include `price_for_humans` in the array