Implement validation framework with Validator, validation rules, and exceptions

Author: Fa-BRAIK

clover.xml

@@ -9,7 +9,6 @@
 use Nuxtifyts\PhpDto\Normalizers\Concerns\HasNormalizers;
 use Nuxtifyts\PhpDto\Pipelines\DeserializePipeline\DeserializePipeline;
 use Nuxtifyts\PhpDto\Pipelines\DeserializePipeline\DeserializePipelinePassable;
-use ReflectionClass;
 use Throwable;
 
 trait BaseData

src/Concerns/BaseData.php

@@ -0,0 +1,16 @@
+<?php
+
+namespace Nuxtifyts\PhpDto\Concerns;
+
+use Nuxtifyts\PhpDto\Exceptions\DataValidationException;
+
+trait ValidateableData
+{
+    /** 
+     *  @return array<string, mixed>
+     */
+    public static function validationRules(): array
+    {
+        return [];
+    }
+}

src/Concerns/ValidateableData.php

@@ -139,7 +139,8 @@ private function syncClassAttributes(): void
     /**
      * @throws ReflectionException
      *
-     * @return T
+     * @return Data
+     * @phpstan-return T
      */
     public function newInstanceWithoutConstructor(): mixed
     {
@@ -149,7 +150,8 @@ public function newInstanceWithoutConstructor(): mixed
     /**
      * @throws ReflectionException
      *
-     * @return T
+     * @return Data
+     * @phpstan-return T
      */
     public function newInstanceWithConstructorCall(mixed ...$args): mixed
     {

src/Contexts/ClassContext.php

@@ -0,0 +1,32 @@
+<?php
+
+namespace Nuxtifyts\PhpDto\Contracts;
+
+use Nuxtifyts\PhpDto\Exceptions\DataValidationException;
+
+interface ValidateableData
+{
+    /**
+     * @param array<string, mixed> $data
+     *
+     * @throws DataValidationException
+     */
+    public static function validate(array $data): void;
+
+    /** 
+     *  @param array<string, mixed> $data
+     * 
+     *  @throws DataValidationException
+     */
+    public static function validateAndCreate(array $data): static;
+
+    /**
+     * @return true|array<string, array<string>>
+     */
+    public function isValid(): true|array;
+
+    /** 
+     * @return array<string, mixed>
+     */
+    public static function validationRules(): array;
+}

src/Contracts/ValidateableData.php

@@ -0,0 +1,9 @@
+<?php
+
+namespace Nuxtifyts\PhpDto\Exceptions;
+
+use Exception;
+
+class DataValidationException extends Exception
+{
+}

src/Exceptions/DataValidationException.php

@@ -0,0 +1,15 @@
+<?php
+
+namespace Nuxtifyts\PhpDto\Exceptions;
+
+use Exception;
+
+class ValidationRuleException extends Exception
+{
+    protected const int INVALID_PARAMETERS = 1;
+
+    public static function invalidParameters(): self
+    {
+        return new self('Invalid parameters', self::INVALID_PARAMETERS);
+    }
+}

src/Exceptions/ValidationRuleException.php

@@ -0,0 +1,88 @@
+<?php
+
+namespace Nuxtifyts\PhpDto\Validation\Rules;
+
+use BackedEnum;
+use Nuxtifyts\PhpDto\Exceptions\ValidationRuleException;
+use Nuxtifyts\PhpDto\Support\Arr;
+
+class BackedEnumRule implements ValidationRule
+{
+    /** @var class-string<BackedEnum> */
+    public protected(set) string $backedEnumClass;
+
+    /** 
+     *  @var ?array<array-key, BackedEnum>
+     */
+    public protected(set) ?array $allowedValues = null;
+
+    public string $name {
+        get {
+            return 'backed_enum';
+        }
+    }
+
+    public function evaluate(mixed $value): bool
+    {
+        if ($value instanceof $this->backedEnumClass) {
+            /** @var BackedEnum $value */
+            $resolvedValue = $value;
+        } else if (is_string($value) || is_integer($value)) {
+            $resolvedValue = $this->backedEnumClass::tryFrom($value);
+        } else {
+            return false;
+        }
+
+        return !!$resolvedValue
+            && (
+                is_null($this->allowedValues) 
+                || in_array($resolvedValue->value, array_column($this->allowedValues, 'value'))
+            );
+    }
+
+    /** 
+     * @param ?array<string, mixed> $parameters
+     *
+     * @throws ValidationRuleException
+     */
+    public static function make(?array $parameters = null): self
+    {
+        $instance = new self();
+
+        $backedEnumClass = $parameters['backedEnumClass'] ?? null;
+
+        if (
+            !is_string($backedEnumClass) 
+            || !enum_exists($backedEnumClass) 
+            || !is_subclass_of($backedEnumClass, BackedEnum::class)
+        ) { 
+            throw ValidationRuleException::invalidParameters();
+        }
+
+        $instance->backedEnumClass = $backedEnumClass;
+        $instance->allowedValues = array_filter(
+            array_map(static fn (mixed $value) =>
+                ($value instanceof $instance->backedEnumClass)
+                    ? $value
+                    : null,
+                Arr::getArray($parameters ?? [], 'allowedValues')
+            )
+        ) ?: null;
+
+        return $instance;
+    }
+
+    public function validationMessage(): string
+    {
+        if ($this->allowedValues) {
+            $allowedValues = implode(
+                ', ', 
+                array_map(static fn (BackedEnum $value) => $value->value, $this->allowedValues)
+            );
+
+            return "The :attribute field must be one of the following values: $allowedValues.";
+        } else {
+            return 'The :attribute field is invalid.';
+        }
+    }
+}

src/Validation/Rules/BackedEnumRule.php

@@ -0,0 +1,30 @@
+<?php
+
+namespace Nuxtifyts\PhpDto\Validation\Rules;
+
+class NullableRule implements ValidationRule
+{
+    public string $name {
+        get {
+            return 'nullable';
+        }
+    }
+
+    public function evaluate(mixed $value): bool
+    {
+        return true;
+    }
+
+    /** 
+     * @param ?array<string, mixed> $parameters
+     */
+    public static function make(?array $parameters = null): self
+    {
+        return new self();
+    }
+
+    public function validationMessage(): string
+    {
+        return '';
+    }
+}

src/Validation/Rules/NullableRule.php

@@ -0,0 +1,30 @@
+<?php
+
+namespace Nuxtifyts\PhpDto\Validation\Rules;
+
+class RequiredRule implements ValidationRule
+{
+    public string $name {
+        get {
+            return 'required';
+        }
+    }
+
+    public function evaluate(mixed $value): bool
+    {
+        return !empty($value);
+    }
+
+    /** 
+     * @param ?array<string, mixed> $parameters
+     */
+    public static function make(?array $parameters = null): self
+    {
+        return new self();
+    }
+
+    public function validationMessage(): string
+    {
+        return 'The :attribute field is required.';
+    }
+}