CoreGatewayFactory.php

<?php

namespace Payum\Core;

use Closure;
use DI\ContainerBuilder;
use Exception;
use GuzzleHttp\Psr7\Request;
use Http\Adapter\Buzz\Client as HttpBuzzClient;
use Http\Adapter\Guzzle5\Client as HttpGuzzle5Client;
use Http\Adapter\Guzzle6\Client as HttpGuzzle6Client;
use Http\Adapter\Guzzle7\Client as HttpGuzzle7Client;
use Http\Client\Curl\Client as HttpCurlClient;
use Http\Client\HttpClient;
use Http\Client\Socket\Client as HttpSocketClient;
use Http\Discovery\HttpClientDiscovery;
use Http\Discovery\MessageFactoryDiscovery;
use Http\Discovery\Psr17FactoryDiscovery;
use Http\Discovery\Psr18ClientDiscovery;
use Http\Discovery\StreamFactoryDiscovery;
use Http\Message\MessageFactory;
use Http\Message\MessageFactory\DiactorosMessageFactory;
use Http\Message\MessageFactory\GuzzleMessageFactory;
use Http\Message\StreamFactory\GuzzleStreamFactory;
use LogicException;
use Money\Currencies;
use Money\Currencies\AggregateCurrencies;
use Money\Currencies\CryptoCurrencies;
use Money\Currencies\ISOCurrencies;
use Money\Formatter\DecimalMoneyFormatter;
use Money\MoneyFormatter;
use Money\MoneyParser;
use Money\Parser\DecimalMoneyParser;
use Nyholm\Psr7\Factory\HttplugFactory;
use Payum\Core\Action\AuthorizePaymentAction;
use Payum\Core\Action\CapturePaymentAction;
use Payum\Core\Action\ExecuteSameRequestWithModelDetailsAction;
use Payum\Core\Action\GetCurrencyAction;
use Payum\Core\Action\GetHttpRequestAction;
use Payum\Core\Action\GetTokenAction;
use Payum\Core\Action\PayoutPayoutAction;
use Payum\Core\Action\PrependActionInterface;
use Payum\Core\Action\RenderTemplateAction;
use Payum\Core\Bridge\Httplug\HttplugClient;
use Payum\Core\Bridge\Spl\ArrayObject;
use Payum\Core\Bridge\Twig\TwigRenderer;
use Payum\Core\Bridge\Twig\TwigUtil;
use Payum\Core\Clock\SystemClock;
use Payum\Core\DI\ContainerConfiguration;
use Payum\Core\DI\CreatesGateway;
use Payum\Core\Event\NullEventDispatcher;
use Payum\Core\Extension\EndlessCycleDetectorExtension;
use Payum\Core\Extension\PrependExtensionInterface;
use Payum\Core\Gateway\DeclaresActions;
use Payum\Core\Gateway\GatewayInterface as PaymentGateway;
use Payum\Core\Handler\HandlerMap;
use Payum\Core\Middleware\EndlessCycleDetectorMiddleware;
use Payum\Core\Middleware\LegacyExtensionMiddleware;
use Payum\Core\Middleware\MiddlewareCollection;
use Payum\Core\Middleware\PersistStateMiddleware;
use Payum\Core\Middleware\RecordPaymentStatusMiddleware;
use Payum\Core\Middleware\TemplateRenderMiddleware;
use Payum\Core\Registry\StorageRegistryInterface;
use Payum\Core\Template\RendererInterface;
use Psr\Clock\ClockInterface;
use Psr\Container\ContainerExceptionInterface;
use Psr\Container\ContainerInterface;
use Psr\Container\NotFoundExceptionInterface;
use Psr\EventDispatcher\EventDispatcherInterface;
use Psr\Http\Client\ClientInterface;
use Psr\Http\Message\RequestFactoryInterface;
use Psr\Http\Message\ResponseFactoryInterface;
use Psr\Http\Message\ServerRequestFactoryInterface;
use Psr\Http\Message\ServerRequestInterface;
use Psr\Http\Message\StreamFactoryInterface;
use ReflectionFunction;
use ReflectionNamedType;
use ReflectionType;
use Symfony\Component\HttpClient\HttplugClient as SymfonyHttplugClient;
use Twig\Environment;
use Twig\Loader\ChainLoader;
use function array_combine;
use function array_map;
use function array_merge;
use function class_exists;
use function func_get_args;
use function func_num_args;
use function in_array;
use function is_string;
use function str_starts_with;
use function trigger_deprecation;
use function trigger_error;
use const E_USER_DEPRECATED;

class CoreGatewayFactory implements GatewayFactoryInterface, ContainerConfiguration, CreatesGateway, GatewayFactoryConfigInterface
{
    /**
     * @var array<string, mixed>
     */
    protected array $defaultConfig = [];

    /**
     * @param array<string, mixed> $defaultConfig
     */
    public function __construct(array $defaultConfig = [])
    {
        $this->defaultConfig = $defaultConfig;
    }

    /**
     * @param array<string, mixed> $config
     *
     * @throws ContainerExceptionInterface|NotFoundExceptionInterface|Exception
     */
    public function create(array $config = []): Gateway
    {
        trigger_deprecation('payum/core', '2.0.0', 'The %s is deprecated. Implement the %s interface instead.', __METHOD__, ContainerConfiguration::class);

        $containerBuilder = new ContainerBuilder();
        $containerBuilder->addDefinitions($config);
        $containerBuilder->addDefinitions($this->configureContainer());
        $containerBuilder->addDefinitions([
            ArrayObject::class => static function (ContainerInterface $container) {
                trigger_deprecation('payum/core', '2.0.0', 'The %s service is deprecated and will be removed in 3.0. Use the %s service instead.', ArrayObject::class, ContainerInterface::class);
                return new class($container) extends ArrayObject {
                    private ContainerInterface $container;

                    public function __construct(ContainerInterface $container)
                    {
                        parent::__construct();

                        $this->container = $container;
                    }

                    public function offsetGet($key): mixed
                    {
                        return $this->container->get($key);
                    }

                    public function offsetExists($key): bool
                    {
                        return $this->container->has($key);
                    }
                };
            },
        ]);

        $container = $containerBuilder->build();

        $entries = $container->getKnownEntryNames();

        $configArray = ArrayObject::ensureArrayObject($config);
        $configArray->defaults(array_combine(
            $entries,
            array_map(static fn (string $name) => static fn () => $container->get($name), $entries)
        ));

        $gateway = new Gateway();

        $this->buildClosures($configArray);
        $this->buildActions($gateway, $configArray);
        $this->buildApis($gateway, $configArray);
        $this->buildExtensions($gateway, $configArray);

        return $this->createGateway($container, $gateway);
    }

    /**
     * @param array<string, mixed> $config
     *
     * @return array<string, mixed>
     */
    public function createConfig(array $config = []): array
    {
        trigger_deprecation('payum/core', '2.0.0', 'The %s is deprecated. Implement the %s interface instead.', __METHOD__, ContainerConfiguration::class);

        $containerConfig = $this->configureContainer();

        $result = array_merge($containerConfig, $config);

        if (isset($config['payum.paths'])) {
            $result['payum.paths'] = array_merge(
                $containerConfig['payum.paths'] ?? [],
                $config['payum.paths']
            );
        }

        return $result;
    }

    public function configureContainer(): array
    {
        return array_merge(
            [
                'httplug.message_factory' => static function (): MessageFactory {
                    @trigger_error('Using "httplug.message_factory" is deprecated, use "payum.http_message_factory" instead, which will return a PSR-17 RequestFactoryInterface since payum/core 2.0.0', E_USER_DEPRECATED);

                    if (class_exists(MessageFactoryDiscovery::class)) {
                        return MessageFactoryDiscovery::find();
                    }

                    if (class_exists(Request::class)) {
                        return new GuzzleMessageFactory();
                    }

                    if (class_exists(\Laminas\Diactoros\Request::class)) {
                        return new DiactorosMessageFactory();
                    }

                    if (class_exists(\Nyholm\Psr7\Request::class)) {
                        return new HttplugFactory();
                    }

                    throw new LogicException('The httplug.message_factory could not be guessed. Install one of the following packages: php-http/guzzle7-adapter. You can also overwrite the config option with your implementation.');
                },
                'httplug.stream_factory' => static function () {
                    @trigger_error('Using "httplug.stream_factory" is deprecated, use "payum.http_stream_factory" instead which will return a PSR-17 StreamFactoryInterface since payum/core 2.0.0', E_USER_DEPRECATED);
                    if (class_exists(StreamFactoryDiscovery::class)) {
                        return StreamFactoryDiscovery::find();
                    }

                    if (class_exists(Request::class)) {
                        return new GuzzleStreamFactory();
                    }

                    if (class_exists(\Nyholm\Psr7\Request::class)) {
                        return new HttplugFactory();
                    }

                    throw new LogicException('The httplug.stream_factory could not be guessed. Install one of the following packages: php-http/guzzle7-adapter. You can also overwrite the config option with your implementation.');
                },
                'httplug.client' => static function (ArrayObject $config) {
                    @trigger_error('Using "httplug.client" is deprecated, use "payum.http_client" instead which will return a PSR-18 ClientInterface since payum/core 2.0.0', E_USER_DEPRECATED);

                    if (class_exists(HttpClientDiscovery::class)) {
                        return HttpClientDiscovery::find();
                    }

                    if (class_exists(HttpGuzzle7Client::class)) {
                        return new HttpGuzzle7Client();
                    }

                    if (class_exists(HttpGuzzle6Client::class)) {
                        return new HttpGuzzle6Client();
                    }

                    if (class_exists(HttpGuzzle5Client::class)) {
                        return new HttpGuzzle5Client();
                    }

                    if (class_exists(SymfonyHttplugClient::class)) {
                        return new SymfonyHttplugClient();
                    }

                    if (class_exists(HttpSocketClient::class)) {
                        return new HttpSocketClient();
                    }

                    if (class_exists(HttpCurlClient::class)) {
                        return new HttpCurlClient($config['httplug.message_factory'], $config['httplug.stream_factory']);
                    }

                    if (class_exists(HttpBuzzClient::class)) {
                        return new HttpBuzzClient();
                    }

                    throw new LogicException('The httplug.client could not be guessed. Install one of the following packages: php-http/guzzle7-adapter, php-http/guzzle7-adapter. You can also overwrite the config option with your implementation.');
                },

                // PSR-18/17 services - lazily discover if not provided
                ClientInterface::class => Psr18ClientDiscovery::find(...),
                StreamFactoryInterface::class => Psr17FactoryDiscovery::findStreamFactory(...),
                RequestFactoryInterface::class => Psr17FactoryDiscovery::findRequestFactory(...),
                ServerRequestFactoryInterface::class => Psr17FactoryDiscovery::findServerRequestFactory(...),

                // Every time read goes through this, so that expiry and staleness can be tested at a
                // fixed instant. The application registers its own through PayumBuilder, which wins
                // over this one.
                ClockInterface::class => static fn (): ClockInterface => new SystemClock(),

                // Where the payment lifecycle is announced. A no-op by default, so core dispatches
                // unconditionally; the application registers its own -- Symfony's, Laravel's, anything
                // PSR-14 -- and starts hearing about it.
                EventDispatcherInterface::class => static fn (): EventDispatcherInterface => new NullEventDispatcher(),

                // Middleware wrapping command execution. The collection is what decides the order;
                // PayumBuilder replaces it with the defaults plus whatever the application and the
                // gateway registered.
                MiddlewareCollection::class => self::defaultMiddleware(...),
                EndlessCycleDetectorMiddleware::class => static fn (): EndlessCycleDetectorMiddleware => new EndlessCycleDetectorMiddleware(),
                LegacyExtensionMiddleware::class => static fn (): LegacyExtensionMiddleware => new LegacyExtensionMiddleware(),
                RecordPaymentStatusMiddleware::class => static fn (ContainerInterface $c): RecordPaymentStatusMiddleware => new RecordPaymentStatusMiddleware(
                    $c->get(EventDispatcherInterface::class),
                ),
                PersistStateMiddleware::class => static fn (ContainerInterface $c): PersistStateMiddleware => new PersistStateMiddleware(
                    $c->has(StorageRegistryInterface::class) ? $c->get(StorageRegistryInterface::class) : null,
                ),
                TemplateRenderMiddleware::class => static fn (): TemplateRenderMiddleware => new TemplateRenderMiddleware(),
                // The body is read from php://input rather than left empty: a PSP signs the raw bytes,
                // and $_POST is empty for the JSON payloads most of them send. An application with a
                // framework should register its own request instead, through
                // PayumBuilder::addGlobalService(), which overrides this.
                ServerRequestInterface::class => static fn (ContainerInterface $c): ServerRequestInterface => $c
                    ->get(ServerRequestFactoryInterface::class)
                    ->createServerRequest($_SERVER['REQUEST_METHOD'] ?? 'GET', $_SERVER['REQUEST_URI'] ?? '/', $_SERVER)
                    ->withQueryParams($_GET)
                    ->withParsedBody($_POST)
                    ->withCookieParams($_COOKIE)
                    ->withBody($c->get(StreamFactoryInterface::class)->createStreamFromFile('php://input', 'r')),

                // Legacy Payum service names - delegate to PSR interfaces
                'payum.http_client' => static fn (ContainerInterface $c): HttplugClient => new HttplugClient($c->get(ClientInterface::class)),
                'payum.http_stream_factory' => static fn (ContainerInterface $c): StreamFactoryInterface => $c->get(StreamFactoryInterface::class),
                'payum.http_message_factory' => static fn (ContainerInterface $c): RequestFactoryInterface => $c->get(RequestFactoryInterface::class),
                'payum.template.layout' => '@PayumCore/layout.html.twig',

                'twig.env' => static fn () => new Environment(new ChainLoader()),

                // The application registers its own through PayumBuilder, which wins over this one: a
                // renderer is shared by every gateway, so this default only covers a gateway built
                // straight from the factory.
                RendererInterface::class => static fn (ContainerInterface $c): RendererInterface => new TwigRenderer(
                    $c->get('twig.env'),
                    $c->get('payum.template.layout'),
                    self::composeTemplatePaths($c),
                ),

                // What every money in this gateway is measured against. ISO 4217 first, so a code that
                // means one thing there cannot be shadowed; crypto after it, which is what makes an
                // eight- or eighteen-decimal amount come out right. Register your own to add a currency
                // neither lists.
                Currencies::class => static fn (): Currencies => new AggregateCurrencies([new ISOCurrencies(), new CryptoCurrencies()]),
                MoneyFormatter::class => static fn (ContainerInterface $c): MoneyFormatter => new DecimalMoneyFormatter($c->get(Currencies::class)),
                MoneyParser::class => static fn (ContainerInterface $c): MoneyParser => new DecimalMoneyParser($c->get(Currencies::class)),

                'payum.default_options' => [],
                'payum.required_options' => [],

                // Backwards compatibility arrays for deprecated build* methods
                'payum.prepend_actions' => [],
                'payum.prepend_apis' => [],
                'payum.prepend_extensions' => [],

                'payum.api.http_client' => static fn (ContainerInterface $c) => $c->get('payum.http_client'),

                // Token storage - should be provided externally
                // 'payum.security.token_storage' => null,

                'payum.paths' => self::corePaths(),

                // Additional aliases
                ResponseFactoryInterface::class => static fn (ContainerInterface $c): RequestFactoryInterface => $c->get(RequestFactoryInterface::class),
                Environment::class => static fn (ContainerInterface $c) => $c->get('twig.env'),
                HttpClient::class => static fn (ContainerInterface $c) => $c->get('payum.http_client'),

                // BC: Deprecated action entries (used by deprecated buildActions method)
                'payum.action.get_http_request' => static fn (ContainerInterface $c) => $c->get(GetHttpRequestAction::class),
                'payum.action.capture_payment' => static fn () => new CapturePaymentAction(),
                'payum.action.authorize_payment' => static fn () => new AuthorizePaymentAction(),
                'payum.action.payout_payout' => static fn () => new PayoutPayoutAction(),
                'payum.action.execute_same_request_with_model_details' => static fn () => new ExecuteSameRequestWithModelDetailsAction(),
                'payum.action.get_currency' => static fn (ContainerInterface $c) => $c->get(GetCurrencyAction::class),
                'payum.action.render_template' => static fn (ContainerInterface $c) => $c->get(RenderTemplateAction::class),
                'payum.action.get_token' => static fn (ContainerInterface $c) => $c->has('payum.security.token_storage')
                    ? new GetTokenAction($c->get('payum.security.token_storage'))
                    : null,

                // BC: Deprecated extension entries (used by deprecated buildExtensions method)
                'payum.extension.endless_cycle_detector' => static fn () => new EndlessCycleDetectorExtension(),

                // The 1.x information requests, answered from the services 2.0 injects. A gateway still
                // dispatching GetHttpRequest or RenderTemplate needs nothing registered by hand.
                GetHttpRequestAction::class => static fn (ContainerInterface $c) => new GetHttpRequestAction($c->get(ServerRequestInterface::class)),
                RenderTemplateAction::class => static fn (ContainerInterface $c) => new RenderTemplateAction($c->get(RendererInterface::class)),
                GetCurrencyAction::class => static fn (ContainerInterface $c) => new GetCurrencyAction($c->get(Currencies::class)),

                // GetTokenAction is conditionally added in createGateway() if token storage is available
                GetTokenAction::class => static fn (ContainerInterface $c) => $c->has('payum.security.token_storage')
                    ? new GetTokenAction($c->get('payum.security.token_storage'))
                    : throw new LogicException('Token storage must be configured to use GetTokenAction'),
            ],
            $this->defaultConfig,
        );
    }

    /**
     * @throws ContainerExceptionInterface|NotFoundExceptionInterface
     */
    /**
     * The middleware every gateway gets, before anything the application or the gateway adds.
     */
    public static function defaultMiddleware(): MiddlewareCollection
    {
        return (new MiddlewareCollection())
            ->with(TemplateRenderMiddleware::class)
            ->with(EndlessCycleDetectorMiddleware::class)
            ->with(LegacyExtensionMiddleware::class)
            ->with(PersistStateMiddleware::class)
            ->with(RecordPaymentStatusMiddleware::class)
        ;
    }

    public function createGateway(ContainerInterface $container): Gateway
    {
        if (2 === func_num_args() && func_get_args()[1] instanceof Gateway) {
            $gateway = func_get_args()[1];
        } else {
            $gateway = new Gateway();
        }

        $gateway->setContainer($container);

        $declaredActions = [];

        if ($container->has(PaymentGateway::class)) {
            $paymentGateway = $container->get(PaymentGateway::class);

            $gateway->setHandlerMap(HandlerMap::fromHandlers($paymentGateway->handlers()));

            // A gateway that has finished moving gets nothing else: no actions, no extensions, no Twig
            // environment it will never render with. One still holding actions says so, and then needs
            // core's own alongside them, since an action dispatching GetHttpRequest expects an answer.
            if (! $paymentGateway instanceof DeclaresActions) {
                return $gateway;
            }

            $declaredActions = $paymentGateway->actions();
        }

        if ($container->has('twig.env')) {
            TwigUtil::registerPaths($container->get('twig.env'), self::composeTemplatePaths($container));
        }

        foreach ([...$this->getActions(), ...$declaredActions] as $action) {
            // Skip GetTokenAction if token storage is not configured
            if (GetTokenAction::class === $action && ! $container->has('payum.security.token_storage')) {
                continue;
            }

            $action = $container->get($action);

            $gateway->addAction($action, $action instanceof PrependActionInterface);
        }

        foreach ($this->getExtensions() as $extension) {
            if (is_string($extension)) {
                $extension = $container->get($extension);
            }

            $gateway->addExtension($extension, $extension instanceof PrependExtensionInterface);
        }

        return $gateway;
    }

    public function getActions(): array
    {
        return [
            GetHttpRequestAction::class,
            CapturePaymentAction::class,
            AuthorizePaymentAction::class,
            PayoutPayoutAction::class,
            ExecuteSameRequestWithModelDetailsAction::class,
            RenderTemplateAction::class,
            GetCurrencyAction::class,
            GetTokenAction::class,
        ];
    }

    public function getExtensions(): array
    {
        return [
            EndlessCycleDetectorExtension::class,
        ];
    }

    /**
     * @deprecated since 2.0. Implement the ContainerConfiguration interface instead.
     */
    protected function buildClosures(ArrayObject $config): void
    {
        trigger_deprecation('payum/core', '2.0.0', 'The %s is deprecated. Implement the %s interface instead.', __METHOD__, ContainerConfiguration::class);

        // Helper to check if closure expects ArrayObject
        $canInvokeWithArrayObject = static function ($value): bool {
            if (! $value instanceof Closure) {
                return false;
            }

            $reflection = new ReflectionFunction($value);
            if (0 === $reflection->getNumberOfParameters()) {
                return true;
            }

            $params = $reflection->getParameters();
            $firstParam = $params[0];
            return ! $firstParam->getType() instanceof ReflectionType || ($firstParam->getType() instanceof ReflectionNamedType && ArrayObject::class === $firstParam->getType()->getName());
        };

        /** @var ContainerInterface $container */
        $container = $config[ContainerInterface::class]();

        foreach ($config as $name => $value) {
            if (GetTokenAction::class === $name && ! $container->has('payum.security.token_storage')) {
                continue;
            }

            if (is_callable($value) && ! (is_string($value) && function_exists('\\' . $value))) {
                if ($canInvokeWithArrayObject($value)) {
                    $config[$name] = $value($config);
                } else {
                    $config[$name] = $container->get($name);
                }
            }
        }
    }

    /**
     * @deprecated since 2.0. Implement the ContainerConfiguration interface instead.
     */
    protected function buildActions(Gateway $gateway, ArrayObject $config): void
    {
        trigger_deprecation('payum/core', '2.0.0', 'The %s is deprecated. Implement the %s interface instead.', __METHOD__, ContainerConfiguration::class);
        foreach ($config as $name => $value) {
            if (str_starts_with($name, 'payum.action') && null !== $value) {
                $prepend = in_array($name, $config['payum.prepend_actions'], true) || $value instanceof PrependActionInterface;

                $gateway->addAction($value, $prepend);
            }
        }
    }

    /**
     * @deprecated since 2.0. Implement the ContainerConfiguration interface instead.
     */
    protected function buildApis(Gateway $gateway, ArrayObject $config): void
    {
        trigger_deprecation('payum/core', '2.0.0', 'The %s is deprecated. Implement the %s interface instead.', __METHOD__, ContainerConfiguration::class);
        foreach ($config as $name => $value) {
            if (str_starts_with($name, 'payum.api')) {
                @trigger_error('The payum.api.* config is deprecated and will be removed in 3.0. Use dependency-injection to inject the api into the action instead.', E_USER_DEPRECATED);
                $prepend = in_array($name, $config['payum.prepend_apis'], true);

                $gateway->addApi($value, $prepend);
            }
        }
    }

    /**
     * @deprecated since 2.0. Implement the ContainerConfiguration interface instead.
     */
    protected function buildExtensions(Gateway $gateway, ArrayObject $config): void
    {
        trigger_deprecation('payum/core', '2.0.0', 'The %s is deprecated. Implement the %s interface instead.', __METHOD__, ContainerConfiguration::class);
        foreach ($config as $name => $value) {
            if (str_starts_with($name, 'payum.extension')) {
                $prepend = in_array($name, $config['payum.prepend_extensions'], true) || $value instanceof PrependExtensionInterface;

                $gateway->addExtension($value, $prepend);
            }
        }
    }

    /**
     * @return array<string, string>
     */
    private static function corePaths(): array
    {
        return [
            'PayumCore' => __DIR__ . '/Resources/views',
        ];
    }

    /**
     * @return array<string, string>
     */
    private static function composeTemplatePaths(ContainerInterface $c): array
    {
        return array_merge(self::corePaths(), (array) $c->get('payum.paths'));
    }
}