Umbrellio\Postgres\PostgresConnection

Complexity

Total Complexity

21

Size/Duplication

Total Lines	109
Duplicated Lines	0 %

Test Coverage

Coverage

100%

Importance

Changes	4
Bugs	1	Features	1

7 Methods

Rating	Name	Duplication	Size	Complexity
A	useDefaultPostProcessor()	0	6	1
A	registerExtension()	0	10	2
A	getSchemaBuilder()	0	6	2
A	bindValues()	0	23	6
A	registerExtensions()	0	8	3
A	registerInitialTypes()	0	5	3
A	prepareBindings()	0	15	4

<?php

declare(strict_types=1);

namespace Umbrellio\Postgres;

use DateTimeInterface;
use Doctrine\DBAL\Types\Type;
use Illuminate\Database\PostgresConnection as BasePostgresConnection;
use Illuminate\Support\Traits\Macroable;
use PDO;
use Umbrellio\Postgres\Extensions\AbstractExtension;
use Umbrellio\Postgres\Extensions\Exceptions\ExtensionInvalidException;
use Umbrellio\Postgres\Schema\Builder;
use Umbrellio\Postgres\Schema\Types\NumericType;
use Umbrellio\Postgres\Schema\Types\TsRangeType;
use Umbrellio\Postgres\Schema\Types\TsTzRangeType;

class PostgresConnection extends BasePostgresConnection
{
    use Macroable;

    public $name;

    private static $extensions = [];

    private $initialTypes = [
        TsRangeType::TYPE_NAME => TsRangeType::class,
        TsTzRangeType::TYPE_NAME => TsTzRangeType::class,
        NumericType::TYPE_NAME => NumericType::class,
    ];

    /**
     * @param AbstractExtension|string $extension
     * @codeCoverageIgnore
     */
    final public static function registerExtension(string $extension): void
    {
        if (! is_subclass_of($extension, AbstractExtension::class)) {
            throw new ExtensionInvalidException(sprintf(
                'Class %s must be implemented from %s',
                $extension,
                AbstractExtension::class
            ));
        }
        self::$extensions[$extension::getName()] = $extension;
    }

    public function getSchemaBuilder()
    {
        if ($this->schemaGrammar === null) {
            $this->useDefaultSchemaGrammar();
        }
        return new Builder($this);
    }

    public function useDefaultPostProcessor(): void
    {
        parent::useDefaultPostProcessor();

        $this->registerExtensions();
        $this->registerInitialTypes();
    }

    public function bindValues($statement, $bindings)
    {
        if ($this->getPdo()->getAttribute(PDO::ATTR_EMULATE_PREPARES)) {
            foreach ($bindings as $key => $value) {
                $parameter = is_string($key) ? $key : $key + 1;

                switch (true) {
                    case is_bool($value):
                        $dataType = PDO::PARAM_BOOL;
                        break;

                    case $value === null:
                        $dataType = PDO::PARAM_NULL;
                        break;

                    default:
                        $dataType = PDO::PARAM_STR;
                }

                $statement->bindValue($parameter, $value, $dataType);
            }
        } else {
            parent::bindValues($statement, $bindings);
        }
    }

    public function prepareBindings(array $bindings)
    {
        if ($this->getPdo()->getAttribute(PDO::ATTR_EMULATE_PREPARES)) {
            $grammar = $this->getQueryGrammar();

            foreach ($bindings as $key => $value) {
                if ($value instanceof DateTimeInterface) {
                    $bindings[$key] = $value->format($grammar->getDateFormat());
                }
            }

            return $bindings;
        }

        return parent::prepareBindings($bindings);
    }

    private function registerInitialTypes(): void
    {
        foreach ($this->initialTypes as $type => $typeClass) {
            if (! Type::hasType($type)) {
                Type::addType($type, $typeClass);
            }
        }
    }

    /**
     * @codeCoverageIgnore
     */
    private function registerExtensions(): void
    {
        collect(self::$extensions)->each(function ($extension) {

self::extensions of type array is incompatible with the type Illuminate\Contracts\Support\Arrayable expected by parameter $value of collect().

            /** @var AbstractExtension $extension */
            $extension::register();
            foreach ($extension::getTypes() as $type => $typeClass) {
                if (! Type::hasType($type)) {
                    Type::addType($type, $typeClass);
                }
            }
        });
    }
}