how best to use computed properties (e.g. name = firstName + lastName)?

[wivaku]

Was wondering what the recommendations are for computed properties.

E.g. the source data in an Array has firstName and lastName, and my target DTO has name.
So, if I process an array I want to set name, by concatenating firstName and lastName.
When I process an object / model etc then I expect the name is already set, so no action is needed/wanted.

Should I use prepareForPipeline / extend the pipeline / use a custom Normalizer (for an Array) / or ... ?

[wivaku]

Here are the options I have been looking at so far.

using prepareForPipeline

This is my current approach, using prepareForPipeline:

class UserData extends Data
{
    public function __construct(
        public string|Optional $name,
    ) {
    }

    public static function prepareForPipeline(Collection $properties) : Collection
    {
        $properties->put('name', $properties->only(['firstName', 'lastName'])->join(' '));
        return $properties;
    }

}

$user = [
    // 'name' => 'John Doe',
    'firstName' => 'John',
    'lastName' => 'Doe',
];

$dto = App\Data\UserData::validateAndCreate($user);

I have to use string|Optional for $name because I otherwise get the error that $name is a required property,
and prepareForPipeline runs after the validations.

extending pipeline

Can't get this to work. Thought I could extend the pipeline, but when using the example in the documentation my IDE complains about cannot use parent in class with no parent.

    public static function pipeline(): DataPipeline
    {
        return parent::pipeline()->firstThrough(MyTransformationsDataPipe::class);
        // IDE error: cannot use parent in class with no parent
    }

using magic creation method (fromArray)

    public static function fromArray($array): self
    {
        $array['name'] = $array['firstName'] .' '. $array['lastName'];

        // preferred: return arguments (as in __construct) automatically instead of manually
        return new self(
            Arr::get($array, 'name'),
            Arr::get($array, 'date'),
            Arr::get($array, 'created_at'),
        );
    }

using custom Normalizer

class UserData extends Data
{
// ...
    public static function normalizers(): array
    {
        $normalizers = array_merge(
            [
                ArrayTransformNormalizer::class,
            ],
            config('data.normalizers')
        );
        return $normalizers;
    }
}

class ArrayTransformNormalizer implements Normalizer
{
    public function normalize(mixed $value): ?array
    {
        if (! is_array($value)) {
            return null;
        }

        // transformations
        $value['name'] = $value['firstName'] .' '. $value['lastName'];

        return $value;
    }
}

It only is used if the source is an array, but I still have to use string|Optional as it seems the Normalizers are run after the Validators.