[5.8] Handle database urls for database connections.

src/Illuminate/Database/DatabaseManager.php

@@ -151,7 +151,7 @@ protected function configuration($name)
             throw new InvalidArgumentException("Database [{$name}] not configured.");
         }
 
-        return $config;
+        return $this->app->make(UrlParser::class)->parseDatabaseConfigWithUrl($config);
     }
 
     /**

src/Illuminate/Database/UrlParser.php

@@ -0,0 +1,152 @@
+<?php
+
+namespace Illuminate\Database;
+
+use function array_map;
+use function parse_str;
+use function parse_url;
+use function array_merge;
+use function preg_replace;
+use Illuminate\Support\Arr;
+
+class UrlParser
+{
+    private static $driverAliases = [
+        'mssql' => 'sqlsrv',
+        'mysql2' => 'mysql', // Amazon RDS, for some weird reason
+        'postgres' => 'pgsql',
+        'postgresql' => 'pgsql',
+        'sqlite3' => 'sqlite',
+    ];
+
+    /**
+     * @var array
+     */
+    private $parsedUrl;
+
+    public static function getDriverAliases(): array
+    {
+        return self::$driverAliases;
+    }
+
+    public static function addDriverAlias(string $alias, string $driver)
+    {
+        self::$driverAliases[$alias] = $driver;
+    }
+
+    /**
+     * @param array|string $config
+     *
+     * @return array
+     */
+    public function parseDatabaseConfigWithUrl($config): array
+    {
+        if (is_string($config)) {
+            $config = ['url' => $config];
+        }
+
+        $url = $config['url'] ?? null;
+        $config = Arr::except($config, 'url');
+
+        if (! $url) {
+            return $config;
+        }
+
+        $this->parsedUrl = $this->parseUrl($url);
+
+        return array_merge(
+            $config,
+            $this->getMainAttributes(),
+            $this->getOtherOptions()
+        );
+    }
+
+    private function parseUrl(string $url): array
+    {
+        // sqlite3?:///... => sqlite3?://null/... or else the URL will be invalid
+        $url = preg_replace('#^(sqlite3?):///#', '$1://null/', $url);
+
+        $parsedUrl = parse_url($url);
+
+        if ($parsedUrl === false) {
+            throw new \InvalidArgumentException('Malformed parameter "url".');
+        }
+
+        return $this->parseStringsToNativeTypes(array_map('rawurldecode', $parsedUrl));
+    }
+
+    private function parseStringsToNativeTypes($value)
+    {
+        if (is_array($value)) {
+            return array_map([$this, 'parseStringsToNativeTypes'], $value);
+        }
+
+        if (! is_string($value)) {
+            return $value;
+        }
+
+        $parsedValue = json_decode($value, true);
+
+        if (json_last_error() === JSON_ERROR_NONE) {
+            return $parsedValue;
+        }
+
+        return $value;
+    }
+
+    private function getMainAttributes(): array
+    {
+        return array_filter([
+            'driver' => $this->getDriver(),
+            'database' => $this->getNormalizedPath(),
+            'host' => $this->getInUrl('host'),
+            'port' => $this->getInUrl('port'),
+            'username' => $this->getInUrl('user'),
+            'password' => $this->getInUrl('pass'),
+        ], function ($value) {
+            return $value !== null;
+        });
+    }
+
+    private function getDriver(): ?string
+    {
+        $alias = $this->getInUrl('scheme');
+
+        if (! $alias) {
+            return null;
+        }
+
+        return self::$driverAliases[$alias] ?? $alias;
+    }
+
+    private function getInUrl(string $key): ?string
+    {
+        return $this->parsedUrl[$key] ?? null;
+    }
+
+    private function getNormalizedPath(): ?string
+    {
+        $path = $this->getInUrl('path');
+
+        if (! $path) {
+            return null;
+        }
+
+        return substr($path, 1);
+    }
+
+    private function getOtherOptions(): array
+    {
+        $queryString = $this->getInUrl('query');
+
+        if (! $queryString) {
+            return [];
+        }
+
+        $query = [];
+
+        parse_str($queryString, $query);
+
+        return $this->parseStringsToNativeTypes($query);
+    }
+}

tests/Database/DatabaseConnectionFactoryTest.php

@@ -13,6 +13,7 @@
 
 class DatabaseConnectionFactoryTest extends TestCase
 {
+    /** @var DB */
     protected $db;
 
     protected function setUp(): void
@@ -24,6 +25,10 @@ protected function setUp(): void
             'database' => ':memory:',
         ]);
 
+        $this->db->addConnection([
+            'url' => 'sqlite:///:memory:',
+        ], 'url');
+
         $this->db->addConnection([
             'driver' => 'sqlite',
             'read' => [
@@ -44,15 +49,47 @@ protected function tearDown(): void
 
     public function testConnectionCanBeCreated()
     {
-        $this->assertInstanceOf(PDO::class, $this->db->connection()->getPdo());
-        $this->assertInstanceOf(PDO::class, $this->db->connection()->getReadPdo());
-        $this->assertInstanceOf(PDO::class, $this->db->connection('read_write')->getPdo());
-        $this->assertInstanceOf(PDO::class, $this->db->connection('read_write')->getReadPdo());
+        $this->assertInstanceOf(PDO::class, $this->db->getConnection()->getPdo());
+        $this->assertInstanceOf(PDO::class, $this->db->getConnection()->getReadPdo());
+        $this->assertInstanceOf(PDO::class, $this->db->getConnection('read_write')->getPdo());
+        $this->assertInstanceOf(PDO::class, $this->db->getConnection('read_write')->getReadPdo());
+        $this->assertInstanceOf(PDO::class, $this->db->getConnection('url')->getPdo());
+        $this->assertInstanceOf(PDO::class, $this->db->getConnection('url')->getReadPdo());
+    }
+
+    public function testConnectionFromUrlHasProperConfig()
+    {
+        $this->db->addConnection([
+            'url' => 'mysql://root:pass@db/local?strict=true',
+            'unix_socket' => '',
+            'charset' => 'utf8mb4',
+            'collation' => 'utf8mb4_unicode_ci',
+            'prefix' => '',
+            'prefix_indexes' => true,
+            'strict' => false,
+            'engine' => null,
+        ], 'url-config');
+
+        $this->assertEquals([
+            'name' => 'url-config',
+            'driver' => 'mysql',
+            'database' => 'local',
+            'host' => 'db',
+            'username' => 'root',
+            'password' => 'pass',
+            'unix_socket' => '',
+            'charset' => 'utf8mb4',
+            'collation' => 'utf8mb4_unicode_ci',
+            'prefix' => '',
+            'prefix_indexes' => true,
+            'strict' => true,
+            'engine' => null,
+        ], $this->db->getConnection('url-config')->getConfig());
     }
 
     public function testSingleConnectionNotCreatedUntilNeeded()
     {
-        $connection = $this->db->connection();
+        $connection = $this->db->getConnection();
         $pdo = new ReflectionProperty(get_class($connection), 'pdo');
         $pdo->setAccessible(true);
         $readPdo = new ReflectionProperty(get_class($connection), 'readPdo');
@@ -64,7 +101,7 @@ public function testSingleConnectionNotCreatedUntilNeeded()
 
     public function testReadWriteConnectionsNotCreatedUntilNeeded()
     {
-        $connection = $this->db->connection('read_write');
+        $connection = $this->db->getConnection('read_write');
         $pdo = new ReflectionProperty(get_class($connection), 'pdo');
         $pdo->setAccessible(true);
         $readPdo = new ReflectionProperty(get_class($connection), 'readPdo');
@@ -105,13 +142,11 @@ public function testCustomConnectorsCanBeResolvedViaContainer()
     public function testSqliteForeignKeyConstraints()
     {
         $this->db->addConnection([
-            'driver' => 'sqlite',
-            'database' => ':memory:',
-            'foreign_key_constraints' => true,
+            'url' => 'sqlite:///:memory:?foreign_key_constraints=true',
         ], 'constraints_set');
 
-        $this->assertEquals(0, $this->db->connection()->select('PRAGMA foreign_keys')[0]->foreign_keys);
+        $this->assertEquals(0, $this->db->getConnection()->select('PRAGMA foreign_keys')[0]->foreign_keys);
 
-        $this->assertEquals(1, $this->db->connection('constraints_set')->select('PRAGMA foreign_keys')[0]->foreign_keys);
+        $this->assertEquals(1, $this->db->getConnection('constraints_set')->select('PRAGMA foreign_keys')[0]->foreign_keys);
     }
 }