├── .github
    └── FUNDING.yml
├── .gitignore
├── README.md
├── composer.json
├── composer.lock
├── phpunit.xml
├── src
    ├── Concerns
    │   └── ValidatesInertiaInput.php
    ├── Exceptions
    │   └── ValidatedException.php
    └── ValidationParser.php
└── tests
    └── TestCase.php


/.github/FUNDING.yml:
--------------------------------------------------------------------------------
1 | # These are supported funding model platforms
2 | 
3 | github: [juhlinus]
4 | 


--------------------------------------------------------------------------------
/.gitignore:
--------------------------------------------------------------------------------
1 | .DS_Store
2 | /vendor/
3 | 


--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
 1 | # ✔️ Kakunin
 2 | ## 💰 Is this useful to you?
 3 | **Consider [sponsoring me on github](https://github.com/sponsors/juhlinus)! 🙏**
 4 | 
 5 | ## 💾 Installation
 6 | ```
 7 | composer require juhlinus/kakunin
 8 | ```
 9 | 
10 | ## 🤔 Usage
11 | Kakunin relies on [Custom Form Requests](https://laravel.com/docs/7.x/validation#form-request-validation).
12 | 
13 | Add the `ValidatesInertiaInput` trait to your newly generated form request like so:
14 | 
15 | ```php
16 | <?php
17 | 
18 | namespace App\Http\Requests;
19 | 
20 | use Kakunin\Concerns\ValidatesInertiaInput;
21 | use Illuminate\Foundation\Http\FormRequest;
22 | 
23 | class CustomFormRequest extends FormRequest
24 | {
25 |     use ValidatesInertiaInput;
26 | 
27 |     /**
28 |      * Determine if the user is authorized to make this request.
29 |      *
30 |      * @return bool
31 |      */
32 |     public function authorize()
33 |     {
34 |         return false;
35 |     }
36 | 
37 |     /**
38 |      * Get the validation rules that apply to the request.
39 |      *
40 |      * @return array
41 |      */
42 |     public function rules()
43 |     {
44 |         return [
45 |             //
46 |         ];
47 |     }
48 | }
49 | ```
50 | 
51 | In order for the validation to be **instant** you need to make use of a [watcher](https://vuejs.org/v2/guide/computed.html#Watchers).
52 | 
53 | Here's an example in Vue.js:
54 | ```vuejs
55 | <template>
56 |     <div>
57 |         <input v-model="email">
58 |     </div>
59 | </template>
60 | 
61 | <script>
62 |     export default {
63 |         watch: {
64 |             email: function (email) {
65 |                 this.$inertia.post('/users', {
66 |                     email: email,
67 |                     validate: true,
68 |                 });
69 |             }
70 |         }
71 |     }
72 | </script>
73 | ```
74 | 
75 | Note that I'm passing a `validate` parameter. If this isn't passed then Kakunin will not validate your request.
76 | 
77 | That's it! Happy validating!
78 | 
79 | ## 📝 Configuration
80 | 
81 | If you wish to change the `validate` to something else, then you can add `KAKUNIN_VALIDATION_KEY` to your `.env` file. Lastly, add the following to your `config/services.php` file:
82 | 
83 | ```php
84 | 'kakunin' => [
85 |     'validation_key' => env('KAKUNIN_VALIDATION_KEY'),
86 | ],
87 | ```
88 | 
89 | ## ⛩ That's a stupid name for a package
90 | 
91 | Kakunin(確認) is the Japanese verb "to validate".


--------------------------------------------------------------------------------
/composer.json:
--------------------------------------------------------------------------------
 1 | {
 2 |     "name": "juhlinus/kakunin",
 3 |     "type": "library",
 4 |     "license": "MIT",
 5 |     "autoload": {
 6 |         "psr-4": {
 7 |             "Kakunin\\": "src"
 8 |         }
 9 |     },
10 |     "autoload-dev": {
11 |         "psr-4": {
12 |             "Kakunin\\Tests\\": "tests/"
13 |         }
14 |     },
15 |     "require-dev": {
16 |         "orchestra/testbench": "^5.1"
17 |     },
18 |     "authors": [
19 |         {
20 |             "name": "Linus Juhlin",
21 |             "email": "linus.juhlin@protonmail.com"
22 |         }
23 |     ],
24 |     "require": {
25 |         "php": "^7.4|^8.0"
26 |     },
27 |     "suggest": {
28 |         "symfony/http-foundation": "Required for requests and responses.",
29 |         "illuminate/support": "Required for redirecting after input has been validated."
30 |     }
31 | }
32 | 


--------------------------------------------------------------------------------
/phpunit.xml:
--------------------------------------------------------------------------------
 1 | <?xml version="1.0" encoding="UTF-8"?>
 2 | <phpunit xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
 3 |          xsi:noNamespaceSchemaLocation="https://schema.phpunit.de/7.4/phpunit.xsd"
 4 |          bootstrap="vendor/autoload.php"
 5 |          forceCoversAnnotation="true"
 6 |          beStrictAboutCoversAnnotation="true"
 7 |          beStrictAboutOutputDuringTests="true"
 8 |          beStrictAboutTodoAnnotatedTests="true"
 9 |          verbose="true">
10 |     <testsuites>
11 |         <testsuite name="default">
12 |             <directory suffix="Test.php">tests</directory>
13 |         </testsuite>
14 |     </testsuites>
15 |     <filter>
16 |         <whitelist processUncoveredFilesFromWhitelist="true">
17 |             <directory suffix=".php">src</directory>
18 |         </whitelist>
19 |     </filter>
20 | </phpunit>


--------------------------------------------------------------------------------
/src/Concerns/ValidatesInertiaInput.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace Kakunin\Concerns;
 4 | 
 5 | use Kakunin\ValidationParser;
 6 | use Kakunin\Exceptions\ValidatedException;
 7 | use Illuminate\Validation\ValidationException;
 8 | use Illuminate\Contracts\Validation\Validator;
 9 | 
10 | /**
11 |  * Provides instant form validation behaviour
12 |  */
13 | trait ValidatesInertiaInput
14 | {
15 |     /**
16 |      * Handle a passed validation attempt.
17 |      *
18 |      * @return void
19 |      *
20 |      * @throws \Kakunin\Exceptions\ValidatedException
21 |      */
22 |     protected function passedValidation(): void
23 |     {
24 |         $validationParser = new ValidationParser($this->getValidatorInstance());
25 | 
26 |         if ($this->request->get($validationParser->getValidationKey(), false)) {
27 |             throw new ValidatedException();
28 |         }
29 |     }
30 | 
31 |     /**
32 |      * Handle a failed validation attempt.
33 |      *
34 |      * @param  \Illuminate\Validation\Validator  $validator
35 |      * @return void
36 |      *
37 |      * @throws \Illuminate\Validation\ValidationException
38 |      */
39 |     protected function failedValidation(Validator $validator): void
40 |     {
41 |         $validationParser = new ValidationParser($validator);
42 | 
43 |         if ($validationParser->shouldNotValidate()) {
44 |             parent::failedValidation($validator);
45 |         }
46 | 
47 |         $messages = $validationParser->parseValidationMessages();
48 | 
49 |         $exception = new ValidationException($validator);
50 | 
51 |         throw $exception->withMessages($messages);
52 |     }
53 | }


--------------------------------------------------------------------------------
/src/Exceptions/ValidatedException.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace Kakunin\Exceptions;
 4 | 
 5 | use Illuminate\Support\Facades\Redirect;
 6 | use Symfony\Component\HttpFoundation\Request;
 7 | use Symfony\Component\HttpFoundation\Response;
 8 | 
 9 | class ValidatedException extends \Exception
10 | {
11 |     /**
12 |      * Render the exception into an HTTP response.
13 |      *
14 |      * @param  \Symfony\Component\HttpFoundation\Request  $request
15 |      * @return \Symfony\Component\HttpFoundation\Response
16 |      */
17 |     public function render(Request $request): Response
18 |     {
19 |         return Redirect::back();
20 |     }
21 | }


--------------------------------------------------------------------------------
/src/ValidationParser.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace Kakunin;
 4 | 
 5 | use Illuminate\Validation\Validator;
 6 | 
 7 | class ValidationParser
 8 | {
 9 |     private Validator $validator;
10 |     private string $validate_key;
11 |     private array $validated_keys = [];
12 | 
13 |     /**
14 |      * Constructs a new instance.
15 |      *
16 |      * @param      \Illuminate\Validation\Validator  $validator
17 |      */
18 |     public function __construct(Validator $validator)
19 |     {
20 |         $this->validator = $validator;
21 |         $this->validate_key = config(
22 |             'services.kakunin.validation_key', 
23 |             'validate'
24 |         );
25 |     }
26 | 
27 |     /**
28 |      * Returns whether or not we should validate the request
29 |      *
30 |      * @return     boolean
31 |      */
32 |     public function shouldNotValidate(): bool
33 |     {
34 |         $this->validated_keys = array_keys(
35 |             array_filter(
36 |                 $this->validator->getData()
37 |             )
38 |         );
39 |         
40 |         if (in_array($this->validate_key, $this->validated_keys)) {
41 |             return false;
42 |         }
43 | 
44 |         return true;
45 |     }
46 | 
47 |     /**
48 |      * Get validation key
49 |      *
50 |      * @return     string
51 |      */
52 |     public function getValidationKey(): string
53 |     {
54 |         return $this->validate_key;
55 |     }
56 | 
57 |     /**
58 |      * Filters out the validation messages we don't need
59 |      *
60 |      * @return     array  
61 |      */
62 |     public function parseValidationMessages(): array
63 |     {
64 |         $parentValidatorMessages = $this->validator->messages()->messages();
65 | 
66 |         $messages = array_filter($parentValidatorMessages, function ($messageKey) {
67 |             return in_array($messageKey, $this->validated_keys);
68 |         }, ARRAY_FILTER_USE_KEY);
69 | 
70 |         return $messages;
71 |     }
72 | }


--------------------------------------------------------------------------------
/tests/TestCase.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace Kakunin\Tests;
 4 | 
 5 | use Orchestra\Testbench\TestCase as BaseTestCase;
 6 | 
 7 | abstract class TestCase extends BaseTestCase
 8 | {
 9 |     protected function setUp(): void
10 |     {
11 |         parent::setUp();
12 |     }
13 | }
14 | 


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