// Наш интерфейс - так мы хотим работать с SMS
type SmsSender interface {
    Send(to, text string) error
}

// Внешний клиент (из чужого SDK) - не наш интерфейс
type ThirdPartySmsClient struct{}
func (c *ThirdPartySmsClient) Push(phone string, msg string) (int, error) {
    // отправка через внешний API
    return 200, nil
}

// Адаптер - переводит наш интерфейс в вызовы SDK
type SmsAdapter struct {
    client *ThirdPartySmsClient
}

func (a *SmsAdapter) Send(to, text string) error {
    code, err := a.client.Push(to, text)
    if err != nil {
        return fmt.Errorf("sms send failed: %w", err)
    }
    if code != 200 {
        return fmt.Errorf("sms api returned code %d", code)
    }
    return nil
}

Теперь бизнес-логика зависит от SmsSender, а не от конкретного SDK - классическая иллюстрация DIP:

type NotificationService struct {
    sms SmsSender  // интерфейс, а не конкретный клиент
}

func (s *NotificationService) NotifyUser(phone, msg string) error {
    return s.sms.Send(phone, msg)
}

Сменили SDK? Написали новый адаптер - остальной код не трогаем.

// Наш интерфейс - так мы хотим работать с SMS
interface SmsSender
{
    public function send(string $to, string $text): void;
}

// Внешний клиент (из чужого SDK) - не наш интерфейс
final class ThirdPartySmsClient
{
    public function push(string $phone, string $msg): int
    {
        return 200;
    }
}

// Адаптер - переводит наш интерфейс в вызовы SDK
final class SmsAdapter implements SmsSender
{
    public function __construct(
        private readonly ThirdPartySmsClient $client,
    ) {}

    public function send(string $to, string $text): void
    {
        $code = $this->client->push($to, $text);
        if ($code !== 200) {
            throw new RuntimeException("sms api returned code $code");
        }
    }
}

Бизнес-логика зависит от интерфейса, а не от SDK:

final class NotificationService
{
    public function __construct(
        private readonly SmsSender $sms,
    ) {}

    public function notifyUser(string $phone, string $msg): void
    {
        $this->sms->send($phone, $msg);
    }
}

Сменили SDK? Написали новый адаптер - NotificationService не трогаем.

// Внешний клиент (из чужого SDK) - не наш интерфейс
class ThirdPartySmsClient {
  push(phone, msg) {
    // отправка через внешний API
    return 200;
  }
}

// Адаптер - переводит наш контракт send(to, text) в вызовы SDK
class SmsAdapter {
  #client;
  constructor(client) {
    this.#client = client;
  }

  send(to, text) {
    const code = this.#client.push(to, text);
    if (code !== 200) {
      throw new Error(`sms api returned code ${code}`);
    }
  }
}

Бизнес-логика зависит от объекта с методом send, а не от SDK:

class NotificationService {
  #sms;
  constructor(sms) { this.#sms = sms; }

  notifyUser(phone, msg) {
    this.#sms.send(phone, msg);
  }
}

const service = new NotificationService(new SmsAdapter(new ThirdPartySmsClient()));
service.notifyUser('+79001112233', 'Welcome!');

Сменили SDK? Написали новый адаптер - NotificationService не трогаем. В JS из-за duck-typing адаптер часто пишут как лёгкую обёртку-объект без класса: const adapter = { send: (to, text) => client.push(to, text) }. Класс полезен, когда у адаптера есть собственное состояние (счётчики, кеш).

// Без адаптера - нужна структура
type myHandler struct{}
func (h myHandler) ServeHTTP(w http.ResponseWriter, r *http.Request) {
    w.Write([]byte("hello"))
}

// С адаптером HandlerFunc - достаточно функции
http.Handle("/", http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
    w.Write([]byte("hello"))
}))

<?php
declare(strict_types=1);

use Psr\Http\Message\ResponseInterface;
use Psr\Http\Message\ServerRequestInterface;
use Psr\Http\Server\RequestHandlerInterface;

// Без адаптера - нужен отдельный класс
final class HelloHandler implements RequestHandlerInterface
{
    public function __construct(
        private readonly ResponseFactory $responses,
    ) {}

    public function handle(ServerRequestInterface $request): ResponseInterface
    {
        return $this->responses->text('hello');
    }
}

// С адаптером - обычная функция-замыкание превращается в Handler
final class CallableHandler implements RequestHandlerInterface
{
    /** @param callable(ServerRequestInterface): ResponseInterface $fn */
    public function __construct(
        private $fn,
    ) {}

    public function handle(ServerRequestInterface $request): ResponseInterface
    {
        return ($this->fn)($request);
    }
}

$router->add('/', new CallableHandler(
    fn (ServerRequestInterface $r): ResponseInterface => $responses->text('hello'),
));

// Express-стиль: маршрут принимает callback (req, res) - это и есть адаптер
// функции под интерфейс «обработчик»
app.get('/hello', (req, res) => {
  res.send('hello');
});

// Если нужен класс-обработчик, оборачиваем его в адаптер-замыкание
class HelloHandler {
  handle(req, res) {
    res.send('hello');
  }
}

const handler = new HelloHandler();
app.get('/hello', (req, res) => handler.handle(req, res));