php-api-clients / foundation

src/Factory.php

<?php declare(strict_types=1);

namespace ApiClients\Foundation;

use ApiClients\Foundation\Hydrator\Factory as HydratorFactory;
use ApiClients\Foundation\Hydrator\Hydrator;
use ApiClients\Foundation\Hydrator\Options as HydratorOptions;
use ApiClients\Foundation\Transport\Client as TransportClient;
use ApiClients\Foundation\Transport\Factory as TransportFactory;
use ApiClients\Foundation\Transport\Options as TransportOptions;
use Interop\Container\ContainerInterface;
use League\Container\Container;
use League\Container\ReflectionContainer;
use League\Event\Emitter;
use League\Event\EmitterInterface;
use League\Tactician\CommandBus;
use League\Tactician\Container\ContainerLocator;
use League\Tactician\Handler\CommandHandlerMiddleware;
use League\Tactician\Handler\CommandNameExtractor\ClassNameExtractor;
use League\Tactician\Handler\MethodNameInflector\HandleInflector;
use React\EventLoop\LoopInterface;

final class Factory
{
    public static function create(
        LoopInterface $loop = null,
        ContainerInterface $wrappedContainer = null,
        array $options = []
    ): Client {
        $container = self::createContainer($wrappedContainer);

        $container->share(EmitterInterface::class, new Emitter());
        $container->share(TransportClient::class, self::createTransport($container, $loop, $options));
        $container->share(Hydrator::class, self::createHydrator($container, $options));
        $container->share(CommandBus::class, function () use ($container) {
            return self::createCommandBus($container);
        });

        return new Client(
            $container
        );
    }

    private static function createContainer(ContainerInterface $wrappedContainer = null): Container
    {
        $container = new Container();
        $container->delegate(new ReflectionContainer());

        if ($wrappedContainer instanceof ContainerInterface) {
            $container->delegate($wrappedContainer);
        }

        return $container;
    }

    private static function createCommandBus(ContainerInterface $container): CommandBus
    {
        $commandToHandlerMap = self::mapCommandsToHandlers($container->get(EmitterInterface::class));

        $containerLocator = new ContainerLocator(
            $container,
            $commandToHandlerMap
        );

        $commandHandlerMiddleware = new CommandHandlerMiddleware(
            new ClassNameExtractor(),
            $containerLocator,
            new HandleInflector()
        );

        return new CommandBus([
            $commandHandlerMiddleware,
        ]);
    }

    private static function mapCommandsToHandlers(Emitter $emitter): array
    {
        return $emitter->emit(CommandLocatorEvent::create())->getMap();
    }

    private static function createTransport(
        ContainerInterface $container,
        LoopInterface $loop = null,
        array $options = []
    ): TransportClient {
        $transport = TransportFactory::create($loop, $options);
        $container->share(LoopInterface::class, $transport->getLoop());
        return $transport;
    }

    private static function createHydrator(ContainerInterface $container, array $options = [])

The parameter $container is not used and could be removed.

    {
        if (isset($options[TransportOptions::HYDRATOR]) && $options[TransportOptions::HYDRATOR] instanceof Hydrator) {
            return $options[TransportOptions::HYDRATOR];
        }

        if (!isset($options[TransportOptions::HYDRATOR_OPTIONS])) {
            throw new \Exception('Missing Hydrator options');
        }

        return HydratorFactory::create($options[TransportOptions::HYDRATOR_OPTIONS]);
    }
}