JsonSchemaInterceptor::invoke() - Code Metrics - bearsunday/BEAR.Resource - Measure and Improve Code Quality continuously with Scrutinizer

JsonSchemaInterceptor::invoke() A
last analyzed 2025-07-02 01:14 UTC

↳ Parent: JsonSchemaInterceptor

Complexity

Conditions	4
Paths	4

Size

Total Lines	18
Code Lines	12

Duplication

Lines	0
Ratio	0 %

Importance

Changes

Metric	Value
cc	4
eloc	12
nc	4
nop	1
dl	0
loc	18
rs	9.8666
c	0
b	0
f	0

<?php

declare(strict_types=1);

namespace BEAR\Resource\Interceptor;

use BEAR\Resource\Annotation\JsonSchema;
use BEAR\Resource\Code;
use BEAR\Resource\Exception\JsonSchemaException;
use BEAR\Resource\Exception\JsonSchemaKeytNotFoundException;
use BEAR\Resource\Exception\JsonSchemaNotFoundException;
use BEAR\Resource\JsonSchemaExceptionHandlerInterface;
use BEAR\Resource\JsonSchemaRequestExceptionHandlerInterface;
use BEAR\Resource\ResourceObject;
use JsonSchema\Constraints\Constraint;
use JsonSchema\Validator;
use Override;
use Ray\Aop\MethodInvocation;
use Ray\Di\Di\Named;
use ReflectionClass;
use stdClass;

use function assert;
use function file_exists;
use function is_array;
use function is_dir;
use function is_object;
use function is_string;
use function json_decode;
use function json_encode;
use function property_exists;
use function sprintf;
use function str_replace;

use const JSON_THROW_ON_ERROR;

final class JsonSchemaInterceptor implements JsonSchemaInterceptorInterface
{
    public function __construct(
        #[Named('json_schema_dir')]
        private readonly string $schemaDir,
        #[Named('json_validate_dir')]
        private readonly string $validateDir,
        private readonly JsonSchemaExceptionHandlerInterface $handler,
        private readonly JsonSchemaRequestExceptionHandlerInterface $requestHandler,
        #[Named('json_schema_host')]
        private readonly string|null $schemaHost = null,
    ) {
    }

    /**
     * {@inheritDoc}
     */
    #[Override]
    public function invoke(MethodInvocation $invocation): ResourceObject
    {
        $method = $invocation->getMethod();
        $jsonSchema = $method->getAnnotation(JsonSchema::class);
        assert($jsonSchema instanceof JsonSchema);
        if ($jsonSchema->params) {
            $arguments = $this->getNamedArguments($invocation);
            $this->validateRequest($invocation, $jsonSchema, $arguments);
        }

        $ro = $invocation->proceed();
        assert($ro instanceof ResourceObject);
        if ($ro->code === 200 || $ro->code === 201) {
            $this->validateResponse($ro, $jsonSchema);
        }

        return $ro;
    }

    /** @param array<string, mixed> $arguments */
    private function validateRequest(MethodInvocation $invocation, JsonSchema $jsonSchema, array $arguments): void // @phpstan-ignore-line
    {
        try {
            $schemaFile = $this->validateDir . '/' . $jsonSchema->params;
            $this->validateFileExists($schemaFile);
            $this->validate($arguments, $schemaFile);
        } catch (JsonSchemaException $e) {
            $ro = $invocation->getThis();
            assert($ro instanceof ResourceObject);
            /** @psalm-suppress PossiblyUndefinedVariable */
            $this->requestHandler->handleRequestException($arguments, $ro, $e, $schemaFile);
        }
    }

    private function validateResponse(ResourceObject $ro, JsonSchema $jsonSchema): void
    {
        $schemaFile = $this->getSchemaFile($jsonSchema, $ro);
        try {
            $this->validateRo($ro, $schemaFile, $jsonSchema);
            if (is_string($this->schemaHost)) {
                $ro->headers['Link'] = sprintf('<%s%s>; rel="describedby"', $this->schemaHost, $jsonSchema->schema);
            }
        } catch (JsonSchemaException $e) {
            $this->handler->handle($ro, $e, $schemaFile);
        }
    }

    private function validateRo(ResourceObject $ro, string $schemaFile, JsonSchema $jsonSchema): void
    {
        $viewJson = $jsonSchema->target === 'view' ? (string) $ro : json_encode($ro, JSON_THROW_ON_ERROR);
        /** @var array<stdClass>|false|stdClass $json */
        $json = json_decode($viewJson, null, 512, JSON_THROW_ON_ERROR);
        /** @var array<stdClass>|stdClass $target */
        $target = is_object($json) ? $this->getTarget($json, $jsonSchema) : $json;
        $this->validate($target, $schemaFile);
    }

    private function getTarget(object $json, JsonSchema $jsonSchema): mixed
    {
        if ($jsonSchema->key === '') {
            return $json;
        }

        if (! property_exists($json, $jsonSchema->key)) {
            throw new JsonSchemaKeytNotFoundException($jsonSchema->key);
        }

        return $json->{$jsonSchema->key};
    }

    /** @param array<mixed>|stdClass $target */
    private function validate(array|stdClass $target, string $schemaFile): void
    {
        $validator = new Validator();
        $schema = (object) ['$ref' => 'file://' . $schemaFile];
        $scanArray = is_array($target) ? $target : $this->deepArray($target);

        $validator->validate($scanArray, $schema, Constraint::CHECK_MODE_TYPE_CAST);
        $isValid = $validator->isValid();
        if ($isValid) {
            return;
        }

        throw $this->throwJsonSchemaException($validator, $schemaFile);
    }

    /** @return array<int|string, mixed> */
    private function deepArray(object $values): array
    {
        $result = [];
        /** @psalm-suppress MixedAssignment */
        foreach ($values as $key => $value) { // @phpstan-ignore-line
            /** @psalm-suppress MixedArrayOffset */
            $result[$key] = is_object($value) ? $this->deepArray($value) : $result[$key] = $value;
        }

        return $result;
    }

    private function throwJsonSchemaException(Validator $validator, string $schemaFile): JsonSchemaException
    {
        /** @var array<array<string, string>> $errors */
        $errors = $validator->getErrors();
        $msg = '';
        foreach ($errors as $error) {
            $msg .= sprintf('[%s] %s; ', $error['property'], $error['message']);
        }

        $msg .= "by {$schemaFile}";

        return new JsonSchemaException($msg, Code::ERROR);
    }

    private function getSchemaFile(JsonSchema $jsonSchema, ResourceObject $ro): string
    {
        if (! $jsonSchema->schema) {
            // for BC only
            new ReflectionClass($ro);
            $roFileName = $this->getParentClassName($ro);
            $bcFile = str_replace('.php', '.json', $roFileName);
            if (file_exists($bcFile)) {
                return $bcFile;
            }
        }

        $schemaFile = $this->schemaDir . '/' . $jsonSchema->schema;
        $this->validateFileExists($schemaFile);

        return $schemaFile;
    }

    private function getParentClassName(ResourceObject $ro): string
    {
        $parent = (new ReflectionClass($ro))->getParentClass();

        return $parent instanceof ReflectionClass ? (string) $parent->getFileName() : '';

    }

    private function validateFileExists(string $schemaFile): void
    {
        if (! file_exists($schemaFile) || is_dir($schemaFile)) {
            throw new JsonSchemaNotFoundException($schemaFile);
        }
    }

    /**
     * @param MethodInvocation<object> $invocation
     *
     * @return array<string, mixed>
     */
    private function getNamedArguments(MethodInvocation $invocation): array
    {
        $parameters = $invocation->getMethod()->getParameters();
        $values = $invocation->getArguments();
        $arguments = [];
        foreach ($parameters as $index => $parameter) {
            /** @psalm-suppress MixedAssignment */
            $arguments[$parameter->name] = $values[$index] ?? $parameter->getDefaultValue();
        }

        return $arguments;
    }
}


1			<?php
2
3			declare(strict_types=1);
4
5			namespace BEAR\Resource\Interceptor;
6
7			use BEAR\Resource\Annotation\JsonSchema;
8			use BEAR\Resource\Code;
9			use BEAR\Resource\Exception\JsonSchemaException;
10			use BEAR\Resource\Exception\JsonSchemaKeytNotFoundException;
11			use BEAR\Resource\Exception\JsonSchemaNotFoundException;
12			use BEAR\Resource\JsonSchemaExceptionHandlerInterface;
13			use BEAR\Resource\JsonSchemaRequestExceptionHandlerInterface;
14			use BEAR\Resource\ResourceObject;
15			use JsonSchema\Constraints\Constraint;
16			use JsonSchema\Validator;
17			use Override;
18			use Ray\Aop\MethodInvocation;
19			use Ray\Di\Di\Named;
20			use ReflectionClass;
21			use stdClass;
22
23			use function assert;
24			use function file_exists;
25			use function is_array;
26			use function is_dir;
27			use function is_object;
28			use function is_string;
29			use function json_decode;
30			use function json_encode;
31			use function property_exists;
32			use function sprintf;
33			use function str_replace;
34
35			use const JSON_THROW_ON_ERROR;
36
37			final class JsonSchemaInterceptor implements JsonSchemaInterceptorInterface
38			{
39			public function __construct(
40			#[Named('json_schema_dir')]
41			private readonly string $schemaDir,
42			#[Named('json_validate_dir')]
43			private readonly string $validateDir,
44			private readonly JsonSchemaExceptionHandlerInterface $handler,
45			private readonly JsonSchemaRequestExceptionHandlerInterface $requestHandler,
46			#[Named('json_schema_host')]
47			private readonly string\|null $schemaHost = null,
48			) {
49			}
50
51			/**
52			* {@inheritDoc}
53			*/
54			#[Override]
55			public function invoke(MethodInvocation $invocation): ResourceObject
56			{
57			$method = $invocation->getMethod();
58			$jsonSchema = $method->getAnnotation(JsonSchema::class);
59			assert($jsonSchema instanceof JsonSchema);
60			if ($jsonSchema->params) {
61			$arguments = $this->getNamedArguments($invocation);
62			$this->validateRequest($invocation, $jsonSchema, $arguments);
63			}
64
65			$ro = $invocation->proceed();
66			assert($ro instanceof ResourceObject);
67			if ($ro->code === 200 \|\| $ro->code === 201) {
68			$this->validateResponse($ro, $jsonSchema);
69			}
70
71			return $ro;
72			}
73
74			/** @param array<string, mixed> $arguments */
75			private function validateRequest(MethodInvocation $invocation, JsonSchema $jsonSchema, array $arguments): void // @phpstan-ignore-line
76			{
77			try {
78			$schemaFile = $this->validateDir . '/' . $jsonSchema->params;
79			$this->validateFileExists($schemaFile);
80			$this->validate($arguments, $schemaFile);
81			} catch (JsonSchemaException $e) {
82			$ro = $invocation->getThis();
83			assert($ro instanceof ResourceObject);
84			/** @psalm-suppress PossiblyUndefinedVariable */
85			$this->requestHandler->handleRequestException($arguments, $ro, $e, $schemaFile);
86			}
87			}
88
89			private function validateResponse(ResourceObject $ro, JsonSchema $jsonSchema): void
90			{
91			$schemaFile = $this->getSchemaFile($jsonSchema, $ro);
92			try {
93			$this->validateRo($ro, $schemaFile, $jsonSchema);
94			if (is_string($this->schemaHost)) {
95			$ro->headers['Link'] = sprintf('<%s%s>; rel="describedby"', $this->schemaHost, $jsonSchema->schema);
96			}
97			} catch (JsonSchemaException $e) {
98			$this->handler->handle($ro, $e, $schemaFile);
99			}
100			}
101
102			private function validateRo(ResourceObject $ro, string $schemaFile, JsonSchema $jsonSchema): void
103			{
104			$viewJson = $jsonSchema->target === 'view' ? (string) $ro : json_encode($ro, JSON_THROW_ON_ERROR);
105			/** @var array<stdClass>\|false\|stdClass $json */
106			$json = json_decode($viewJson, null, 512, JSON_THROW_ON_ERROR);
107			/** @var array<stdClass>\|stdClass $target */
108			$target = is_object($json) ? $this->getTarget($json, $jsonSchema) : $json;
109			$this->validate($target, $schemaFile);
110			}
111
112			private function getTarget(object $json, JsonSchema $jsonSchema): mixed
113			{
114			if ($jsonSchema->key === '') {
115			return $json;
116			}
117
118			if (! property_exists($json, $jsonSchema->key)) {
119			throw new JsonSchemaKeytNotFoundException($jsonSchema->key);
120			}
121
122			return $json->{$jsonSchema->key};
123			}
124
125			/** @param array<mixed>\|stdClass $target */
126			private function validate(array\|stdClass $target, string $schemaFile): void
127			{
128			$validator = new Validator();
129			$schema = (object) ['$ref' => 'file://' . $schemaFile];
130			$scanArray = is_array($target) ? $target : $this->deepArray($target);
			0 ignored issues – show introduced 2022-11-19 01:14 UTC by Report Bug Copy Issue Report The condition `is_array($target)` is always `true`. Loading history...
131			$validator->validate($scanArray, $schema, Constraint::CHECK_MODE_TYPE_CAST);
132			$isValid = $validator->isValid();
133			if ($isValid) {
134			return;
135			}
136
137			throw $this->throwJsonSchemaException($validator, $schemaFile);
138			}
139
140			/** @return array<int\|string, mixed> */
141			private function deepArray(object $values): array
142			{
143			$result = [];
144			/** @psalm-suppress MixedAssignment */
145			foreach ($values as $key => $value) { // @phpstan-ignore-line
146			/** @psalm-suppress MixedArrayOffset */
147			$result[$key] = is_object($value) ? $this->deepArray($value) : $result[$key] = $value;
148			}
149
150			return $result;
151			}
152
153			private function throwJsonSchemaException(Validator $validator, string $schemaFile): JsonSchemaException
154			{
155			/** @var array<array<string, string>> $errors */
156			$errors = $validator->getErrors();
157			$msg = '';
158			foreach ($errors as $error) {
159			$msg .= sprintf('[%s] %s; ', $error['property'], $error['message']);
160			}
161
162			$msg .= "by {$schemaFile}";
163
164			return new JsonSchemaException($msg, Code::ERROR);
165			}
166
167			private function getSchemaFile(JsonSchema $jsonSchema, ResourceObject $ro): string
168			{
169			if (! $jsonSchema->schema) {
170			// for BC only
171			new ReflectionClass($ro);
172			$roFileName = $this->getParentClassName($ro);
173			$bcFile = str_replace('.php', '.json', $roFileName);
174			if (file_exists($bcFile)) {
175			return $bcFile;
176			}
177			}
178
179			$schemaFile = $this->schemaDir . '/' . $jsonSchema->schema;
180			$this->validateFileExists($schemaFile);
181
182			return $schemaFile;
183			}
184
185			private function getParentClassName(ResourceObject $ro): string
186			{
187			$parent = (new ReflectionClass($ro))->getParentClass();
188
189			return $parent instanceof ReflectionClass ? (string) $parent->getFileName() : '';
			0 ignored issues – show introduced 2021-10-31 14:08 UTC by Report Bug Copy Issue Report `$parent` is always a sub-type of `ReflectionClass`. Loading history...
190			}
191
192			private function validateFileExists(string $schemaFile): void
193			{
194			if (! file_exists($schemaFile) \|\| is_dir($schemaFile)) {
195			throw new JsonSchemaNotFoundException($schemaFile);
196			}
197			}
198
199			/**
200			* @param MethodInvocation<object> $invocation
201			*
202			* @return array<string, mixed>
203			*/
204			private function getNamedArguments(MethodInvocation $invocation): array
205			{
206			$parameters = $invocation->getMethod()->getParameters();
207			$values = $invocation->getArguments();
208			$arguments = [];
209			foreach ($parameters as $index => $parameter) {
210			/** @psalm-suppress MixedAssignment */
211			$arguments[$parameter->name] = $values[$index] ?? $parameter->getDefaultValue();
212			}
213
214			return $arguments;
215			}
216			}
217

bearsunday / BEAR.Resource

JsonSchemaInterceptor::invoke() A last analyzed 2025-07-02 01:14 UTC

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like

JsonSchemaInterceptor::invoke() A
last analyzed 2025-07-02 01:14 UTC