Why do computed values throw an exception rather than be ignored?

[samlev]

I'm sure that there's a reason for it, but I would expect that a property marked with #[Computed] would be computed each time the object is hydrated. Because of this, I would expect that any value passed for it would simply be ignored like a readonly property, rather than throw an exception.

As it is, it makes #[Computed] difficult to use in situations like livewire where you want the frontend to have access to the computed property, but the hydration step throws an exception for the computed property instead of ignoring it.

In some situations I can mark the computed property as readonly, but there are times where that is also not ideal (e.g. if a property gets changed and you want to re-compute the property some how).

What would the implications be if computed properties were by default rejected alongside readonly properties instead of throwing an exception?

[rubenvanassche]

Hi @samlev,

If I'm not mistaken the reason I've written it like this is to protect the developer, by setting computed properties expecting something will be set. And avoiding a lot of GitHub issues about this 😄

Since LiveWire always uses the wireable trait to hydrate, we could maybe add an option over there to DataFromSomethingResolver and DataFromArrayResolver to allow computed values to be set and ignored. Because livewire looks like the only place where this behavior is required.

You're always welcome to PR such a thing.

[samlev]

Short term I've built a DataSynth that recurses down the tree on hydrate and removes any properties from the payload that are flagged as computed:

<?php

namespace App\Livewire\Synths;

use Livewire\Mechanisms\HandleComponents\ComponentContext;
use Livewire\Mechanisms\HandleComponents\Synthesizers\Synth;
use Spatie\LaravelData\Contracts\BaseData;
use Spatie\LaravelData\Support\DataConfig;

class DataSynth extends Synth
{
    protected DataConfig $dataConfig;
    /** @var array<class-string<BaseData>, string[]> */
    protected array $computedProperties = [];
    
    /**
     * @param ComponentContext $context
     * @param mixed $path
     */
    public function __construct(
        public ComponentContext $context,
        public $path,
    ) {
        parent::__construct($this->context, $this->path);
        $this->dataConfig = app(DataConfig::class);
    }
    
    // ... general synth stuff ...
    
    /**
     * @param class-string<BaseData> $class
     * @param mixed $value
     * @return mixed
     * @throws \ReflectionException
     */
    protected function sanitizeInput(string $class, mixed &$value): mixed
    {
        foreach ($this->computedProperties($class) as $property) {
            data_forget($value, $property);
        }
        return $value;
    }
    
    /**
     * @param class-string<BaseData> $class
     * @return string[]
     * @throws \ReflectionException
     */
    protected function computedProperties(string $class): array
    {
        if (! isset($this->computedProperties[$class])) {
            $this->computedProperties[$class] = [];
            $properties = $this->dataConfig->getDataClass($class)->properties;

            foreach ($properties as $property) {
                if ($property->computed) {
                    $this->computedProperties[$class][] = $property->name;
                } elseif ($property->type->dataClass) {
                    $path = $property->name . ($property->type->isDataCollectable ? '.*.' : '.');

                    // Check for computed properties in nested classes
                    $this->computedProperties[$class] += array_map(
                        fn (string $prop) => $path . $prop,
                        $this->computedProperties($property->type->dataClass)
                    );
                }
            }
        }

        return $this->computedProperties[$class];
    }
}

However this is super hacky (in my opinion, at least).

While livewire is where I originally ran into this, it's not the only place where you might run into this issue where you want to keep computed properties in a transformed payload (JSON/whatever), but don't want to ingest those properties when hydrating, but also it's annoying to inspect the payload to remove them.

The #[Computed] attribute throws exceptions at you if you pass that data in a payload, but readonly properties are simply ignored from the payload. I could add readonly to the computed properties, but that's not always something that would reflect reality.