Create Decorator

Decorator Pattern Generator

Creates Decorator pattern infrastructure for dynamically adding behavior to objects.

When to Use

Component Characteristics

Component Interface

• Defines core operations
• Shared by concrete and decorators
• Enables transparent wrapping

Abstract Decorator

• Wraps component
• Delegates to wrapped object
• Base for concrete decorators

Concrete Decorators

• Add specific behavior
• Before/after wrapped call
• Can be stacked

Generation Process

Step 1: Generate Component Interface

Path: src/Domain/{BoundedContext}/

1. {Name}Interface.php — Core operations contract

Step 2: Generate Abstract Decorator

Path: src/Domain/{BoundedContext}/Decorator/

1. Abstract{Name}Decorator.php — Base decorator with delegation

Step 3: Generate Concrete Decorators

Path: src/Infrastructure/{BoundedContext}/Decorator/

1. Logging{Name}Decorator.php — Logging behavior
2. Caching{Name}Decorator.php — Caching behavior
3. Metrics{Name}Decorator.php — Performance metrics
4. Transactional{Name}Decorator.php — Transaction wrapping

Step 4: Generate Factory (Optional)

Path: src/Infrastructure/{BoundedContext}/

1. {Name}Factory.php — Stack decorators in correct order

Step 5: Generate Tests

1. {Feature}{Name}DecoratorTest.php — Individual decorator tests

File Placement

Naming Conventions

Quick Template Reference

Why the base is not a readonly class. readonly on a class is inherited-mandatory: every subclass must also be readonly, and a readonly class cannot hold mutable state. That would forbid the stateful decorators listed under Common Decorators below — Retry needs an attempt counter, CircuitBreaker needs open/closed state. So the immutability is applied to the injected $wrapped property instead, which is where it actually matters. Do not "fix" this by promoting readonly to the class: final readonly class X extends Abstract…Decorator is a fatal error while the base is not readonly, and making the base readonly breaks Retry and CircuitBreaker.

Abstract Decorator

abstract class Abstract{Name}Decorator implements {Name}Interface
{
    public function __construct(
        protected readonly {Name}Interface $wrapped
    ) {}

    public function {operation}({params}): {returnType}
    {
        return $this->wrapped->{operation}({args});
    }
}

Concrete Decorator

final class {Feature}{Name}Decorator extends Abstract{Name}Decorator
{
    public function __construct(
        {Name}Interface $wrapped,
        private {Dependency} $dependency
    ) {
        parent::__construct($wrapped);
    }

    public function {operation}({params}): {returnType}
    {
        {beforeBehavior}
        $result = parent::{operation}({args});
        {afterBehavior}
        return $result;
    }
}

Usage Example

// Stack decorators in order
$service = new TransactionalOrderServiceDecorator(
    new CachingOrderServiceDecorator(
        new MetricsOrderServiceDecorator(
            new LoggingOrderServiceDecorator(
                $baseService,
                $logger
            ),
            $metrics
        ),
        $cache
    ),
    $transaction
);

// Use normally - all decorators execute
$order = $service->create($command);

Common Decorators

Anti-patterns to Avoid

References

For complete PHP templates and examples, see:

• references/templates.md — Abstract Decorator, Concrete Decorator, Interface templates
• references/examples.md — Logging, Caching, Metrics, Transaction decorators and tests