Phrest\Application::run()

Complexity

Conditions	9
Paths	1

Size

Total Lines	169
Code Lines	95

Duplication

Lines	0
Ratio	0 %

Code Coverage

Tests	0
CRAP Score	90

Importance

Changes

0

<?php
    static public function run(
        string $applicationName = 'phrest-application',
        string $configDirectoryPattern = self::DEFAULT_CONFIG_DIRECTORY_PATTERN,
        ?\Psr\Http\Message\ServerRequestInterface $request = null
    )
    {
        $logger = new \Monolog\Logger($applicationName, [new \Monolog\Handler\StreamHandler('php://stdout')]);
        \Monolog\ErrorHandler::register($logger);

        $userConfigAggregator = new ConfigAggregator([
            new PhpFileProvider($configDirectoryPattern),
        ]);
        $userConfig = $userConfigAggregator->getMergedConfig();

        $swaggerScanDirectory = (string)($userConfig[\Phrest\Application::CONFIG_SWAGGER_SCAN_DIRECTORY] ?? null);

        $enableCache = (boolean)($userConfig[\Phrest\Application::CONFIG_ENABLE_CACHE] ?? false);
        $cacheDirectory = $userConfig[\Phrest\Application::CONFIG_CACHE_DIRECTORY] ?? null;

        $monologHandler = $userConfig[\Phrest\Application::CONFIG_MONOLOG_HANDLER] ?? [];
        $monologProcessor = $userConfig[\Phrest\Application::CONFIG_MONOLOG_PROCESSOR] ?? [];

        $errorCodes = $userConfig[\Phrest\Application::CONFIG_ERROR_CODES] ?? null;

        $cache = self::createCache($enableCache, $cacheDirectory);

        $internalConfigAggregator = new ConfigAggregator([
            new ArrayProvider([
                'dependencies' => $userConfig[\Phrest\Application::CONFIG_DEPENDENCIES] ?? []
            ]),
            new ArrayProvider([
                ConfigAggregator::ENABLE_CACHE => $enableCache,
                'zend-expressive' => [
                    'programmatic_pipeline' => true,
                ],
                'dependencies' => [
                    'factories' => [
                        \Zend\Expressive\Helper\UrlHelper::class => \Zend\Expressive\Helper\UrlHelperFactory::class,

                        \Phrest\Application::SERVICE_LOGGER => function (\Interop\Container\ContainerInterface $container) use ($logger, $monologHandler, $monologProcessor) {
                            $handlers = [];
                            foreach ($monologHandler as $handler) {
                                $handlers[] = $container->get($handler);
                            }
                            foreach ($monologProcessor as $processor) {
                                $logger->pushProcessor($container->get($processor));
                            }
                            $logger->setHandlers($handlers);
                            return $logger;
                        },

                        \Phrest\Application::SERVICE_SWAGGER => function () use ($cache, $swaggerScanDirectory) {
                            return new \Phrest\Swagger($cache, $swaggerScanDirectory);
                        },

                        \Phrest\Application::SERVICE_HATEOAS => function (\Interop\Container\ContainerInterface $container) use ($enableCache, $cacheDirectory) {
                            /** @var \Zend\Expressive\Router\RouterInterface $router */
                            $router = $container->get(\Zend\Expressive\Router\RouterInterface::class);

                            /** @var \Zend\Expressive\Helper\ServerUrlHelper $serverUrlHelper */
                            $serverUrlHelper = $container->get(\Zend\Expressive\Helper\ServerUrlHelper::class);

                            /* @todo registerLoader is deprecated! */
                            \Doctrine\Common\Annotations\AnnotationRegistry::registerLoader('class_exists');

The function Doctrine\Common\Annotations\AnnotationRegistry::registerLoader() has been deprecated: this method is deprecated and will be removed in doctrine/annotations 2.0 autoloading should be deferred to the globally registered autoloader by then. For now, use @example AnnotationRegistry::registerLoader('class_exists')

                            $hateoasBuilder = \Hateoas\HateoasBuilder::create();
                            if ($enableCache) {
                                $hateoasBuilder->setCacheDir($cacheDirectory);
                            }
                            $hateoasBuilder->setUrlGenerator(
                                null,
                                new \Hateoas\UrlGenerator\CallableUrlGenerator(
                                    function ($route, array $parameters, $absolute) use ($router, $serverUrlHelper) {
                                        $uri = $router->generateUri($route, $parameters);
                                        if ($absolute) {
                                            return $serverUrlHelper($uri);
                                        }
                                        return $uri;
                                    }
                                )
                            );
                            return $hateoasBuilder->build();
                        },

                        \Phrest\Application::ACTION_SWAGGER => function (\Interop\Container\ContainerInterface $container) {
                            return new \Phrest\API\Action\Swagger($container->get(\Phrest\Application::SERVICE_SWAGGER));
                        },

                        \Phrest\Application::ACTION_ERROR_CODES => function (\Interop\Container\ContainerInterface $container) use ($cache, $errorCodes) {
                            if ($errorCodes) {
                                $errorCodesInstance = $container->get($errorCodes);
                            } else {
                                $errorCodesInstance = new API\ErrorCodes();
                            }
                            return new \Phrest\API\Action\ErrorCodes($cache, $errorCodesInstance);
                        },

                        \Phrest\Application::SERVICE_HATEOAS_RESPONSE_GENERATOR => function (\Interop\Container\ContainerInterface $container) {
                            return new \Phrest\API\HateoasResponseGenerator(
                                $container->get(\Phrest\Application::SERVICE_HATEOAS)
                            );
                        },

                        \Phrest\Application::SERVICE_REQUEST_SWAGGER_VALIDATOR => function (\Interop\Container\ContainerInterface $container) {
                            /** @var \Phrest\Swagger $swagger */
                            $swagger = $container->get(\Phrest\Application::SERVICE_SWAGGER);
                            $jsonValidator = new \JsonSchema\Validator(
                                new \JsonSchema\Constraints\Factory($swagger->getSchemaStorage())
                            );
                            return new \Phrest\API\RequestSwaggerValidator($swagger, $jsonValidator);
                        },

                        \Phrest\Application::SERVICE_ROUTER => function () {
                            return new \Zend\Expressive\Router\FastRouteRouter();
                        },

                        \Zend\Expressive\Router\RouterInterface::class => function (\Interop\Container\ContainerInterface $container) {
                            return $container->get(\Phrest\Application::SERVICE_ROUTER);
                        }
                    ],
                    'invokables' => [
                        \Zend\Expressive\Helper\ServerUrlHelper::class => \Zend\Expressive\Helper\ServerUrlHelper::class
                    ],
                    'initializers' => [
                        \Psr\Log\LoggerAwareInterface::class => function (\Interop\Container\ContainerInterface $container, $service) {
                            if ($service instanceof \Psr\Log\LoggerAwareInterface) {
                                $service->setLogger(
                                    $container->get(\Phrest\Application::SERVICE_LOGGER)
                                );
                            }
                        },
                        API\RequestSwaggerValidatorAwareInterface::class => function (\Interop\Container\ContainerInterface $container, $service) {
                            if ($service instanceof API\RequestSwaggerValidatorAwareInterface) {
                                $service->setRequestSwaggerValidator(
                                    $container->get(\Phrest\Application::SERVICE_REQUEST_SWAGGER_VALIDATOR)
                                );
                            }
                        },
                        API\HateoasResponseGeneratorAwareInterface::class => function (\Interop\Container\ContainerInterface $container, $service) {
                            if ($service instanceof API\HateoasResponseGeneratorAwareInterface) {
                                $service->setHateoasResponseGenerator(
                                    $container->get(\Phrest\Application::SERVICE_HATEOAS_RESPONSE_GENERATOR)
                                );
                            }
                        },
                    ]
                ]
            ]),
        ]);

        $container = self::createContainer(
            $internalConfigAggregator->getMergedConfig(),
            $userConfig
        );

        // Register logging handler / processors - can only happen after loaded user dependencies
        $container->get(\Phrest\Application::SERVICE_LOGGER);

        $app = new \Zend\Expressive\Application($container->get(\Zend\Expressive\Router\RouterInterface::class), $container);

        self::registerRoutes($app, $userConfig[\Phrest\Application::CONFIG_ROUTES] ?? []);
        self::pipeMiddleware(
            $app,
            $userConfig[\Phrest\Application::CONFIG_PRE_ROUTING_MIDDLEWARE] ?? [],
            $userConfig[\Phrest\Application::CONFIG_PRE_DISPATCHING_MIDDLEWARE] ?? []
        );

        $logger->debug('application init completed', ['userConfig' => $userConfig]);

        $app->run($request);
    }