Un cubo de vidrio con un punto de luz amarilla cálida en su interior, rozado por dos haces finos.
Funcionalidad · Hooks de propiedades

Intercepta cada lectura y escritura de una propiedad.

Valida, normaliza y audita el acceso a propiedades sin añadir getters, setters ni métodos mágicos. Aplica comportamientos directamente a las propiedades y mantén tu código legible y analizable estáticamente.

Casi* cualquier propiedad

Qué puedes interceptar

Las lecturas y escrituras de las propiedades que declaras pasan por un comportamiento: valídalas, normalízalas o audítalas. En una escritura, proceed() devuelve el valor que se guarda, así que un comportamiento alrededor de la escritura puede cambiarlo antes de que se asigne.

  • Propiedades public, protected y private declaradas en la clase
  • Propiedades promovidas en el constructor y final: la asignación del constructor es una escritura
  • Propiedades public y protected heredadas de una clase padre
  • La visibilidad asimétrica (private(set)) y los atributos se mantienen intactos
  • Las propiedades de tipo array siguen funcionando con array_push(), gracias a los hooks &get
  • No soportado: *Las propiedades static, readonly y las que ya tienen hooks se dejan como están: PHP no permite hooks en ellas.
src/Aspect/UserAspect.phpnormalizar al escribir
#[Around('access(public App\Entity\User->email)')]public function normalizeEmail(FieldAccess $access): mixed{    if ($access->getAccessType() === FieldAccessType::Write) {        return strtolower($access->proceed());    }     return $access->proceed();}
Cómo funciona

Hooks nativos de PHP. Generados automáticamente.

El framework transforma tu clase en archivos PHP corrientes. Las propiedades marcadas se reescriben con hooks nativos get y set de PHP 8.4+, que invocan los comportamientos aplicados cada vez que se accede a la propiedad.

Tu clase

Dos propiedades llevan #[Auditable], el atributo que busca el comportamiento de auditoría de abajo; la tercera no. El archivo queda exactamente como lo escribiste.

Customer.phptu código

        
        
        <?php
        
        
        
      
        
        
         
        
        
        
      
        
        
        declare(strict_types=1);
        
        
        
      
        
        
         
        
        
        
      
        
        
        namespace App\Entity;
        
        
        
      
        
        
         
        
        
        
      
        
        
        use App\Attribute\Auditable;
        
        
        
      
        
        
         
        
        
        
      
        
        
        class Customer
        
        
        
      
        
        
        {
        
        
        
      
        
        
            #[Auditable]
        
        
        
      
        
        
            public string $email = '';
        
        
        
      
        
        
         
        
        
        
      
        
        
            #[Auditable]
        
        
        
      
        
        
            public string $plan = 'free';
        
        
        
      
        
        
         
        
        
        
      
        
        
            public string $displayName = '';
        
        
        
      
        
        
         
        
        
        
      
        
        
            public function upgrade(string $plan): void
        
        
        
      
        
        
            {
        
        
        
      
        
        
                $this->plan = $plan;
        
        
        
      
        
        
            }
        
        
        
      
        
        
        }
        
        
        
      

Código compilado

El cuerpo de tu clase como el trait CustomerOriginalTrait. Cada propiedad marcada deja una nota de una línea, y todas las demás líneas conservan su número para Xdebug.

CustomerOriginalTrait.phpcompilado

        
        
        <?php
        
        
        
      
        
        
         
        
        
        
      
        
        
        declare(strict_types=1);
        
        
        
      
        
        
         
        
        
        
      
        
        
        namespace App\Entity;
        
        
        
      
        
        
         
        
        
        
      
        
        
        use App\Attribute\Auditable;
        
        
        
      
        
        
         
        
        
        
      
        
        
        trait CustomerOriginalTrait
        era: class Customer
        
        
      
        
        
        {
        
        
        
      
        
        
            /* Moved by weaving interceptor to the {@see App\Entity\Customer->email} */
        
        
        
      
        
        
         
        
        
        
      
        
        
         
        
        
        
      
        
        
            /* Moved by weaving interceptor to the {@see App\Entity\Customer->plan} */
        
        
        
      
        
        
         
        
        
        
      
        
        
         
        
        
        
      
        
        
            public string $displayName = '';
        
        
        
      
        
        
         
        
        
        
      
        
        
            public function upgrade(string $plan): void
        
        
        
      
        
        
            {
        
        
        
      
        
        
                $this->plan = $plan;
        
        
        
      
        
        
            }
        
        
        
      
        
        
        }
        
        
        
      
        
        
        include_once AOP_CACHE_DIR . '/src/Entity/Customer.php';
        
        
        
      

Clase proxy con hooks

La clase que carga PHP: el nombre de tu clase, el trait y las propiedades marcadas declaradas de nuevo con su atributo, tipo y valor por defecto, más los hooks get y set. Cada hook hace pasar el acceso por el middleware de auditoría.

Customer.phpgenerado

        
        
        <?php
        
        
        
      
        
        
        declare(strict_types=1);
        
        
        
      
        
        
        namespace App\Entity;
        
        
        
      
        
        
         
        
        
        
      
        
        
        use Go\Aop\Framework\InterceptorInjector;
        
        
        
      
        
        
        use Go\Aop\Framework\Interceptor;
        
        
        
      
        
        
        use Go\Aop\Framework\The;
        
        
        
      
        
        
        use Go\Aop\Intercept\FieldAccess;
        
        
        
      
        
        
        use App\Aspect\AuditAspect;
        
        
        
      
        
        
        use App\Attribute\Auditable;
        
        
        
      
        
        
        class Customer implements \Go\Aop\Proxy
        mismo nombre de clase
        
        
      
        
        
        {
        
        
        
      
        
        
            use CustomerOriginalTrait;
        el resto de tu clase
        
        
      
        
        
            #[\App\Attribute\Auditable]
        atributo conservado
        
        
      
        
        
            public string $email = '' {
        hooks nativos de PHP 8.4
        
        
      
        
        
                get {
        
        
        
      
        
        
                    /** @var FieldAccess<self, string> $__joinPoint */
        tipado para PHPStan e IDE
        
        
      
        
        
                    static $__joinPoint = InterceptorInjector::forProperty(
        
        
        
      
        
        
                        self::class,
        
        
        
      
        
        
                        'email',
        
        
        
      
        
        
                        [
        
        
        
      
        
        
                            Interceptor::around(The::aspect(AuditAspect::class)->auditWrite(...)),
        tu comportamiento de auditoría
        
        
      
        
        
                        ],
        
        
        
      
        
        
                    );
        
        
        
      
        
        
                    return $__joinPoint->read($this, $this->email);
        las lecturas pasan
        
        
      
        
        
                }
        
        
        
      
        
        
                set {
        
        
        
      
        
        
                    /** @var FieldAccess<self, string> $__joinPoint */
        
        
        
      
        
        
                    static $__joinPoint = InterceptorInjector::forProperty(
        
        
        
      
        
        
                        self::class,
        
        
        
      
        
        
                        'email',
        
        
        
      
        
        
                        [
        
        
        
      
        
        
                            Interceptor::around(The::aspect(AuditAspect::class)->auditWrite(...)),
        
        
        
      
        
        
                        ],
        
        
        
      
        
        
                    );
        
        
        
      
        
        
                    $this->email = $__joinPoint->write($this, $value, $this->email);
        las escrituras van por el comportamiento
        
        
      
        
        
                }
        
        
        
      
        
        
            }
        
        
        
      
        
        
            #[\App\Attribute\Auditable]
        
        
        
      
        
        
            public string $plan = 'free' {
        
        
        
      
        
        
                get {
        
        
        
      
        
        
                    /** @var FieldAccess<self, string> $__joinPoint */
        
        
        
      
        
        
                    static $__joinPoint = InterceptorInjector::forProperty(
        
        
        
      
        
        
                        self::class,
        
        
        
      
        
        
                        'plan',
        
        
        
      
        
        
                        [
        
        
        
      
        
        
                            Interceptor::around(The::aspect(AuditAspect::class)->auditWrite(...)),
        
        
        
      
        
        
                        ],
        
        
        
      
        
        
                    );
        
        
        
      
        
        
                    return $__joinPoint->read($this, $this->plan);
        
        
        
      
        
        
                }
        
        
        
      
        
        
                set {
        
        
        
      
        
        
                    /** @var FieldAccess<self, string> $__joinPoint */
        
        
        
      
        
        
                    static $__joinPoint = InterceptorInjector::forProperty(
        
        
        
      
        
        
                        self::class,
        
        
        
      
        
        
                        'plan',
        
        
        
      
        
        
                        [
        
        
        
      
        
        
                            Interceptor::around(The::aspect(AuditAspect::class)->auditWrite(...)),
        
        
        
      
        
        
                        ],
        
        
        
      
        
        
                    );
        
        
        
      
        
        
                    $this->plan = $__joinPoint->write($this, $value, $this->plan);
        
        
        
      
        
        
                }
        
        
        
      
        
        
            }
        
        
        
      
        
        
        }
        
        
        
      
Registro de auditoría

Audita cada cambio con un solo atributo

Marca las propiedades que importan con #[Auditable]. El comportamiento de auditoría se aplica a cada una como middleware dinámico: cada escritura se registra con el nombre de la propiedad, el valor anterior y el nuevo, venga de donde venga la escritura.

  • Cada escritura de una propiedad marcada, desde cualquier código: desde fuera, dentro de la clase, el constructor
  • El valor anterior y el nuevo, antes de que se asigne
  • Las propiedades no marcadas y las lecturas no cuestan nada extra
  • La entidad mantiene propiedades public simples: sin setters, sin __set()
src/Attribute/Auditable.phptu atributo
#[\Attribute(\Attribute::TARGET_PROPERTY)]final class Auditable {}
Qué se registrauso
$customer->plan = 'pro';         // audit: plan, from "free" to "pro"$customer->upgrade('team');      // audit: plan, from "pro" to "team"$customer->displayName = 'Ann';  // no record: no #[Auditable]echo $customer->email;           // reads pass through untouched
Customer.phptu entidad

        
        
        <?php
        
        
        
      
        
        
         
        
        
        
      
        
        
        declare(strict_types=1);
        
        
        
      
        
        
         
        
        
        
      
        
        
        namespace App\Entity;
        
        
        
      
        
        
         
        
        
        
      
        
        
        use App\Attribute\Auditable;
        
        
        
      
        
        
         
        
        
        
      
        
        
        class Customer
        
        
        
      
        
        
        {
        
        
        
      
        
        
            #[Auditable]
        auditada
        
        
      
        
        
            public string $email = '';
        
        
        
      
        
        
         
        
        
        
      
        
        
            #[Auditable]
        auditada
        
        
      
        
        
            public string $plan = 'free';
        
        
        
      
        
        
         
        
        
        
      
        
        
            public string $displayName = '';
        no auditada
        
        
      
        
        
         
        
        
        
      
        
        
            public function upgrade(string $plan): void
        
        
        
      
        
        
            {
        
        
        
      
        
        
                $this->plan = $plan;
        
        
        
      
        
        
            }
        
        
        
      
        
        
        }
        
        
        
      
AuditAspect.phpcomportamiento de auditoría

        
        
        <?php
        
        
        
      
        
        
         
        
        
        
      
        
        
        namespace App\Aspect;
        
        
        
      
        
        
         
        
        
        
      
        
        
        use Go\Aop\Aspect;
        
        
        
      
        
        
        use Go\Aop\Intercept\FieldAccess;
        
        
        
      
        
        
        use Go\Aop\Intercept\FieldAccessType;
        
        
        
      
        
        
        use Go\Lang\Attribute\Around;
        
        
        
      
        
        
        use Psr\Log\LoggerInterface;
        
        
        
      
        
        
         
        
        
        
      
        
        
        final class AuditAspect implements Aspect
        
        
        
      
        
        
        {
        
        
        
      
        
        
            public function __construct(private LoggerInterface $audit) {}
        
        
        
      
        
        
         
        
        
        
      
        
        
            #[Around('@access(App\Attribute\Auditable)')]
        cada propiedad #[Auditable]
        
        
      
        
        
            public function auditWrite(FieldAccess $access): mixed
        
        
        
      
        
        
            {
        
        
        
      
        
        
                if ($access->getAccessType() === FieldAccessType::Write) {
        solo escrituras
        
        
      
        
        
                    $this->audit->info('Property changed', [
        
        
        
      
        
        
                        'property' => $access->getField()->name,
        
        
        
      
        
        
                        'from'     => $access->getValue(),
        
        
        
      
        
        
                        'to'       => $access->getValueToSet(),
        
        
        
      
        
        
                    ]);
        
        
        
      
        
        
                }
        
        
        
      
        
        
         
        
        
        
      
        
        
                return $access->proceed();
        el valor se asigna
        
        
      
        
        
            }
        
        
        
      
        
        
        }
        
        
        
      

Lo bastante rápido para dejarlo activado

Las mediciones y la lista completa de reglas están en docs/advices.md y docs/performance.md.

  • magia0sin __get ni __set: los IDE y PHPStan ven propiedades reales
  • nativoPHP 8.4compilado en los propios hooks de propiedades del lenguaje
Playground

Selecciona tus propias propiedades

Empieza con @access(App\Attribute\Auditable) y luego cámbialo: cada propiedad que alcanza se ilumina en el playground, línea a línea.

Prueba tu pointcut