[13.x] Typed Form Requests

src/Illuminate/Foundation/Http/Attributes/HydrateFromRequest.php

@@ -0,0 +1,11 @@
+<?php
+
+namespace Illuminate\Foundation\Http\Attributes;
+
+use Attribute;
+
+#[Attribute(Attribute::TARGET_CLASS | Attribute::TARGET_PARAMETER)]
+class HydrateFromRequest
+{
+    //
+}

src/Illuminate/Foundation/Http/Attributes/MapFrom.php

@@ -0,0 +1,16 @@
+<?php
+
+namespace Illuminate\Foundation\Http\Attributes;
+
+use Attribute;
+
+#[Attribute(Attribute::TARGET_PARAMETER)]
+class MapFrom
+{
+    /**
+     * @param  string  $name  The request field to map from.
+     */
+    public function __construct(public $name)
+    {
+    }
+}

src/Illuminate/Foundation/Http/Attributes/WithoutInferringRules.php

@@ -0,0 +1,10 @@
+<?php
+
+namespace Illuminate\Foundation\Http\Attributes;
+
+use Attribute;
+
+#[Attribute(Attribute::TARGET_PARAMETER | Attribute::TARGET_CLASS)]
+class WithoutInferringRules
+{
+}

src/Illuminate/Foundation/Http/Concerns/CastsValidatedData.php

@@ -0,0 +1,221 @@
+<?php
+
+namespace Illuminate\Foundation\Http\Concerns;
+
+use BackedEnum;
+use Carbon\CarbonImmutable;
+use DateTime;
+use DateTimeImmutable;
+use DateTimeInterface;
+use Illuminate\Foundation\Http\TypedFormRequest;
+use Illuminate\Support\Arr;
+use Illuminate\Support\Collection;
+use Illuminate\Support\Facades\Date;
+use Illuminate\Validation\ValidationException;
+use ReflectionNamedType;
+use ReflectionParameter;
+use ReflectionUnionType;
+use stdClass;
+
+use function Illuminate\Support\enum_value;
+
+trait CastsValidatedData
+{
+    /**
+     * Cast validated data into constructor arguments for the request class.
+     *
+     * @param  array<string, mixed>  $validated
+     * @return array<string, mixed>
+     *
+     * @throws \ReflectionException
+     */
+    protected function castValidatedData(array $validated): array
+    {
+        if (($constructor = $this->reflectRequest()->getConstructor()) === null) {
+            return $validated;
+        }
+
+        $arguments = [];
+
+        foreach ($constructor->getParameters() as $param) {
+            $fieldName = $this->fieldNameFor($param);
+            $name = $param->getName();
+
+            if (! Arr::has($validated, $fieldName)) {
+                continue;
+            }
+
+            $value = Arr::get($validated, $fieldName);
+
+            if ($value === null) {
+                $arguments[$name] = null;
+
+                continue;
+            }
+
+            $type = $param->getType();
+
+            if ($type instanceof ReflectionUnionType) {
+                $nestedRequestClass = $this->nestedHydrationClassFromUnion($type, $param);
+
+                if ($nestedRequestClass !== null && is_array($value)) {
+                    $arguments[$name] = $this->instantiateFromValidatedArray(
+                        $nestedRequestClass,
+                        $this->ensureArrayValue($fieldName, $value)
+                    );
+                } else {
+                    $arguments[$name] = $value;
+                }
+
+                continue;
+            }
+
+            if (! $type instanceof ReflectionNamedType) {
+                $arguments[$name] = $value;
+
+                continue;
+            }
+
+            $typeName = $type->getName();
+            if ($type->isBuiltin()) {
+                if ($typeName === 'object') {
+                    $arguments[$name] = $this->castBuiltinObjectValue($value);
+                } else {
+                    $arguments[$name] = $value;
+                }
+
+                continue;
+            }
+
+            if ($this->isDateObjectType($typeName)) {
+                $arguments[$name] = $this->castDateValue($typeName, $value);
+            } elseif (is_a($typeName, stdClass::class, true)) {
+                $arguments[$name] = $this->castBuiltinObjectValue($value);
+            } elseif ($this->shouldHydrateParameter($param, $typeName) || is_subclass_of($typeName, TypedFormRequest::class)) {
+                $arguments[$name] = $this->instantiateFromValidatedArray(
+                    $typeName,
+                    $this->ensureArrayValue($fieldName, $value)
+                );
+            } elseif (is_subclass_of($typeName, BackedEnum::class)) {
+                $arguments[$name] = $typeName::from($value);
+            } elseif (is_a($typeName, Collection::class, true)) {
+                if ($value instanceof $typeName) {
+                    $arguments[$name] = $value;
+                } else {
+                    $arguments[$name] = new $typeName($this->ensureArrayValue($fieldName, $value));
+                }
+            } else {
+                $arguments[$name] = $value;
+            }
+        }
+
+        return $arguments;
+    }
+
+    /**
+     * Cast an "object" builtin value into a stdClass instance when appropriate.
+     */
+    protected function castBuiltinObjectValue(mixed $value): mixed
+    {
+        return is_array($value) ? (object) $value : $value;
+    }
+
+    /**
+     * Cast the given value to the requested date object type.
+     *
+     * @param  class-string  $typeName  The date object class name.
+     * @param  mixed  $value  The validated value.
+     */
+    protected function castDateValue(string $typeName, mixed $value): ?DateTimeInterface
+    {
+        if ($value === null || ($value instanceof DateTimeInterface && $value instanceof $typeName)) {
+            return $value;
+        }
+
+        $parsed = Date::parse($value);
+
+        return match (true) {
+            $typeName === DateTimeInterface::class => $parsed,
+            $typeName === DateTime::class => $parsed->toDateTime(),
+            $typeName === DateTimeImmutable::class => $parsed->toDateTimeImmutable(),
+            is_a($typeName, CarbonImmutable::class, true) => CarbonImmutable::instance($parsed),
+            default => $parsed,
+        };
+    }
+
+    /**
+     * Determine if the given class name is a date object type.
+     *
+     * @param  class-string  $name
+     */
+    protected function isDateObjectType(string $name): bool
+    {
+        return is_a($name, DateTimeInterface::class, true);
+    }
+
+
+    /**
+     * Get the first union branch that should be hydrated from an array payload.
+     *
+     * @return class-string|null
+     */
+    protected function nestedHydrationClassFromUnion(ReflectionUnionType $type, ReflectionParameter $param): ?string
+    {
+        foreach ($type->getTypes() as $named) {
+            if ($named->getName() === 'null' || $named->isBuiltin()) {
+                continue;
+            }
+
+            $class = $named->getName();
+
+            if (in_array($class, $this->ancestors)) {
+                continue;
+            }
+
+            if (is_subclass_of($class, TypedFormRequest::class) || $this->shouldHydrateParameter($param, $class)) {
+                return $class;
+            }
+        }
+
+        return null;
+    }
+
+    /**
+     * Ensure the given value is an array payload or throw a validation exception.
+     *
+     * @template TValue of array<array-key, mixed>
+     *
+     * @param  string  $fieldName
+     * @param  TValue|mixed  $value
+     * @return array<array-key, mixed>
+     *
+     * @phpstan-return ($value is array<array-key, mixed> ? TValue : never)
+     *
+     * @throws \Illuminate\Validation\ValidationException
+     */
+    protected function ensureArrayValue(string $fieldName, mixed $value): array
+    {
+        if (is_array($value)) {
+            return $value;
+        }
+
+        throw ValidationException::withMessages([
+            $fieldName => ["The {$fieldName} field must be an array."],
+        ]);
+    }
+
+    /**
+     * Convert a reflected default value to a native value.
+     *
+     * @template TValue
+     *
+     * @param  TValue  $value
+     * @return mixed
+     *
+     * @phpstan-return ($value is empty ? null : ($value is \BackedEnum ? value-of<TValue> : ($value is \UnitEnum ? string : TValue)))
+     */
+    protected function mapToNativeFromDefaultValue(mixed $value): mixed
+    {
+        return enum_value($value);
+    }
+}