DyarWeb / php-telegram-bot

src/DB/Json.php

<?php
declare(strict_types=1);

namespace DyarWeb\DB;

/**
 * Class Json
 * @package DyarWeb
 */
class Json
{
    private $DBDir;

    public function __construct()
    {
        $this->DBDir = getenv('jsonDBDir');
    }

    /**
     * @param $DBName
     * @param $TableName
     * @return bool
     */
    public function DeleteTable($DBName, $TableName)
    {
        return unlink($this->DBDir . '/' . $DBName . '/' . $TableName . '.json');
    }

    /**
     * @param $DBName
     * @return bool
     */
    public function DeleteDB($DBName)
    {
        $files = array_diff(scandir($this->DBDir . '/' . $DBName), ['.', '..']);

It seems like scandir($this->DBDir . '/' . $DBName) can also be of type false; however, parameter $array1 of array_diff() does only seem to accept array, maybe add an additional type check?

        foreach ($files as $file) {
            (is_dir($this->DBDir . '/' . $DBName . '/' . $file)) ? $this->DeleteDB($this->DBDir . '/' . $DBName . '/' . $file) : unlink($this->DBDir . '/' . $DBName . '/' . $file);
        }
        return rmdir($this->DBDir . '/' . $DBName);
    }

    /**
     * @param string $DBName
     * @param string $TableName
     * @param array $data
     * @return false|int
     */
    public function InsertData($DBName, $TableName, array $data)
    {
        $fileName = $this->DBDir . '/' . $DBName . '/' . $TableName . '.json';
        if (!is_file($fileName)) {
            return $this->CreateTable($DBName, $TableName, $data);
        } else {
            $out = json_decode(file_get_contents($fileName));
            $out[] = $data;
            return file_put_contents($fileName, json_encode($out));
        }
    }

    /**
     * @param string $DBName
     * @param string $TableName
     * @param array $columns
     * @param int|string $mode
     * @return false|int
     */
    public function CreateTable($DBName, $TableName, array $columns, $mode = 0600)
    {
        if (!is_dir($DBName)) {
            $this->CreateDB($DBName, 0700);
        }
        $json = json_encode([$columns]);
        $fileName = $this->DBDir . '/' . $DBName . '/' . $TableName . '.json';
        $res = file_put_contents($fileName, $json);
        $res .= chmod($fileName, $mode);

It seems like $mode can also be of type string; however, parameter $mode of chmod() does only seem to accept integer, maybe add an additional type check?

        return $res;

The expression return $res returns the type string which is incompatible with the documented return type false|integer.

    }

    /**
     * @param string $DBName
     * @param int $mode
     * @return bool
     */
    public function CreateDB($DBName, int $mode = 0700)
    {
        if (!is_dir($this->DBDir)) {
            mkdir($this->DBDir, 0700);
        }
        $Folders = explode('/', $DBName);
        $dir = '';
        $return = '';
        foreach ($Folders as $folder) {
            $dir .= '/' . $folder;
            if (!is_dir($this->DBDir . $dir)) {
                $return .= mkdir($this->DBDir . $dir, $mode);
            }
        }
        return $return;

The expression return $return returns the type string which is incompatible with the documented return type boolean.

    }

    /**
     * @param string $DBName
     * @param string $TableName
     * @param array $data
     * @param array $where
     * @return false|int
     */
    public function UpdateData($DBName, $TableName, array $data, array $where)
    {
        $fileName = $this->DBDir . '/' . $DBName . '/' . $TableName . '.json';
        $out = json_decode(file_get_contents($fileName));
        foreach ($out as $item) {
            $res = true;
            foreach ($where as $key => $value) {
                if ($item->$key != $value || !$item->$key) {
                    $res = false;
                    break;
                }
            }
            if ($res) {
                foreach ($data as $key => $value) {
                    $item->$key = $value;
                }
            }
        }
        return file_put_contents($fileName, json_encode($out));
    }

    /**
     * @param string $DBName
     * @param string $TableName
     * @param array|null $where
     * @return false|int
     */
    public function DeleteData($DBName, $TableName, array $where)
    {
        $fileName = $this->DBDir . '/' . $DBName . '/' . $TableName . '.json';
        if (is_file($fileName)) {
            $out = json_decode(file_get_contents($fileName));
            $i=-1;
            foreach ($out as $item) {
                $i++;
                $res = true;
                foreach ($where as $key => $value) {
                    if ($item->$key != $value || !$item->$key) {
                        $res = false;
                        break;
                    }
                }
                if ($res) {
                    unset($out[$i]);
                }
            }
            $out = array_values($out);
            return file_put_contents($fileName, json_encode($out));
        } else {
            return false;
        }
    }

    /**
     * @param string $DBName
     * @param string $TableName
     * @param null $where

Are you sure the doc-type for parameter $where is correct as it would always require null to be passed?

     * @param null $limit

Are you sure the doc-type for parameter $limit is correct as it would always require null to be passed?

     * @return array|mixed
     */
    public function SelectData($DBName, $TableName, array $where = null, int $limit = null)
    {
        $fileName = $this->DBDir . '/' . $DBName . '/' . $TableName . '.json';
        if (is_file($fileName)) {
            $out = json_decode(file_get_contents($fileName));
            if ($where == null) {
                return $out;
            } else {
                $items = [];
                foreach ($out as $item) {
                    $res = true;
                    foreach ($where as $key => $value) {
                        if ($item->$key != $value || !$item->$key) {
                            $res = false;
                            break;
                        }
                    }
                    if ($res) {
                        $items[] = $item;
                    }
                    if ($limit != null && count($items) >= $limit) {

It seems like you are loosely comparing $limit of type integer|null against null; this is ambiguous if the integer can be zero. Consider using a strict comparison !== instead.

                        break;
                    }
                }
                if (count($items) == 1) {
                    return (object)$items[0];
                } elseif (empty($items)) {
                    return false;
                } else {
                    return (object)$items;
                }
            }
        } else {
            return false;
        }
    }
}