Client.php

<?php

declare(strict_types = 1);

namespace DnsMadeEasy;

use DnsMadeEasy\Exceptions\Client\Http\BadRequestException;
use DnsMadeEasy\Exceptions\Client\Http\HttpException;
use DnsMadeEasy\Exceptions\Client\Http\NotFoundException;
use DnsMadeEasy\Exceptions\Client\ManagerNotFoundException;
use DnsMadeEasy\Interfaces\ClientInterface;
use DnsMadeEasy\Interfaces\Managers\AbstractManagerInterface;
use DnsMadeEasy\Interfaces\Managers\ContactListManagerInterface;
use DnsMadeEasy\Interfaces\Managers\FolderManagerInterface;
use DnsMadeEasy\Interfaces\Managers\ManagedDomainManagerInterface;
use DnsMadeEasy\Interfaces\Managers\RecordFailoverManagerInterface;
use DnsMadeEasy\Interfaces\Managers\SecondaryDomainManagerInterface;
use DnsMadeEasy\Interfaces\Managers\SecondaryIPSetManagerInterface;
use DnsMadeEasy\Interfaces\Managers\SOARecordManagerInterface;
use DnsMadeEasy\Interfaces\Managers\TemplateManagerInterface;
use DnsMadeEasy\Interfaces\Managers\TransferAclManagerInterface;
use DnsMadeEasy\Interfaces\Managers\UsageManagerInterface;
use DnsMadeEasy\Interfaces\Managers\VanityNameServerManagerInterface;
use DnsMadeEasy\Interfaces\PaginatorFactoryInterface;
use DnsMadeEasy\Managers\ContactListManager;
use DnsMadeEasy\Managers\FolderManager;
use DnsMadeEasy\Managers\ManagedDomainManager;
use DnsMadeEasy\Managers\RecordFailoverManager;
use DnsMadeEasy\Managers\SecondaryDomainManager;
use DnsMadeEasy\Managers\SecondaryIPSetManager;
use DnsMadeEasy\Managers\SOARecordManager;
use DnsMadeEasy\Managers\TemplateManager;
use DnsMadeEasy\Managers\TransferAclManager;
use DnsMadeEasy\Managers\UsageManager;
use DnsMadeEasy\Managers\VanityNameServerManager;
use DnsMadeEasy\Pagination\Factories\PaginatorFactory;
use GuzzleHttp\Client as HttpClient;
use GuzzleHttp\Psr7\Request;
use GuzzleHttp\RequestOptions;
use Psr\Http\Message\RequestInterface;
use Psr\Http\Message\ResponseInterface;
use Psr\Log\LoggerAwareInterface;
use Psr\Log\LoggerInterface;
use Psr\Log\NullLogger;

/**
 * DNS Made Easy API Client SDK.
 *
 * @package DnsMadeEasy
 *
 * @property-read ContactListManagerInterface $contactlists
 * @property-read FolderManagerInterface $folders
 * @property-read ManagedDomainManagerInterface $domains
 * @property-read VanityNameServerManagerInterface $vanity
 * @property-read TemplateManagerInterface $templates
 * @property-read TransferAclManagerInterface $transferacls
 * @property-read SOARecordManagerInterface $soarecords
 * @property-read UsageManagerInterface $usage
 * @property-read SecondaryIPSetManagerInterface $secondaryipsets;
 * @property-read SecondaryDomainManagerInterface $secondarydomains;
 * @property-read RecordFailoverManagerInterface $failover;
 */
class Client implements ClientInterface, LoggerAwareInterface
{
    /**
     * Logger interface to use for log messages.
     *
     * @var LoggerInterface|NullLogger
     */
    public LoggerInterface $logger;

    protected HttpClient $client;

    /**
     * The DNS Made Easy API Key.
     */
    protected string $apiKey;

    /**
     * The DNS Made Easy Secret Key.
     */
    protected string $secretKey;

    /**
     * The DNS Made Easy API Endpoint.
     */
    protected string $endpoint = 'https://api.dnsmadeeasy.com/V2.0';

    /**
     * The pagination factory to use for paginated resource collections.
     *
     * @var PaginatorFactoryInterface|PaginatorFactory
     */
    protected PaginatorFactoryInterface $paginatorFactory;

    /**
     * A cache of instantiated manager classes.
     *
     * @var mixed[]
     */
    protected array $managers = [];

    /**
     * A map of manager names to classes.
     *
     * @var string[]
     */
    protected array $managerMap = [
        'contactlists' => ContactListManager::class,
        'domains' => ManagedDomainManager::class,
        'folders' => FolderManager::class,
        'vanity' => VanityNameServerManager::class,
        'templates' => TemplateManager::class,
        'transferacls' => TransferAclManager::class,
        'soarecords' => SOARecordManager::class,
        'secondaryipsets' => SecondaryIPSetManager::class,
        'secondarydomains' => SecondaryDomainManager::class,
        'failover' => RecordFailoverManager::class,
    ];

    /**
     * The ID of the last request to the API.
     */
    protected ?string $requestId = null;

    /**
     * The request limit on the API.
     */
    protected ?int $requestLimit = null;

    /**
     * The number of requests remaining until the limit is hit.
     */
    protected ?int $requestsRemaining = null;

    public function __construct(?HttpClient $client = null, ?PaginatorFactoryInterface $paginatorFactory = null, ?LoggerInterface $logger = null)
    {
        // If we weren't given a HTTP client, create a new Guzzle client.
        if ($client === null) {
            $client = new HttpClient();
        }

        // If we don't have a paginator factory, use our own.
        if ($paginatorFactory === null) {
            $this->paginatorFactory = new PaginatorFactory();
        }

        $this->setHttpClient($client);

        // If we don't have a logger, use the null logger.
        if ($logger === null) {
            $logger = new NullLogger();
        }
        $this->logger = $logger;
    }

    public function __get(string $name): mixed
    {
        // Usage is a special manager and not like the others.
        if ($name === 'usage') {
            if (! isset($this->managers['usage'])) {
                $this->managers['usage'] = new UsageManager($this);
            }
            return $this->managers['usage'];
        }

        return $this->getManager($name);
    }

    public function setLogger(LoggerInterface $logger): void
    {
        $this->logger = $logger;
    }

    public function getLogger(): LoggerInterface
    {
        return $this->logger;
    }

    public function setHttpClient(HttpClient $client): self
    {
        $this->client = $client;
        return $this;
    }

    public function getHttpClient(): HttpClient
    {
        return $this->client;
    }

    public function setEndpoint(string $endpoint): self
    {
        $this->endpoint = $endpoint;
        return $this;
    }

    public function getEndpoint(): string
    {
        return $this->endpoint;
    }

    public function setApiKey(string $key): self
    {
        $this->apiKey = $key;
        return $this;
    }

    public function getApiKey(): string
    {
        return $this->apiKey;
    }

    public function setSecretKey(string $key): self
    {
        $this->secretKey = $key;
        return $this;
    }

    public function getSecretKey(): string
    {
        return $this->secretKey;
    }

    public function setPaginatorFactory(PaginatorFactoryInterface $factory): self
    {
        $this->paginatorFactory = $factory;
        return $this;
    }

    public function getPaginatorFactory(): PaginatorFactoryInterface
    {
        return $this->paginatorFactory;
    }

    public function get(string $url, ?array $params = null): ResponseInterface
    {
        $queryString = '';
        if ($params !== null) {
            $queryString = '?' . http_build_query($params);
        }
        $url .= $queryString;

        $request = new Request('GET', $this->endpoint . $url);
        return $this->send($request);
    }

    public function post(string $url, mixed $payload): ResponseInterface
    {
        $request = new Request('POST', $this->endpoint . $url, [], 'php://temp');
        $request->withHeader('Content-Type', 'application/json');
        $request->getBody()->write(json_encode($payload, JSON_THROW_ON_ERROR));
        return $this->send($request);
    }

    public function put(string $url, mixed $payload): ResponseInterface
    {
        $request = new Request('PUT', $this->endpoint . $url, [], 'php://temp');
        $request->withHeader('Content-Type', 'application/json');
        $request->getBody()->write(json_encode($payload, JSON_THROW_ON_ERROR));
        return $this->send($request);
    }

    public function delete(string $url, mixed $payload = null): ResponseInterface
    {
        $request = new Request('DELETE', $this->endpoint . $url);
        if ($payload !== null) {
            $request->withHeader('Content-Type', 'application/json');
            $request->getBody()->write(json_encode($payload, JSON_THROW_ON_ERROR));
        }
        return $this->send($request);
    }

    public function send(RequestInterface $request): ResponseInterface
    {
        $this->logger->debug("[DnsMadeEasy] API Request: {$request->getMethod()} {$request->getUri()}");

        $request = $request->withHeader('Accept', 'application/json');
        $request = $this->addAuthHeaders($request);
        $response = $this->client->send($request, [RequestOptions::HTTP_ERRORS => false]);

        $this->logger->debug("[DnsMadeEasy] API Response: {$response->getStatusCode()} {$response->getReasonPhrase()}");
        $this->updateLimits($response);
        $statusCode = $response->getStatusCode();
        if ((int) substr((string) $statusCode, 0, 1) <= 3) {
            return $response;
        }
        $lookup = [
                400 => BadRequestException::class,
                404 => NotFoundException::class,
            ];
        if (array_key_exists($statusCode, $lookup)) {
            $exceptionClass = $lookup[$statusCode];
        } else {
            $exceptionClass = HttpException::class;
        }
        $exception = new $exceptionClass($response->getReasonPhrase(), $statusCode);
        $exception->setRequest($request);
        $exception->setResponse($response);
        throw $exception;
    }

    /**
     * Return the ID of the last API request.
     */
    public function getLastRequestId(): ?string
    {
        return $this->requestId;
    }

    /**
     * Get the request limit.
     */
    public function getRequestLimit(): ?int
    {
        return $this->requestLimit;
    }

    /**
     * Get the number of requests remaining before you hit the request limit.
     */
    public function getRequestsRemaining(): ?int
    {
        return $this->requestsRemaining;
    }

    /**
     * Fetch the API request details from the last API response.
     */
    protected function updateLimits(ResponseInterface $response): void
    {
        $requestId = current($response->getHeader('x-dnsme-requestId'));
        if ($requestId === false) {
            $this->requestId = null;
        } else {
            $this->requestId = $requestId;
        }

        $requestsRemaining = current($response->getHeader('x-dnsme-requestsRemaining'));
        if ($requestsRemaining === false) {
            $this->requestsRemaining = null;
        } else {
            $this->requestsRemaining = (int) $requestsRemaining;
        }

        $requestLimit = current($response->getHeader('x-dnsme-requestLimit'));
        if ($requestLimit === false) {
            $this->requestLimit = null;
        } else {
            $this->requestLimit = (int) $requestLimit;
        }
    }

    /**
     * Adds auth headers to requests. These are generated based on the Api Key and the Secret Key.
     *
     * @throws \Exception
     */
    protected function addAuthHeaders(RequestInterface $request): RequestInterface
    {
        $now = new \DateTime('now', new \DateTimeZone('UTC'));
        $timestamp = $now->format('r');
        $hmac = hash_hmac('sha1', $timestamp, $this->getSecretKey());

        $request = $request->withHeader('x-dnsme-apiKey', $this->getApiKey());
        $request = $request->withHeader('x-dnsme-requestDate', $timestamp);
        $request = $request->withHeader('x-dnsme-hmac', $hmac);
        return $request;
    }

    /**
     * Check if a manager exists with that name in our manager map.
     */
    protected function hasManager(string $name): bool
    {
        $name = strtolower($name);
        return array_key_exists($name, $this->managerMap);
    }

    /**
     * Gets the manager with the specified name.
     *
     * @throws ManagerNotFoundException
     */
    protected function getManager(string $name): AbstractManagerInterface
    {
        if (! $this->hasManager($name)) {
            throw new ManagerNotFoundException();
        }

        $name = strtolower($name);

        if (! isset($this->managers[$name])) {
            $this->managers[$name] = new $this->managerMap[$name]($this);
        }

        return $this->managers[$name];
    }
}