
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.
Comportamientos en las propiedades, no en los setters
Marca una propiedad con un atributo y sus lecturas y escrituras ejecutan automáticamente los comportamientos que definas.
Casi* cualquier propiedad
Valida, normaliza o audita propiedades public, protected, private, promovidas y final, con la visibilidad asimétrica intacta.
Mira qué se cubreCómo funciona
Las propiedades marcadas reaparecen en la clase que carga PHP como hooks get y set nativos de PHP 8.4 que ejecutan el comportamiento.
Sigue una claseRegistro de auditoría
Marca propiedades con #[Auditable] y registra cada cambio con el valor anterior y el nuevo, venga de donde venga la escritura.
Ver el comportamiento
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.
#[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();}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.
<?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.
<?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.
<?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);
}
}
}
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()
#[\Attribute(\Attribute::TARGET_PROPERTY)]final class Auditable {}$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
<?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;
}
}
<?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.
- por acceso< 0.3 µspara una lectura o escritura de una propiedad a través de su middleware
- magia0sin __get ni __set: los IDE y PHPStan ven propiedades reales
- nativoPHP 8.4compilado en los propios hooks de propiedades del lenguaje
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 pointcutTodo lo demás que incluye
- PHP puroSin extensiones. Sin cajas negras. Solo PHP.
- Intercepta cualquier cosaNingún método queda fuera de alcance.
- DepurableNada de magia que no puedas recorrer paso a paso.
- RendimientoCoste cero sin comportamientos, menos de 1 µs con ellos.
- Lenguaje de pointcutsSelecciona exactamente el código que quieres y pruébalo en vivo.
- Extensiones de claseNuevas interfaces y traits para clases existentes.
- Encaja en tu stackSymfony, Laravel, Yii3 y tu agente de programación con IA.