Write Accessors and Mutators with PHP property hooks

[balthild]

It would be great if I can write Accessors and Mutators like this

class User extends Model {
    #[AttributeHook]
    public string $full_name {
        get => "{$this->first_name} {$this->last_name}"
    }
}

and get it recognized by serialization (appends/hidden).

The framework can distinguish them from other properties with the AttributeHook attribute.

Benefits:

• Less indentation.
• Do not need to convert the attribute name between camelCase and snake_case, which reduces cognitive overhead.
• IDE/editors friendly.

[balthild]

Just found that I can implement it in my application by overriding model methods, but it would be nice if it becomes a framework feature.

<?php

namespace App\Models\Attributes;

use Attribute;

#[Attribute(Attribute::TARGET_PROPERTY)]
class AttributeHook {}

<?php

namespace App\Models\Concerns;

use App\Models\Attributes\AttributeHook;
use Override;
use PropertyHookType;
use ReflectionProperty;

trait HasHookMutator
{
    protected static $hookMutatorCache = [];

    #[Override]
    public function hasGetMutator($key)
    {
        return $this->hasHookMutator($key, PropertyHookType::Get) || parent::hasGetMutator($key);
    }

    #[Override]
    protected function mutateAttribute($key, $value)
    {
        if ($this->hasHookMutator($key, PropertyHookType::Get)) {
            return $this->{$key};
        }

        return parent::mutateAttribute($key, $value);
    }

    #[Override]
    public function hasSetMutator($key)
    {
        return $this->hasHookMutator($key, PropertyHookType::Set) || parent::hasSetMutator($key);
    }

    #[Override]
    protected function setMutatedAttributeValue($key, $value)
    {
        if ($this->hasHookMutator($key, PropertyHookType::Set)) {
            return $this->{$key} = $value;
        }

        return parent::setMutatedAttributeValue($key, $value);
    }

    protected function hasHookMutator(string $key, PropertyHookType $type)
    {
        $class = \get_class($this);
        $cache = &static::$hookMutatorCache["{$class}:{$key}:{$type->name}"];

        if (isset($cache)) {
            return $cache;
        }

        if (!property_exists($this, $key)) {
            return $cache = false;
        }

        $property = new ReflectionProperty($this, $key);

        if (!$property->hasHook($type) || !$property->getAttributes(AttributeHook::class)) {
            return $cache = false;
        }

        return $cache = true;
    }
}

[balthild]

There's another way to write accesors/mutators since Laravel 9.0 (already EOL for a long time). Property hooks won't slower than that way.

[marius-ciclistu]

Property hooks no, reflection I believe so.

[balthild]

That way also uses reflection

[balthild]

And no, PHP reflection is not slow anymore since PHP 8. Also the entire Laravel is built on a IOC container based on reflection. If you care about performance too much you won't use Laravel at the first place.

[marius-ciclistu]

Go ahead and submit a PR then. ;)