mkorkmaz / redislabs-rejson

src/ReJSON/ReJSON.php

<?php
declare(strict_types=1);

namespace Redislabs\Module\ReJSON;

use Redislabs\Interfaces\ModuleInterface;
use Redislabs\Module\ModuleTrait;
use Redislabs\Module\ReJSON\Command\Delete;
use Redislabs\Module\ReJSON\Command\Get;
use Redislabs\Module\ReJSON\Command\Set;
use Redislabs\Module\ReJSON\Command\MultipleGet;
use Redislabs\Module\ReJSON\Command\Type;
use Redislabs\Module\ReJSON\Command\NumberIncrementBy;
use Redislabs\Module\ReJSON\Command\NumberMultiplyBy;
use Redislabs\Module\ReJSON\Command\StringAppend;
use Redislabs\Module\ReJSON\Command\StringLength;
use Redislabs\Module\ReJSON\Command\ArrayAppend;
use Redislabs\Module\ReJSON\Command\ArrayIndex;
use Redislabs\Module\ReJSON\Command\ArrayInsert;
use Redislabs\Module\ReJSON\Command\ArrayLength;
use Redislabs\Module\ReJSON\Command\ArrayPop;
use Redislabs\Module\ReJSON\Command\ArrayTrim;
use Redislabs\Module\ReJSON\Command\ObjectKeys;
use Redislabs\Module\ReJSON\Command\ObjectLength;
use Redislabs\Module\ReJSON\Command\Debug;
use Redislabs\Module\ReJSON\Command\Forget;

The type Redislabs\Module\ReJSON\Command\Forget was not found. Maybe you did not declare it correctly or list all dependencies?

use Redislabs\Module\ReJSON\Command\Resp;

class ReJSON implements ModuleInterface
{
    use ModuleTrait;
    protected static $moduleName = 'ReJSON';

    public function del(string $key, ?string $path = '.') : int
    {
        return $this->runCommand(
            Delete::createCommandWithArguments($key, $path)

It seems like $path can also be of type null; however, parameter $path of Redislabs\Module\ReJSON\Command\Delete::createCommandWithArguments() does only seem to accept string, maybe add an additional type check?

        );
    }

    public function forget(string $key, ?string $path = '.') : int
    {
        return $this->del($key, $path);
    }

    public function set(string $key, string $path, $json, ?string $existentialModifier = null)
    {
        return $this->runCommand(
            Set::createCommandWithArguments($key, $path, $json, $existentialModifier)
        );
    }

    public function get(string $key, $paths = null)
    {
        return $this->runCommand(
            Get::createCommandWithArguments($key, $paths)
        );
    }

    public function mget(...$arguments)
    {
        return $this->runCommand(
            MultipleGet::createCommandWithArguments($arguments)
        );
    }

    public function type(string $key, ?string $paths = '.')
    {
        return $this->runCommand(
            Type::createCommandWithArguments($key, $paths)
        );
    }

    public function numincrby(string $key, string $path, int $incrementBy)
    {
        return $this->runCommand(
            NumberIncrementBy::createCommandWithArguments($key, $path, $incrementBy)
        );
    }

    public function nummultby(string $key, string $path, int $multiplyBy)
    {
        return $this->runCommand(
            NumberMultiplyBy::createCommandWithArguments($key, $path, $multiplyBy)
        );
    }

    public function strappend(string $key, $json, ?string $path = '.')
    {
        return $this->runCommand(
            StringAppend::createCommandWithArguments($key, $path, $json)

It seems like $path can also be of type null; however, parameter $path of Redislabs\Module\ReJSON\Command\StringAppend::createCommandWithArguments() does only seem to accept string, maybe add an additional type check?

        );
    }

    public function strlen(string $key, ?string $path = '.')
    {
        return $this->runCommand(
            StringLength::createCommandWithArguments($key, $path)

It seems like $path can also be of type null; however, parameter $path of Redislabs\Module\ReJSON\Command\StringLength::createCommandWithArguments() does only seem to accept string, maybe add an additional type check?

        );
    }

    public function arrappend(string $key, string $path, ...$jsons)
    {
        return $this->runCommand(
            ArrayAppend::createCommandWithArguments($key, $path, $jsons)
        );
    }

    public function arrindex(string $key, string $path, $json, ?int $start = 0, ?int $stop = 0)
    {
        return $this->runCommand(
            ArrayIndex::createCommandWithArguments($key, $path, $json, $start, $stop)

It seems like $start can also be of type null; however, parameter $start of Redislabs\Module\ReJSON\Command\ArrayIndex::createCommandWithArguments() does only seem to accept integer, maybe add an additional type check?

It seems like $stop can also be of type null; however, parameter $stop of Redislabs\Module\ReJSON\Command\ArrayIndex::createCommandWithArguments() does only seem to accept integer, maybe add an additional type check?

        );
    }

    public function arrinsert(string $key, string $path, int $index, ...$jsons)
    {
        return $this->runCommand(
            ArrayInsert::createCommandWithArguments($key, $path, $index, $jsons)
        );
    }

    public function arrlen(string $key, string $path = '.')
    {
        return $this->runCommand(
            ArrayLength::createCommandWithArguments($key, $path)
        );
    }

    public function arrpop(string $key, ?string $path = '.', ?int $index = -1)
    {
        return $this->runCommand(
            ArrayPop::createCommandWithArguments($key, $path, $index)

It seems like $path can also be of type null; however, parameter $path of Redislabs\Module\ReJSON\Command\ArrayPop::createCommandWithArguments() does only seem to accept string, maybe add an additional type check?

It seems like $index can also be of type null; however, parameter $index of Redislabs\Module\ReJSON\Command\ArrayPop::createCommandWithArguments() does only seem to accept integer, maybe add an additional type check?

        );
    }

    public function arrtrim(string $key, $path, ?int $start = 0, ?int $stop = 0)
    {
        return $this->runCommand(
            ArrayTrim::createCommandWithArguments($key, $path, $start, $stop)

It seems like $stop can also be of type null; however, parameter $stop of Redislabs\Module\ReJSON\Command\ArrayTrim::createCommandWithArguments() does only seem to accept integer, maybe add an additional type check?

It seems like $start can also be of type null; however, parameter $start of Redislabs\Module\ReJSON\Command\ArrayTrim::createCommandWithArguments() does only seem to accept integer, maybe add an additional type check?

        );
    }

    public function objkeys(string $key, ?string $path = '.')
    {
        return $this->runCommand(
            ObjectKeys::createCommandWithArguments($key, $path)

It seems like $path can also be of type null; however, parameter $path of Redislabs\Module\ReJSON\Command\ObjectKeys::createCommandWithArguments() does only seem to accept string, maybe add an additional type check?

        );
    }

    public function objlen(string $key, ?string $path = '.')
    {
        return $this->runCommand(
            ObjectLength::createCommandWithArguments($key, $path)

It seems like $path can also be of type null; however, parameter $path of Redislabs\Module\ReJSON\Command\ObjectLength::createCommandWithArguments() does only seem to accept string, maybe add an additional type check?

        );
    }

    public function debug(string $subcommand, ?string $key = null, ?string $path = '.')
    {
        return $this->runCommand(
            Debug::createCommandWithArguments($subcommand, $key, $path)

It seems like $path can also be of type null; however, parameter $path of Redislabs\Module\ReJSON\Command\Debug::createCommandWithArguments() does only seem to accept string, maybe add an additional type check?

        );
    }

    public function resp(string $key, ?string $paths = '.')
    {
        return $this->runCommand(
            Resp::createCommandWithArguments($key, $paths)
        );
    }
}