BlitzPHP\Core\Database

Complexity

Total Complexity

19

Size/Duplication

Total Lines	117
Duplicated Lines	0 %

Importance

Changes	1
Bugs	0	Features	0

5 Methods

Rating	Name	Duplication	Size	Complexity
C	connect()	0	45	14
A	utils()	0	5	1
A	getConnections()	0	3	1
A	forge()	0	5	1
A	ensureFactory()	0	7	2

<?php

/**
 * This file is part of Blitz PHP framework.
 *
 * (c) 2022 Dimitri Sitchet Tomkeu <devcode.dst@gmail.com>
 *
 * For the full copyright and license information, please view
 * the LICENSE file that was distributed with this source code.
 */

namespace BlitzPHP\Core;

use BlitzPHP\Database\BaseUtils;

The type BlitzPHP\Database\BaseUtils was not found. Maybe you did not declare it correctly or list all dependencies?

use BlitzPHP\Database\Contracts\ConnectionInterface;

The type BlitzPHP\Database\Contracts\ConnectionInterface was not found. Maybe you did not declare it correctly or list all dependencies?

use BlitzPHP\Database\Database as Db;

The type BlitzPHP\Database\Database was not found. Maybe you did not declare it correctly or list all dependencies?

use InvalidArgumentException;

/**
 * Configuration pour la base de données
 */
class Database
{
    /**
     * Cache pour les instances de toutes les connections
     * qui ont été requetées en tant que instance partagées
     *
     * @var ConnectionInterface[]
     */
    protected static $instances = [];

    /**
     * L'instance principale utilisée pour gérer toutes les ouvertures à la base de données.
     *
     * @var Db|null
     */
    protected static $factory;

    /**
     * Ouvre une connexion
     *
     * @param array|string $group  Nom du groupe de connexion à utiliser, ou un tableau de paramètres de configuration.
     * @param bool         $shared Doit-on retourner une instance partagée
     */
    public static function connect($group = null, bool $shared = true): ConnectionInterface
    {
        // Si on a deja passer une connection, pas la peine de continuer
        if ($group instanceof ConnectionInterface) {
            return $group;
        }

        if (is_array($group)) {
            $config = $group;
            $group  = 'custom-' . md5(json_encode($config));
        }

        $config ??= config('database');

The variable $config does not seem to be defined for all execution paths leading up to this point.

        if (empty($group)) {
            $group = $config['group'] ?? 'auto';

            if ($group === 'auto') {
                $group = on_test() ? 'test' : (on_prod() ? 'production' : 'development');
            }

            if (! isset($config[$group])) {
                $group = 'default';
            }
        }

        if (is_string($group) && ! isset($config[$group]) && strpos($group, 'custom-') !== 0) {
            throw new InvalidArgumentException($group . ' is not a valid database connection group.');
        }

        if ($shared && isset(static::$instances[$group])) {
            return static::$instances[$group];
        }

        static::ensureFactory();

        if (isset($config[$group])) {
            $config = $config[$group];
        }

        $connection = static::$factory->load($config, $group);

The method load() does not exist on null.

        static::$instances[$group] = &$connection;

        return $connection;
    }

    /**
     * Renvoie un tableau contenant toute les connxions deja etablies.
     */
    public static function getConnections(): array
    {
        return static::$instances;
    }

    /**
     * Charge et retourne une instance du Forge specifique au groupe de la base de donnees
     * et charge le groupe s'il n'est pas encore chargé.
     *
     * @param array|ConnectionInterface|string|null $group
     *
     * @return Forge

The type BlitzPHP\Core\Forge was not found. Maybe you did not declare it correctly or list all dependencies?

     */
    public static function forge($group = null)
    {
        $db = static::connect($group);

        return static::$factory->loadForge($db);
    }

    /**
     * Retourne une nouvelle de la classe Database Utilities.
     *
     * @param array|string|null $group
     *
     * @return BaseUtils
     */
    public static function utils($group = null)
    {
        $db = static::connect($group);

        return static::$factory->loadUtils($db);
    }

    /**
     * S'assure que le gestionnaire de la base de données est chargé et prêt à être utiliser.
     */
    protected static function ensureFactory()
    {
        if (static::$factory instanceof Db) {
            return;
        }

        static::$factory = new Db();
    }
}