4135501466

Build Type

push

github

Committed by darkdarin

Commit Message

Merge remote-tracking branch 'origin/v5.0'

Run Details

209 of 813 new or added lines in 51 files covered. (25.71%)

233 of 1307 relevant lines covered (17.83%)

1.84 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

0.0

/src/JsonRpcServer.php

<?php

namespace Tochka\JsonRpc;

use Illuminate\Container\Container;
use Illuminate\Pipeline\Pipeline;
use Psr\Http\Message\ServerRequestInterface;
use Tochka\JsonRpc\Contracts\ExceptionHandlerInterface;
use Tochka\JsonRpc\Contracts\HandleResolverInterface;
use Tochka\JsonRpc\Contracts\HttpRequestMiddlewareInterface;
use Tochka\JsonRpc\Contracts\JsonRpcRequestMiddlewareInterface;
use Tochka\JsonRpc\Contracts\JsonRpcServerInterface;
use Tochka\JsonRpc\Contracts\MiddlewareRegistryInterface;
use Tochka\JsonRpc\Contracts\ParserInterface;
use Tochka\JsonRpc\DTO\JsonRpcResponseCollection;
use Tochka\JsonRpc\DTO\JsonRpcServerRequest;
use Tochka\JsonRpc\Facades\JsonRpcRouter;
use Tochka\JsonRpc\Standard\DTO\JsonRpcResponse;
use Tochka\JsonRpc\Standard\Exceptions\MethodNotFoundException;

class JsonRpcServer implements JsonRpcServerInterface
{
    private ParserInterface $parser;
    private HandleResolverInterface $resolver;
    private Container $container;
    private ExceptionHandlerInterface $exceptionHandler;
    private MiddlewareRegistryInterface $middlewareRegistry;

    /**
     * @psalm-suppress PossiblyUnusedMethod
     */
    public function __construct(
        ParserInterface $parser,
        HandleResolverInterface $resolver,
        ExceptionHandlerInterface $exceptionHandler,
        MiddlewareRegistryInterface $middlewareRegistry,
        Container $container
    ) {
        $this->parser = $parser;
        $this->resolver = $resolver;
        $this->container = $container;
        $this->exceptionHandler = $exceptionHandler;
        $this->middlewareRegistry = $middlewareRegistry;
    }

    public function handle(
        ServerRequestInterface $request,
        string $serverName = 'default',
        string $group = null,
        string $action = null
    ): JsonRpcResponseCollection {
        try {
            $pipeline = new Pipeline($this->container);

            /** @var JsonRpcResponseCollection $responses */
            $responses = $pipeline->send($request)
                ->through($this->middlewareRegistry->getMiddleware($serverName, HttpRequestMiddlewareInterface::class))
                ->via('handleHttpRequest')
                ->then(
                    function (ServerRequestInterface $httpRequest) use ($serverName, $group, $action) {
                        $requests = $this->parser->parse($httpRequest);

                        $responses = new JsonRpcResponseCollection();

                        foreach ($requests as $request) {
                            $response = $this->handleRequest($request, $serverName, $group, $action);

                            if ($response !== null) {
                                $responses->add($response);
                            }
                        }

                        return $responses;
                    }
                );
        } catch (\Throwable $e) {
            $responses = new JsonRpcResponseCollection();

            $responses->add(
                new JsonRpcResponse(
                    id:    'empty',
                    error: $this->exceptionHandler->handle($e)
                )
            );
        }

        return $responses;
    }

    public function handleRequest(
        JsonRpcServerRequest $request,
        string $serverName,
        string $group = null,
        string $action = null
    ): ?JsonRpcResponse {
        try {
            $pipeline = new Pipeline($this->container);

            $route = JsonRpcRouter::get($serverName, $request->getJsonRpcRequest()->method, $group, $action);

            if ($route === null) {
                throw new MethodNotFoundException();
            }

            $request->setRoute($route);

            /** @var JsonRpcResponse|null */
            return $pipeline->send($request)
                ->through(
                    $this->middlewareRegistry->getMiddleware($serverName, JsonRpcRequestMiddlewareInterface::class)
                )
                ->via('handleJsonRpcRequest')
                ->then(
                    function (JsonRpcServerRequest $request) {
                        /** @psalm-suppress MixedAssignment */
                        $result = $this->resolver->handle($request);

                        if ($request->getJsonRpcRequest()->id === null) {
                            return null;
                        }

                        return new JsonRpcResponse(
                            id:     $request->getJsonRpcRequest()->id,
                            result: $result
                        );
                    }
                );
        } catch (\Throwable $e) {
            return new JsonRpcResponse(
                id:    $request->getJsonRpcRequest()->id ?? 'empty',
                error: $this->exceptionHandler->handle($e)
            );
        }
    }
}

1	<?php
2
3	namespace Tochka\JsonRpc;
4
5	use Illuminate\Container\Container;
6	use Illuminate\Pipeline\Pipeline;
7	use Psr\Http\Message\ServerRequestInterface;
8	use Tochka\JsonRpc\Contracts\ExceptionHandlerInterface;
9	use Tochka\JsonRpc\Contracts\HandleResolverInterface;
10	use Tochka\JsonRpc\Contracts\HttpRequestMiddlewareInterface;
11	use Tochka\JsonRpc\Contracts\JsonRpcRequestMiddlewareInterface;
12	use Tochka\JsonRpc\Contracts\JsonRpcServerInterface;
13	use Tochka\JsonRpc\Contracts\MiddlewareRegistryInterface;
14	use Tochka\JsonRpc\Contracts\ParserInterface;
15	use Tochka\JsonRpc\DTO\JsonRpcResponseCollection;
16	use Tochka\JsonRpc\DTO\JsonRpcServerRequest;
17	use Tochka\JsonRpc\Facades\JsonRpcRouter;
18	use Tochka\JsonRpc\Standard\DTO\JsonRpcResponse;
19	use Tochka\JsonRpc\Standard\Exceptions\MethodNotFoundException;
20
21	class JsonRpcServer implements JsonRpcServerInterface
22	{
23	private ParserInterface $parser;
24	private HandleResolverInterface $resolver;
25	private Container $container;
26	private ExceptionHandlerInterface $exceptionHandler;
27	private MiddlewareRegistryInterface $middlewareRegistry;
28
29	/**
30	* @psalm-suppress PossiblyUnusedMethod
31	*/
32	public function __construct(
33	ParserInterface $parser,
34	HandleResolverInterface $resolver,
35	ExceptionHandlerInterface $exceptionHandler,
36	MiddlewareRegistryInterface $middlewareRegistry,
37	Container $container
38	) {
39	$this->parser = $parser;	×
40	$this->resolver = $resolver;	×
NEW 41	$this->container = $container;	×
NEW 42	$this->exceptionHandler = $exceptionHandler;	×
NEW 43	$this->middlewareRegistry = $middlewareRegistry;	×
44	}
45
46	public function handle(
47	ServerRequestInterface $request,
48	string $serverName = 'default',
49	string $group = null,
50	string $action = null
51	): JsonRpcResponseCollection {
52	try {
NEW 53	$pipeline = new Pipeline($this->container);	×
54
55	/** @var JsonRpcResponseCollection $responses */
NEW 56	$responses = $pipeline->send($request)	×
NEW 57	->through($this->middlewareRegistry->getMiddleware($serverName, HttpRequestMiddlewareInterface::class))	×
NEW 58	->via('handleHttpRequest')	×
59	->then(	×
NEW 60	function (ServerRequestInterface $httpRequest) use ($serverName, $group, $action) {	×
NEW 61	$requests = $this->parser->parse($httpRequest);	×
62
NEW 63	$responses = new JsonRpcResponseCollection();	×
64
65	foreach ($requests as $request) {	×
66	$response = $this->handleRequest($request, $serverName, $group, $action);	×
67
68	if ($response !== null) {	×
69	$responses->add($response);	×
70	}
71	}
72
73	return $responses;	×
74	}	×
75	);	×
NEW 76	} catch (\Throwable $e) {	×
NEW 77	$responses = new JsonRpcResponseCollection();	×
78
NEW 79	$responses->add(	×
NEW 80	new JsonRpcResponse(	×
NEW 81	id: 'empty',	×
NEW 82	error: $this->exceptionHandler->handle($e)	×
NEW 83	)	×
NEW 84	);	×
85	}
86
87	return $responses;	×
88	}
89
90	public function handleRequest(
91	JsonRpcServerRequest $request,
92	string $serverName,
93	string $group = null,
94	string $action = null
95	): ?JsonRpcResponse {
96	try {
NEW 97	$pipeline = new Pipeline($this->container);	×
98
NEW 99	$route = JsonRpcRouter::get($serverName, $request->getJsonRpcRequest()->method, $group, $action);	×
100
101	if ($route === null) {	×
NEW 102	throw new MethodNotFoundException();	×
103	}
104
105	$request->setRoute($route);	×
106
107	/** @var JsonRpcResponse\|null */
108	return $pipeline->send($request)	×
NEW 109	->through(	×
NEW 110	$this->middlewareRegistry->getMiddleware($serverName, JsonRpcRequestMiddlewareInterface::class)	×
NEW 111	)	×
NEW 112	->via('handleJsonRpcRequest')	×
113	->then(	×
NEW 114	function (JsonRpcServerRequest $request) {	×
115	/** @psalm-suppress MixedAssignment */
116	$result = $this->resolver->handle($request);	×
117
NEW 118	if ($request->getJsonRpcRequest()->id === null) {	×
119	return null;	×
120	}
121
NEW 122	return new JsonRpcResponse(	×
NEW 123	id: $request->getJsonRpcRequest()->id,	×
NEW 124	result: $result	×
NEW 125	);	×
126	}	×
127	);	×
NEW 128	} catch (\Throwable $e) {	×
NEW 129	return new JsonRpcResponse(	×
NEW 130	id: $request->getJsonRpcRequest()->id ?? 'empty',	×
NEW 131	error: $this->exceptionHandler->handle($e)	×
NEW 132	);	×
133	}
134	}
135	}

tochka-developers / jsonrpc / 4135501466

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous