├── .github
    └── workflows
    │   └── build.yml
├── LICENSE
├── composer.json
└── lib
    ├── Dispatcher.php
    ├── Error.php
    ├── ErrorCode.php
    ├── ErrorResponse.php
    ├── Message.php
    ├── Notification.php
    ├── Request.php
    ├── Response.php
    └── SuccessResponse.php


/.github/workflows/build.yml:
--------------------------------------------------------------------------------
 1 | name: build
 2 | 
 3 | on: [push, pull_request]
 4 | 
 5 | env:
 6 |   FORCE_COLOR: 1
 7 |   GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
 8 | 
 9 | jobs:
10 |   test:
11 |     strategy:
12 |       matrix:
13 |         php:
14 |           - 7.1
15 |           - 7.2
16 |           - 7.3
17 |           - 7.4
18 |           - 8.0
19 |         deps:
20 |           - lowest
21 |           - highest
22 |         include:
23 |           - php: 8.1
24 |             deps: highest
25 |             composer-options: --ignore-platform-reqs
26 |         exclude:
27 |           # that config currently breaks as older PHPUnit cannot generate coverage on PHP 8
28 |           - php: 8
29 |             deps: lowest
30 | 
31 |     runs-on: ubuntu-latest
32 |     steps:
33 |       - uses: actions/checkout@v2
34 | 
35 |       - name: Setup PHP
36 |         uses: shivammathur/setup-php@v2
37 |         with:
38 |           php-version: ${{ matrix.php }}
39 | 
40 |       - uses: ramsey/composer-install@v1
41 |         with:
42 |           dependency-versions: ${{ matrix.deps }}
43 |           composer-options: ${{ matrix.composer-options }}
44 | 
45 |       - run: vendor/bin/phpunit --coverage-clover=coverage.xml --whitelist lib --bootstrap vendor/autoload.php tests
46 | 
47 |       - uses: codecov/codecov-action@v1
48 | 
49 |   release:
50 |     needs: test
51 |     if: github.repository_owner == 'felixfbecker' && github.event_name == 'push' && github.ref == 'refs/heads/master'
52 |     runs-on: ubuntu-latest
53 |     steps:
54 |       - uses: actions/checkout@v2
55 | 
56 |       - name: Setup Node.js
57 |         uses: actions/setup-node@v2
58 | 
59 |       - name: Install npm dependencies
60 |         run: npm ci
61 | 
62 |       - name: Release
63 |         run: npm run semantic-release
64 | 


--------------------------------------------------------------------------------
/LICENSE:
--------------------------------------------------------------------------------
 1 | ISC License
 2 | 
 3 | Copyright (c) 2016, Felix Frederick Becker
 4 | 
 5 | Permission to use, copy, modify, and/or distribute this software for any
 6 | purpose with or without fee is hereby granted, provided that the above
 7 | copyright notice and this permission notice appear in all copies.
 8 | 
 9 | THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
10 | WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
11 | MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
12 | ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
13 | WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
14 | ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
15 | OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
16 | 


--------------------------------------------------------------------------------
/composer.json:
--------------------------------------------------------------------------------
 1 | {
 2 |     "name": "felixfbecker/advanced-json-rpc",
 3 |     "description": "A more advanced JSONRPC implementation",
 4 |     "type": "library",
 5 |     "license": "ISC",
 6 |     "authors": [
 7 |         {
 8 |             "name": "Felix Becker",
 9 |             "email": "felix.b@outlook.com"
10 |         }
11 |     ],
12 |     "autoload": {
13 |         "psr-4": {
14 |             "AdvancedJsonRpc\\": "lib/"
15 |         }
16 |     },
17 |     "autoload-dev": {
18 |         "psr-4": {
19 |             "AdvancedJsonRpc\\Tests\\": "tests/"
20 |         }
21 |     },
22 |     "require": {
23 |         "php": "^7.1 || ^8.0",
24 |         "netresearch/jsonmapper": "^1.0 || ^2.0 || ^3.0 || ^4.0",
25 |         "phpdocumentor/reflection-docblock": "^4.3.4 || ^5.0.0"
26 |     },
27 |     "require-dev": {
28 |         "phpunit/phpunit": "^7.0 || ^8.0"
29 |     },
30 |     "minimum-stability": "dev",
31 |     "prefer-stable": true
32 | }
33 | 


--------------------------------------------------------------------------------
/lib/Dispatcher.php:
--------------------------------------------------------------------------------
  1 | <?php
  2 | declare(strict_types = 1);
  3 | 
  4 | namespace AdvancedJsonRpc;
  5 | 
  6 | use JsonMapper;
  7 | use JsonMapper_Exception;
  8 | use phpDocumentor\Reflection\DocBlockFactory;
  9 | use phpDocumentor\Reflection\Types;
 10 | use ReflectionException;
 11 | use ReflectionMethod;
 12 | use ReflectionNamedType;
 13 | 
 14 | class Dispatcher
 15 | {
 16 |     /**
 17 |      * @var object
 18 |      */
 19 |     private $target;
 20 | 
 21 |     /**
 22 |      * @var string
 23 |      */
 24 |     private $delimiter;
 25 | 
 26 |     /**
 27 |      * method => ReflectionMethod[]
 28 |      *
 29 |      * @var ReflectionMethod
 30 |      */
 31 |     private $methods;
 32 | 
 33 |     /**
 34 |      * @var \phpDocumentor\Reflection\DocBlockFactory
 35 |      */
 36 |     private $docBlockFactory;
 37 | 
 38 |     /**
 39 |      * @var \phpDocumentor\Reflection\Types\ContextFactory
 40 |      */
 41 |     private $contextFactory;
 42 | 
 43 |     /**
 44 |      * @param object $target    The target object that should receive the method calls
 45 |      * @param string $delimiter A delimiter for method calls on properties, for example someProperty->someMethod
 46 |      */
 47 |     public function __construct($target, $delimiter = '->')
 48 |     {
 49 |         $this->target = $target;
 50 |         $this->delimiter = $delimiter;
 51 |         $this->docBlockFactory = DocBlockFactory::createInstance();
 52 |         $this->contextFactory = new Types\ContextFactory();
 53 |         $this->mapper = new JsonMapper();
 54 |     }
 55 | 
 56 |     /**
 57 |      * Calls the appropriate method handler for an incoming Message
 58 |      *
 59 |      * @param string|object $msg The incoming message
 60 |      * @return mixed
 61 |      */
 62 |     public function dispatch($msg)
 63 |     {
 64 |         if (is_string($msg)) {
 65 |             $msg = json_decode($msg);
 66 |             if (json_last_error() !== JSON_ERROR_NONE) {
 67 |                 throw new Error(json_last_error_msg(), ErrorCode::PARSE_ERROR);
 68 |             }
 69 |         }
 70 |         // Find out the object and function that should be called
 71 |         $obj = $this->target;
 72 |         $parts = explode($this->delimiter, $msg->method);
 73 |         // The function to call is always the last part of the method
 74 |         $fn = array_pop($parts);
 75 |         // For namespaced methods like textDocument/didOpen, call the didOpen method on the $textDocument property
 76 |         // For simple methods like initialize, shutdown, exit, this loop will simply not be entered and $obj will be
 77 |         // the target
 78 |         foreach ($parts as $part) {
 79 |             if (!isset($obj->$part)) {
 80 |                 throw new Error("Method {$msg->method} is not implemented", ErrorCode::METHOD_NOT_FOUND);
 81 |             }
 82 |             $obj = $obj->$part;
 83 |         }
 84 |         if (!isset($this->methods[$msg->method])) {
 85 |             try {
 86 |                 $method = new ReflectionMethod($obj, $fn);
 87 |                 $this->methods[$msg->method] = $method;
 88 |             } catch (ReflectionException $e) {
 89 |                 throw new Error($e->getMessage(), ErrorCode::METHOD_NOT_FOUND, null, $e);
 90 |             }
 91 |         }
 92 |         $method = $this->methods[$msg->method];
 93 |         $parameters = $method->getParameters();
 94 |         if ($method->getDocComment()) {
 95 |             $docBlock = $this->docBlockFactory->create(
 96 |                 $method->getDocComment(),
 97 |                 $this->contextFactory->createFromReflector($method->getDeclaringClass())
 98 |             );
 99 |             $paramTags = $docBlock->getTagsByName('param');
100 |         }
101 |         $args = [];
102 |         if (isset($msg->params)) {
103 |             // Find out the position
104 |             if (is_array($msg->params)) {
105 |                 $args = $msg->params;
106 |             } else if (is_object($msg->params)) {
107 |                 foreach ($parameters as $pos => $parameter) {
108 |                     $value = null;
109 |                     foreach(get_object_vars($msg->params) as $key => $val) {
110 |                         if ($parameter->name === $key) {
111 |                             $value = $val;
112 |                             break;
113 |                         }
114 |                     }
115 |                     $args[$pos] = $value;
116 |                 }
117 |             } else {
118 |                 throw new Error('Params must be structured or omitted', ErrorCode::INVALID_REQUEST);
119 |             }
120 |             foreach ($args as $position => $value) {
121 |                 try {
122 |                     // If the type is structured (array or object), map it with JsonMapper
123 |                     if (is_object($value)) {
124 |                         // Does the parameter have a type hint?
125 |                         $param = $parameters[$position];
126 |                         if ($param->hasType()) {
127 |                             $paramType = $param->getType();
128 |                             if ($paramType instanceof ReflectionNamedType) {
129 |                                 // We have object data to map and want the class name.
130 |                                 // This should not include the `?` if the type was nullable.
131 |                                 $class = $paramType->getName();
132 |                             } else {
133 |                                 // Fallback for php 7.0, which is still supported (and doesn't have nullable).
134 |                                 $class = (string)$paramType;
135 |                             }
136 |                             $value = $this->mapper->map($value, new $class());
137 |                         }
138 |                     } else if (is_array($value) && isset($docBlock)) {
139 |                         // Get the array type from the DocBlock
140 |                         $type = $paramTags[$position]->getType();
141 |                         // For union types, use the first one that is a class array (often it is SomeClass[]|null)
142 |                         if ($type instanceof Types\Compound) {
143 |                             for ($i = 0; $t = $type->get($i); $i++) {
144 |                                 if (
145 |                                     $t instanceof Types\Array_
146 |                                     && $t->getValueType() instanceof Types\Object_
147 |                                     && (string)$t->getValueType() !== 'object'
148 |                                 ) {
149 |                                     $class = (string)$t->getValueType()->getFqsen();
150 |                                     $value = $this->mapper->mapArray($value, [], $class);
151 |                                     break;
152 |                                 }
153 |                             }
154 |                         } else if ($type instanceof Types\Array_) {
155 |                             $class = (string)$type->getValueType()->getFqsen();
156 |                             $value = $this->mapper->mapArray($value, [], $class);
157 |                         } else {
158 |                             throw new Error('Type is not matching @param tag', ErrorCode::INVALID_PARAMS);
159 |                         }
160 |                     }
161 |                 } catch (JsonMapper_Exception $e) {
162 |                     throw new Error($e->getMessage(), ErrorCode::INVALID_PARAMS, null, $e);
163 |                 }
164 |                 $args[$position] = $value;
165 |             }
166 |         }
167 |         ksort($args);
168 |         $result = $obj->$fn(...$args);
169 |         return $result;
170 |     }
171 | }
172 | 


--------------------------------------------------------------------------------
/lib/Error.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | declare(strict_types = 1);
 3 | 
 4 | namespace AdvancedJsonRpc;
 5 | 
 6 | use Exception;
 7 | use Throwable;
 8 | 
 9 | class Error extends Exception
10 | {
11 |     /**
12 |      * A Number that indicates the error type that occurred. This MUST be an integer.
13 |      *
14 |      * @var int
15 |      */
16 |     public $code;
17 | 
18 |     /**
19 |      * A String providing a short description of the error. The message SHOULD be limited to a concise single sentence.
20 |      *
21 |      * @var string
22 |      */
23 |     public $message;
24 | 
25 |     /**
26 |      * A Primitive or Structured value that contains additional information about the error. This may be omitted. The
27 |      * value of this member is defined by the Server (e.g. detailed error information, nested errors etc.).
28 |      *
29 |      * @var mixed
30 |      */
31 |     public $data;
32 | 
33 |     public function __construct(string $message, int $code, $data = null, Throwable $previous = null)
34 |     {
35 |         parent::__construct($message, $code, $previous);
36 |         $this->data = $data;
37 |     }
38 | }
39 | 


--------------------------------------------------------------------------------
/lib/ErrorCode.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | declare(strict_types = 1);
 3 | 
 4 | namespace AdvancedJsonRpc;
 5 | 
 6 | /**
 7 |  * The error codes from and including -32768 to -32000 are reserved for pre-defined errors. Any code within this range,
 8 |  * but not defined explicitly below is reserved for future use. The error codes are nearly the same as those suggested
 9 |  * for XML-RPC at the following url: http://xmlrpc-epi.sourceforge.net/specs/rfc.fault_codes.php
10 |  * The remainder of the space is available for application defined errors.
11 |  */
12 | abstract class ErrorCode
13 | {
14 |     /**
15 |      * Invalid JSON was received by the server. An error occurred on the server while parsing the JSON text.
16 |      */
17 |     const PARSE_ERROR = -32700;
18 | 
19 |     /**
20 |      * The JSON sent is not a valid Request object.
21 |      */
22 |     const INVALID_REQUEST = -32600;
23 | 
24 |     /**
25 |      * The method does not exist / is not available.
26 |      */
27 |     const METHOD_NOT_FOUND = -32601;
28 | 
29 |     /**
30 |      * Invalid method parameter(s).
31 |      */
32 |     const INVALID_PARAMS = -32602;
33 | 
34 |     /**
35 |      * Internal JSON-RPC error.
36 |      */
37 |     const INTERNAL_ERROR = -32603;
38 | 
39 |     /**
40 |      * Reserved for implementation-defined server-errors.
41 |      */
42 |     const SERVER_ERROR_START = -32099;
43 | 
44 |     /**
45 |      * Reserved for implementation-defined server-errors.
46 |      */
47 |     const SERVER_ERROR_END = -32000;
48 | }
49 | 


--------------------------------------------------------------------------------
/lib/ErrorResponse.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | declare(strict_types = 1);
 3 | 
 4 | namespace AdvancedJsonRpc;
 5 | 
 6 | /**
 7 |  * When a rpc call is made, the Server MUST reply with a Response, except for in the case of Notifications. The Response
 8 |  * is expressed as a single JSON Object, with the following members:
 9 |  */
10 | class ErrorResponse extends Response
11 | {
12 |     /**
13 |      * This member is REQUIRED on error. This member MUST NOT exist if there was no error triggered during invocation.
14 |      * The value for this member MUST be an Object as defined in section 5.1.
15 |      *
16 |      * @var \AdvancedJsonRpc\Error
17 |      */
18 |     public $error;
19 | 
20 |     /**
21 |      * A message is considered a Response if it has an ID and either a result or an error
22 |      *
23 |      * @param object $msg A decoded message body
24 |      * @return bool
25 |      */
26 |     public static function isErrorResponse($msg): bool
27 |     {
28 |         return is_object($msg) && isset($msg->id) && isset($msg->error);
29 |     }
30 | 
31 |     /**
32 |      * @param int|string $id
33 |      * @param \AdvancedJsonRpc\Error $error
34 |      */
35 |     public function __construct($id, Error $error)
36 |     {
37 |         parent::__construct($id);
38 |         $this->error = $error;
39 |     }
40 | }
41 | 


--------------------------------------------------------------------------------
/lib/Message.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | declare(strict_types = 1);
 3 | 
 4 | namespace AdvancedJsonRpc;
 5 | 
 6 | /**
 7 |  * Base message
 8 |  */
 9 | abstract class Message
10 | {
11 |     /**
12 |      * A String specifying the version of the JSON-RPC protocol. MUST be exactly "2.0".
13 |      *
14 |      * @var string
15 |      */
16 |     public $jsonrpc = '2.0';
17 | 
18 |     /**
19 |      * Returns the appropriate Message subclass
20 |      *
21 |      * @param string $msg
22 |      * @return Message
23 |      */
24 |     public static function parse(string $msg): Message
25 |     {
26 |         $decoded = json_decode($msg);
27 |         if (json_last_error() !== JSON_ERROR_NONE) {
28 |             throw new Error(json_last_error_msg(), ErrorCode::PARSE_ERROR);
29 |         }
30 |         if (Notification::isNotification($decoded)) {
31 |             $obj = new Notification($decoded->method, $decoded->params ?? null);
32 |         } else if (Request::isRequest($decoded)) {
33 |             $obj = new Request($decoded->id, $decoded->method, $decoded->params ?? null);
34 |         } else if (SuccessResponse::isSuccessResponse($decoded)) {
35 |             $obj = new SuccessResponse($decoded->id, $decoded->result);
36 |         } else if (ErrorResponse::isErrorResponse($decoded)) {
37 |             $obj = new ErrorResponse($decoded->id, new Error($decoded->error->message, $decoded->error->code, $decoded->error->data ?? null));
38 |         } else {
39 |             throw new Error('Invalid message', ErrorCode::INVALID_REQUEST);
40 |         }
41 |         return $obj;
42 |     }
43 | 
44 |     public function __toString(): string
45 |     {
46 |         $encoded = json_encode($this);
47 |         if ($encoded === false) {
48 |             throw new Error(json_last_error_msg(), ErrorCode::INTERNAL_ERROR);
49 |         }
50 |         return $encoded;
51 |     }
52 | }
53 | 


--------------------------------------------------------------------------------
/lib/Notification.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | declare(strict_types = 1);
 3 | 
 4 | namespace AdvancedJsonRpc;
 5 | 
 6 | /**
 7 |  * A Notification is a Request object without an "id" member. A Request object that is a Notification signifies the
 8 |  * Client's lack of interest in the corresponding Response object, and as such no Response object needs to be returned
 9 |  * to the client. The Server MUST NOT reply to a Notification, including those that are within a batch request.
10 |  * Notifications are not confirmable by definition, since they do not have a Response object to be returned. As such,
11 |  * the Client would not be aware of any errors (like e.g. "Invalid params","Internal error").
12 |  */
13 | class Notification extends Message
14 | {
15 |     /**
16 |      * A String containing the name of the method to be invoked. Method names that begin with the word rpc followed by a
17 |      * period character (U+002E or ASCII 46) are reserved for rpc-internal methods and extensions and MUST NOT be used
18 |      * for anything else.
19 |      *
20 |      * @var string
21 |      */
22 |     public $method;
23 | 
24 |     /**
25 |      * A Structured value that holds the parameter values to be used during the invocation of the method. This member
26 |      * MAY be omitted. If present, parameters for the rpc call MUST be provided as a Structured value. Either
27 |      * by-position through an Array or by-name through an Object. by-position: params MUST be an Array, containing the
28 |      * values in the Server expected order. by-name: params MUST be an Object, with member names that match the Server
29 |      * expected parameter names. The absence of expected names MAY result in an error being generated. The names MUST
30 |      * match exactly, including case, to the method's expected parameters.
31 |      *
32 |      * @var object|array|null
33 |      */
34 |     public $params;
35 | 
36 |     /**
37 |      * A message is considered a Notification if it has a method but no ID.
38 |      *
39 |      * @param object $msg A decoded message body
40 |      * @return bool
41 |      */
42 |     public static function isNotification($msg): bool
43 |     {
44 |         return is_object($msg) && !property_exists($msg, 'id') && isset($msg->method);
45 |     }
46 | 
47 |     /**
48 |      * @param string $method
49 |      * @param mixed $params
50 |      */
51 |     public function __construct(string $method, $params = null)
52 |     {
53 |         $this->method = $method;
54 |         $this->params = $params;
55 |     }
56 | }
57 | 


--------------------------------------------------------------------------------
/lib/Request.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | declare(strict_types = 1);
 3 | 
 4 | namespace AdvancedJsonRpc;
 5 | 
 6 | /**
 7 |  * A rpc call is represented by sending a Request object to a Server
 8 |  */
 9 | class Request extends Message
10 | {
11 |     /**
12 |      * An identifier established by the Client that MUST contain a String, Number, or NULL value if included. If it is
13 |      * not included it is assumed to be a notification. The value SHOULD normally not be NULL and Numbers SHOULD NOT
14 |      * contain fractional parts.
15 |      *
16 |      * @var int|string
17 |      */
18 |     public $id;
19 | 
20 |     /**
21 |      * A String containing the name of the method to be invoked. Method names that begin with the word rpc followed by a
22 |      * period character (U+002E or ASCII 46) are reserved for rpc-internal methods and extensions and MUST NOT be used
23 |      * for anything else.
24 |      *
25 |      * @var string
26 |      */
27 |     public $method;
28 | 
29 |     /**
30 |      * A Structured value that holds the parameter values to be used during the invocation of the method. This member
31 |      * MAY be omitted. If present, parameters for the rpc call MUST be provided as a Structured value. Either
32 |      * by-position through an Array or by-name through an Object. by-position: params MUST be an Array, containing the
33 |      * values in the Server expected order. by-name: params MUST be an Object, with member names that match the Server
34 |      * expected parameter names. The absence of expected names MAY result in an error being generated. The names MUST
35 |      * match exactly, including case, to the method's expected parameters.
36 |      *
37 |      * @var object|array|null
38 |      */
39 |     public $params;
40 | 
41 |     /**
42 |      * A message is considered a Request if it has an ID and a method.
43 |      *
44 |      * @param object $msg A decoded message body
45 |      * @return bool
46 |      */
47 |     public static function isRequest($msg): bool
48 |     {
49 |         return is_object($msg) && property_exists($msg, 'id') && isset($msg->method);
50 |     }
51 | 
52 |     /**
53 |      * @param string|int $id
54 |      * @param string $method
55 |      * @param object|array $params
56 |      */
57 |     public function __construct($id, string $method, $params = null)
58 |     {
59 |         $this->id = $id;
60 |         $this->method = $method;
61 |         $this->params = $params;
62 |     }
63 | }
64 | 


--------------------------------------------------------------------------------
/lib/Response.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | declare(strict_types = 1);
 3 | 
 4 | namespace AdvancedJsonRpc;
 5 | 
 6 | /**
 7 |  * When a rpc call is made, the Server MUST reply with a Response, except for in the case of Notifications. The Response
 8 |  * is expressed as a single JSON Object, with the following members:
 9 |  */
10 | abstract class Response extends Message
11 | {
12 |     /**
13 |      * This member is REQUIRED. It MUST be the same as the value of the id member in the Request Object. If there was an
14 |      * error in detecting the id in the Request object (e.g. Parse error/Invalid Request), it MUST be Null.
15 |      *
16 |      * @var int|string
17 |      */
18 |     public $id;
19 | 
20 |     /**
21 |      * A message is considered a Response if it has an ID and either a result or an error
22 |      *
23 |      * @param object $msg A decoded message body
24 |      * @return bool
25 |      */
26 |     public static function isResponse($msg): bool
27 |     {
28 |         return is_object($msg) && property_exists($msg, 'id') && (property_exists($msg, 'result') || isset($msg->error));
29 |     }
30 | 
31 |     /**
32 |      * @param int|string $id
33 |      * @param mixed $result
34 |      * @param ResponseError $error
35 |      */
36 |     public function __construct($id)
37 |     {
38 |         $this->id = $id;
39 |     }
40 | }
41 | 


--------------------------------------------------------------------------------
/lib/SuccessResponse.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | declare(strict_types = 1);
 3 | 
 4 | namespace AdvancedJsonRpc;
 5 | 
 6 | /**
 7 |  * When a rpc call is made, the Server MUST reply with a Response, except for in the case of Notifications. The Response
 8 |  * is expressed as a single JSON Object, with the following members:
 9 |  */
10 | class SuccessResponse extends Response
11 | {
12 |     /**
13 |      * This member is REQUIRED on success. This member MUST NOT exist if there was an error invoking the method. The
14 |      * value of this member is determined by the method invoked on the Server.
15 |      *
16 |      * @var mixed
17 |      */
18 |     public $result;
19 | 
20 |     /**
21 |      * A message is considered a SuccessResponse if it has an ID and either a result
22 |      *
23 |      * @param object $msg A decoded message body
24 |      * @return bool
25 |      */
26 |     public static function isSuccessResponse($msg): bool
27 |     {
28 |         return is_object($msg) && property_exists($msg, 'id') && property_exists($msg, 'result');
29 |     }
30 | 
31 |     /**
32 |      * @param int|string $id
33 |      * @param mixed $result
34 |      */
35 |     public function __construct($id, $result)
36 |     {
37 |         parent::__construct($id);
38 |         $this->result = $result;
39 |     }
40 | }
41 | 


--------------------------------------------------------------------------------