BEAR\Resource\Interceptor\JsonSchemaInterceptor

Complexity

Total Complexity

34

Size/Duplication

Total Lines	185
Duplicated Lines	0 %

Importance

Changes	1
Bugs	0	Features	0

<?php
final readonly class JsonSchemaInterceptor implements JsonSchemaInterceptorInterface

A parse error occurred: Syntax error, unexpected T_READONLY, expecting T_CLASS on line 42 at column 6

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

    /**
     * {@inheritDoc}
     */
    #[Override]
    public function invoke(MethodInvocation $invocation): ResourceObject
    {
        $method = $invocation->getMethod();
        $attributes = $method->getAttributes(JsonSchema::class);
        $jsonSchema = isset($attributes[0]) ? $attributes[0]->newInstance() : null;
        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 Query $arguments
     *
     * MethodInvocation<T> generic cannot be specified without breaking interface compatibility
     *
     * @phpstan-ignore-next-line missingType.generics
     */
    private function validateRequest(MethodInvocation $invocation, JsonSchema $jsonSchema, array $arguments): void
    {
        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 Body */
    private function deepArray(object $values): array
    {
        $result = [];
        // Iterating over object properties yields mixed key/value types
        /** @psalm-suppress MixedAssignment */
        foreach ($values as $key => $value) { // @phpstan-ignore-line
            /** @psalm-suppress MixedArrayOffset */
            $result[$key] = is_object($value) ? $this->deepArray($value) : $value; // @phpstan-ignore-line
        }

        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 Query
     */
    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;