Remove direction from types repository

Author: SerafimArts

src/Context/BuildingContext.php

@@ -17,10 +17,6 @@ class BuildingContext extends MapperContext implements
     use InteractWithTypeRepository;
 
     protected function __construct(
-        /**
-         * Gets data transformation direction.
-         */
-        public readonly DirectionInterface $direction,
         TypeRepositoryInterface $types,
         TypeParserInterface $parser,
         TypeExtractorInterface $extractor,
@@ -39,11 +35,9 @@ protected function __construct(
 
     public static function createFromMapperContext(
         MapperContext $context,
-        DirectionInterface $direction,
         TypeRepositoryInterface $types,
     ): self {
         return new self(
-            direction: $direction,
             types: $types,
             parser: $context->parser,
             extractor: $context->extractor,

src/Kernel/Repository/Factory/DefaultTypeRepositoryFactory.php

@@ -5,7 +5,6 @@
 namespace TypeLang\Mapper\Kernel\Repository\Factory;
 
 use TypeLang\Mapper\Configuration;
-use TypeLang\Mapper\Context\DirectionInterface;
 use TypeLang\Mapper\Context\MapperContext;
 use TypeLang\Mapper\Kernel\Repository\DecorateByCoercibleTypeRepository;
 use TypeLang\Mapper\Kernel\Repository\DecorateByLoggableTypeRepository;
@@ -97,11 +96,10 @@ public function __construct(
         ),
     ) {}
 
-    public function createTypeRepository(MapperContext $context, DirectionInterface $direction): TypeRepositoryInterface
+    public function createTypeRepository(MapperContext $context): TypeRepositoryInterface
     {
         $types = new TypeRepository(
             context: $context,
-            direction: $direction,
             builders: $context->platform->getTypes(),
         );
 

src/Kernel/Repository/Factory/TypeRepositoryFactoryInterface.php

@@ -4,7 +4,6 @@
 
 namespace TypeLang\Mapper\Kernel\Repository\Factory;
 
-use TypeLang\Mapper\Context\DirectionInterface;
 use TypeLang\Mapper\Context\MapperContext;
 use TypeLang\Mapper\Kernel\Repository\TypeRepositoryInterface;
 
@@ -18,8 +17,5 @@
  */
 interface TypeRepositoryFactoryInterface
 {
-    public function createTypeRepository(
-        MapperContext $context,
-        DirectionInterface $direction,
-    ): TypeRepositoryInterface;
+    public function createTypeRepository(MapperContext $context): TypeRepositoryInterface;
 }

src/Kernel/Repository/TypeRepository.php

@@ -5,7 +5,6 @@
 namespace TypeLang\Mapper\Kernel\Repository;
 
 use TypeLang\Mapper\Context\BuildingContext;
-use TypeLang\Mapper\Context\DirectionInterface;
 use TypeLang\Mapper\Context\MapperContext;
 use TypeLang\Mapper\Exception\Definition\TypeNotFoundException;
 use TypeLang\Mapper\Type\Builder\TypeBuilderInterface;
@@ -25,12 +24,13 @@ final class TypeRepository implements
 
     private TypeRepositoryInterface $repository;
 
+    private ?BuildingContext $building = null;
+
     /**
      * @param iterable<mixed, TypeBuilderInterface> $builders
      */
     public function __construct(
         private readonly MapperContext $context,
-        private readonly DirectionInterface $direction,
         iterable $builders,
     ) {
         $this->repository = $this;
@@ -47,9 +47,8 @@ public function setTypeRepository(TypeRepositoryInterface $parent): void
 
     private function buildType(TypeStatement $statement): TypeInterface
     {
-        $context = BuildingContext::createFromMapperContext(
+        $context = $this->building ??= BuildingContext::createFromMapperContext(
             context: $this->context,
-            direction: $this->direction,
             types: $this->repository,
         );
 

src/Mapper.php

@@ -23,22 +23,21 @@
 
 final class Mapper implements NormalizerInterface, DenormalizerInterface
 {
-    /**
-     * @var \WeakMap<DirectionInterface, TypeRepositoryInterface>
-     */
-    private readonly \WeakMap $repository;
+    private readonly TypeRepositoryInterface $types;
 
     public readonly MapperContext $context;
 
     public function __construct(
         private readonly PlatformInterface $platform = new StandardPlatform(),
         private readonly Configuration $config = new Configuration(),
     ) {
-        $this->repository = new \WeakMap();
-
         $this->context = $this->createMapperContext(
             context: $this->createBootContext(),
         );
+
+        $this->types = $this->createTypeRepository(
+            context: $this->context,
+        );
     }
 
     private function createBootContext(): BootContext
@@ -72,15 +71,11 @@ private function createTypeParser(BootContext $context): TypeParserInterface
         return $factory->createTypeParser($context);
     }
 
-    private function getTypeRepository(DirectionInterface $direction): TypeRepositoryInterface
+    private function createTypeRepository(MapperContext $context): TypeRepositoryInterface
     {
-        $factory = $this->config->getTypeRepositoryFactory();
+        $factory = $context->config->getTypeRepositoryFactory();
 
-        return $this->repository[$direction]
-            ??= $factory->createTypeRepository(
-                context: $this->context,
-                direction: $direction,
-            );
+        return $factory->createTypeRepository($context);
     }
 
     private function createRuntimeContext(mixed $value, DirectionInterface $direction): RuntimeContext
@@ -89,7 +84,7 @@ private function createRuntimeContext(mixed $value, DirectionInterface $directio
             context: $this->context,
             value: $value,
             direction: $direction,
-            types: $this->getTypeRepository($direction),
+            types: $this->types,
         );
     }
 
@@ -166,11 +161,9 @@ public function canMap(DirectionInterface $direction, mixed $value, #[Language('
      * @throws TypeNotFoundException in case of type not found
      * @throws \Throwable in case of internal error occurs
      */
-    public function getType(DirectionInterface $direction, #[Language('PHP')] string $type): TypeInterface
+    public function getType(#[Language('PHP')] string $type): TypeInterface
     {
-        $repository = $this->getTypeRepository($direction);
-
-        return $repository->getTypeByStatement(
+        return $this->types->getTypeByStatement(
             statement: $this->context->getStatementByDefinition($type),
         );
     }
@@ -183,12 +176,11 @@ public function getType(DirectionInterface $direction, #[Language('PHP')] string
      * @throws TypeNotFoundException in case of type not found
      * @throws \Throwable in case of internal error occurs
      */
-    public function getTypeByValue(DirectionInterface $direction, mixed $value): TypeInterface
+    public function getTypeByValue(mixed $value): TypeInterface
     {
-        return $this->getType(
-            direction: $direction,
-            type: $this->context->getDefinitionByValue($value),
-        );
+        $definition = $this->context->getDefinitionByValue($value);
+
+        return $this->getType($definition);
     }
 
     /**
@@ -204,12 +196,12 @@ public function getTypeByValue(DirectionInterface $direction, mixed $value): Typ
      * @throws TypeNotFoundException
      * @throws \Throwable
      */
-    public function warmup(DirectionInterface $direction, string|object $class): void
+    public function warmup(string|object $class): void
     {
         if (\is_object($class)) {
             $class = $class::class;
         }
 
-        $this->getType($direction, $class);
+        $this->getType($class);
     }
 }