Support in param

Author: walkor

src/Annotation/Param.php

@@ -11,7 +11,8 @@ class Param
     public function __construct(
         public string|array $rules = '',
         public array $messages = [],
-        public string $attribute = ''
+        public string $attribute = '',
+        public string|array|null $in = null
     ) {
     }
 }

src/Annotation/Validate.php

@@ -13,7 +13,8 @@ public function __construct(
         public array $messages = [],
         public array $attributes = [],
         public ?string $validator = null,
-        public ?string $scene = null
+        public ?string $scene = null,
+        public string|array|null $in = null
     ) {
     }
 }

src/Middleware.php

@@ -26,10 +26,10 @@ public function process(Request $request, callable $handler)
             return $handler($request);
         }
 
-        $data = $this->getRequestData($request);
+        $defaultData = $this->getRequestData($request);
 
-        $this->handleMethodValidation($metadata['methods'], $data);
-        $this->handleParamValidation($metadata['params'], $data);
+        $this->handleMethodValidation($request, $metadata['methods'], $defaultData);
+        $this->handleParamValidation($request, $metadata['params'], $defaultData);
 
         return $handler($request);
     }
@@ -46,18 +46,19 @@ private function resolveMetadata(Request $request): ?array
         return $this->getCallableMetadata($request);
     }
 
-    private function handleMethodValidation(array $methods, array $data): void
+    private function handleMethodValidation(Request $request, array $methods, array $defaultData): void
     {
         if ($methods === []) {
             return;
         }
 
         foreach ($methods as $config) {
+            $data = $this->resolveRequestData($request, $config->in, $defaultData);
             $this->validateMethod($config, $data);
         }
     }
 
-    private function handleParamValidation(array $params, array $data): void
+    private function handleParamValidation(Request $request, array $params, array $defaultData): void
     {
         if ($params === []) {
             return;
@@ -73,7 +74,8 @@ private function handleParamValidation(array $params, array $data): void
             /** @var \Webman\Validation\Annotation\Param $config */
             $config = $item['config'];
 
-            $value = $data[$name] ?? null;
+            $dataForParam = $this->resolveRequestData($request, $config->in, $defaultData);
+            $value = $dataForParam[$name] ?? null;
             if ($value === null && $item['hasDefault']) {
                 $value = $item['default'];
             }
@@ -135,6 +137,40 @@ private function getRequestData(Request $request): array
         return array_merge($request->all() ?: [], $routeParams);
     }
 
+    private function resolveRequestData(Request $request, string|array|null $in, array $defaultData): array
+    {
+        if ($in === null || $in === []) {
+            return $defaultData;
+        }
+
+        $parts = is_array($in) ? $in : [$in];
+        $data = [];
+        foreach ($parts as $part) {
+            $data = array_merge($data, $this->getRequestPartData($request, $part));
+        }
+        return $data;
+    }
+
+    private function getRequestPartData(Request $request, mixed $part): array
+    {
+        if (!is_string($part) || $part === '') {
+            throw new InvalidArgumentException('Validate/Param in must be a non-empty string or string array.');
+        }
+
+        return match ($part) {
+            'query' => $request->get() ?: [],
+            'body' => $request->post() ?: [],
+            'path' => $this->getPathParams($request),
+            default => throw new InvalidArgumentException("Unsupported in value: {$part}. Only query|body|path are supported."),
+        };
+    }
+
+    private function getPathParams(Request $request): array
+    {
+        $routeParams = $request->route ? $request->route->param() : [];
+        return is_array($routeParams) ? $routeParams : [];
+    }
+
     private function getMethodMetadata(string $controller, string $action): ?array
     {
         $key = $controller . '::' . $action;
@@ -251,7 +287,8 @@ private function resolveParamConfig(ReflectionParameter $parameter, bool $inferW
                 return new Param(
                     rules: $completedRules,
                     messages: $config->messages,
-                    attribute: $config->attribute
+                    attribute: $config->attribute,
+                    in: $config->in
                 );
             }
 

src/Tests/ValidateMiddlewareTest.php

@@ -123,6 +123,91 @@ public function testMultipleMethodValidation(): void
         $this->assertTrue($called);
     }
 
+    public function testValidateInQueryBodyBodyOverridesQueryByOrder(): void
+    {
+        $request = $this->makeRequest(
+            controller: InQueryBodyController::class,
+            action: 'send',
+            query: ['id' => 1],
+            body: ['id' => 2]
+        );
+
+        $called = false;
+        (new Middleware())->process($request, function () use (&$called) {
+            $called = true;
+            return 'ok';
+        });
+
+        $this->assertTrue($called);
+    }
+
+    public function testValidateInBodyQueryQueryOverridesBodyByOrder(): void
+    {
+        $request = $this->makeRequest(
+            controller: InBodyQueryController::class,
+            action: 'send',
+            query: ['id' => 1],
+            body: ['id' => 2]
+        );
+
+        $called = false;
+        (new Middleware())->process($request, function () use (&$called) {
+            $called = true;
+            return 'ok';
+        });
+
+        $this->assertTrue($called);
+    }
+
+    public function testValidateInQueryPathPathOverridesQueryByOrder(): void
+    {
+        $request = $this->makeRequest(
+            controller: InQueryPathController::class,
+            action: 'send',
+            query: ['id' => 1],
+            routeParams: ['id' => 7]
+        );
+
+        $called = false;
+        (new Middleware())->process($request, function () use (&$called) {
+            $called = true;
+            return 'ok';
+        });
+
+        $this->assertTrue($called);
+    }
+
+    public function testParamInPathReadsFromPathOnly(): void
+    {
+        $request = $this->makeRequest(
+            controller: ParamInPathController::class,
+            action: 'send',
+            query: ['id' => 1],
+            routeParams: ['id' => 7]
+        );
+
+        $called = false;
+        (new Middleware())->process($request, function () use (&$called) {
+            $called = true;
+            return 'ok';
+        });
+
+        $this->assertTrue($called);
+    }
+
+    public function testValidateInUnsupportedValueThrows(): void
+    {
+        $request = $this->makeRequest(
+            controller: InvalidInController::class,
+            action: 'send',
+            query: ['id' => 1]
+        );
+
+        $this->expectException(InvalidArgumentException::class);
+        $this->expectExceptionMessage('Unsupported in value');
+        (new Middleware())->process($request, fn () => 'ok');
+    }
+
     public function testParamValidationUsesRouteParams(): void
     {
         $request = $this->makeRequest(
@@ -1018,6 +1103,47 @@ public function send(Request $request): void
     }
 }
 
+final class InQueryBodyController
+{
+    #[Validate(in: ['query', 'body'], rules: ['id' => 'required|in:2'])]
+    public function send(Request $request): void
+    {
+    }
+}
+
+final class InBodyQueryController
+{
+    #[Validate(in: ['body', 'query'], rules: ['id' => 'required|in:1'])]
+    public function send(Request $request): void
+    {
+    }
+}
+
+final class InQueryPathController
+{
+    #[Validate(in: ['query', 'path'], rules: ['id' => 'required|in:7'])]
+    public function send(Request $request): void
+    {
+    }
+}
+
+final class ParamInPathController
+{
+    public function send(
+        #[Param(in: 'path', rules: 'required|in:7')]
+        int $id
+    ): void {
+    }
+}
+
+final class InvalidInController
+{
+    #[Validate(in: 'header', rules: ['id' => 'required|integer'])]
+    public function send(Request $request): void
+    {
+    }
+}
+
 final class ParamController
 {
     public function send(

src/Tests/ValidatorExceptionTest.php

@@ -38,7 +38,7 @@ public function test_exception_override_uses_custom_exception(): void
             ['name' => null],
             ['name' => 'required']
         )
-            ->exception(\RuntimeException::class)
+            ->withException(\RuntimeException::class)
             ->validate();
     }
 }

src/Validator.php

@@ -52,7 +52,7 @@ public function withScene(string $scene): static
         return $clone;
     }
 
-    public function exception(string $exceptionClass): static
+    public function withException(string $exceptionClass): static
     {
         if ($exceptionClass === '') {
             throw new InvalidArgumentException('Validation exception must be a non-empty class string.');