ElevenLabs\Api\Service\ApiServiceBuilder

Complexity

Total Complexity

22

Size/Duplication

Total Lines	157
Duplicated Lines	0 %

Test Coverage

Coverage

75%

Importance

Changes

0

14 Methods

Rating	Name	Duplication	Size	Complexity
A	withEncoder()	0	5	1
A	withPaginationProvider()	0	3	1
A	withDenormalizer()	0	5	1
A	withCacheProvider()	0	5	1
A	withUriFactory()	0	5	1
A	enableResponseValidation()	0	5	1
A	withBaseUri()	0	5	1
A	create()	0	3	1
A	disableRequestValidation()	0	5	1
A	withHttpClient()	0	5	1
B	build()	0	56	9
A	withSerializer()	0	5	1
A	returnResponse()	0	5	1
A	withMessageFactory()	0	5	1

<?php
namespace ElevenLabs\Api\Service;

use ElevenLabs\Api\Decoder\Adapter\SymfonyDecoderAdapter;
use ElevenLabs\Api\Factory\CachedSchemaFactoryDecorator;
use ElevenLabs\Api\Factory\SwaggerSchemaFactory;
use ElevenLabs\Api\Service\Denormalizer\ResourceDenormalizer;
use ElevenLabs\Api\Service\Pagination\PaginationProvider;
use ElevenLabs\Api\Validator\MessageValidator;
use Http\Client\HttpClient;
use Http\Discovery\HttpClientDiscovery;
use Http\Discovery\MessageFactoryDiscovery;
use Http\Discovery\UriFactoryDiscovery;
use Http\Message\MessageFactory;
use Http\Message\UriFactory;
use JsonSchema\Validator;
use Psr\Cache\CacheItemPoolInterface;
use Rize\UriTemplate;
use Symfony\Component\Serializer\Encoder\ChainDecoder;
use Symfony\Component\Serializer\Encoder\EncoderInterface;
use Symfony\Component\Serializer\Encoder\JsonEncoder;
use Symfony\Component\Serializer\Encoder\XmlEncoder;
use Symfony\Component\Serializer\Normalizer\NormalizerInterface;
use Symfony\Component\Serializer\Serializer;
use Symfony\Component\Serializer\SerializerInterface;

/**
 * Builder for ApiService instances
 */
class ApiServiceBuilder
{
    private $httpClient;
    private $messageFactory;
    private $uriFactory;
    private $serializer;
    private $denormalizers = [];
    private $encoders = [];
    private $schema;
    private $cache;
    private $config = [];
    private $paginationProvider = null;
    private $requestValidator;

    public static function create()
    {
        return new static();
    }

    public function withCacheProvider(CacheItemPoolInterface $cache)
    {
        $this->cache = $cache;

        return $this;
    }

    public function withHttpClient(HttpClient $httpClient)
    {
        $this->httpClient = $httpClient;

        return $this;
    }

    public function withMessageFactory(MessageFactory $messageFactory)
    {
        $this->messageFactory = $messageFactory;

        return $this;
    }

    public function withUriFactory(UriFactory $uriFactory)
    {
        $this->uriFactory = $uriFactory;

        return $this;
    }

    public function withSerializer(SerializerInterface $serializer)
    {
        $this->serializer = $serializer;

        return $this;
    }

    public function withEncoder(EncoderInterface $encoder)
    {
        $this->encoders[] = $encoder;

        return $this;
    }

    public function withDenormalizer(NormalizerInterface $normalizer)
    {
        $this->denormalizers[] = $normalizer;

        return $this;
    }

    public function withPaginationProvider(PaginationProvider $paginationProvider)
    {
        $this->paginationProvider = $paginationProvider;
    }

    public function withBaseUri($baseUri)
    {
        $this->config['baseUri'] = $baseUri;

        return $this;
    }

    public function disableRequestValidation()
    {
        $this->config['validateRequest'] = false;

        return $this;
    }

    public function enableResponseValidation()
    {
        $this->config['validateResponse'] = true;

        return $this;
    }

    public function returnResponse()
    {
        $this->config['returnResponse'] = true;

        return $this;
    }

    public function build($schemaPath)
    {
        // Build serializer
        if ($this->serializer === null) {
            if (empty($this->encoders)) {
                $this->encoders = [new JsonEncoder(), new XmlEncoder()];
            }

            if (empty($this->denormalizers)) {
                $this->denormalizers[] = new ResourceDenormalizer($this->paginationProvider);
            }

            $this->serializer = new Serializer(
                $this->denormalizers,
                $this->encoders
            );
        }

        if ($this->uriFactory === null) {
            $this->uriFactory = UriFactoryDiscovery::find();
        }

        if ($this->messageFactory === null) {
            $this->messageFactory = MessageFactoryDiscovery::find();
        }

        if ($this->httpClient === null) {
            $this->httpClient = HttpClientDiscovery::find();
        }

        $schemaFactory = new SwaggerSchemaFactory();
        if ($this->cache !== null) {
            $schemaFactory = new CachedSchemaFactoryDecorator(
                $this->cache,
                $schemaFactory
            );
        }

        $this->schema = $schemaFactory->createSchema($schemaPath);

        if (!isset($this->requestValidator)) {
            $this->requestValidator = new MessageValidator(
                new Validator(),
                new SymfonyDecoderAdapter(new ChainDecoder($this->encoders))
            );
        }

        return new ApiService(
            $this->uriFactory,
            new UriTemplate(),
            $this->httpClient,
            $this->messageFactory,
            $this->schema,
            $this->requestValidator,
            $this->serializer,
            $this->config
        );
    }
}