terah / fluent-pdo-model

src/ConnectionPool.php

<?php declare(strict_types=1);
/**
 * @package Terah\FluentPdoModel
 *
 * Licensed under The MIT License
 * For full copyright and license information, please see the LICENSE.txt
 * Redistributions of files must retain the above copyright notice.
 *
 * @license       http://www.opensource.org/licenses/mit-license.php MIT License
 */
namespace Terah\FluentPdoModel;

use Psr\Log\LoggerInterface;
use Terah\FluentPdoModel\Drivers\AbstractPdo;
use Terah\FluentPdoModel\Drivers\DriverInterface;
use Terah\RedisCache\CacheInterface;
use function Terah\Assert\Assert;

class ConnectionPool
{
    /**
     * @var DriverInterface|\Closure[] $_connections
     */
    protected $_connections         = [];

    /**
     * @var ConnectionPool
     */
    static protected $instance      = null;

    /**
     * Constructor
     */
    protected function __construct()
    {}

    /**
     * @param array           $connections
     * @param LoggerInterface $logger
     * @param CacheInterface   $cache
     */
    public function addConnections(array $connections=[], LoggerInterface $logger=null, CacheInterface $cache=null)
    {
        foreach ( $connections as $name => $conn )
        {
            $this->addConnection($name, $conn, $logger, $cache);
        }
    }

    /**
     * @param array $config
     * @param LoggerInterface|null $logger
     * @param CacheInterface|null $cache
     * @return \Closure
     */
    public static function getDriverFromArray(array $config, LoggerInterface $logger=null, CacheInterface $cache=null) : \Closure
    {
        $dsn        = $user = $pass = '';
        extract($config);
        unset($config['dsn'],$config['user'], $config['pass']);
        Assert($dsn)->notEmpty("The dsn cannot be empty.");
        $driver     = 'Terah\\FluentPdoModel\\Drivers\\' . ucfirst(strtolower(substr($dsn, 0, strpos($dsn, ':')))) . 'Pdo';
        Assert($driver)->classExists("The database driver {$driver} is not supported.");

        return function() use ($driver, $dsn, $user, $pass, $config, $logger, $cache) {

            return new $driver($dsn, $user, $pass, $config, $logger, $cache);
        };
    }

    /**
     * @param String $name
     * @param DriverInterface|array|\Closure $conn
     * @param LoggerInterface $logger
     * @param CacheInterface   $cache
     *
     * @return ConnectionPool
     * @throws \Exception
     */
    public function addConnection(string $name, $conn, LoggerInterface $logger=null, CacheInterface $cache=null) : ConnectionPool
    {
        Assert($name)->notEmpty("The connection name cannot be empty.");
        Assert($conn)->notEmpty("The connection details cannot be empty.");

        if ( $conn instanceof AbstractPdo || $conn instanceof \Closure )
        {
            $this->_connections[$name] = $conn;

            return $this;
        }
        $this->_connections[$name] = static::getDriverFromArray($conn, $logger, $cache);

It seems like $conn defined by parameter $conn on line 80 can also be of type object<Terah\FluentPdoModel\Drivers\DriverInterface>; however, Terah\FluentPdoModel\ConnectionPool::getDriverFromArray() does only seem to accept array, maybe add an additional type check?

        return $this;
    }

    /**
     * @param $name
     * @param AbstractPdo $conn
     * @return ConnectionPool
     */
    public static function add(string $name, AbstractPdo $conn) : ConnectionPool
    {
        return static::getInstance()->addConnection($name, $conn);
    }

    /**
     * @param string $name
     * @return AbstractPdo
     */
    public function getConnection(string $name) : AbstractPdo
    {
        Assert($this->_connections)->keyExists($name, "The database connection {$name} has not been added.");

        if ( $this->_connections[$name] instanceof \Closure )
        {
            $this->_connections[$name] = $this->_connections[$name]->__invoke();
        }

        return $this->_connections[$name];
    }

    /**
     * @param string $name
     * @return AbstractPdo
     */
    public static function get(string $name) : AbstractPdo
    {
        return static::getInstance()->getConnection($name);
    }


    /**
     * @return ConnectionPool
     */
    final public static function getInstance() : ConnectionPool
    {
        if ( ! static::$instance )
        {
            $calledClass        = get_called_class();
            static::$instance   = new $calledClass();
        }

        return static::$instance;
    }

    final private function __clone()
    {}
}