├── LICENSE.md
├── README.md
├── composer.json
├── config
    └── sajya.php
├── src
    ├── App.php
    ├── Attributes
    │   └── RpcMethod.php
    ├── Binding.php
    ├── Commands
    │   ├── DocsCommand.php
    │   └── ProcedureMakeCommand.php
    ├── Docs.php
    ├── Exceptions
    │   ├── InternalErrorException.php
    │   ├── InvalidParams.php
    │   ├── InvalidRequestException.php
    │   ├── MaxBatchSizeExceededException.php
    │   ├── MethodNotFound.php
    │   ├── ParseErrorException.php
    │   ├── RpcException.php
    │   └── RuntimeRpcException.php
    ├── Facades
    │   └── RPC.php
    ├── HandleProcedure.php
    ├── Http
    │   ├── Parser.php
    │   ├── Request.php
    │   └── Response.php
    ├── JsonRpcController.php
    ├── Middleware
    │   └── GzipCompress.php
    ├── Procedure.php
    ├── Proxy.php
    ├── Rules
    │   └── Identifier.php
    ├── ServerServiceProvider.php
    └── Testing
    │   └── ProceduralRequests.php
├── stubs
    └── procedure.stub
└── views
    └── docs.blade.php


/LICENSE.md:
--------------------------------------------------------------------------------
 1 | The MIT License (MIT)
 2 | 
 3 | Copyright (c) Alexandr Chernyaev
 4 | 
 5 | Permission is hereby granted, free of charge, to any person obtaining a copy
 6 | of this software and associated documentation files (the "Software"), to deal
 7 | in the Software without restriction, including without limitation the rights
 8 | to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 9 | copies of the Software, and to permit persons to whom the Software is
10 | furnished to do so, subject to the following conditions:
11 | 
12 | The above copyright notice and this permission notice shall be included in
13 | all copies or substantial portions of the Software.
14 | 
15 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
16 | IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
17 | FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
18 | AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
19 | LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
20 | OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
21 | THE SOFTWARE.
22 | 


--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
 1 | ## Introduction
 2 | 
 3 | [![Tests](https://github.com/sajya/server/actions/workflows/phpunit.yml/badge.svg)](https://github.com/sajya/server/actions/workflows/phpunit.yml)
 4 | [![Quality Assurance](https://github.com/sajya/server/actions/workflows/quality.yml/badge.svg)](https://github.com/sajya/server/actions/workflows/quality.yml)
 5 | [![Coding Guidelines](https://github.com/sajya/server/actions/workflows/php-cs-fixer.yml/badge.svg)](https://github.com/sajya/server/actions/workflows/php-cs-fixer.yml)
 6 | [![codecov](https://codecov.io/gh/sajya/server/branch/master/graph/badge.svg)](https://codecov.io/gh/sajya/server)
 7 | [![Total Downloads](https://img.shields.io/packagist/dt/sajya/server.svg)](https://packagist.org/packages/sajya/server)
 8 | 
 9 | Sajya empowers Laravel developers to bring the full power of JSON-RPC 2.0 to life. With Sajya, you can:
10 | 
11 | * **Achieve Complete JSON-RPC 2.0 Compliance:** Seamlessly implement every feature of the specification.
12 | * **Ensure Robust Validation:** Automatically validate parameters to keep your interactions safe and sound.
13 | * **Handle Batch & Notification Requests:** Easily manage multiple requests or fire-and-forget notifications.
14 | * **Set Up in a Snap:** Get your JSON-RPC server up and running with minimal fuss.
15 | 
16 | It’s all about making your life easier so you can focus on building amazing applications.
17 | 
18 | ## Official Documentation
19 | 
20 | Discover all there is to know about Sajya on our [website](https://sajya.github.io/). You'll find everything from
21 | installation guides to deep dives into each feature.
22 | 
23 | ## Changelog
24 | 
25 | Curious about what’s new? Check out our [CHANGELOG](CHANGELOG.md) to keep up with the latest updates and improvements.
26 | 
27 | ## Contributing
28 | 
29 | We’re all about community! Whether you have a bug fix, a new feature idea, or an improvement for our docs, we’d love to
30 | hear from you.
31 | 
32 | ## Maintainers
33 | 
34 | Sajya is proudly maintained by [Alexandr Chernyaev](https://github.com/tabuna). Feel free to reach out or get involved!
35 | 
36 | ## License
37 | 
38 | Sajya is released under the MIT License. See the [License File](LICENSE.md) for more details.
39 | 


--------------------------------------------------------------------------------
/composer.json:
--------------------------------------------------------------------------------
 1 | {
 2 |     "name": "sajya/server",
 3 |     "description": "Easy implementation of the JSON-RPC 2.0 server for the Laravel framework.",
 4 |     "keywords": [
 5 |         "rpc",
 6 |         "json-prc",
 7 |         "api"
 8 |     ],
 9 |     "homepage": "https://sajya.github.io",
10 |     "license": "MIT",
11 |     "authors": [
12 |         {
13 |             "name": "Alexandr Chernyaev",
14 |             "email": "bliz48rus@gmail.com"
15 |         }
16 |     ],
17 |     "require": {
18 |         "ext-json": "*",
19 |         "laravel/framework": "^10.0|^11.0|^12.0"
20 |     },
21 |     "require-dev": {
22 |         "laravel/pint": "^v1.20",
23 |         "orchestra/testbench": "^8.0|^9.0|^10.0",
24 |         "phpunit/phpunit": "^10.5|^11.0",
25 |         "phpunit/php-code-coverage": "^10.|^11.0|^12.0",
26 |         "vimeo/psalm": "^5.0 | ^6.0"
27 |     },
28 |     "conflict": {
29 |         "league/flysystem": "<3.0.16",
30 |         "mockery/mockery": "<1.6.1",
31 |         "laravel/framework": ">=10.0.0,<=10.48.27 || >11.0.0,<=11.42.0",
32 |         "orchestra/testbench": ">=9.0.0,<9.8.2"
33 |     },
34 |     "autoload": {
35 |         "psr-4": {
36 |             "Sajya\\Server\\": "src"
37 |         }
38 |     },
39 |     "autoload-dev": {
40 |         "psr-4": {
41 |             "Sajya\\Server\\Tests\\": "tests"
42 |         }
43 |     },
44 |     "scripts": {
45 |         "test": "vendor/bin/phpunit",
46 |         "test-coverage": "vendor/bin/phpunit --coverage-html coverage"
47 |     },
48 |     "config": {
49 |         "sort-packages": true
50 |     },
51 |     "suggest": {
52 |         "ext-zlib": "Required to compress the response into gzip",
53 |         "sajya/client": "HTTP(S) client for JSON-RPC 2.0"
54 |     },
55 |     "prefer-stable": true,
56 |     "extra": {
57 |         "laravel": {
58 |             "providers": [
59 |                 "Sajya\\Server\\ServerServiceProvider"
60 |             ],
61 |             "aliases": {
62 |                 "RPC": "Sajya\\Server\\Facades\\RPC"
63 |             }
64 |         }
65 |     }
66 | }
67 | 


--------------------------------------------------------------------------------
/config/sajya.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | return [
 4 | 
 5 |     /*
 6 |     |--------------------------------------------------------------------------
 7 |     | Delimiter
 8 |     |--------------------------------------------------------------------------
 9 |     |
10 |     | This value defines the delimiter used to separate class and method names
11 |     | when specifying JSON-RPC method handlers. By default, "@" is used.
12 |     |
13 |     | Example:
14 |     |
15 |     | If you want to change the delimiter to dot, you can set this value
16 |     | to ".".
17 |     |
18 |     | Please note that the delimiter should be a single character.
19 |     | This can be useful if you have a different convention for
20 |     | naming your methods.
21 |     |
22 |     */
23 | 
24 |     'delimiter' => '@',
25 | 
26 |     /*
27 |     |--------------------------------------------------------------------------
28 |     | Maximum Batch Size
29 |     |--------------------------------------------------------------------------
30 |     |
31 |     | This value defines the maximum number of JSON-RPC requests allowed in
32 |     | a single batch request. Adjust this according to your application's
33 |     | requirements and server capabilities.
34 |     |
35 |     | Example:
36 |     |
37 |     | If you anticipate handling large batches of requests, you may need to
38 |     | increase this value. To allow an unlimited number of requests in a
39 |     | single batch, you can set this value to PHP_INT_MAX.
40 |     |
41 |     */
42 | 
43 |     'max_batch_size' => 30,
44 | 
45 |     /*
46 |     |--------------------------------------------------------------------------
47 |     | Encode Options
48 |     |--------------------------------------------------------------------------
49 |     |
50 |     | This value defines the JSON encoding options used when encoding
51 |     | JSON-RPC responses. Refer to the PHP json_encode documentation
52 |     | for available options.
53 |     |
54 |     | Example:
55 |     |
56 |     | If you want to format the JSON response for better readability, you can
57 |     | include the JSON_PRETTY_PRINT option. This will add indentation and
58 |     | line breaks to the JSON output.
59 |     |
60 |     */
61 | 
62 |     'encode_options' => 0,
63 | ];
64 | 


--------------------------------------------------------------------------------
/src/App.php:
--------------------------------------------------------------------------------
  1 | <?php
  2 | 
  3 | declare(strict_types=1);
  4 | 
  5 | namespace Sajya\Server;
  6 | 
  7 | use Illuminate\Support\Collection;
  8 | use Illuminate\Support\Facades\App as LaravelApplication;
  9 | use Illuminate\Support\Str;
 10 | use ReflectionClass;
 11 | use ReflectionMethod;
 12 | use Sajya\Server\Exceptions\MaxBatchSizeExceededException;
 13 | use Sajya\Server\Exceptions\MethodNotFound;
 14 | use Sajya\Server\Http\Parser;
 15 | use Sajya\Server\Http\Request;
 16 | use Sajya\Server\Http\Response;
 17 | 
 18 | class App
 19 | {
 20 |     /**
 21 |      * Default delimiter for method name.
 22 |      */
 23 |     protected const DEFAULT_DELIMITER = '@';
 24 | 
 25 |     /**
 26 |      * Stores all available RPC commands.
 27 |      *
 28 |      * @var Collection
 29 |      */
 30 |     protected Collection $map;
 31 | 
 32 |     /**
 33 |      * Stores delimiter
 34 |      *
 35 |      * @var string
 36 |      */
 37 |     protected string $delimiter;
 38 | 
 39 |     /**
 40 |      * App constructor.
 41 |      *
 42 |      * @param string[]    $procedures An array of procedures to register with the App.
 43 |      * @param null|string $delimiter  The delimiter to use for separating procedure names from method names.
 44 |      */
 45 |     public function __construct(array $procedures = [], ?string $delimiter = null)
 46 |     {
 47 |         $this->map = collect($procedures)
 48 |             ->each(fn (string $class) => abort_unless(
 49 |                 is_subclass_of($class, Procedure::class),
 50 |                 500,
 51 |                 "Class '$class' must extends ".Procedure::class
 52 |             ));
 53 |         $this->delimiter = $delimiter ?? config('sajya.delimiter', self::DEFAULT_DELIMITER);
 54 |     }
 55 | 
 56 |     /**
 57 |      * Terminate the application and return the JSON-RPC response.
 58 |      *
 59 |      * @param string $content
 60 |      *
 61 |      * @return Response[]|Response|null
 62 |      */
 63 |     public function terminate(string $content = '')
 64 |     {
 65 |         return tap($this->handle($content), fn () => LaravelApplication::terminate());
 66 |     }
 67 | 
 68 |     /**
 69 |      * Handles a JSON-RPC request or batch of requests.
 70 |      *
 71 |      * @param string $content
 72 |      *
 73 |      * @return Response[]|Response|null
 74 |      */
 75 |     public function handle(string $content = '')
 76 |     {
 77 |         $parser = new Parser($content);
 78 | 
 79 |         if ($this->checkBatchSizeWithinLimit($parser->countBatchingRequests())) {
 80 |             return $this->makeResponse(new MaxBatchSizeExceededException);
 81 |         }
 82 | 
 83 |         $result = collect($parser->makeRequests())
 84 |             ->map(
 85 |                 fn ($request) => $request instanceof Request
 86 |                     ? $this->handleProcedure($request, $request->isNotification())
 87 |                     : $this->makeResponse($request)
 88 |             )
 89 |             ->reject(fn (Response $response) => $response->isNotification())
 90 |             ->values();
 91 | 
 92 |         return $parser->isBatch()
 93 |             ? $result->all()
 94 |             : $result->first();
 95 |     }
 96 | 
 97 |     /**
 98 |      * Search for a procedure and execute it.
 99 |      *
100 |      * @param Request $request
101 |      * @param bool    $notification
102 |      *
103 |      * @return Response
104 |      */
105 |     public function handleProcedure(Request $request, bool $notification): Response
106 |     {
107 |         request()->replace($request->getParams()->toArray());
108 |         app()->bind(Request::class, fn () => $request);
109 | 
110 |         $procedure = $this->findProcedure($request);
111 | 
112 |         if ($procedure === null) {
113 |             return $this->makeResponse(new MethodNotFound, $request);
114 |         }
115 | 
116 |         $result = $notification
117 |             ? HandleProcedure::dispatchAfterResponse($procedure, $request)
118 |             : (new HandleProcedure($procedure, $request))->handle();
119 | 
120 |         return $this->makeResponse($result, $request);
121 |     }
122 | 
123 |     /**
124 |      * Find procedure by request.
125 |      *
126 |      * @param Request $request
127 |      *
128 |      * @return null|string
129 |      */
130 |     public function findProcedure(Request $request): ?string
131 |     {
132 |         $class = Str::beforeLast($request->getMethod(), $this->delimiter);
133 |         $method = Str::afterLast($request->getMethod(), $this->delimiter);
134 | 
135 |         return $this->map
136 |             ->filter(fn (string $procedure) => $this->getProcedureName($procedure) === $class)
137 |             ->filter(fn (string $procedure) => $this->checkExistPublicMethod($procedure, $method))
138 |             ->map(fn (string $procedure) => Str::finish($procedure, self::DEFAULT_DELIMITER.$method))
139 |             ->whenEmpty(fn (Collection $collection) => $collection->push($this->findProxy($class)))
140 |             ->first();
141 |     }
142 | 
143 |     /**
144 |      * Get the name of the procedure for the given class.
145 |      *
146 |      * @param string $procedure
147 |      *
148 |      * @return string
149 |      */
150 |     private function getProcedureName(string $procedure): string
151 |     {
152 |         return (new ReflectionClass($procedure))->getStaticPropertyValue('name');
153 |     }
154 | 
155 |     /**
156 |      * Check if the given procedure has a public method with the given name.
157 |      *
158 |      * @param string $procedure
159 |      * @param string $method
160 |      *
161 |      * @return bool
162 |      */
163 |     private function checkExistPublicMethod(string $procedure, string $method): bool
164 |     {
165 |         return method_exists($procedure, $method) && (new ReflectionMethod($procedure, $method))->isPublic();
166 |     }
167 | 
168 |     /**
169 |      * Fallback to the first procedure that implements the Proxy interface.
170 |      *
171 |      * @param string $class
172 |      *
173 |      * @return null|string
174 |      */
175 |     public function findProxy(string $class): ?string
176 |     {
177 |         return $this->map
178 |             ->filter(fn (string $procedure) => $this->getProcedureName($procedure) === $class)
179 |             ->filter(fn (string $procedure) => is_subclass_of($procedure, Proxy::class))
180 |             ->map(fn (string $procedure) => Str::finish($procedure, self::DEFAULT_DELIMITER.'__invoke'))
181 |             ->first();
182 |     }
183 | 
184 |     /**
185 |      * Create a Response object from the given result and Request object.
186 |      *
187 |      * @param mixed|null   $result
188 |      * @param Request|null $request
189 |      *
190 |      * @return Response
191 |      */
192 |     public function makeResponse($result = null, ?Request $request = null): Response
193 |     {
194 |         return Response::makeFromResult($result, $request);
195 |     }
196 | 
197 |     /**
198 |      * Checks if the number of requests in the batch exceeds the maximum allowed size.
199 |      *
200 |      * @param int $currentRequests
201 |      *
202 |      * @return bool
203 |      */
204 |     public function checkBatchSizeWithinLimit(int $currentRequests): bool
205 |     {
206 |         $maxBatchSize = config('sajya.max_batch_size', 50);
207 | 
208 |         return $currentRequests > $maxBatchSize;
209 |     }
210 | }
211 | 


--------------------------------------------------------------------------------
/src/Attributes/RpcMethod.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Sajya\Server\Attributes;
 6 | 
 7 | use Attribute;
 8 | 
 9 | #[Attribute(Attribute::TARGET_METHOD)]
10 | class RpcMethod
11 | {
12 |     public function __construct(
13 |         public ?string $description = null,
14 |         public ?array $params = null,
15 |         public ?array $result = null
16 |     ) {}
17 | }
18 | 


--------------------------------------------------------------------------------
/src/Binding.php:
--------------------------------------------------------------------------------
  1 | <?php
  2 | 
  3 | declare(strict_types=1);
  4 | 
  5 | namespace Sajya\Server;
  6 | 
  7 | use Closure;
  8 | use Illuminate\Container\Container;
  9 | use Illuminate\Routing\RouteBinding;
 10 | use Illuminate\Support\Arr;
 11 | use Illuminate\Support\Collection;
 12 | use Illuminate\Support\Facades\Route;
 13 | use Illuminate\Support\Str;
 14 | use ReflectionClass;
 15 | use ReflectionParameter;
 16 | 
 17 | class Binding
 18 | {
 19 |     /**
 20 |      * The IoC container instance.
 21 |      *
 22 |      * @var \Illuminate\Container\Container
 23 |      */
 24 |     protected $container;
 25 | 
 26 |     /**
 27 |      * The registered route value binders.
 28 |      *
 29 |      * @var array
 30 |      */
 31 |     protected $binders = [];
 32 | 
 33 |     /**
 34 |      * Application constructor.
 35 |      *
 36 |      * @param Container $container
 37 |      */
 38 |     public function __construct(Container $container)
 39 |     {
 40 |         $this->container = $container;
 41 |     }
 42 | 
 43 |     /**
 44 |      * Register a model binder for a wildcard.
 45 |      *
 46 |      * @param string        $key
 47 |      * @param string        $class
 48 |      * @param \Closure|null $callback
 49 |      *
 50 |      * @return void
 51 |      */
 52 |     public function model(string $key, string $class, ?Closure $callback = null): void
 53 |     {
 54 |         $this->bind($key, RouteBinding::forModel($this->container, $class, $callback));
 55 |     }
 56 | 
 57 |     /**
 58 |      * Add a new route parameter binder.
 59 |      *
 60 |      * @param string         $key
 61 |      * @param Closure|string $binder
 62 |      *
 63 |      * @return void
 64 |      */
 65 |     public function bind(string $key, $binder): void
 66 |     {
 67 |         $this->binders[$key] = RouteBinding::forCallback(
 68 |             $this->container, $binder
 69 |         );
 70 |     }
 71 | 
 72 |     /**
 73 |      * Binds the values of the given parameters to their corresponding type.
 74 |      *
 75 |      * @param string                         $procedure
 76 |      * @param \Illuminate\Support\Collection $params
 77 |      *
 78 |      * @throws \ReflectionException
 79 |      *
 80 |      * @return array
 81 |      */
 82 |     public function bindResolve(string $procedure, Collection $params): array
 83 |     {
 84 |         $class = new ReflectionClass(Str::before($procedure, '@'));
 85 |         $method = $class->getMethod(Str::after($procedure, '@'));
 86 | 
 87 |         return collect($method->getParameters())
 88 |             ->map(fn (ReflectionParameter $parameter) => $parameter->getName())
 89 |             ->mapWithKeys(function (string $key) use ($params) {
 90 |                 $value = Arr::get($params, $key);
 91 |                 $valueDot = Arr::get($params, Str::snake($key, '.'));
 92 | 
 93 |                 return [$key => $value ?? $valueDot];
 94 |             })
 95 |             ->map(function ($value, string $key) {
 96 | 
 97 |                 $closure = $this->binders[$key] ?? null;
 98 | 
 99 |                 if (is_callable($closure)) {
100 |                     return app()->call($closure, [
101 |                         'value' => $value,
102 |                         'route' => Route::current(),
103 |                     ]);
104 |                 }
105 | 
106 |                 return $value;
107 |             })
108 |             ->filter()
109 |             ->toArray();
110 |     }
111 | }
112 | 


--------------------------------------------------------------------------------
/src/Commands/DocsCommand.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Sajya\Server\Commands;
 6 | 
 7 | use Illuminate\Console\Command;
 8 | use Illuminate\Support\Facades\Route;
 9 | use Illuminate\Support\Facades\Storage;
10 | use Sajya\Server\Docs;
11 | 
12 | class DocsCommand extends Command
13 | {
14 |     /**
15 |      * The name and signature of the console command.
16 |      *
17 |      * @var string
18 |      */
19 |     protected $signature = 'sajya:docs {route}
20 |                                        {--name=docs.html : Name of the generated documentation}
21 |                                        {--path=/api/ : Path where included documentation files are located}';
22 | 
23 |     /**
24 |      * The console command description.
25 |      *
26 |      * @var string
27 |      */
28 |     protected $description = 'Generate API documentation from annotated procedures';
29 | 
30 |     /**
31 |      * Execute the console command.
32 |      *
33 |      * @throws \Throwable
34 |      *
35 |      * @return int
36 |      */
37 |     public function handle(): int
38 |     {
39 |         $routeName = $this->argument('route');
40 | 
41 |         $route = Route::getRoutes()->getByName($routeName);
42 | 
43 |         if ($route === null) {
44 |             $this->warn("Route '$routeName' not found");
45 | 
46 |             return 1;
47 |         }
48 | 
49 |         $docs = new Docs($route);
50 | 
51 |         $html = view('sajya::docs', [
52 |             'title'      => config('app.name'),
53 |             'uri'        => route($routeName),
54 |             'procedures' => $docs->getAnnotations(),
55 |         ]);
56 | 
57 |         Storage::disk()->put($this->option('path').$this->option('name'), $html->render());
58 |         $this->info('Documentation was generated successfully.');
59 | 
60 |         return Command::SUCCESS;
61 |     }
62 | }
63 | 


--------------------------------------------------------------------------------
/src/Commands/ProcedureMakeCommand.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Sajya\Server\Commands;
 6 | 
 7 | use Illuminate\Console\GeneratorCommand;
 8 | 
 9 | class ProcedureMakeCommand extends GeneratorCommand
10 | {
11 |     /**
12 |      * The console command name.
13 |      *
14 |      * @var string
15 |      */
16 |     protected $name = 'make:procedure';
17 | 
18 |     /**
19 |      * The console command description.
20 |      *
21 |      * @var string
22 |      */
23 |     protected $description = 'Create a new procedure class';
24 | 
25 |     /**
26 |      * The type of class being generated.
27 |      *
28 |      * @var string
29 |      */
30 |     protected $type = 'Procedure';
31 | 
32 |     /**
33 |      * Get the stub file for the generator.
34 |      *
35 |      * @return string
36 |      */
37 |     protected function getStub(): string
38 |     {
39 |         return __DIR__.'/../../stubs/procedure.stub';
40 |     }
41 | 
42 |     /**
43 |      * Get the default namespace for the class.
44 |      *
45 |      * @param string $rootNamespace
46 |      *
47 |      * @return string
48 |      */
49 |     protected function getDefaultNamespace($rootNamespace): string
50 |     {
51 |         return $rootNamespace.'\Http\Procedures';
52 |     }
53 | }
54 | 


--------------------------------------------------------------------------------
/src/Docs.php:
--------------------------------------------------------------------------------
  1 | <?php
  2 | 
  3 | declare(strict_types=1);
  4 | 
  5 | namespace Sajya\Server;
  6 | 
  7 | use Illuminate\Routing\Route;
  8 | use Illuminate\Support\Collection;
  9 | use Illuminate\Support\Str;
 10 | use Illuminate\Support\Stringable;
 11 | use ReflectionClass;
 12 | use ReflectionMethod;
 13 | use Sajya\Server\Annotations\Param;
 14 | use Sajya\Server\Attributes\RpcMethod;
 15 | 
 16 | class Docs
 17 | {
 18 |     /**
 19 |      * @var string[]
 20 |      */
 21 |     protected $procedures;
 22 | 
 23 |     /**
 24 |      * @var string
 25 |      */
 26 |     protected $delimiter;
 27 | 
 28 |     /**
 29 |      * Docs constructor.
 30 |      *
 31 |      * @param Route $route
 32 |      */
 33 |     public function __construct(Route $route)
 34 |     {
 35 |         $this->procedures = $route->defaults['procedures'];
 36 |         $this->delimiter = $route->defaults['delimiter'] ?? '@';
 37 |     }
 38 | 
 39 |     /**
 40 |      * @return \Illuminate\Support\Collection
 41 |      */
 42 |     public function getAnnotations(): Collection
 43 |     {
 44 |         return collect($this->procedures)
 45 |             ->map(function (string $class) {
 46 |                 $reflectionClass = new ReflectionClass($class);
 47 |                 $name = $reflectionClass->getProperty('name')->getValue();
 48 | 
 49 |                 return collect($reflectionClass->getMethods(ReflectionMethod::IS_PUBLIC))
 50 |                     ->map(function (ReflectionMethod $method) use ($name) {
 51 | 
 52 |                         $attributes = $this->getMethodAnnotations($method);
 53 | 
 54 |                         $request = [
 55 |                             'jsonrpc' => '2.0',
 56 |                             'id'      => 1,
 57 |                             'method'  => $name.$this->delimiter.$method->getName(),
 58 |                             'params'  => $attributes?->params,
 59 |                         ];
 60 | 
 61 |                         $response = [
 62 |                             'jsonrpc' => '2.0',
 63 |                             'id'      => 1,
 64 |                             'result'  => $attributes?->result,
 65 |                         ];
 66 | 
 67 |                         return [
 68 |                             'name'        => $name,
 69 |                             'delimiter'   => $this->delimiter,
 70 |                             'method'      => $method->getName(),
 71 |                             'description' => $attributes?->description,
 72 |                             'params'      => $attributes?->params,
 73 |                             'result'      => $attributes?->result,
 74 |                             'request'     => $this->highlight($request),
 75 |                             'response'    => $this->highlight($response),
 76 |                         ];
 77 |                     });
 78 |             })
 79 |             ->flatten(1);
 80 |     }
 81 | 
 82 |     private function getMethodAnnotations(ReflectionMethod $method): ?RpcMethod
 83 |     {
 84 |         $attributes = $method->getAttributes(RpcMethod::class);
 85 | 
 86 |         foreach ($attributes as $attribute) {
 87 |             /** @var RpcMethod $instance */
 88 |             $instance = $attribute->newInstance();
 89 | 
 90 |             return $instance;
 91 |         }
 92 | 
 93 |         return null;
 94 |     }
 95 | 
 96 |     /**
 97 |      * Highlights a JSON structure using HTML span tags with colors.
 98 |      *
 99 |      * @param array $value The JSON data to be highlighted.
100 |      *
101 |      * @throws \JsonException If encoding fails.
102 |      *
103 |      * @return \Illuminate\Support\Stringable The highlighted JSON as a string.
104 |      */
105 |     private function highlight(array $value): Stringable
106 |     {
107 |         $json = json_encode($value, JSON_THROW_ON_ERROR | JSON_PRETTY_PRINT | JSON_UNESCAPED_UNICODE);
108 | 
109 |         return Str::of($json)
110 |             // Highlight keys (both string and numeric)
111 |             ->replaceMatches('/"(\w+)":/i', '"<span style="color:#A0AEC0;">$1</span>":')
112 |             ->replaceMatches('/"(\d+)":/i', '"<span style="color:#A0AEC0;">$1</span>":')
113 | 
114 |             // Highlight null values
115 |             ->replaceMatches('/":\s*(null)/i', '": <span style="color:#F7768E;">$1</span>')
116 | 
117 |             // Highlight string values
118 |             ->replaceMatches('/":\s*"([^"]*)"/', '": "<span style="color:#9ECE6A;">$1</span>"')
119 | 
120 |             // Highlight numeric values
121 |             ->replaceMatches('/":\s*(\d+(\.\d+)?)/', '": <span style="color:#E0AF68;">$1</span>')
122 | 
123 |             // Highlight boolean values (true/false)
124 |             ->replaceMatches('/":\s*(true|false)/i', '": <span style="color:#7AA2F7;">$1</span>')
125 | 
126 |             ->wrap('<pre style="color:rgba(212,212,212,0.75);">', '</pre>');
127 |     }
128 | }
129 | 


--------------------------------------------------------------------------------
/src/Exceptions/InternalErrorException.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Sajya\Server\Exceptions;
 6 | 
 7 | class InternalErrorException extends RpcException
 8 | {
 9 |     /**
10 |      * InternalErrorException constructor.
11 |      *
12 |      * @param null $data
13 |      */
14 |     public function __construct($data = null)
15 |     {
16 |         parent::__construct();
17 | 
18 |         $this->setData($data);
19 |     }
20 | 
21 |     /**
22 |      * Internal JSON-RPC error.
23 |      */
24 |     protected function getDefaultCode(): int
25 |     {
26 |         return -32603;
27 |     }
28 | 
29 |     /**
30 |      * A String providing a short description of the error.
31 |      * The message SHOULD be limited to a concise single sentence.
32 |      */
33 |     protected function getDefaultMessage(): string
34 |     {
35 |         return 'Internal error';
36 |     }
37 | }
38 | 


--------------------------------------------------------------------------------
/src/Exceptions/InvalidParams.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Sajya\Server\Exceptions;
 6 | 
 7 | class InvalidParams extends RpcException
 8 | {
 9 |     /**
10 |      * InvalidParams constructor.
11 |      *
12 |      * @param mixed|null $data
13 |      */
14 |     public function __construct($data = null)
15 |     {
16 |         parent::__construct();
17 | 
18 |         $this->setData($data);
19 |     }
20 | 
21 |     /**
22 |      * Invalid method parameter(s).
23 |      */
24 |     protected function getDefaultCode(): int
25 |     {
26 |         return -32602;
27 |     }
28 | 
29 |     /**
30 |      * A String providing a short description of the error.
31 |      * The message SHOULD be limited to a concise single sentence.
32 |      */
33 |     protected function getDefaultMessage(): string
34 |     {
35 |         return 'Invalid params';
36 |     }
37 | }
38 | 


--------------------------------------------------------------------------------
/src/Exceptions/InvalidRequestException.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Sajya\Server\Exceptions;
 6 | 
 7 | class InvalidRequestException extends RpcException
 8 | {
 9 |     /**
10 |      * InvalidRequestException constructor.
11 |      *
12 |      * @param null $data
13 |      */
14 |     public function __construct($data = null)
15 |     {
16 |         parent::__construct();
17 | 
18 |         $this->setData($data);
19 |     }
20 | 
21 |     /**
22 |      * The JSON sent is not a valid Request object.
23 |      */
24 |     protected function getDefaultCode(): int
25 |     {
26 |         return -32600;
27 |     }
28 | 
29 |     /**
30 |      * A String providing a short description of the error.
31 |      * The message SHOULD be limited to a concise single sentence.
32 |      */
33 |     protected function getDefaultMessage(): string
34 |     {
35 |         return 'Invalid Request';
36 |     }
37 | }
38 | 


--------------------------------------------------------------------------------
/src/Exceptions/MaxBatchSizeExceededException.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Sajya\Server\Exceptions;
 6 | 
 7 | class MaxBatchSizeExceededException extends RpcException
 8 | {
 9 |     /**
10 |      * MaxBatchSizeExceededException constructor.
11 |      *
12 |      * @param null $data
13 |      */
14 |     public function __construct($data = null)
15 |     {
16 |         parent::__construct();
17 | 
18 |         $this->setData($data);
19 |     }
20 | 
21 |     /**
22 |      * Retrieve the error code.
23 |      */
24 |     protected function getDefaultCode(): int
25 |     {
26 |         return -32000;
27 |     }
28 | 
29 |     /**
30 |      * Retrieve the error message.
31 |      */
32 |     protected function getDefaultMessage(): string
33 |     {
34 |         return 'Maximum batch size exceeded.';
35 |     }
36 | }
37 | 


--------------------------------------------------------------------------------
/src/Exceptions/MethodNotFound.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Sajya\Server\Exceptions;
 6 | 
 7 | class MethodNotFound extends RpcException
 8 | {
 9 |     /**
10 |      * MethodNotFound constructor.
11 |      *
12 |      * @param null $data
13 |      */
14 |     public function __construct($data = null)
15 |     {
16 |         parent::__construct();
17 | 
18 |         $this->setData($data);
19 |     }
20 | 
21 |     /**
22 |      * The method does not exist / is not available.
23 |      */
24 |     protected function getDefaultCode(): int
25 |     {
26 |         return -32601;
27 |     }
28 | 
29 |     /**
30 |      * A String providing a short description of the error.
31 |      * The message SHOULD be limited to a concise single sentence.
32 |      */
33 |     protected function getDefaultMessage(): string
34 |     {
35 |         return 'Method not found';
36 |     }
37 | }
38 | 


--------------------------------------------------------------------------------
/src/Exceptions/ParseErrorException.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Sajya\Server\Exceptions;
 6 | 
 7 | class ParseErrorException extends RpcException
 8 | {
 9 |     /**
10 |      * ParseErrorException constructor.
11 |      *
12 |      * @param null $data
13 |      */
14 |     public function __construct($data = null)
15 |     {
16 |         parent::__construct();
17 | 
18 |         $this->setData($data);
19 |     }
20 | 
21 |     /**
22 |      * Invalid JSON was received by the server.
23 |      * An error occurred on the server while parsing the JSON text.
24 |      */
25 |     protected function getDefaultCode(): int
26 |     {
27 |         return -32700;
28 |     }
29 | 
30 |     /**
31 |      * A String providing a short description of the error.
32 |      * The message SHOULD be limited to a concise single sentence.
33 |      */
34 |     protected function getDefaultMessage(): string
35 |     {
36 |         return 'Parse error';
37 |     }
38 | }
39 | 


--------------------------------------------------------------------------------
/src/Exceptions/RpcException.php:
--------------------------------------------------------------------------------
  1 | <?php
  2 | 
  3 | declare(strict_types=1);
  4 | 
  5 | namespace Sajya\Server\Exceptions;
  6 | 
  7 | use JsonSerializable;
  8 | use RuntimeException;
  9 | 
 10 | abstract class RpcException extends RuntimeException implements JsonSerializable
 11 | {
 12 |     /**
 13 |      * The value of this member is defined by the Server
 14 |      * (e.g. detailed error information, nested errors etc.).
 15 |      */
 16 |     protected $data;
 17 | 
 18 |     /**
 19 |      * RpcException constructor.
 20 |      *
 21 |      * @param string|null           $message
 22 |      * @param int|null              $code
 23 |      * @param RuntimeException|null $previous
 24 |      */
 25 |     public function __construct(?string $message = null, ?int $code = null, ?RuntimeException $previous = null)
 26 |     {
 27 |         parent::__construct(
 28 |             $message ?? $this->getDefaultMessage(),
 29 |             $code ?? $this->getDefaultCode(),
 30 |             $previous
 31 |         );
 32 |     }
 33 | 
 34 |     /**
 35 |      * A String providing a short description of the error.
 36 |      * The message SHOULD be limited to a concise single sentence.
 37 |      *
 38 |      * @return string
 39 |      */
 40 |     abstract protected function getDefaultMessage(): string;
 41 | 
 42 |     /**
 43 |      * A Number that indicates the error type that occurred.
 44 |      * This MUST be an integer.
 45 |      *
 46 |      * @return int
 47 |      */
 48 |     abstract protected function getDefaultCode(): int;
 49 | 
 50 |     /**
 51 |      * A Primitive or Structured value that contains additional information about the error.
 52 |      * This may be omitted.
 53 |      */
 54 |     public function getData()
 55 |     {
 56 |         return $this->data;
 57 |     }
 58 | 
 59 |     /**
 60 |      * @param mixed|null $data
 61 |      *
 62 |      * @return $this
 63 |      */
 64 |     public function setData($data = null): RpcException
 65 |     {
 66 |         $this->data = $data;
 67 | 
 68 |         return $this;
 69 |     }
 70 | 
 71 |     /**
 72 |      * @return array{code:int, message:?string, data:?array}
 73 |      */
 74 |     public function jsonSerialize(): array
 75 |     {
 76 |         $message = [
 77 |             'code'    => $this->getCode(),
 78 |             'message' => $this->getMessage(),
 79 |             'data'    => $this->getData(),
 80 |         ];
 81 | 
 82 |         if (config('app.debug', false)) {
 83 |             $message = array_merge($message, [
 84 |                 'file'  => $this->getFile(),
 85 |                 'line'  => $this->getLine(),
 86 |                 'trace' => $this->getTraceAsString(),
 87 |             ]);
 88 |         }
 89 | 
 90 |         return $message;
 91 |     }
 92 | 
 93 |     /**
 94 |      * Report the exception.
 95 |      *
 96 |      * @return bool|null
 97 |      */
 98 |     public function report(): ?bool
 99 |     {
100 |         return true;
101 |     }
102 | }
103 | 


--------------------------------------------------------------------------------
/src/Exceptions/RuntimeRpcException.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Sajya\Server\Exceptions;
 6 | 
 7 | namespace Sajya\Server\Exceptions;
 8 | 
 9 | class RuntimeRpcException extends RpcException
10 | {
11 |     /**
12 |      * @return string
13 |      */
14 |     protected function getDefaultMessage(): string
15 |     {
16 |         return 'Unknown';
17 |     }
18 | 
19 |     /**
20 |      * @return int
21 |      */
22 |     protected function getDefaultCode(): int
23 |     {
24 |         return -1;
25 |     }
26 | }
27 | 


--------------------------------------------------------------------------------
/src/Facades/RPC.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Sajya\Server\Facades;
 6 | 
 7 | use Closure;
 8 | use Illuminate\Support\Collection;
 9 | use Illuminate\Support\Facades\Facade;
10 | use Sajya\Server\Binding;
11 | 
12 | /**
13 |  * Class RPC
14 |  *
15 |  * @method static void  bind(string $key, string|callable $binder)
16 |  * @method static void  model(string $key, string $class, Closure|null $callback = null)
17 |  * @method static array bindResolve(string $procedure, Collection $params)
18 |  *
19 |  * @see \Sajya\Server\Binding
20 |  */
21 | class RPC extends Facade
22 | {
23 |     /**
24 |      * Initiate a mock expectation on the facade.
25 |      *
26 |      * @return string
27 |      */
28 |     protected static function getFacadeAccessor(): string
29 |     {
30 |         return Binding::class;
31 |     }
32 | }
33 | 


--------------------------------------------------------------------------------
/src/HandleProcedure.php:
--------------------------------------------------------------------------------
  1 | <?php
  2 | 
  3 | declare(strict_types=1);
  4 | 
  5 | namespace Sajya\Server;
  6 | 
  7 | use Illuminate\Bus\Queueable;
  8 | use Illuminate\Contracts\Queue\ShouldQueue;
  9 | use Illuminate\Foundation\Bus\Dispatchable;
 10 | use Illuminate\Queue\InteractsWithQueue;
 11 | use Illuminate\Queue\SerializesModels;
 12 | use Illuminate\Support\Facades\App;
 13 | use Illuminate\Validation\ValidationException;
 14 | use Sajya\Server\Exceptions\InternalErrorException;
 15 | use Sajya\Server\Exceptions\InvalidParams;
 16 | use Sajya\Server\Exceptions\RpcException;
 17 | use Sajya\Server\Exceptions\RuntimeRpcException;
 18 | use Sajya\Server\Facades\RPC;
 19 | use Sajya\Server\Http\Request;
 20 | use Throwable;
 21 | 
 22 | class HandleProcedure implements ShouldQueue
 23 | {
 24 |     use Dispatchable, InteractsWithQueue, Queueable, SerializesModels;
 25 | 
 26 |     /**
 27 |      * Name of the procedure.
 28 |      *
 29 |      * @var string
 30 |      */
 31 |     protected string $procedure;
 32 | 
 33 |     /**
 34 |      * Request instance.
 35 |      *
 36 |      * @var Request
 37 |      */
 38 |     protected $request;
 39 | 
 40 |     /**
 41 |      * Create a new job instance.
 42 |      *
 43 |      * @param string  $procedure
 44 |      * @param Request $request
 45 |      */
 46 |     public function __construct(string $procedure, Request $request)
 47 |     {
 48 |         $this->procedure = $procedure;
 49 |         $this->request = $request;
 50 |     }
 51 | 
 52 |     /**
 53 |      * Execute the job.
 54 |      */
 55 |     public function handle()
 56 |     {
 57 |         try {
 58 |             $parameters = RPC::bindResolve($this->procedure, $this->request->getParams());
 59 | 
 60 |             return App::call($this->procedure, $parameters);
 61 |         } catch (Throwable $exception) {
 62 |             return $this->handleException($exception);
 63 |         }
 64 |     }
 65 | 
 66 |     /**
 67 |      * Handle the exception into JSON-RPC.
 68 |      *
 69 |      * @param Throwable $exception
 70 |      *
 71 |      * @return string|RpcException|\Illuminate\Http\Response
 72 |      */
 73 |     protected function handleException(Throwable $exception)
 74 |     {
 75 |         report($exception);
 76 | 
 77 |         if ($exception instanceof ValidationException) {
 78 |             return new InvalidParams($exception->validator->errors()->toArray());
 79 |         }
 80 | 
 81 |         if ($exception instanceof RpcException) {
 82 |             return $exception;
 83 |         }
 84 | 
 85 |         $code = method_exists($exception, 'getStatusCode')
 86 |             ? $exception->getStatusCode()
 87 |             : $exception->getCode();
 88 | 
 89 |         if ($code === 500) {
 90 |             return new InternalErrorException;
 91 |         }
 92 | 
 93 |         if (! is_int($code)) {
 94 |             $code = -1;
 95 |         }
 96 | 
 97 |         return new RuntimeRpcException($exception->getMessage(), $code);
 98 |     }
 99 | }
100 | 


--------------------------------------------------------------------------------
/src/Http/Parser.php:
--------------------------------------------------------------------------------
  1 | <?php
  2 | 
  3 | declare(strict_types=1);
  4 | 
  5 | namespace Sajya\Server\Http;
  6 | 
  7 | use Exception;
  8 | use Illuminate\Support\Arr;
  9 | use Illuminate\Support\Collection;
 10 | use Illuminate\Support\Facades\Validator;
 11 | use Sajya\Server\Exceptions\InvalidParams;
 12 | use Sajya\Server\Exceptions\InvalidRequestException;
 13 | use Sajya\Server\Exceptions\ParseErrorException;
 14 | use Sajya\Server\Rules\Identifier;
 15 | use TypeError;
 16 | 
 17 | class Parser
 18 | {
 19 |     /**
 20 |      * Flag indicating a parse error.
 21 |      */
 22 |     protected bool $isParseError = false;
 23 | 
 24 |     /**
 25 |      * Raw content.
 26 |      */
 27 |     protected string $content;
 28 | 
 29 |     /**
 30 |      * Extract content.
 31 |      */
 32 |     protected Collection $decode;
 33 | 
 34 |     /**
 35 |      * Indicates whether the content is a batch request.
 36 |      *
 37 |      * @var bool
 38 |      */
 39 |     protected bool $batching = false;
 40 | 
 41 |     /**
 42 |      * Indicates whether the content is a notification request.
 43 |      *
 44 |      * @var bool
 45 |      */
 46 |     protected bool $notification = false;
 47 | 
 48 |     /**
 49 |      * Parser constructor.
 50 |      *
 51 |      * @param string $content
 52 |      */
 53 |     public function __construct(string $content = '')
 54 |     {
 55 |         $this->content = $content;
 56 | 
 57 |         try {
 58 |             $decode = json_decode($content, true, 512, JSON_THROW_ON_ERROR);
 59 | 
 60 |             $this->decode = collect($decode);
 61 |             $this->batching = $this->decode->isNotEmpty() && Arr::isList($this->decode->toArray());
 62 | 
 63 |             $emptyIdRequest = $this->decode
 64 |                 ->when(! $this->batching, fn ($request) => collect([$request]))
 65 |                 ->first(fn ($value) => ! isset($value['id']));
 66 | 
 67 |             $this->notification = $emptyIdRequest !== null;
 68 |         } catch (Exception|TypeError $e) {
 69 |             $this->decode = collect();
 70 |             $this->isParseError = true;
 71 |         }
 72 |     }
 73 | 
 74 |     /**
 75 |      * Check if the response is an error.
 76 |      *
 77 |      * @return bool
 78 |      */
 79 |     public function isError(): bool
 80 |     {
 81 |         return $this->isParseError;
 82 |     }
 83 | 
 84 |     /**
 85 |      * @return Collection
 86 |      */
 87 |     public function getContent(): Collection
 88 |     {
 89 |         return $this->decode;
 90 |     }
 91 | 
 92 |     /**
 93 |      * @return Request[]|Exception[]
 94 |      */
 95 |     public function makeRequests(): array
 96 |     {
 97 |         $content = $this->getContent();
 98 | 
 99 |         if ($this->isBatch()) {
100 |             return $content
101 |                 ->map(fn ($options) => $this->checkValidation($options))
102 |                 ->whenEmpty(fn (Collection $collection) => $collection->push($this->checkValidation()))
103 |                 ->map(fn ($options) => $options instanceof Exception ? $options : Request::loadArray($options))
104 |                 ->toArray();
105 |         }
106 | 
107 |         $options = $this->checkValidation($content->toArray());
108 | 
109 |         return [is_array($options) ? Request::loadArray($options) : $options];
110 |     }
111 | 
112 |     /**
113 |      * Determine whether the current request is a batch request.
114 |      *
115 |      * @return bool
116 |      */
117 |     public function isBatch(): bool
118 |     {
119 |         return $this->batching;
120 |     }
121 | 
122 |     /**
123 |      * Determine whether the current request is a notification request.
124 |      *
125 |      * @return bool
126 |      */
127 |     public function isNotification(): bool
128 |     {
129 |         return $this->notification;
130 |     }
131 | 
132 |     /**
133 |      * Count the number of requests in a batch request.
134 |      *
135 |      * @return int
136 |      */
137 |     public function countBatchingRequests(): int
138 |     {
139 |         return $this->getContent()->count();
140 |     }
141 | 
142 |     /**
143 |      * @param bool|string|array|int $options
144 |      *
145 |      * @return InvalidParams|ParseErrorException|InvalidRequestException|array
146 |      */
147 |     public function checkValidation($options = [])
148 |     {
149 |         if ($this->isError()) {
150 |             return new ParseErrorException;
151 |         }
152 | 
153 |         if (! is_array($options) || Arr::isList($options)) {
154 |             return new InvalidRequestException;
155 |         }
156 | 
157 |         $data = $options;
158 | 
159 |         // skip deep parameters for validator
160 |         if (isset($options['params']) && is_array($options['params'])) {
161 |             $data['params'] = [];
162 |         }
163 | 
164 |         $validation = Validator::make($data, self::rules());
165 | 
166 |         return $validation->fails()
167 |             ? new InvalidParams($validation->errors()->toArray())
168 |             : $options;
169 |     }
170 | 
171 |     /**
172 |      * Defines the rules for validating a JSON-RPC 2.0 request.
173 |      *
174 |      * @return array
175 |      */
176 |     public static function rules(): array
177 |     {
178 |         return [
179 |             'jsonrpc' => 'required|in:"2.0"',
180 |             'method'  => 'required|string',
181 |             'params'  => 'array',
182 |             'id'      => new Identifier,
183 |         ];
184 |     }
185 | }
186 | 


--------------------------------------------------------------------------------
/src/Http/Request.php:
--------------------------------------------------------------------------------
  1 | <?php
  2 | 
  3 | declare(strict_types=1);
  4 | 
  5 | namespace Sajya\Server\Http;
  6 | 
  7 | use Illuminate\Support\Collection;
  8 | use Illuminate\Support\Str;
  9 | use JsonSerializable;
 10 | 
 11 | class Request implements JsonSerializable
 12 | {
 13 |     /**
 14 |      * Request ID.
 15 |      */
 16 |     protected $id;
 17 | 
 18 |     /**
 19 |      * Requested method.
 20 |      *
 21 |      * @var string|null
 22 |      */
 23 |     protected ?string $method;
 24 | 
 25 |     /**
 26 |      * Request parameters.
 27 |      *
 28 |      * @var Collection
 29 |      */
 30 |     protected Collection $params;
 31 | 
 32 |     /**
 33 |      * JSON-RPC version of request.
 34 |      *
 35 |      * @var string
 36 |      */
 37 |     protected string $version = '2.0';
 38 | 
 39 |     /**
 40 |      * Request constructor.
 41 |      */
 42 |     public function __construct()
 43 |     {
 44 |         $this->params = collect();
 45 |     }
 46 | 
 47 |     /**
 48 |      * Set request state based on array.
 49 |      *
 50 |      * @param array $collection
 51 |      *
 52 |      * @return Request
 53 |      */
 54 |     public static function loadArray(array $collection): Request
 55 |     {
 56 |         $request = new static;
 57 |         $methods = get_class_methods($request);
 58 | 
 59 |         collect($collection)
 60 |             ->each(static function ($value, string $key) use ($request, $methods) {
 61 |                 $method = Str::start(ucfirst($key), 'set');
 62 | 
 63 |                 if (in_array($method, $methods, true)) {
 64 |                     $request->$method($value);
 65 |                 }
 66 | 
 67 |                 if ($key === 'jsonrpc') {
 68 |                     $request->setVersion($value);
 69 |                 }
 70 |             });
 71 | 
 72 |         return $request;
 73 |     }
 74 | 
 75 |     /**
 76 |      * @return array
 77 |      */
 78 |     public function jsonSerialize(): array
 79 |     {
 80 |         $jsonArray = [
 81 |             'jsonrpc' => $this->getVersion(),
 82 |             'method'  => $this->getMethod(),
 83 |         ];
 84 | 
 85 |         if ($this->getParams()->isNotEmpty()) {
 86 |             $jsonArray['params'] = $this->getParams()->toArray();
 87 |         }
 88 | 
 89 |         if (null !== ($id = $this->getId())) {
 90 |             $jsonArray['id'] = $id;
 91 |         }
 92 | 
 93 |         return $jsonArray;
 94 |     }
 95 | 
 96 |     /**
 97 |      * Retrieve JSON-RPC version.
 98 |      *
 99 |      * @return string
100 |      */
101 |     public function getVersion(): string
102 |     {
103 |         return $this->version;
104 |     }
105 | 
106 |     /**
107 |      * Set JSON-RPC version.
108 |      *
109 |      * @param string $version
110 |      *
111 |      * @return Request
112 |      */
113 |     public function setVersion(string $version = '2.0'): Request
114 |     {
115 |         $this->version = $version;
116 | 
117 |         return $this;
118 |     }
119 | 
120 |     /**
121 |      * Get request method name.
122 |      *
123 |      * @return string|null
124 |      */
125 |     public function getMethod(): ?string
126 |     {
127 |         return $this->method;
128 |     }
129 | 
130 |     /**
131 |      * Set request method.
132 |      *
133 |      * @param string $name
134 |      *
135 |      * @return Request
136 |      */
137 |     public function setMethod(string $name): Request
138 |     {
139 |         $this->method = $name;
140 | 
141 |         return $this;
142 |     }
143 | 
144 |     /**
145 |      * Retrieve parameters.
146 |      *
147 |      * @return Collection
148 |      */
149 |     public function getParams(): Collection
150 |     {
151 |         return $this->params;
152 |     }
153 | 
154 |     /**
155 |      * Overwrite params.
156 |      *
157 |      * @param array $params
158 |      *
159 |      * @return Request
160 |      */
161 |     public function setParams(array $params): self
162 |     {
163 |         $this->params = $this->params->merge($params);
164 | 
165 |         return $this;
166 |     }
167 | 
168 |     /**
169 |      * Retrieve request identifier.
170 |      *
171 |      * @return string|null|int
172 |      */
173 |     public function getId()
174 |     {
175 |         return $this->id;
176 |     }
177 | 
178 |     /**
179 |      * Set request identifier.
180 |      *
181 |      * @param int|string $name
182 |      *
183 |      * @return Request
184 |      */
185 |     public function setId($name): Request
186 |     {
187 |         $this->id = (string) $name;
188 | 
189 |         return $this;
190 |     }
191 | 
192 |     /**
193 |      * @return bool
194 |      */
195 |     public function isNotification(): bool
196 |     {
197 |         return empty($this->getId());
198 |     }
199 | }
200 | 


--------------------------------------------------------------------------------
/src/Http/Response.php:
--------------------------------------------------------------------------------
  1 | <?php
  2 | 
  3 | declare(strict_types=1);
  4 | 
  5 | namespace Sajya\Server\Http;
  6 | 
  7 | use Exception;
  8 | use JsonSerializable;
  9 | 
 10 | class Response implements JsonSerializable
 11 | {
 12 |     /**
 13 |      * Response error.
 14 |      *
 15 |      * @var null|Exception
 16 |      */
 17 |     protected $error;
 18 | 
 19 |     /**
 20 |      * Request ID.
 21 |      *
 22 |      * @var string|int|null
 23 |      */
 24 |     protected $id;
 25 | 
 26 |     /**
 27 |      * Result.
 28 |      */
 29 |     protected $result;
 30 | 
 31 |     /**
 32 |      * JSON-RPC version.
 33 |      */
 34 |     protected ?string $version;
 35 | 
 36 |     /**
 37 |      * Make Response instance based on result and request.
 38 |      */
 39 |     public static function makeFromResult($result, ?Request $request = null): self
 40 |     {
 41 |         $request ??= new Request;
 42 | 
 43 |         return tap(
 44 |             new self,
 45 |             fn (Response $response) => $response->setId($request->getId())
 46 |                 ->setVersion($request->getVersion())
 47 |                 ->setResult($result)
 48 |         );
 49 |     }
 50 | 
 51 |     public function jsonSerialize(): array
 52 |     {
 53 |         $response = ['id' => $this->getId()];
 54 | 
 55 |         if ($this->isError()) {
 56 |             $response['error'] = $this->getError();
 57 |         } else {
 58 |             $response['result'] = $this->getResult();
 59 |         }
 60 | 
 61 |         if (null !== ($version = $this->getVersion())) {
 62 |             $response['jsonrpc'] = $version;
 63 |         }
 64 | 
 65 |         return $response;
 66 |     }
 67 | 
 68 |     /**
 69 |      * Get request ID.
 70 |      *
 71 |      * @return string|int|null
 72 |      */
 73 |     public function getId()
 74 |     {
 75 |         return $this->id;
 76 |     }
 77 | 
 78 |     /**
 79 |      * Set request ID.
 80 |      *
 81 |      * @param string|int|null $name
 82 |      */
 83 |     public function setId($name): self
 84 |     {
 85 |         $this->id = $name;
 86 | 
 87 |         return $this;
 88 |     }
 89 | 
 90 |     /**
 91 |      * Is the response an error?
 92 |      */
 93 |     public function isError(): bool
 94 |     {
 95 |         return $this->getError() instanceof Exception;
 96 |     }
 97 | 
 98 |     /**
 99 |      * Get response error.
100 |      */
101 |     public function getError(): ?Exception
102 |     {
103 |         return $this->error;
104 |     }
105 | 
106 |     /**
107 |      * Get result.
108 |      */
109 |     public function getResult()
110 |     {
111 |         return $this->result;
112 |     }
113 | 
114 |     /**
115 |      * Set result.
116 |      */
117 |     public function setResult($value): self
118 |     {
119 |         if ($value instanceof Exception) {
120 |             $this->setError($value);
121 | 
122 |             return $this;
123 |         }
124 | 
125 |         $this->result = $value;
126 | 
127 |         return $this;
128 |     }
129 | 
130 |     /**
131 |      * Retrieve JSON-RPC version.
132 |      */
133 |     public function getVersion(): ?string
134 |     {
135 |         return $this->version;
136 |     }
137 | 
138 |     /**
139 |      * Set JSON-RPC version.
140 |      */
141 |     public function setVersion(string $version): self
142 |     {
143 |         $this->version = $version;
144 | 
145 |         return $this;
146 |     }
147 | 
148 |     /**
149 |      * Set result error.
150 |      *
151 |      * RPC error, if response results in fault.
152 |      */
153 |     public function setError(?Exception $error = null): Response
154 |     {
155 |         $this->error = $error;
156 | 
157 |         return $this;
158 |     }
159 | 
160 |     public function isNotification(): bool
161 |     {
162 |         return empty($this->getId()) && $this->getError() === null;
163 |     }
164 | }
165 | 


--------------------------------------------------------------------------------
/src/JsonRpcController.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Sajya\Server;
 6 | 
 7 | use Illuminate\Http\JsonResponse;
 8 | use Illuminate\Http\Request;
 9 | 
10 | class JsonRpcController
11 | {
12 |     /**
13 |      * @var App|null
14 |      */
15 |     protected ?App $guide;
16 | 
17 |     /**
18 |      * Invoke the controller method.
19 |      *
20 |      * @param Request     $request
21 |      * @param string[]    $procedures
22 |      * @param null|string $delimiter
23 |      *
24 |      * @return JsonResponse
25 |      */
26 |     public function __invoke(Request $request, array $procedures, ?string $delimiter = null): JsonResponse
27 |     {
28 |         $application = new App($procedures, $delimiter);
29 | 
30 |         $response = $application->handle($request->getContent());
31 | 
32 |         return response()->json($response, 200, [], config('sajya.encode_options', 0));
33 |     }
34 | }
35 | 


--------------------------------------------------------------------------------
/src/Middleware/GzipCompress.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Sajya\Server\Middleware;
 6 | 
 7 | use Closure;
 8 | use Illuminate\Http\JsonResponse;
 9 | use Illuminate\Http\Request;
10 | 
11 | class GzipCompress
12 | {
13 |     /**
14 |      * Handle an incoming request.
15 |      */
16 |     public function handle(Request $request, Closure $next, int $compress = 6)
17 |     {
18 |         $response = $next($request);
19 | 
20 |         return in_array('gzip', $request->getEncodings(), true)
21 |             ? $this->compress($response, $compress)
22 |             : $response;
23 |     }
24 | 
25 |     /**
26 |      * Compresses the content of the given response using gzip compression.
27 |      *
28 |      * @param JsonResponse $response
29 |      *
30 |      * @return \Illuminate\Http\JsonResponse
31 |      */
32 |     protected function compress($response, int $compress)
33 |     {
34 |         $content = gzencode($response->content(), $compress);
35 | 
36 |         return $response->setContent($content)->withHeaders([
37 |             'Content-Encoding' => 'gzip',
38 |         ]);
39 |     }
40 | }
41 | 


--------------------------------------------------------------------------------
/src/Procedure.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Sajya\Server;
 6 | 
 7 | abstract class Procedure
 8 | {
 9 |     /**
10 |      * The name of the procedure that will be
11 |      * displayed and taken into account in the search.
12 |      *
13 |      * Must be unique.
14 |      *
15 |      * @var string
16 |      */
17 |     public static string $name;
18 | }
19 | 


--------------------------------------------------------------------------------
/src/Proxy.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Sajya\Server;
 6 | 
 7 | use Sajya\Server\Http\Request;
 8 | 
 9 | interface Proxy
10 | {
11 |     /**
12 |      * The method used by request handlers.
13 |      *
14 |      * @param \Sajya\Server\Http\Request $request
15 |      *
16 |      * @return mixed
17 |      */
18 |     public function __invoke(Request $request): mixed;
19 | }
20 | 


--------------------------------------------------------------------------------
/src/Rules/Identifier.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Sajya\Server\Rules;
 6 | 
 7 | use Illuminate\Contracts\Validation\Rule;
 8 | 
 9 | class Identifier implements Rule
10 | {
11 |     /**
12 |      * Determine if the validation rule passes.
13 |      *
14 |      * @param string $attribute
15 |      */
16 |     public function passes($attribute, $value): bool
17 |     {
18 |         return is_numeric($value) || is_string($value) || $value === null;
19 |     }
20 | 
21 |     /**
22 |      * Get the validation error message.
23 |      */
24 |     public function message(): string
25 |     {
26 |         return 'The :attribute must be a string or integer.';
27 |     }
28 | }
29 | 


--------------------------------------------------------------------------------
/src/ServerServiceProvider.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Sajya\Server;
 6 | 
 7 | use Illuminate\Support\Facades\Route;
 8 | use Illuminate\Support\ServiceProvider;
 9 | use Sajya\Server\Commands\DocsCommand;
10 | use Sajya\Server\Commands\ProcedureMakeCommand;
11 | 
12 | class ServerServiceProvider extends ServiceProvider
13 | {
14 |     /**
15 |      * The available command shortname.
16 |      *
17 |      * @var string[]
18 |      */
19 |     protected array $commands = [
20 |         ProcedureMakeCommand::class,
21 |         DocsCommand::class,
22 |     ];
23 | 
24 |     /**
25 |      * Boot the application events.
26 |      */
27 |     public function boot(): void
28 |     {
29 |         $this->publishes([
30 |             __DIR__.'/../config/sajya.php' => config_path('sajya.php'),
31 |         ]);
32 | 
33 |         $this->registerViews();
34 |     }
35 | 
36 |     /**
37 |      * Register the application services.
38 |      */
39 |     public function register(): void
40 |     {
41 |         $this->commands($this->commands);
42 | 
43 |         $this->mergeConfigFrom(
44 |             __DIR__.'/../config/sajya.php', 'sajya'
45 |         );
46 | 
47 |         Route::macro('rpc', fn (string $uri, array $procedures = [], ?string $delimiter = null) => Route::post($uri, [JsonRpcController::class, '__invoke'])
48 |             ->setDefaults([
49 |                 'procedures' => $procedures,
50 |                 'delimiter'  => $delimiter,
51 |             ]));
52 | 
53 |         $this->app->singleton(Binding::class, fn ($container) => new Binding($container));
54 |     }
55 | 
56 |     /**
57 |      * Register views & Publish views.
58 |      *
59 |      * @return $this
60 |      */
61 |     public function registerViews(): self
62 |     {
63 |         $path = __DIR__.'/../views';
64 | 
65 |         $this->loadViewsFrom($path, 'sajya');
66 | 
67 |         $this->publishes([
68 |             $path => resource_path('views/vendor/sajya'),
69 |         ], 'views');
70 | 
71 |         return $this;
72 |     }
73 | }
74 | 


--------------------------------------------------------------------------------
/src/Testing/ProceduralRequests.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Sajya\Server\Testing;
 6 | 
 7 | use Illuminate\Testing\TestResponse;
 8 | 
 9 | trait ProceduralRequests
10 | {
11 |     /**
12 |      * URL to which procedure requests will be sent
13 |      *
14 |      * @var string|null
15 |      */
16 |     protected ?string $rpcEndpoint;
17 | 
18 |     /**
19 |      * @param string $name
20 |      *
21 |      * @return $this
22 |      */
23 |     public function setRpcRoute(string $name)
24 |     {
25 |         $this->rpcEndpoint = route($name);
26 | 
27 |         return $this;
28 |     }
29 | 
30 |     /**
31 |      * @param string $url
32 |      *
33 |      * @return $this
34 |      */
35 |     public function setRpcUrl(string $url)
36 |     {
37 |         $this->rpcEndpoint = $url;
38 | 
39 |         return $this;
40 |     }
41 | 
42 |     /**
43 |      * Call the given method procedure and return the Response.
44 |      *
45 |      * @param string          $method
46 |      * @param array           $content
47 |      * @param string|int|null $id
48 |      *
49 |      * @return \Illuminate\Testing\TestResponse
50 |      */
51 |     public function callProcedure(string $method, array $content = [], $id = 1): TestResponse
52 |     {
53 |         return $this
54 |             ->callHttpProcedure($method, $content, $id)
55 |             ->assertOk()
56 |             ->assertHeader('content-type', 'application/json');
57 |     }
58 | 
59 |     /**
60 |      * @param string          $method
61 |      * @param array           $content
62 |      * @param string|int|null $id
63 |      *
64 |      * @return \Illuminate\Testing\TestResponse
65 |      */
66 |     public function callHttpProcedure(string $method, array $content = [], $id = 1): TestResponse
67 |     {
68 |         return $this->json('POST', $this->rpcEndpoint, [
69 |             'jsonrpc' => '2.0',
70 |             'id'      => $id,
71 |             'method'  => $method,
72 |             'params'  => $content,
73 |         ]);
74 |     }
75 | }
76 | 


--------------------------------------------------------------------------------
/stubs/procedure.stub:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace {{ namespace }};
 6 | 
 7 | use Sajya\Server\Procedure;
 8 | use Illuminate\Http\Request;
 9 | 
10 | class {{ class }} extends Procedure
11 | {
12 |     /**
13 |      * The name of the procedure that is used for referencing.
14 |      *
15 |      * @var string
16 |      */
17 |     public static string $name = '{{ class }}';
18 | 
19 |     /**
20 |      * Execute the procedure.
21 |      *
22 |      * @param Request $request
23 |      *
24 |      * @return mixed
25 |      */
26 |     public function handle(Request $request)
27 |     {
28 |         // write your code
29 |     }
30 | }
31 | 


--------------------------------------------------------------------------------
/views/docs.blade.php:
--------------------------------------------------------------------------------
 1 | <!doctype html>
 2 | <html lang="en">
 3 | <head>
 4 |     <!-- Required meta tags -->
 5 |     <meta charset="utf-8">
 6 |     <meta name="viewport" content="width=device-width, initial-scale=1">
 7 | 
 8 |     <!-- Bootstrap CSS -->
 9 |     <link href="https://cdn.jsdelivr.net/npm/bootstrap@5.2.2/dist/css/bootstrap.min.css" rel="stylesheet"
10 |           integrity="sha384-Zenh87qX5JnK2Jl0vWa8Ck2rdkQ2Bzep5IDxbcnCeuOxjzrPF/et3URy9Bv1WTRi" crossorigin="anonymous">
11 | 
12 |     <title>{{ $title }} - JSON-RPC Documentation</title>
13 |     <meta name="description" content="JSON-RPC Documentation">
14 |     <link rel="icon" type="image/png" sizes="32x32" href="https://sajya.github.io/favicon-32x32.png">
15 |     <meta name="robots" content="noindex">
16 | 
17 |     <style>
18 |         ul {
19 |             list-style: circle;
20 |         }
21 | 
22 |         code {
23 |             display: block;
24 |             background: rgb(37 42 55);
25 |             padding: 0.5em;
26 |         }
27 |     </style>
28 | 
29 | </head>
30 | <body>
31 | 
32 | <div class="container">
33 | <div class="col-lg-11 mx-auto pt-3 pt-md-5">
34 |     <header class="row d-flex align-items-center pb-md-3 mb-4 mb-md-5 border-bottom">
35 |         <span class="col d-flex align-items-center text-dark text-decoration-none me-auto user-select-none gap-2">
36 |             <svg fill="currentColor" width="2.5em" height="2.5em" xmlns="http://www.w3.org/2000/svg"
37 |                  viewBox="231 232 276.5 275.49">
38 |                 <path
39 |                     d="M504.07 328.344H391.678C388.889 328.344 387.237 325.261 388.779 322.949L444.938 237.395C446.443 235.083 444.791 232 442.038 232H347.485C346.31 232 345.209 232.587 344.585 233.578L231.57 405.75C230.065 408.063 231.717 411.145 234.469 411.145H278.589V411.256H328.765H346.751C349.504 411.256 351.192 414.339 349.651 416.651L293.565 502.095C292.06 504.407 293.712 507.49 296.465 507.49H391.018C392.192 507.49 393.293 506.903 393.917 505.912L506.933 333.74C508.438 331.427 506.786 328.344 504.033 328.344H504.07ZM481.276 347.613L386.503 492.038C385.842 493.029 384.778 493.616 383.603 493.616H322.269C319.479 493.616 317.827 490.533 319.369 488.221L368.848 412.834C369.508 411.843 370.573 411.256 371.747 411.256H401.222C403.828 415.99 408.82 419.257 414.619 419.257C423.098 419.257 429.925 412.393 429.925 403.952C429.925 395.51 423.061 388.647 414.619 388.647C408.526 388.647 403.277 392.244 400.818 397.419H378.978H292.501V397.309H260.2C257.41 397.309 255.758 394.226 257.3 391.913L352.073 247.489C352.734 246.498 353.798 245.91 354.973 245.91H416.307C419.097 245.91 420.749 248.993 419.207 251.306L369.655 326.803C368.994 327.794 367.93 328.381 366.755 328.381H337.942C335.446 323.353 330.27 319.866 324.287 319.866C315.808 319.866 308.981 326.729 308.981 335.171C308.981 343.613 315.845 350.476 324.287 350.476C330.197 350.476 335.226 347.099 337.795 342.218H478.376C481.166 342.218 482.818 345.301 481.276 347.613Z">
40 |                 </path>
41 |             </svg>
42 |             <span class="fs-3">
43 |                {{ $title }}
44 |                 <span class="text-muted ps-md-2 fs-6 d-block d-md-inline">{ JSON-RPC }</span>
45 |             </span>
46 |         </span>
47 | 
48 |         <mark class="col-12 col-md-auto px-2 user-select-all mt-2 mt-md-0 p-4 px-md-2 py-md-1">{{ $uri }}</mark>
49 |     </header>
50 | 
51 |     @foreach($procedures as $procedure)
52 | 
53 |         <div class="row g-2 g-md-5 mb-3 mb-md-0">
54 |             <div class="col-12 col-md-3 pe-md-0">
55 |                 <h4 class="user-select-all mb-3">
56 |                     {{ $procedure['name'] }}
57 |                     <span class="d-block text-muted">{{ $procedure['delimiter'] }}{{ $procedure['method'] }}</span>
58 |                 </h4>
59 |                 <p>
60 |                     {{ $procedure['description'] ?? '' }}
61 |                 </p>
62 |             </div>
63 | 
64 | 
65 |             <div class="col">
66 |                 <div class="p-4 {{ $loop->last ? 'rounded-bottom': '' }} {{ $loop->first ? 'rounded-top' : '' }}" style="background: rgb(37 42 55)">
67 |                 <div class="row">
68 |                     <div class="col">
69 |                         <p class="user-select-none fw-light text-white opacity-50 mb-1 small">Request:</p>
70 |                         {!! $procedure['request'] ?? '' !!}
71 |                     </div>
72 | 
73 |                     <div class="col">
74 |                         <p class="user-select-none fw-light text-white opacity-50 mb-1 small">Response:</p>
75 |                         {!! $procedure['response'] ?? '' !!}
76 |                     </div>
77 |                 </div>
78 |                 </div>
79 |             </div>
80 |         </div>
81 |     @endforeach
82 | 
83 | 
84 |     <footer class="pt-5 my-5 text-muted d-flex align-items-center">
85 |         <div class="mx-auto">
86 |             <abbr title="{{ date(DATE_ATOM) }}">Created</abbr> by the <a href="http://sajya.github.io" class="text-dark" target="_blank">Sajya</a>.
87 |         </div>
88 |     </footer>
89 | </div>
90 | </div>
91 | 
92 | </body>
93 | </html>
94 | 


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