type UserRepo interface {
    Get(id int64) (User, error)
}

// Основная реализация
type PgUserRepo struct{ db *sql.DB }
func (r *PgUserRepo) Get(id int64) (User, error) {
    // SELECT * FROM users WHERE id = $1
    return User{}, nil
}

// Декоратор логирования
type LoggingUserRepo struct {
    next   UserRepo
    logger *slog.Logger
}

func (r *LoggingUserRepo) Get(id int64) (User, error) {
    start := time.Now()
    u, err := r.next.Get(id)  // делегируем основную работу
    r.logger.Info("UserRepo.Get",
        "id", id,
        "duration_ms", time.Since(start).Milliseconds(),
        "error", err,
    )
    return u, err
}

Ключевой момент: LoggingUserRepo реализует UserRepo и содержит поле next UserRepo. Он не знает, что внутри - PgUserRepo, кэш или другой декоратор.

Стек декораторов

Декораторы складываются как матрёшка:

// Собираем стек: pg → cache → logging
var repo UserRepo
repo = &PgUserRepo{db: db}
repo = &CachingUserRepo{next: repo, cache: redis}
repo = &LoggingUserRepo{next: repo, logger: logger}

// Внешний код видит просто UserRepo
user, err := repo.Get(42)
// Путь: logging → caching → pg (или из кэша)

interface UserRepo
{
    public function get(int $id): array;
}

final class PgUserRepo implements UserRepo
{
    public function get(int $id): array
    {
        return ['id' => $id];
    }
}

final class LoggingUserRepo implements UserRepo
{
    public function __construct(
        private readonly UserRepo $next,
        private readonly LoggerInterface $logger,
    ) {}

    public function get(int $id): array
    {
        $t = microtime(true);
        try {
            return $this->next->get($id);
        } finally {
            $ms = (int) ((microtime(true) - $t) * 1000);
            $this->logger->info('UserRepo.get', ['id' => $id, 'ms' => $ms]);
        }
    }
}

Ключевой момент: LoggingUserRepo реализует тот же UserRepo и принимает другой UserRepo в конструктор. Он не знает, что внутри.

Стек декораторов

Декораторы складываются как матрёшка:

$repo = new PgUserRepo($pdo);
$repo = new CachingUserRepo($repo, $cache);
$repo = new LoggingUserRepo($repo, $logger);

// Внешний код видит просто UserRepo
$user = $repo->get(42);
// Путь: logging → caching → pg (или из кэша)

В Symfony такой стек собирается автоматически через #[AsDecorator(decorates: UserRepo::class)].

class PgUserRepo {
  async get(id) {
    // SELECT * FROM users WHERE id = $1
    return { id };
  }
}

// Декоратор логирования
class LoggingUserRepo {
  #next;
  #logger;
  constructor(next, logger) {
    this.#next = next;
    this.#logger = logger ?? console;
  }

  async get(id) {
    const start = Date.now();
    try {
      return await this.#next.get(id);
    } finally {
      this.#logger.info?.('UserRepo.get', { id, ms: Date.now() - start });
    }
  }
}

Ключевой момент: LoggingUserRepo имеет тот же метод get(id), что и PgUserRepo, и принимает другой репозиторий в конструктор. Он не знает, что внутри.

Стек декораторов

Декораторы складываются как матрёшка:

let repo = new PgUserRepo(db);
repo = new CachingUserRepo(repo, cache);
repo = new LoggingUserRepo(repo, logger);

// Внешний код видит просто репозиторий
const user = await repo.get(42);
// Путь: logging → caching → pg (или из кэша)

В JS такой стек часто собирают через простую функцию-обёртку (особенно для middleware) - withLogging(withCache(repo)). Это та же идея, только без явного класса. ES-decorators (@logging) - отдельная история на уровне синтаксиса класса, но семантически - то же самое.

func LoggingMiddleware(next http.Handler) http.Handler {
    return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
        start := time.Now()
        next.ServeHTTP(w, r)  // делегируем
        log.Printf("%s %s %v", r.Method, r.URL.Path, time.Since(start))
    })
}

func AuthMiddleware(next http.Handler) http.Handler {
    return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
        if !isAuthed(r) {
            http.Error(w, "unauthorized", 401)
            return  // не делегируем - прерываем цепочку
        }
        next.ServeHTTP(w, r)
    })
}

// Стек middleware = стек декораторов
handler := AuthMiddleware(LoggingMiddleware(myHandler))

<?php
declare(strict_types=1);

use Psr\Http\Message\ResponseInterface;
use Psr\Http\Message\ServerRequestInterface;
use Psr\Http\Server\MiddlewareInterface;
use Psr\Http\Server\RequestHandlerInterface;
use Psr\Log\LoggerInterface;

final class LoggingMiddleware implements MiddlewareInterface
{
    public function __construct(
        private readonly LoggerInterface $logger,
    ) {}

    public function process(
        ServerRequestInterface $request,
        RequestHandlerInterface $handler,
    ): ResponseInterface {
        $t = microtime(true);
        try {
            return $handler->handle($request); // делегируем
        } finally {
            $ms = (int) ((microtime(true) - $t) * 1000);
            $this->logger->info(sprintf(
                '%s %s %d ms',
                $request->getMethod(),
                (string) $request->getUri(),
                $ms,
            ));
        }
    }
}

final class AuthMiddleware implements MiddlewareInterface
{
    public function __construct(
        private readonly ResponseFactory $responses,
    ) {}

    public function process(
        ServerRequestInterface $request,
        RequestHandlerInterface $handler,
    ): ResponseInterface {
        if (!$this->isAuthed($request)) {
            return $this->responses->error(401, 'unauthorized');
            // не делегируем - прерываем цепочку
        }

        return $handler->handle($request);
    }

    private function isAuthed(ServerRequestInterface $request): bool
    {
        return $request->hasHeader('Authorization');
    }
}

// Стек middleware = стек декораторов
$pipeline = new Pipeline([new AuthMiddleware($responses), new LoggingMiddleware($logger)], $myHandler);

// Express-стиль: middleware = (req, res, next) => { ... next(); }
function logging(req, res, next) {
  const start = Date.now();
  res.on('finish', () => {
    console.log(`${req.method} ${req.url} ${Date.now() - start} ms`);
  });
  next(); // делегируем
}

function auth(req, res, next) {
  if (!req.headers.authorization) {
    res.status(401).send('unauthorized');
    return; // не делегируем - прерываем цепочку
  }
  next();
}

// Стек middleware = стек декораторов
app.use(auth);
app.use(logging);
app.get('/me', myHandler);