vendor/json-mapper/json-mapper/src/JsonMapperBuilder.php line 48

Open in your IDE?
  1. <?php
  3. declare(strict_types=1);
  5. namespace JsonMapper;
  7. use JsonMapper\Cache\ArrayCache;
  8. use JsonMapper\Dto\NamedMiddleware;
  9. use JsonMapper\Enums\TextNotation;
  10. use JsonMapper\Exception\BuilderException;
  11. use JsonMapper\Handler\PropertyMapper;
  12. use JsonMapper\Middleware\Attributes\Attributes;
  13. use JsonMapper\Middleware\CaseConversion;
  14. use JsonMapper\Middleware\Debugger;
  15. use JsonMapper\Middleware\DocBlockAnnotations;
  16. use JsonMapper\Middleware\FinalCallback;
  17. use JsonMapper\Middleware\NamespaceResolver;
  18. use JsonMapper\Middleware\Rename\Mapping;
  19. use JsonMapper\Middleware\Rename\Rename;
  20. use JsonMapper\Middleware\TypedProperties;
  21. use Psr\Log\LoggerInterface;
  22. use Psr\SimpleCache\CacheInterface;
  24. /**
  25.  * @template T of \JsonMapper\JsonMapperInterface
  26.  */
  27. class JsonMapperBuilder
  28. {
  29.     /**
  30.      * @psalm-var class-string<T>
  31.      */
  32.     protected $jsonMapperClassName = JsonMapper::class;
  33.     /** @var PropertyMapper */
  34.     protected $propertyMapper;
  35.     /** @var CacheInterface */
  36.     protected $defaultCache;
  37.     /** @var NamedMiddleware[] */
  38.     protected $namedMiddleware = [];
  40.     public static function new(): JsonMapperBuilder
  41.     {
  42.         return new JsonMapperBuilder();
  43.     }
  45.     public function __construct()
  46.     {
  47.         $this->withPropertyMapper(new PropertyMapper())
  48.             ->withDefaultCache(new ArrayCache());
  49.     }
  51.     public function build(): JsonMapperInterface
  52.     {
  53.         if (empty($this->namedMiddleware)) {
  54.             throw BuilderException::forBuildingWithoutMiddleware();
  55.         }
  57.         /** @var JsonMapperInterface $mapper */
  58.         $mapper = new $this->jsonMapperClassName();
  59.         $mapper->setPropertyMapper($this->propertyMapper);
  60.         foreach ($this->namedMiddleware as $namedMiddleware) {
  61.             $mapper->push($namedMiddleware->getMiddleware(), $namedMiddleware->getName());
  62.         }
  64.         return $mapper;
  65.     }
  67.     /** @psalm-param class-string<T> $jsonMapperClassName */
  68.     public function withJsonMapperClassName(string $jsonMapperClassName): JsonMapperBuilder
  69.     {
  70.         $reflectedClass = new \ReflectionClass($jsonMapperClassName);
  71.         if (!$reflectedClass->implementsInterface(JsonMapperInterface::class)) {
  72.             throw BuilderException::invalidJsonMapperClassName($jsonMapperClassName);
  73.         }
  75.         $this->jsonMapperClassName = $jsonMapperClassName;
  77.         return $this;
  78.     }
  80.     public function withPropertyMapper(PropertyMapper $propertyMapper): JsonMapperBuilder
  81.     {
  82.         $this->propertyMapper = $propertyMapper;
  84.         return $this;
  85.     }
  87.     public function withDefaultCache(CacheInterface $defaultCache): JsonMapperBuilder
  88.     {
  89.         $this->defaultCache = $defaultCache;
  91.         return $this;
  92.     }
  94.     public function withDocBlockAnnotationsMiddleware(?CacheInterface $cache = null): JsonMapperBuilder
  95.     {
  96.         return $this->withMiddleware(
  97.             new DocBlockAnnotations($cache ?: $this->defaultCache),
  98.             DocBlockAnnotations::class
  99.         );
  100.     }
  102.     public function withNamespaceResolverMiddleware(?CacheInterface $cache = null): JsonMapperBuilder
  103.     {
  104.         return $this->withMiddleware(
  105.             new NamespaceResolver($cache ?: $this->defaultCache),
  106.             NamespaceResolver::class
  107.         );
  108.     }
  110.     public function withTypedPropertiesMiddleware(?CacheInterface $cache = null): JsonMapperBuilder
  111.     {
  112.         return $this->withMiddleware(
  113.             new TypedProperties($cache ?: $this->defaultCache),
  114.             TypedProperties::class
  115.         );
  116.     }
  118.     public function withAttributesMiddleware(): JsonMapperBuilder
  119.     {
  120.         return $this->withMiddleware(new Attributes(), Attributes::class);
  121.     }
  123.     public function withRenameMiddleware(Mapping ...$mapping): JsonMapperBuilder
  124.     {
  125.         return $this->withMiddleware(new Rename(...$mapping), Rename::class);
  126.     }
  128.     public function withCaseConversionMiddleware(
  129.         TextNotation $searchSeparator,
  130.         TextNotation $replacementSeparator
  131.     ): JsonMapperBuilder {
  132.         return $this->withMiddleware(
  133.             new CaseConversion($searchSeparator, $replacementSeparator),
  134.             CaseConversion::class
  135.         );
  136.     }
  138.     public function withDebuggerMiddleware(LoggerInterface $logger): JsonMapperBuilder
  139.     {
  140.         return $this->withMiddleware(new Debugger($logger), Debugger::class);
  141.     }
  143.     public function withFinalCallbackMiddleware(
  144.         callable $callback,
  145.         bool $onlyApplyCallBackOnTopLevel = true
  146.     ): JsonMapperBuilder {
  147.         return $this->withMiddleware(new FinalCallback($callback, $onlyApplyCallBackOnTopLevel), FinalCallback::class);
  148.     }
  150.     public function withMiddleware(callable $middleware, ?string $name = null): JsonMapperBuilder
  151.     {
  152.         $fallbackName = is_object($middleware) ? get_class($middleware) : '<anonymous>';
  153.         $this->namedMiddleware[] = new NamedMiddleware($middleware, $name ?: $fallbackName);
  155.         return $this;
  156.     }
  157. }