wip

src/Casts/Cast.php

@@ -7,4 +7,6 @@
 interface Cast
 {
     public function cast(DataProperty $property, mixed $value, array $context): mixed;
+
+    public function preValidationRules(DataProperty $property, mixed $value): array;
 }

src/Casts/DateTimeInterfaceCast.php

@@ -46,4 +46,9 @@ public function cast(DataProperty $property, mixed $value, array $context): Date
 
         return $datetime;
     }
+
+    public function preValidationRules(DataProperty $property, mixed $value): array
+    {
+
+    }
 }

src/Casts/EnumCast.php

@@ -29,4 +29,9 @@ public function cast(DataProperty $property, mixed $value, array $context): Back
             throw CannotCastEnum::create($type, $value);
         }
     }
+
+    public function preValidationRules(DataProperty $property, mixed $value): array
+    {
+
+    }
 }

src/Concerns/BaseData.php

@@ -15,6 +15,7 @@
 use Spatie\LaravelData\DataPipes\CastPropertiesDataPipe;
 use Spatie\LaravelData\DataPipes\DefaultValuesDataPipe;
 use Spatie\LaravelData\DataPipes\FillRouteParameterPropertiesDataPipe;
+use Spatie\LaravelData\DataPipes\InitialValidationDataPipe;
 use Spatie\LaravelData\DataPipes\MapPropertiesDataPipe;
 use Spatie\LaravelData\DataPipes\ValidatePropertiesDataPipe;
 use Spatie\LaravelData\PaginatedDataCollection;
@@ -86,8 +87,9 @@ public static function pipeline(): DataPipeline
             ->through(AuthorizedDataPipe::class)
             ->through(MapPropertiesDataPipe::class)
             ->through(FillRouteParameterPropertiesDataPipe::class)
-            ->through(ValidatePropertiesDataPipe::class)
             ->through(DefaultValuesDataPipe::class)
+            ->through(ValidatePropertiesDataPipe::class)
+//            ->through(InitialValidationDataPipe::class)
             ->through(CastPropertiesDataPipe::class);
     }
 

src/DataPipes/FillRouteParameterPropertiesDataPipe.php

@@ -60,6 +60,5 @@ protected function resolveValue(
         }
 
         return data_get($parameter, $attribute->property ?? $dataProperty->name);
-        ;
     }
 }

src/DataPipes/InitialValidationDataPipe.php

@@ -0,0 +1,24 @@
+<?php
+
+namespace Spatie\LaravelData\DataPipes;
+
+use Illuminate\Support\Collection;
+use Illuminate\Support\Facades\Validator;
+use Spatie\LaravelData\Rules\InitialPropertyRule;
+use Spatie\LaravelData\Support\DataClass;
+
+class InitialValidationDataPipe implements DataPipe
+{
+    public function handle(mixed $payload, DataClass $class, Collection $properties): Collection
+    {
+        $rules = [];
+
+        foreach ($class->properties as $property) {
+            $rules[$property->name] = new InitialPropertyRule($property);
+        }
+
+        Validator::make($properties->toArray(), $rules)->validate();
+
+        return $properties;
+    }
+}

src/Rules/InitialPropertyRule.php

@@ -0,0 +1,157 @@
+<?php
+
+namespace Spatie\LaravelData\Rules;
+
+use Closure;
+use Exception;
+use Illuminate\Contracts\Validation\ValidationRule;
+use Illuminate\Support\Facades\Validator;
+use Spatie\LaravelData\Support\DataProperty;
+use Spatie\LaravelData\Support\Types\MultiType;
+use Spatie\LaravelData\Support\Types\PartialType;
+use Spatie\LaravelData\Support\Types\SingleType;
+use Spatie\LaravelData\Support\Types\UndefinedType;
+use Stringable;
+
+class InitialPropertyRule implements ValidationRule
+{
+    public function __construct(
+        protected DataProperty $property
+    ) {
+    }
+
+    public function validate(string $attribute, mixed $value, Closure $fail): void
+    {
+        $dataType = $this->property->type;
+        $type = $dataType->type;
+
+        if ($dataType->isMixed() || $type instanceof UndefinedType) {
+            return;
+        }
+
+        if (! $dataType->isNullable() && $value === null) {
+            $fail(__('validation.required', ['attribute' => $attribute]));
+        }
+
+        if ($dataType->isNullable() && $value === null) {
+            return;
+        }
+
+        if ($dataType->type instanceof SingleType) {
+            $this->validateSingleType($dataType->type, $attribute, $value, $fail);
+
+            return;
+        }
+
+        if ($dataType->type instanceof MultiType) {
+            $this->validateMultiType($dataType->type, $attribute, $value, $fail);
+
+            return;
+        }
+
+        throw new Exception('Unexpected path, we should never get here');
+    }
+
+    protected function validateSingleType(
+        SingleType $singleType,
+        string $attribute,
+        mixed $value,
+        Closure $fail,
+    ): void {
+        $validity = $this->isPartialTypeValid($singleType->type, $attribute, $value);
+
+        if ($validity === true) {
+            return;
+        }
+
+        $fail($validity);
+    }
+
+    protected function validateMultiType(
+        MultiType $multiType,
+        string $attribute,
+        mixed $value,
+        Closure $fail,
+    ): void {
+        $invalidMessages = [];
+
+        foreach ($multiType->types as $type) {
+            $validity = $this->isPartialTypeValid($type, $attribute, $value);
+
+            if ($validity === true) {
+                return;
+            }
+
+            $invalidMessages[] = $validity;
+        }
+
+        $fail(implode(' or ', $invalidMessages));
+    }
+
+    protected function isPartialTypeValid(
+        PartialType $type,
+        string $attribute,
+        mixed $value
+    ): true|string {
+        // TODO: casts always have precedence over here
+        if ($this->property->cast) {
+            return Validator::make(
+                [$attribute => $value],
+                [$attribute => $this->property->cast->preValidationRules($this->property, $value)]
+            )->validate();
+        }
+
+        if ($type->name === 'string' && ! $this->isValidString($value)) {
+            return __('validation.string', ['attribute' => $attribute]);
+        }
+
+        if ($type->name === 'bool' && ! $this->isValidBool($value)) {
+            return __('validation.boolean', ['attribute' => $attribute]);
+        }
+
+        if ($type->name === 'int' && ! $this->isValidIntOrFloat($value)) {
+            return __('validation.integer', ['attribute' => $attribute]);
+        }
+
+        if ($type->name === 'float' && ! $this->isValidIntOrFloat($value)) {
+            return __('validation.float', ['attribute' => $attribute]);
+        }
+
+        if ($type->name === 'array' && ! $this->isValidArray($value)) {
+            return __('validation.array', ['attribute' => $attribute]);
+        }
+
+        // We're having an object over here, this should basically be catched by the casts
+        // Unless it is a data object
+        // Data objects can be created using magic methods, so we need check these types and count them all up
+        // Data objects also can be created using from which accepts all values based upon their normalizer
+        // Then there are datacollectables, these we can also automatically create
+        // Again magic collect methods which can take any type
+        // + some default types
+        // For each item in such a collection we need to, again check the data objects
+
+        return true;
+    }
+
+    protected function isValidString(mixed $value): bool
+    {
+        return is_scalar($value) || $value instanceof Stringable;
+    }
+
+    protected function isValidBool(mixed $value): bool
+    {
+        return is_scalar($value);
+    }
+
+    protected function isValidIntOrFloat(mixed $value): bool
+    {
+        return is_numeric($value) || is_bool($value);
+    }
+
+    protected function isValidArray(mixed $value): bool
+    {
+        return is_array($value); // TODO what if we have an arrayble? A) cast before validation, B) split casting and decide a cast before validation
+        // Follow up -> add a new pipe, auto infer casts, which automatically adds global casts
+        // We'll add support for a collection global cast from array which solves our problem
+    }
+}

src/Support/TransientProperty.php

@@ -0,0 +1,18 @@
+<?php
+
+namespace Spatie\LaravelData\Support;
+
+use Spatie\LaravelData\Casts\Cast;
+
+class TransientProperty
+{
+    public function __construct(
+        public mixed $value,
+        public DataProperty $property,
+        public ?Cast $cast = null, // Pre determined cast -> see idea to set this in stone on the data property
+        public bool $isExactValue = false, // Whether an object is exaxctly what the property needed,
+        public bool $noCastFound = false, // Whether no cast was found for the property
+        public ?DataMethod $magicMethod = null, // A determined magic method that can be used to create the value
+    ) {
+    }
+}

tests/DataPipes/InitialValidationDataPipeTest.php

@@ -0,0 +1,47 @@
+<?php
+
+use Spatie\LaravelData\Data;
+
+it('can handle multiple cases', function () {
+    $stringable = new class implements Stringable {
+        public function __toString()
+        {
+            return 'stringable';
+        }
+    };
+
+    class DataTestBreakableValidation extends Data
+    {
+        // strict types are not a problem since this all happens in the data context which is not strict
+        public function __construct(
+            // Takes everything
+            public mixed $mixed,
+            // Takes string, bool, float, int, class implementing Stringable
+            public string $string,
+            // Takes string, bool, float, int
+            public bool $bool,
+            // Takes bool, float, int
+            public int $int,
+            // Takes bool, float, int
+            public float $float,
+            // Takes array
+            public array $array,
+            // Takes string, bool, float, int, class implementing Stringable, null
+            public ?string $nullable,
+        ) {
+        }
+    }
+
+
+    $data = new DataTestBreakableValidation(
+        'mixed',
+        'string',
+        '1d',
+        '12',
+        3.14,
+        [],
+        null,
+    );
+
+    expect($data)->toBeInstanceOf(DataTestBreakableValidation::class);
+});

tests/Fakes/Castables/SimpleCastable.php

@@ -19,6 +19,11 @@ public function cast(DataProperty $property, mixed $value, array $context): mixe
             {
                 return new SimpleCastable($value);
             }
+
+            public function preValidationRules(DataProperty $property, mixed $value): array
+            {
+
+            }
         };
     }
 }

tests/Fakes/Casts/ConfidentialDataCast.php

@@ -12,4 +12,9 @@ public function cast(DataProperty $property, mixed $value, array $context): Simp
     {
         return SimpleData::from('CONFIDENTIAL');
     }
+
+    public function preValidationRules(DataProperty $property, mixed $value): array
+    {
+
+    }
 }

tests/Fakes/Casts/ConfidentialDataCollectionCast.php

@@ -12,4 +12,9 @@ public function cast(DataProperty $property, mixed $value, array $context): arra
     {
         return array_map(fn () => SimpleData::from('CONFIDENTIAL'), $value);
     }
+
+    public function preValidationRules(DataProperty $property, mixed $value): array
+    {
+
+    }
 }

tests/Fakes/Casts/ContextAwareCast.php

@@ -11,4 +11,9 @@ public function cast(DataProperty $property, mixed $value, array $context): mixe
     {
         return $value . '+' . json_encode($context);
     }
+
+    public function preValidationRules(DataProperty $property, mixed $value): array
+    {
+
+    }
 }

tests/Fakes/Casts/StringToUpperCast.php

@@ -11,4 +11,9 @@ public function cast(DataProperty $property, mixed $value, array $context): stri
     {
         return strtoupper($value);
     }
+
+    public function preValidationRules(DataProperty $property, mixed $value): array
+    {
+
+    }
 }