7 files changed, 556 insertions, 0 deletions

diff --git a/vendor/doctrine/dbal/src/Portability/Connection.php b/vendor/doctrine/dbal/src/Portability/Connection.php
new file mode 100644
index 0000000..4a821d8
--- /dev/null
+++ b/vendor/doctrine/dbal/src/Portability/Connection.php
@@ -0,0 +1,41 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Doctrine\DBAL\Portability;
+
+use Doctrine\DBAL\Driver\Connection as ConnectionInterface;
+use Doctrine\DBAL\Driver\Middleware\AbstractConnectionMiddleware;
+
+/**
+ * Portability wrapper for a Connection.
+ */
+final class Connection extends AbstractConnectionMiddleware
+{
+    public const PORTABILITY_ALL           = 255;
+    public const PORTABILITY_NONE          = 0;
+    public const PORTABILITY_RTRIM         = 1;
+    public const PORTABILITY_EMPTY_TO_NULL = 4;
+    public const PORTABILITY_FIX_CASE      = 8;
+
+    public function __construct(ConnectionInterface $connection, private readonly Converter $converter)
+    {
+        parent::__construct($connection);
+    }
+
+    public function prepare(string $sql): Statement
+    {
+        return new Statement(
+            parent::prepare($sql),
+            $this->converter,
+        );
+    }
+
+    public function query(string $sql): Result
+    {
+        return new Result(
+            parent::query($sql),
+            $this->converter,
+        );
+    }
+}
diff --git a/vendor/doctrine/dbal/src/Portability/Converter.php b/vendor/doctrine/dbal/src/Portability/Converter.php
new file mode 100644
index 0000000..09a4712
--- /dev/null
+++ b/vendor/doctrine/dbal/src/Portability/Converter.php
@@ -0,0 +1,280 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Doctrine\DBAL\Portability;
+
+use Closure;
+
+use function array_change_key_case;
+use function array_map;
+use function array_reduce;
+use function is_string;
+use function rtrim;
+
+use const CASE_LOWER;
+use const CASE_UPPER;
+
+final class Converter
+{
+    public const CASE_LOWER = CASE_LOWER;
+    public const CASE_UPPER = CASE_UPPER;
+
+    private readonly Closure $convertNumeric;
+    private readonly Closure $convertAssociative;
+    private readonly Closure $convertOne;
+    private readonly Closure $convertAllNumeric;
+    private readonly Closure $convertAllAssociative;
+    private readonly Closure $convertFirstColumn;
+
+    /**
+     * @param bool                                   $convertEmptyStringToNull Whether each empty string should
+     *                                                                         be converted to NULL
+     * @param bool                                   $rightTrimString          Whether each string should right-trimmed
+     * @param self::CASE_LOWER|self::CASE_UPPER|null $case                     Convert the case of the column names
+     *                                                                         (one of {@see self::CASE_LOWER} and
+     *                                                                         {@see self::CASE_UPPER})
+     */
+    public function __construct(bool $convertEmptyStringToNull, bool $rightTrimString, ?int $case)
+    {
+        $convertValue       = $this->createConvertValue($convertEmptyStringToNull, $rightTrimString);
+        $convertNumeric     = $this->createConvertRow($convertValue, null);
+        $convertAssociative = $this->createConvertRow($convertValue, $case);
+
+        $this->convertNumeric     = $this->createConvert($convertNumeric);
+        $this->convertAssociative = $this->createConvert($convertAssociative);
+        $this->convertOne         = $this->createConvert($convertValue);
+
+        $this->convertAllNumeric     = $this->createConvertAll($convertNumeric);
+        $this->convertAllAssociative = $this->createConvertAll($convertAssociative);
+        $this->convertFirstColumn    = $this->createConvertAll($convertValue);
+    }
+
+    /**
+     * @param array<int,mixed>|false $row
+     *
+     * @return list<mixed>|false
+     */
+    public function convertNumeric(array|false $row): array|false
+    {
+        return ($this->convertNumeric)($row);
+    }
+
+    /**
+     * @param array<string,mixed>|false $row
+     *
+     * @return array<string,mixed>|false
+     */
+    public function convertAssociative(array|false $row): array|false
+    {
+        return ($this->convertAssociative)($row);
+    }
+
+    public function convertOne(mixed $value): mixed
+    {
+        return ($this->convertOne)($value);
+    }
+
+    /**
+     * @param list<list<mixed>> $data
+     *
+     * @return list<list<mixed>>
+     */
+    public function convertAllNumeric(array $data): array
+    {
+        return ($this->convertAllNumeric)($data);
+    }
+
+    /**
+     * @param list<array<string,mixed>> $data
+     *
+     * @return list<array<string,mixed>>
+     */
+    public function convertAllAssociative(array $data): array
+    {
+        return ($this->convertAllAssociative)($data);
+    }
+
+    /**
+     * @param list<mixed> $data
+     *
+     * @return list<mixed>
+     */
+    public function convertFirstColumn(array $data): array
+    {
+        return ($this->convertFirstColumn)($data);
+    }
+
+    /**
+     * @param T $value
+     *
+     * @return T
+     *
+     * @template T
+     */
+    private static function id(mixed $value): mixed
+    {
+        return $value;
+    }
+
+    /**
+     * @param T $value
+     *
+     * @return T|null
+     *
+     * @template T
+     */
+    private static function convertEmptyStringToNull(mixed $value): mixed
+    {
+        if ($value === '') {
+            return null;
+        }
+
+        return $value;
+    }
+
+    /**
+     * @param T $value
+     *
+     * @return T|string
+     * @psalm-return (T is string ? string : T)
+     *
+     * @template T
+     */
+    private static function rightTrimString(mixed $value): mixed
+    {
+        if (! is_string($value)) {
+            return $value;
+        }
+
+        return rtrim($value);
+    }
+
+    /**
+     * Creates a function that will convert each individual value retrieved from the database
+     *
+     * @param bool $convertEmptyStringToNull Whether each empty string should be converted to NULL
+     * @param bool $rightTrimString          Whether each string should right-trimmed
+     *
+     * @return Closure|null The resulting function or NULL if no conversion is needed
+     */
+    private function createConvertValue(bool $convertEmptyStringToNull, bool $rightTrimString): ?Closure
+    {
+        $functions = [];
+
+        if ($convertEmptyStringToNull) {
+            $functions[] = self::convertEmptyStringToNull(...);
+        }
+
+        if ($rightTrimString) {
+            $functions[] = self::rightTrimString(...);
+        }
+
+        return $this->compose(...$functions);
+    }
+
+    /**
+     * Creates a function that will convert each array-row retrieved from the database
+     *
+     * @param Closure|null                           $function The function that will convert each value
+     * @param self::CASE_LOWER|self::CASE_UPPER|null $case     Column name case
+     *
+     * @return Closure|null The resulting function or NULL if no conversion is needed
+     */
+    private function createConvertRow(?Closure $function, ?int $case): ?Closure
+    {
+        $functions = [];
+
+        if ($function !== null) {
+            $functions[] = $this->createMapper($function);
+        }
+
+        if ($case !== null) {
+            $functions[] = static fn (array $row): array => array_change_key_case($row, $case);
+        }
+
+        return $this->compose(...$functions);
+    }
+
+    /**
+     * Creates a function that will be applied to the return value of Statement::fetch*()
+     * or an identity function if no conversion is needed
+     *
+     * @param Closure|null $function The function that will convert each tow
+     */
+    private function createConvert(?Closure $function): Closure
+    {
+        if ($function === null) {
+            return self::id(...);
+        }
+
+        return /**
+                * @param T $value
+                *
+                * @psalm-return (T is false ? false : T)
+                *
+                * @template T
+                */
+            static function (mixed $value) use ($function): mixed {
+                if ($value === false) {
+                    return false;
+                }
+
+                return $function($value);
+            };
+    }
+
+    /**
+     * Creates a function that will be applied to the return value of Statement::fetchAll*()
+     * or an identity function if no transformation is required
+     *
+     * @param Closure|null $function The function that will transform each value
+     */
+    private function createConvertAll(?Closure $function): Closure
+    {
+        if ($function === null) {
+            return self::id(...);
+        }
+
+        return $this->createMapper($function);
+    }
+
+    /**
+     * Creates a function that maps each value of the array using the given function
+     *
+     * @param Closure $function The function that maps each value of the array
+     *
+     * @return Closure(array<mixed>):array<mixed>
+     */
+    private function createMapper(Closure $function): Closure
+    {
+        return static fn (array $array): array => array_map($function, $array);
+    }
+
+    /**
+     * Creates a composition of the given set of functions
+     *
+     * @param Closure(T):T ...$functions The functions to compose
+     *
+     * @return Closure(T):T|null
+     *
+     * @template T
+     */
+    private function compose(Closure ...$functions): ?Closure
+    {
+        return array_reduce($functions, static function (?Closure $carry, Closure $item): Closure {
+            if ($carry === null) {
+                return $item;
+            }
+
+            return /**
+                    * @param T $value
+                    *
+                    * @return T
+                    *
+                    * @template T
+                    */
+                static fn (mixed $value): mixed => $item($carry($value));
+        });
+    }
+}
diff --git a/vendor/doctrine/dbal/src/Portability/Driver.php b/vendor/doctrine/dbal/src/Portability/Driver.php
new file mode 100644
index 0000000..bb67c25
--- /dev/null
+++ b/vendor/doctrine/dbal/src/Portability/Driver.php
@@ -0,0 +1,69 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Doctrine\DBAL\Portability;
+
+use Doctrine\DBAL\ColumnCase;
+use Doctrine\DBAL\Driver as DriverInterface;
+use Doctrine\DBAL\Driver\Connection as ConnectionInterface;
+use Doctrine\DBAL\Driver\Middleware\AbstractDriverMiddleware;
+use PDO;
+use SensitiveParameter;
+
+use const CASE_LOWER;
+use const CASE_UPPER;
+
+final class Driver extends AbstractDriverMiddleware
+{
+    public function __construct(
+        DriverInterface $driver,
+        private readonly int $mode,
+        private readonly ?ColumnCase $case,
+    ) {
+        parent::__construct($driver);
+    }
+
+    /**
+     * {@inheritDoc}
+     */
+    public function connect(
+        #[SensitiveParameter]
+        array $params,
+    ): ConnectionInterface {
+        $connection = parent::connect($params);
+
+        $portability = (new OptimizeFlags())(
+            $this->getDatabasePlatform($connection),
+            $this->mode,
+        );
+
+        $case = null;
+
+        if ($this->case !== null && ($portability & Connection::PORTABILITY_FIX_CASE) !== 0) {
+            $nativeConnection = $connection->getNativeConnection();
+
+            $case = match ($this->case) {
+                ColumnCase::LOWER => CASE_LOWER,
+                ColumnCase::UPPER => CASE_UPPER,
+            };
+
+            if ($nativeConnection instanceof PDO) {
+                $portability &= ~Connection::PORTABILITY_FIX_CASE;
+                $nativeConnection->setAttribute(PDO::ATTR_CASE, $case);
+            }
+        }
+
+        $convertEmptyStringToNull = ($portability & Connection::PORTABILITY_EMPTY_TO_NULL) !== 0;
+        $rightTrimString          = ($portability & Connection::PORTABILITY_RTRIM) !== 0;
+
+        if (! $convertEmptyStringToNull && ! $rightTrimString && $case === null) {
+            return $connection;
+        }
+
+        return new Connection(
+            $connection,
+            new Converter($convertEmptyStringToNull, $rightTrimString, $case),
+        );
+    }
+}
diff --git a/vendor/doctrine/dbal/src/Portability/Middleware.php b/vendor/doctrine/dbal/src/Portability/Middleware.php
new file mode 100644
index 0000000..b97897c
--- /dev/null
+++ b/vendor/doctrine/dbal/src/Portability/Middleware.php
@@ -0,0 +1,25 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Doctrine\DBAL\Portability;
+
+use Doctrine\DBAL\ColumnCase;
+use Doctrine\DBAL\Driver as DriverInterface;
+use Doctrine\DBAL\Driver\Middleware as MiddlewareInterface;
+
+final class Middleware implements MiddlewareInterface
+{
+    public function __construct(private readonly int $mode, private readonly ?ColumnCase $case)
+    {
+    }
+
+    public function wrap(DriverInterface $driver): DriverInterface
+    {
+        if ($this->mode !== 0) {
+            return new Driver($driver, $this->mode, $this->case);
+        }
+
+        return $driver;
+    }
+}
diff --git a/vendor/doctrine/dbal/src/Portability/OptimizeFlags.php b/vendor/doctrine/dbal/src/Portability/OptimizeFlags.php
new file mode 100644
index 0000000..c985d4b
--- /dev/null
+++ b/vendor/doctrine/dbal/src/Portability/OptimizeFlags.php
@@ -0,0 +1,42 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Doctrine\DBAL\Portability;
+
+use Doctrine\DBAL\Platforms\AbstractPlatform;
+use Doctrine\DBAL\Platforms\DB2Platform;
+use Doctrine\DBAL\Platforms\OraclePlatform;
+use Doctrine\DBAL\Platforms\PostgreSQLPlatform;
+use Doctrine\DBAL\Platforms\SQLitePlatform;
+use Doctrine\DBAL\Platforms\SQLServerPlatform;
+
+final class OptimizeFlags
+{
+    /**
+     * Platform-specific portability flags that need to be excluded from the user-provided mode
+     * since the platform already operates in this mode to avoid unnecessary conversion overhead.
+     *
+     * @var array<class-string, int>
+     */
+    private static array $platforms = [
+        DB2Platform::class        => 0,
+        OraclePlatform::class     => Connection::PORTABILITY_EMPTY_TO_NULL,
+        PostgreSQLPlatform::class => 0,
+        SQLitePlatform::class     => 0,
+        SQLServerPlatform::class  => 0,
+    ];
+
+    public function __invoke(AbstractPlatform $platform, int $flags): int
+    {
+        foreach (self::$platforms as $class => $mask) {
+            if ($platform instanceof $class) {
+                $flags &= ~$mask;
+
+                break;
+            }
+        }
+
+        return $flags;
+    }
+}
diff --git a/vendor/doctrine/dbal/src/Portability/Result.php b/vendor/doctrine/dbal/src/Portability/Result.php
new file mode 100644
index 0000000..d158683
--- /dev/null
+++ b/vendor/doctrine/dbal/src/Portability/Result.php
@@ -0,0 +1,68 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Doctrine\DBAL\Portability;
+
+use Doctrine\DBAL\Driver\Middleware\AbstractResultMiddleware;
+use Doctrine\DBAL\Driver\Result as ResultInterface;
+
+final class Result extends AbstractResultMiddleware
+{
+    /** @internal The result can be only instantiated by the portability connection or statement. */
+    public function __construct(ResultInterface $result, private readonly Converter $converter)
+    {
+        parent::__construct($result);
+    }
+
+    public function fetchNumeric(): array|false
+    {
+        return $this->converter->convertNumeric(
+            parent::fetchNumeric(),
+        );
+    }
+
+    public function fetchAssociative(): array|false
+    {
+        return $this->converter->convertAssociative(
+            parent::fetchAssociative(),
+        );
+    }
+
+    public function fetchOne(): mixed
+    {
+        return $this->converter->convertOne(
+            parent::fetchOne(),
+        );
+    }
+
+    /**
+     * {@inheritDoc}
+     */
+    public function fetchAllNumeric(): array
+    {
+        return $this->converter->convertAllNumeric(
+            parent::fetchAllNumeric(),
+        );
+    }
+
+    /**
+     * {@inheritDoc}
+     */
+    public function fetchAllAssociative(): array
+    {
+        return $this->converter->convertAllAssociative(
+            parent::fetchAllAssociative(),
+        );
+    }
+
+    /**
+     * {@inheritDoc}
+     */
+    public function fetchFirstColumn(): array
+    {
+        return $this->converter->convertFirstColumn(
+            parent::fetchFirstColumn(),
+        );
+    }
+}
diff --git a/vendor/doctrine/dbal/src/Portability/Statement.php b/vendor/doctrine/dbal/src/Portability/Statement.php
new file mode 100644
index 0000000..de0c76f
--- /dev/null
+++ b/vendor/doctrine/dbal/src/Portability/Statement.php
@@ -0,0 +1,31 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Doctrine\DBAL\Portability;
+
+use Doctrine\DBAL\Driver\Middleware\AbstractStatementMiddleware;
+use Doctrine\DBAL\Driver\Result as ResultInterface;
+use Doctrine\DBAL\Driver\Statement as DriverStatement;
+
+/**
+ * Portability wrapper for a Statement.
+ */
+final class Statement extends AbstractStatementMiddleware
+{
+    /**
+     * Wraps <tt>Statement</tt> and applies portability measures.
+     */
+    public function __construct(DriverStatement $stmt, private readonly Converter $converter)
+    {
+        parent::__construct($stmt);
+    }
+
+    public function execute(): ResultInterface
+    {
+        return new Result(
+            parent::execute(),
+            $this->converter,
+        );
+    }
+}