CoffeeCode\DataLayer\DataLayer

Complexity

Total Complexity

61

Size/Duplication

Total Lines	439
Duplicated Lines	0 %

Importance

Changes	9
Bugs	0	Features	0

28 Methods

Rating	Name	Duplication	Size	Complexity
A	__get()	0	3	1
A	clauseWhere()	0	8	4
B	clauseJoins()	0	17	7
A	rightJoin()	0	6	4
A	count()	0	5	1
A	data()	0	3	1
A	whereRaw()	0	4	1
A	limit()	0	4	1
A	offset()	0	4	1
A	find()	0	10	2
A	required()	0	9	3
A	get()	0	4	1
A	__isset()	0	3	1
A	save()	0	30	6
A	concatParams()	0	5	3
A	where()	0	7	1
A	order()	0	4	1
A	fail()	0	3	1
A	whereIn()	0	4	1
A	destroy()	0	11	2
A	findById()	0	4	1
A	join()	0	6	4
A	safe()	0	6	1
A	group()	0	4	1
A	__construct()	0	6	1
A	__set()	0	7	2
A	leftJoin()	0	6	4
A	fetch()	0	22	4

<?php

namespace CoffeeCode\DataLayer;

use Exception;
use PDO;
use PDOException;
use stdClass;

/**
 * Class DataLayer
 * @package CoffeeCode\DataLayer
 */
abstract class DataLayer
{
    use CrudTrait;

    /** @var string $entity database table */
    private $entity;

    /** @var string $primary table primary key field */
    private $primary;

    /** @var array $required table required fields */
    private $required;

    /** @var string $timestamps control created and updated at */
    private $timestamps;

    /** @var string */
    protected $statement;

    /** @var string */
    protected $params;

    /** @var string */
    protected $group;

    /** @var string */
    protected $order;

    /** @var int */
    protected $limit;

    /** @var int */
    protected $offset;

    /** @var \PDOException|null */
    protected $fail;

    /** @var object|null */
    protected $data;

    /** @var array */
    protected $join;

    /** @var array */
    protected $leftJoin;

    /** @var array */
    protected $rightJoin;

    /** @var array */
    protected $where;

    /**
     * DataLayer constructor.
     * @param string $entity
     * @param array $required
     * @param string $primary
     * @param bool $timestamps
     */
    public function __construct(string $entity, array $required, string $primary = 'id', bool $timestamps = true)
    {
        $this->entity = $entity;
        $this->primary = $primary;
        $this->required = $required;
        $this->timestamps = $timestamps;

The property $timestamps was declared of type string, but $timestamps is of type boolean. Maybe add a type cast?

    }

    /**
     * @param $name
     * @param $value
     */
    public function __set($name, $value)
    {
        if (empty($this->data)) {
            $this->data = new stdClass();
        }

        $this->data->$name = $value;
    }

    /**
     * @param $name
     * @return bool
     */
    public function __isset($name)
    {
        return isset($this->data->$name);
    }

    /**
     * @param $name
     * @return string|null
     */
    public function __get($name)
    {
        return ($this->data->$name ?? null);
    }

    /**
     * @return object|null
     */
    public function data(): ?object
    {
        return $this->data;
    }

    /**
     * @return PDOException|Exception|null
     */
    public function fail()
    {
        return $this->fail;
    }

    /**
     * @param string|null $terms
     * @param string|null $params
     * @param string $columns
     * @return DataLayer
     */
    public function find(?string $terms = null, ?string $params = null, string $columns = "*"): DataLayer
    {
        if ($terms) {
            $this->statement = "SELECT {$columns} FROM {$this->entity} WHERE {$terms}";
            parse_str($params, $this->params);

$this->params of type string is incompatible with the type array|null expected by parameter $arr of parse_str().

            return $this;
        }

        $this->statement = "SELECT {$columns} FROM {$this->entity}";
        return $this;
    }

    /**
     * @param int $id
     * @param string $columns
     * @return DataLayer|null
     */
    public function findById(int $id, string $columns = "*"): ?DataLayer
    {
        $find = $this->find($this->primary . " = :id", "id={$id}", $columns);
        return $find->fetch();

The expression return $find->fetch() could return the type array which is incompatible with the type-hinted return CoffeeCode\DataLayer\DataLayer|null. Consider adding an additional type-check to rule them out.

    }

    /**
     * for use with the new functions:
     * join(), leftJoin(), rightJoin(), where(), whereRaw(), whereIn()
     *
     * @param bool $all
     * @return null|array|mixed|DataLayer
     */
    public function get(bool $all = false)
    {
        $find = $this->find();
        return $find->fetch($all);
    }

    /**
     * @param string $column
     * @return DataLayer|null
     */
    public function group(string $column): ?DataLayer
    {
        $this->group = " GROUP BY {$column}";
        return $this;
    }

    /**
     * @param string $columnOrder
     * @return DataLayer|null
     */
    public function order(string $columnOrder): ?DataLayer
    {
        $this->order = " ORDER BY {$columnOrder}";
        return $this;
    }

    /**
     * @param int $limit
     * @return DataLayer|null
     */
    public function limit(int $limit): ?DataLayer
    {
        $this->limit = " LIMIT {$limit}";

The property $limit was declared of type integer, but ' LIMIT '.$limit is of type string. Maybe add a type cast?

        return $this;
    }

    /**
     * @param int $offset
     * @return DataLayer|null
     */
    public function offset(int $offset): ?DataLayer
    {
        $this->offset = " OFFSET {$offset}";

The property $offset was declared of type integer, but ' OFFSET '.$offset is of type string. Maybe add a type cast?

        return $this;
    }

    /**
     * @param string $table
     * @param mixed ...$args
     * @return DataLayer
     */
    public function join(string $table, ...$args): DataLayer
    {
        if (!$args[0] instanceof \Closure && $args[0] && $args[1]) {
            $this->join[] = " INNER JOIN {$table} ON ({$table}.{$args[0]} = {$this->entity}.{$args[1]}) ";
        }
        return $this;
    }

    /**
     * @param string $table
     * @param mixed ...$args
     * @return DataLayer
     */
    public function leftJoin(string $table, ...$args): DataLayer
    {
        if (!$args[0] instanceof \Closure && $args[0] && $args[1]) {
            $this->leftJoin[] = " LEFT OUTER JOIN {$table} ON ({$table}.{$args[0]} = {$this->entity}.{$args[1]}) ";
        }
        return $this;
    }

    /**
     * @param string $table
     * @param mixed ...$args
     * @return DataLayer
     */
    public function rightJoin(string $table, ...$args): DataLayer
    {
        if (!$args[0] instanceof \Closure && $args[0] && $args[1]) {
            $this->rightJoin[] = " RIGHT OUTER JOIN {$table} ON ({$table}.{$args[0]} = {$this->entity}.{$args[1]}) ";
        }
        return $this;
    }

    /**
     * @param string $whereRaw
     * @return DataLayer
     */
    public function whereRaw(string $whereRaw): DataLayer
    {
        $this->where[] = " {$whereRaw} ";
        return $this;
    }

    /**
     * @param string $field
     * @param array $values
     * @return DataLayer
     */
    public function whereIn(string $field, array $values = []): DataLayer
    {
        $this->where[] = " {$field} IN (" . implode(",", $values) . ")";
        return $this;
    }

    /**
     * @param string $field
     * @param string $operator
     * @param $value
     * @return DataLayer
     */
    public function where(string $field, string $operator, $value): DataLayer
    {
        $this->where[] = " {$field} {$operator} :" . str_replace(".", "_", $field);
        $params = "{$field}={$value}";
        $this->concatParams($params);
        parse_str($params, $this->params);

$this->params of type string is incompatible with the type array|null expected by parameter $arr of parse_str().

        return $this;
    }

    /**
     * @param string|null $params
     */
    private function concatParams(?string &$params): void
    {
        if ($this->params) {
            foreach ($this->params as $key => $value) {

The expression $this->params of type string is not traversable.

                $params .= "&{$key}={$value}";
            }
        }
    }

    /**
     * clauseWhere
     * @return void
     */
    private function clauseWhere(): void
    {
        if ($this->where) {

The expression $this->where of type array is implicitly converted to a boolean; are you sure this is intended? If so, consider using ! empty($expr) instead to make it clear that you intend to check for an array without elements.

            foreach ($this->where as $key => $value) {
                if (strpos($this->statement, "WHERE") === false) {
                    $this->statement .= " WHERE {$value} ";
                } else {
                    $this->statement .= " AND {$value} ";
                }
            }
        }
    }

    /**
     * clauseJoins
     * @return void
     */
    private function clauseJoins(): void
    {
        if ($this->join) {

The expression $this->join of type array is implicitly converted to a boolean; are you sure this is intended? If so, consider using ! empty($expr) instead to make it clear that you intend to check for an array without elements.

            foreach ($this->join as $key => $value) {
                $this->statement .= $value;
            }
        }

        if ($this->leftJoin) {

The expression $this->leftJoin of type array is implicitly converted to a boolean; are you sure this is intended? If so, consider using ! empty($expr) instead to make it clear that you intend to check for an array without elements.

            foreach ($this->leftJoin as $key => $value) {
                $this->statement .= $value;
            }
        }

        if ($this->rightJoin) {

The expression $this->rightJoin of type array is implicitly converted to a boolean; are you sure this is intended? If so, consider using ! empty($expr) instead to make it clear that you intend to check for an array without elements.

            foreach ($this->rightJoin as $key => $value) {
                $this->statement .= $value;
            }
        }
    }

    /**
     * @param bool $all
     * @return array|mixed|null
     */
    public function fetch(bool $all = false)
    {
        try {

            $this->clauseJoins();
            $this->clauseWhere();

            $stmt = Connect::getInstance()->prepare($this->statement . $this->group . $this->order . $this->limit . $this->offset);
            $stmt->execute($this->params);

$this->params of type string is incompatible with the type array expected by parameter $input_parameters of PDOStatement::execute().

            if (!$stmt->rowCount()) {
                return null;
            }

            if ($all) {
                return $stmt->fetchAll(PDO::FETCH_CLASS, static::class);
            }

            return $stmt->fetchObject(static::class);
        } catch (PDOException $exception) {
            $this->fail = $exception;
            return null;
        }
    }

    /**
     * @return int
     */
    public function count(): int
    {
        $stmt = Connect::getInstance()->prepare($this->statement);
        $stmt->execute($this->params);

$this->params of type string is incompatible with the type array expected by parameter $input_parameters of PDOStatement::execute().

        return $stmt->rowCount();
    }

    /**
     * @return bool
     */
    public function save(): bool
    {
        $primary = $this->primary;
        $id = null;

        try {
            if (!$this->required()) {
                throw new Exception("Preencha os campos necessários");
            }

            /** Update */
            if (!empty($this->data->$primary)) {
                $id = $this->data->$primary;
                $this->update($this->safe(), $this->primary . " = :id", "id={$id}");
            }

            /** Create */
            if (empty($this->data->$primary)) {
                $id = $this->create($this->safe());
            }

            if (!$id) {
                return false;
            }

            $this->data = $this->findById($id)->data();
            return true;
        } catch (Exception $exception) {
            $this->fail = $exception;

$exception is of type Exception, but the property $fail was declared to be of type PDOException|null. Are you sure that you always receive this specific sub-class here, or does it make sense to add an instanceof check?

            return false;
        }
    }

    /**
     * @return bool
     */
    public function destroy(): bool
    {
        $primary = $this->primary;
        $id = $this->data->$primary;

        if (empty($id)) {
            return false;
        }

        $destroy = $this->delete($this->primary . " = :id", "id={$id}");
        return $destroy;
    }

    /**
     * @return bool
     */
    protected function required(): bool
    {
        $data = (array)$this->data();
        foreach ($this->required as $field) {
            if (empty($data[$field])) {
                return false;
            }
        }
        return true;
    }

    /**
     * @return array|null
     */
    protected function safe(): ?array
    {
        $safe = (array)$this->data;
        unset($safe[$this->primary]);

        return $safe;
    }
}