refactor: remplacement de ConnectionResolver par DatabaseManager et mise à jour des services de connexion

src/Builder/BaseBuilder.php

@@ -794,7 +794,7 @@ public function query(string $sql, array $params = [])
      */
     public function result(int|string $type = PDO::FETCH_OBJ): array
     {
-        return $this->execute()->result($type);
+        return $this->execute()->get($type);
     }
 
     /**

src/Config/Services.php

@@ -12,87 +12,114 @@
 namespace BlitzPHP\Database\Config;
 
 use BlitzPHP\Container\Services as BaseServices;
-use BlitzPHP\Contracts\Database\ConnectionResolverInterface;
 use BlitzPHP\Database\Builder\BaseBuilder;
 use BlitzPHP\Database\Connection\BaseConnection;
-use BlitzPHP\Database\Database;
-use Dimtrovich\DbDumper\Exceptions\Exception as DumperException;
+use BlitzPHP\Database\DatabaseManager;
 use Dimtrovich\DbDumper\Exporter;
 use Dimtrovich\DbDumper\Importer;
+use InvalidArgumentException;
 
+/**
+ * Services de base de données
+ */
 class Services extends BaseServices
 {
     /**
-     * Query Builder
+     * Instance du gestionnaire de base de données
      */
-    public static function builder(?string $group = null, bool $shared = true): BaseBuilder
+    protected static ?DatabaseManager $manager = null;
+
+    /**
+     * Récupère le gestionnaire de base de données
+     */
+    protected static function manager(): DatabaseManager
     {
-        if (true === $shared && isset(static::$instances[BaseBuilder::class])) {
-            return static::$instances[BaseBuilder::class];
+        if (static::$manager === null) {
+            static::$manager = new DatabaseManager(static::logger(), static::event());
         }
 
-        return static::$instances[BaseBuilder::class] = Database::builder(static::database($group));
+        return static::$manager;
     }
 
     /**
-     * Connexion a la base de données
+     * Récupère une connexion à la base de données
      */
     public static function database(?string $group = null, bool $shared = true): BaseConnection
     {
-        /** @var ConnectionResolverInterface */
-        $connectionResolver = static::container()->get(ConnectionResolverInterface::class);
-        [$group]            = $connectionResolver->connectionInfo($group);
+        $connection = static::manager()->connect($group, $shared);
 
-        if (true === $shared && isset(static::$instances[Database::class]) && static::$instances[Database::class]->group === $group) {
-            return static::$instances[Database::class];
+        if (!$connection instanceof BaseConnection) {
+            throw new InvalidArgumentException('La connexion retournée n\'est pas une instance de BaseConnection');
         }
 
-        return static::$instances[Database::class] = $connectionResolver->connect($group);
+        return $connection;
     }
 
     /**
-     * Systeme d'exportation de la base de donnees
+     * Récupère un query builder
      */
-    public static function dbExporter(?BaseConnection $db = null, array $config = [], bool $shared = true): Exporter
+    public static function builder(?string $group = null, bool $shared = true): BaseBuilder
     {
-        if (true === $shared && isset(static::$instances[Exporter::class])) {
-            return static::$instances[Exporter::class];
+        $key = 'builder_' . ($group ?? 'default');
+
+        if ($shared && isset(static::$instances[$key])) {
+            return static::$instances[$key];
+        }
+
+        $builder = static::manager()->builder(static::database($group, $shared));
+
+        if ($shared) {
+            static::$instances[$key] = $builder;
         }
 
-        $db ??= self::database();
-        $config ??= config('dump', []);
+        return $builder;
+    }
 
-        if (! $db->conn) {
-            $db->initialize();
+    /**
+     * Récupère un exportateur de base de données
+     */
+    public static function dbExporter(?BaseConnection $db = null, array $config = [], bool $shared = true): Exporter
+    {
+        if ($shared) {
+            return static::sharedInstance('dbExporter', $db, $config);
         }
 
-        if (! $db->isPdo()) {
-            throw new DumperException('Impossible de sauvegarder la base de données. Vous devez utiliser un pilote PDO', DumperException::PDO_EXCEPTION);
+        $db ??= static::database();
+        $config = $config ?: (array) config('dump', []);
+
+        // Initialiser la connexion si nécessaire
+        $db->initialize();
+
+        $exporter = new Exporter($db->getDatabase(), $db->getConnection(), $config);
+
+        if ($shared) {
+            static::$instances[Exporter::class] = $exporter;
         }
 
-        return static::$instances[Exporter::class] = new Exporter($db->database, $db->conn, $config);
+        return $exporter;
     }
 
     /**
-     * Systeme d'importation de la base de donnees
+     * Récupère un importateur de base de données
      */
     public static function dbImporter(?BaseConnection $db = null, array $config = [], bool $shared = true): Importer
     {
-        if (true === $shared && isset(static::$instances[Importer::class])) {
-            return static::$instances[Importer::class];
+        if ($shared) {
+            return static::sharedInstance('dbImporter', $db, $config);
         }
 
-        $db ??= self::database();
-        $config ??= config('dump', []);
+        $db ??= static::database();
+        $config = $config ?: (array) config('dump', []);
 
-        if (! $db->conn) {
-            $db->initialize();
-        }
+        // Initialiser la connexion si nécessaire
+        $db->initialize();
+
+        $importer = new Importer($db->getDatabase(), $db->getConnection(), $config);
 
-        if (! $db->isPdo()) {
-            throw new DumperException('Impossible de restaurer la base de données. Vous devez utiliser un pilote PDO', DumperException::PDO_EXCEPTION);
+        if ($shared) {
+            static::$instances[Importer::class] = $importer;
         }
 
-        return static::$instances[Importer::class] = new Importer($db->database, $db->conn, $config);
+        return $importer;
     }
 }

src/Config/database.php

@@ -29,11 +29,11 @@
         /**
          * @var string Pilote de base de données à utiliser
          */
-        'driver' => env('db.default.driver', 'pdomysql'),
+        'driver' => env('db.default.driver', 'mysql'),
         /** @var int */
         'port' => env('db.default.port', 3306),
         /** @var string */
-        'host' => env('db.default.hostname', 'localhost'),
+        'hostname' => env('db.default.hostname', 'localhost'),
         /** @var string */
         'username' => env('db.default.username', 'root'),
         /** @var string */

src/Connection/BaseConnection.php

@@ -595,7 +595,11 @@ public function escapeIdentifiers(mixed $item): mixed
      */
     protected function escapeIdentifier(string $item): string
     {
-        return $this->escapeChar . str_replace($this->escapeChar, $this->escapeChar . $this->escapeChar, $item) . $this->escapeChar;
+        if ($this->isEscapedIdentifier($item)) {
+            return $item;
+        }
+
+        return $this->escapeChar . $item . $this->escapeChar;
     }
 
     /**
@@ -606,6 +610,22 @@ protected function isReserved(string $item): bool
         return in_array($item, ['*'], true);
     }
 
+    /**
+     * Determine si une chaine est échappée comme un identifiant SQL
+     */
+    public function isEscapedIdentifier(string $value): bool
+    {
+        if ($value === '') {
+            return false;
+        }
+
+        $value = trim($value);
+
+        return str_starts_with($value, $this->escapeChar)
+            // && str_contains($value, '.')
+            && str_ends_with($value, $this->escapeChar);
+    }
+
     /**
      * Crée le nom de la table avec son alias et le prefix des table de la base de données
      */