Feature / data validation

.gitignore

@@ -1,7 +1,9 @@
 vendor/
 .idea/
 coverage.xml
+clover.xml
 package.xml
 coverage-html/
 .phpunit/
 /.php-cs-fixer.cache
+tests/.DS_Store

composer.json

@@ -28,7 +28,8 @@
         }
     },
     "scripts": {
-        "ci-test": "XDEBUG_MODE=coverage vendor/bin/phpunit --testsuite=ci --configuration phpunit.xml",
+        "ci-test": "XDEBUG_MODE=coverage vendor/bin/phpunit --coverage-text --testsuite=ci --configuration phpunit.xml",
+        "unit-test": "XDEBUG_MODE=coverage vendor/bin/phpunit --testsuite=unit --configuration phpunit.xml",
         "phpstan": "vendor/bin/phpstan analyse --configuration phpstan.neon --memory-limit=256M"
     }
 }

src/Concerns/BaseData.php

@@ -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/Contexts/ClassContext.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/Contracts/ValidateableData.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/Enums/Property/Type.php

@@ -20,4 +20,10 @@ enum Type: string
         self::BOOLEAN,
         self::STRING,
     ];
+
+    /** @var list<Type> */
+    public const array NUMERIC_TYPES = [
+        self::FLOAT,
+        self::INT,
+    ];
 }

src/Exceptions/DataValidationException.php

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

src/Exceptions/LogicalRuleException.php

@@ -0,0 +1,15 @@
+<?php
+
+namespace Nuxtifyts\PhpDto\Exceptions;
+
+use Exception;
+
+class LogicalRuleException extends Exception
+{
+    protected const int UNABLE_TO_CREATE_RULE_CODE = 1;
+
+    public static function unableToCreateRule(string $message = 'Unable to create rule'): self
+    {
+        return new self($message, self::UNABLE_TO_CREATE_RULE_CODE);
+    }
+}

src/Exceptions/ValidationRuleException.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/Support/Arr.php

@@ -2,11 +2,13 @@
 
 namespace Nuxtifyts\PhpDto\Support;
 
+use BackedEnum;
+use InvalidArgumentException;
+
 final readonly class Arr
 {
     /**
      * @param array<array-key, mixed> $array
-     * @param string $key
      * @param array<array-key, mixed> $default
      *
      * @return array<array-key, mixed>
@@ -18,6 +20,130 @@ public static function getArray(array $array, string $key, array $default = []):
         return is_array($value) ? $value : $default;
     }
 
+    /** 
+     *  @param array<array-key, mixed> $array
+     */
+    public static function getStringOrNull(array $array, string $key): ?string
+    {
+        $value = $array[$key] ?? null;
+
+        return is_string($value) ? $value : null;
+    }
+
+    /** 
+     * @param array<array-key, mixed> $array
+     */
+    public static function getString(array $array, string $key, string $default = ''): string
+    {
+        return self::getStringOrNull($array, $key) ?? $default;
+    }
+
+        /** 
+     * @param array<array-key, mixed> $array
+     */
+    public static function getIntegerOrNull(array $array, string $key): ?int
+    {
+        $value = $array[$key] ?? null;
+
+        return is_int($value) ? $value : null;
+    }
+
+    /** 
+     * @param array<array-key, mixed> $array
+     */
+    public static function getInteger(array $array, string $key, int $default = 0): int
+    {
+        return self::getIntegerOrNull($array, $key) ?? $default;
+    }
+
+    /** 
+     * @param array<array-key, mixed> $array
+     */
+    public static function getFloatOrNull(array $array, string $key): ?float
+    {
+        $value = $array[$key] ?? null;
+
+        return is_float($value) ? $value : null;
+    }
+
+    /** 
+     * @param array<array-key, mixed> $array
+     */
+    public static function getFloat(array $array, string $key, float $default = 0.0): float
+    {
+        return self::getFloatOrNull($array, $key) ?? $default;
+    }
+
+    /** 
+     * @param array<array-key, mixed> $array
+     */
+    public static function getBooleanOrNull(array $array, string $key): ?bool
+    {
+        $value = $array[$key] ?? null;
+
+        return is_bool($value) ? $value : null;
+    }
+
+    /** 
+     * @param array<array-key, mixed> $array
+     */
+    public static function getBoolean(array $array, string $key, bool $default = false): bool
+    {
+        return self::getBooleanOrNull($array, $key) ?? $default;
+    }
+
+    /** 
+     * @template T of BackedEnum 
+     * 
+     * @param array<array-key, mixed> $array
+     * @param class-string<T> $enumClass
+     * @param ?T $default
+     * 
+     * @return ?T
+     */
+    public static function getBackedEnumOrNull(
+        array $array, 
+        string $key, 
+        string $enumClass, 
+        ?BackedEnum $default = null
+    ): ?BackedEnum {
+        $value = $array[$key] ?? null;
+
+        if ($value instanceof $enumClass) {
+            return $value;
+        } else if (
+            (is_string($value) || is_integer($value))
+            && $resolvedValue = $enumClass::tryFrom($value)
+        ) {
+            return $resolvedValue;
+        }
+
+        return is_null($default)
+            ? null
+            : ($default instanceof $enumClass
+                ? $default
+                : throw new InvalidArgumentException('Default value must be an instance of ' . $enumClass)
+            );        
+    }
+
+    /** 
+     * @template T of BackedEnum 
+     * 
+     * @param array<array-key, mixed> $array
+     * @param class-string<T> $enumClass
+     * @param T $default
+     * 
+     * @return T
+     */
+    public static function getBackedEnum(
+        array $array, 
+        string $key, 
+        string $enumClass, 
+        BackedEnum $default
+    ): BackedEnum {
+        return self::getBackedEnumOrNull($array, $key, $enumClass, $default) ?? $default;
+    }
+
     /**
      * @param array<array-key, mixed> $array
      * @param class-string<object> $classString
@@ -30,4 +156,40 @@ public static function isArrayOfClassStrings(array $array, string $classString):
                 && is_subclass_of($value, $classString)
         );
     }
+
+    /**
+     * @param array<array-key, mixed> $array
+     *
+     * @return ($preserveKeys is true ? array<array-key, mixed> : list<mixed>)
+     */
+    public static function flatten(array $array, float $depth = INF, bool $preserveKeys = true): array
+    {
+        $result = [];
+
+        foreach ($array as $key => $item) {
+            $item = $item instanceof Collection ? $item->all() : $item;
+
+            if (! is_array($item)) {
+                if ($preserveKeys) {
+                    $result[$key] = $item;
+                } else {
+                    $result[] = $item;
+                }
+            } else {
+                $values = $depth === 1.0
+                    ? $item
+                    : self::flatten($item, $depth - 1, $preserveKeys);
+
+                foreach ($values as $subKey => $value) {
+                    if ($preserveKeys) {
+                        $result[$subKey] = $value;
+                    } else {
+                        $result[] = $value;
+                    }
+                }
+            }
+        }
+
+        return $result;
+    }
 }