slovocast/app/src/Bootstrap.php

<?php

namespace Slovocast;

use DI\Container;
use DI\ContainerBuilder;
use Exception;
use League\Config\Configuration;
use Monolog\Handler\StreamHandler;
use Monolog\Level;
use Monolog\Logger;
use Odan\Session\PhpSession;
use Odan\Session\SessionInterface;
use Odan\Session\SessionManagerInterface;
use Psr\Container\ContainerExceptionInterface;
use Psr\Container\ContainerInterface;
use Psr\Container\NotFoundExceptionInterface;
use Psr\Http\Message\ResponseFactoryInterface;
use Psr\Log\LoggerInterface;
use React\Mysql\MysqlClient;
use Slim\App;
use Slim\Factory\AppFactory;
use Slim\Psr7\Factory\ResponseFactory;
use Slovocast\Configuration\DatabaseConnectionSchema;
use Slovocast\Configuration\SessionSchema;
use Slovocast\Configuration\SiteInformationSchema;
use Slovocast\Domain\Repository\User\UserRepository;
use Slovocast\Domain\Repository\User\UserRepositoryInterface;
use Slovocast\Infrastructure\Api\User\UserAuthorizationInterface;
use Slovocast\Infrastructure\User\BasicUserAuthorization;
use Twig\Error\LoaderError;

/**
 * Defines here are used globally
 */
define('APP_ROOT_DIR', realpath(__DIR__ . '/..'));
define('APP_SRC_DIR', realpath(__DIR__));
define('APP_PUBLIC_DIR', realpath(__DIR__ . '/../public'));
define('APP_TEMPLATES_DIR', realpath(__DIR__ . '/../templates'));
define('APP_LOGS_DIR', realpath(__DIR__ . '/../var/logs'));
define('APP_TEMP_DIR', realpath(__DIR__ . '/../var/temp'));

class Bootstrap
{
    /**
     * Pulls out all the configuration schemas and configuration values.
     *
     * @return Configuration
     */
    protected static function initConfig(): Configuration
    {
        $config = new Configuration();
        $dotenv = \DotenvVault\DotenvVault::createImmutable(APP_ROOT_DIR);
        $dotenv->safeLoad();

        // set all configuration details
        $config->addSchema('site', SiteInformationSchema::getSchema());
        $config->addSchema('database', DatabaseConnectionSchema::getSchema());
        $config->addSchema('session', SessionSchema::getSchema());


        $config->merge([
            'site' => [
                'name' => "Slovocast",
                'description' => "A no-bullshit podcast hosting platform.",
                'tags' => [
                    'podcast', 'hosting', 'indie', 'independent', 'easy'
                ]
            ],
            'session' => [
                'name' => 'slovocast'
            ],
            'database' => [
                'host' => $_ENV['DB_HOST'],
                'database' => $_ENV['DB_SCHEMA'],
                'username' => $_ENV['DB_USER'],
                'password' => $_ENV['DB_PASSWORD'],
                'port' => (int) $_ENV['DB_PORT'],
            ]
        ]);

        return $config;
    }

    /**
     * Set up the Container with all of its definitions, as well as initialization of configuration.
     *
     * @return Container
     * @throws Exception
     */
    protected static function initContainer(): Container
    {
        $containerBuilder = new ContainerBuilder();

        $config = self::initConfig();
        $containerBuilder->addDefinitions([
            'config' => $config,
            LoggerInterface::class => function() {
                $logger = new Logger();
                $logger->pushHandler(new StreamHandler(APP_LOGS_DIR, Level::Warning));
                return $logger;
            },

            /**
             * Session and Flash classes here
             */
            SessionManagerInterface::class => function (ContainerInterface $container) {
                return $container->get(SessionInterface::class);
            },
            SessionInterface::class => function (ContainerInterface $container) {
                $options = $container->get('config')->get('session');
                return new PhpSession($options);
            },
            'flash' => function (ContainerInterface $container) {
                return $container->get(SessionInterface::class)->getFlash();
            },

            /**
             * Application DI
             */
            ResponseFactoryInterface::class => function (ContainerInterface $container) {
                return new ResponseFactory();
            },

            /**
             * Database Connections
             */
            MysqlClient::class => function (ContainerInterface $container) {
                $config = $container->get('config')->get('database');
                $connectionString = sprintf(
                    "%s:%s@%s/%s",
                    rawurlencode($config['username']),
                    rawurlencode($config['password']),
                    $config['host'],
                    $config['database']
                );
                return new MysqlClient($connectionString);
            },

            /**
             * Utility classes
             */
            UserAuthorizationInterface::class => function(ContainerInterface $container) {
                return new BasicUserAuthorization();
            },

            /**
             * Add the Domain Repositories Here
             */
            UserRepositoryInterface::class => function (ContainerInterface $container) {
                return new UserRepository(
                    $container->get(MysqlClient::class),
                    $container->get(UserAuthorizationInterface::class)
                );
            }
        ]);

        return $containerBuilder->build();
    }

    /**
     * Tasking the instantiated Application, sets up all the routes for the
     * application.
     *
     * @param App $app
     * @return void
     */
    protected static function establishRoutes(App $app): void
    {
        Routes::setup($app);
    }

    /**
     * Taking an instantiated application, sets up all the middleware required for the application to run. This appends
     * Middleware in a Global sense not per-route. Per-route middleware will be set in the `establishRoutes` method.
     *
     * @param App $app
     * @throws ContainerExceptionInterface
     * @throws NotFoundExceptionInterface
     * @throws LoaderError
     */
    protected static function establishMiddleware(App $app): void
    {
        Middlewares::setup($app);
    }

    /**
     * Instantiates the application.
     *
     * @return App
     * @throws ContainerExceptionInterface
     * @throws LoaderError
     * @throws NotFoundExceptionInterface
     * @throws Exception
     */
    public static function init(): App
    {
        $container = self::initContainer();
        $app = AppFactory::createFromContainer($container);
        self::establishMiddleware($app);
        self::establishRoutes($app);
        return $app;
    }
}