Shamaseen\Repository\Utility\Models\ConnectionProxy

Complexity

Total Complexity

29

Size/Duplication

Total Lines	182
Duplicated Lines	0 %

Importance

Changes	3
Bugs	1	Features	0

26 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	3	1
A	__call()	0	3	1
A	query()	0	7	1
A	commit()	0	3	1
A	cursor()	0	3	1
A	selectOne()	0	6	1
A	transaction()	0	3	1
A	pretend()	0	3	1
A	cacheOrNext()	0	22	4
A	select()	0	6	1
A	getDatabaseName()	0	3	1
A	statement()	0	3	1
A	raw()	0	3	1
A	__get()	0	3	1
A	beginTransaction()	0	3	1
A	delete()	0	3	1
A	affectingStatement()	0	3	1
A	prepareBindings()	0	3	1
A	table()	0	3	1
A	update()	0	3	1
A	insert()	0	3	1
A	__set()	0	3	1
A	rollBack()	0	3	1
A	unprepared()	0	3	1
A	transactionLevel()	0	3	1
A	scalar()	0	3	1

<?php

namespace Shamaseen\Repository\Utility\Models;

use Closure;
use Illuminate\Database\Connection;
use Illuminate\Database\ConnectionInterface;
use Illuminate\Database\Eloquent\Model as LaravelModel;
use Illuminate\Database\Query\Builder as QueryBuilder;
use Illuminate\Support\Str;
use Psr\SimpleCache\InvalidArgumentException;
use Shamaseen\Repository\Utility\Model;

class ConnectionProxy implements ConnectionInterface
{
    public Connection $realConnection;

    public function __construct(Connection $realConnection, private readonly Model|LaravelModel $model)
    {
        $this->realConnection = $realConnection;
    }

    // Proxy methods >>>

    /**
     * @throws InvalidArgumentException
     */
    public function cacheOrNext($fullQuery, callable $next)
    {
        if(config('repository.disable_cache')) {
            return $next();
        }

        if ($this->model->requestCacheEnabled) {
            $cache = $this->model->requestCache;

            // if the key exist then return the cached version
            if ($fromCache = $cache->get($fullQuery)) {

The method get() does not exist on null.

                return $fromCache;
            }

            $result = $next();

            $cache->set($fullQuery, $result);

            return $result;
        }

        return $next();
    }

    // Laravel methods >>>

    /**
     * @throws InvalidArgumentException
     */
    public function selectOne($query, $bindings = [], $useReadPdo = true)
    {
        $fullQuery = Str::replaceArray('?', $bindings, $query);

        return $this->cacheOrNext($fullQuery, function () use ($query, $bindings, $useReadPdo) {
            return $this->realConnection->selectOne($query, $bindings, $useReadPdo);
        });
    }

    /**
     * @throws InvalidArgumentException
     */
    public function select($query, $bindings = [], $useReadPdo = true)
    {
        $fullQuery = Str::replaceArray('?', $bindings, $query);

        return $this->cacheOrNext($fullQuery, function () use ($query, $bindings, $useReadPdo) {

The expression return $this->cacheOrNext($fullQuery, function(...) { /* ... */ }) also could return the type Illuminate\Database\Eloquent\Collection which is incompatible with the return type mandated by Illuminate\Database\ConnectionInterface::select() of array.

            return $this->realConnection->select($query, $bindings, $useReadPdo);
        });
    }

    public function table($table, $as = null)
    {
        return $this->realConnection->table($table, $as);
    }

    public function raw($value)
    {
        return $this->realConnection->raw($value);
    }

    public function cursor($query, $bindings = [], $useReadPdo = true)
    {
        return $this->realConnection->cursor($query, $bindings, $useReadPdo);
    }

    public function insert($query, $bindings = [])
    {
        return $this->realConnection->insert($query, $bindings);
    }

    public function update($query, $bindings = [])
    {
        return $this->realConnection->update($query, $bindings);
    }

    public function delete($query, $bindings = [])
    {
        return $this->realConnection->delete($query, $bindings);
    }

    public function statement($query, $bindings = [])
    {
        return $this->realConnection->statement($query, $bindings);
    }

    public function affectingStatement($query, $bindings = [])
    {
        return $this->realConnection->affectingStatement($query, $bindings);
    }

    public function unprepared($query)
    {
        return $this->realConnection->unprepared($query);
    }

    public function prepareBindings(array $bindings)
    {
        return $this->realConnection->prepareBindings($bindings);
    }

    public function transaction(Closure $callback, $attempts = 1)
    {
        return $this->realConnection->transaction($callback, $attempts);
    }

    public function beginTransaction()
    {
        return $this->realConnection->beginTransaction();

Are you sure the usage of $this->realConnection->beginTransaction() targeting Illuminate\Database\Connection::beginTransaction() seems to always return null.

    }

    public function commit()
    {
        return $this->realConnection->commit();

Are you sure the usage of $this->realConnection->commit() targeting Illuminate\Database\Connection::commit() seems to always return null.

    }

    public function rollBack()
    {
        return $this->realConnection->rollBack();

Are you sure the usage of $this->realConnection->rollBack() targeting Illuminate\Database\Connection::rollBack() seems to always return null.

    }

    public function transactionLevel()
    {
        return $this->realConnection->transactionLevel();
    }

    public function pretend(Closure $callback)
    {
        return $this->realConnection->pretend($callback);
    }

    public function getDatabaseName()
    {
        return $this->realConnection->getDatabaseName();
    }

    public function __set(string $name, $value): void
    {
        $this->realConnection->{$name} = $value;
    }

    public function __get(string $name)
    {
        return $this->realConnection->{$name};
    }

    public function __call(string $name, array $arguments)
    {
        return $this->realConnection->{$name}(...$arguments);
    }

    /**
     * Get a new query builder instance.
     *
     * @return QueryBuilder
     */
    public function query()
    {
        return new QueryBuilder(
            // pass our connection instead of laravel one.
            $this,
            $this->realConnection->getQueryGrammar(),
            $this->realConnection->getPostProcessor()
        );
    }

    public function scalar($query, $bindings = [], $useReadPdo = true)
    {
        return $this->scalar($query, $bindings, $useReadPdo);
    }
}