VGirol\JsonApiStructure\Concern\ValidateResourceObject

Complexity

Total Complexity

31

Size/Duplication

Total Lines	237
Duplicated Lines	0 %

Test Coverage

Coverage

98.51%

Importance

Changes	1
Bugs	0	Features	0

8 Methods

Rating	Name	Duplication	Size	Complexity
A	validateResourceObject()	0	21	5
A	validateResourceObjectCollection()	0	18	5
A	validateResourceTypeMember()	0	15	4
A	validateResourceObjectTopLevelStructure()	0	12	2
B	validateFields()	0	16	7
A	validateResourceLinksObject()	0	3	1
A	isNotForbiddenResourceFieldName()	0	4	2
A	validateResourceIdMember()	0	16	5

<?php

declare(strict_types=1);

namespace VGirol\JsonApiStructure\Concern;

use VGirol\JsonApiConstant\Members;
use VGirol\JsonApiStructure\Messages;

/**
 * Assertions relating to the resource object
 */
trait ValidateResourceObject
{
    /**
     * Asserts that a json fragment is a valid collection of resource objects.
     *
     * It will do the following checks :
     * 1) asserts that the provided resource collection is either an empty array or an array of objects
     * (@see mustBeArrayOfObjects).
     * 2) asserts that the collection of resources is valid (@see validateResourceObject).
     *
     * @param array|null $json
     * @param boolean    $strict If true, unsafe characters are not allowed when checking members name.
     *
     * @return void
     * @throws \VGirol\JsonApiStructure\Exception\ValidationException
     */
    public function validateResourceObjectCollection($json, bool $strict): void
    {
        if ($json === null) {
            return;
        }

        if (!\is_array($json)) {

The condition is_array($json) is always true.

            $this->throw(Messages::RESOURCE_OBJECT_COLLECTION_MUST_BE_ARRAY, 403);
        }

        if (\count($json) == 0) {
            return;
        }

        $this->mustBeArrayOfObjects($json);

It seems like mustBeArrayOfObjects() must be provided by classes using this trait. How about adding it as abstract method to this trait?

        foreach ($json as $resource) {
            $this->validateResourceObject($resource, $strict);
        }
    }

    /**
     * Asserts that a json fragment is a valid resource.
     *
     * It will do the following checks :
     * 1) asserts that the resource object has valid top-level structure
     * (@see validateResourceObjectTopLevelStructure).
     * 2) asserts that the resource object has valid "type" and "id" members
     * (@see validateResourceIdMember and @see validateResourceTypeMember).
     * 3) asserts that the resource object has valid fields (@see hasValidFields).
     *
     * Optionaly, if presents, it will checks :
     * 4) asserts thats the resource object has valid "attributes" member.
     * 5) asserts thats the resource object has valid "relationships" member.
     * 6) asserts thats the resource object has valid "links" member.
     * 7) asserts thats the resource object has valid "meta" member.
     *
     * @param array   $json
     * @param boolean $strict If true, unsafe characters are not allowed when checking members name.
     *
     * @return void
     * @throws \VGirol\JsonApiStructure\Exception\ValidationException
     */
    public function validateResourceObject($json, bool $strict): void
    {
        $this->validateResourceObjectTopLevelStructure($json, $strict);

        if (\array_key_exists(Members::ATTRIBUTES, $json)) {
            $this->validateAttributesObject($json[Members::ATTRIBUTES], $strict);

It seems like validateAttributesObject() must be provided by classes using this trait. How about adding it as abstract method to this trait?

        }

        if (\array_key_exists(Members::RELATIONSHIPS, $json)) {
            $this->validateRelationshipsObject($json[Members::RELATIONSHIPS], $strict);

It seems like validateRelationshipsObject() must be provided by classes using this trait. How about adding it as abstract method to this trait?

        }

        if (\array_key_exists(Members::LINKS, $json)) {
            $this->validateResourceLinksObject($json[Members::LINKS], $strict);
        }

        if (\array_key_exists(Members::META, $json)) {
            $this->validateMetaObject($json[Members::META], $strict);

It seems like validateMetaObject() must be provided by classes using this trait. How about adding it as abstract method to this trait?

        }

        $this->validateFields($json);
    }

    /**
     * Asserts that a resource object has a valid top-level structure.
     *
     * It will do the following checks :
     * 1) asserts that the resource has an "id" member.
     * 2) asserts that the resource has a "type" member.
     * 3) asserts that the resource contains at least one of the following members :
     * "attributes", "relationships", "links", "meta" (@see containsAtLeastOneMember).
     * 4) asserts that the resource contains only the following allowed members :
     * "id", "type", "meta", "attributes", "links", "relationships" (@see containsOnlyAllowedMembers).
     *
     * @param array   $resource
     * @param boolean $strict   If true, unsafe characters are not allowed when checking members name.
     *
     * @return void
     * @throws \VGirol\JsonApiStructure\Exception\ValidationException
     */
    public function validateResourceObjectTopLevelStructure($resource, $strict): void
    {
        if (!\is_array($resource)) {

The condition is_array($resource) is always true.

            $this->throw(Messages::RESOURCE_OBJECT_MUST_BE_ARRAY, 403);
        }

        $this->validateResourceIdMember($resource);
        $this->validateResourceTypeMember($resource, $strict);

        $this->containsAtLeastOneMember($this->getRule('ResourceObject.AtLeast'), $resource);

It seems like containsAtLeastOneMember() must be provided by classes using this trait. How about adding it as abstract method to this trait?

It seems like getRule() must be provided by classes using this trait. How about adding it as abstract method to this trait?

        $this->containsOnlyAllowedMembers($this->getRule('ResourceObject.Allowed'), $resource);

It seems like containsOnlyAllowedMembers() must be provided by classes using this trait. How about adding it as abstract method to this trait?

    }

    /**
     * Asserts that a resource id member is valid.
     *
     * It will do the following checks :
     * 1) asserts that the "id" member is not empty.
     * 2) asserts that the "id" member is a string.
     *
     * @param array $resource
     *
     * @return void
     * @throws \VGirol\JsonApiStructure\Exception\ValidationException
     */
    public function validateResourceIdMember($resource): void
    {
        if (!\array_key_exists(Members::ID, $resource)) {
            if ($this->isPost()) {

It seems like isPost() must be provided by classes using this trait. How about adding it as abstract method to this trait?

                return;
            }

            $this->throw(Messages::RESOURCE_ID_MEMBER_IS_ABSENT, 403);

It seems like throw() must be provided by classes using this trait. How about adding it as abstract method to this trait?

        }

        if (!\is_string($resource[Members::ID])) {
            $this->throw(Messages::RESOURCE_ID_MEMBER_MUST_BE_STRING, 403);
        }

        if ($resource[Members::ID] == '') {
            $this->throw(Messages::RESOURCE_ID_MEMBER_CAN_NOT_BE_EMPTY, 403);
        }
    }

    /**
     * Asserts that a resource type member is valid.
     *
     * It will do the following checks :
     * 1) asserts that the "type" member is not empty.
     * 2) asserts that the "type" member is a string.
     * 3) asserts that the "type" member has a valid value (@see validateMemberName).
     *
     * @param array   $resource
     * @param boolean $strict   If true, excludes not safe characters when checking members name
     *
     * @return void
     * @throws \VGirol\JsonApiStructure\Exception\ValidationException
     */
    public function validateResourceTypeMember($resource, bool $strict): void
    {
        if (!\array_key_exists(Members::TYPE, $resource)) {
            $this->throw(Messages::RESOURCE_TYPE_MEMBER_IS_ABSENT, 403);
        }

        if (!\is_string($resource[Members::TYPE])) {
            $this->throw(Messages::RESOURCE_TYPE_MEMBER_MUST_BE_STRING, 403);
        }

        if ($resource[Members::TYPE] == '') {
            $this->throw(Messages::RESOURCE_TYPE_MEMBER_CAN_NOT_BE_EMPTY, 403);
        }

        $this->validateMemberName($resource[Members::TYPE], $strict);

It seems like validateMemberName() must be provided by classes using this trait. How about adding it as abstract method to this trait?

    }

    /**
     * Asserts that a json fragment is a valid resource links object.
     *
     * It will do the following checks :
     * 1) asserts that le links object is valid (@see validateLinksObject) with only "self" member allowed.
     *
     * @param array   $json
     * @param boolean $strict If true, excludes not safe characters when checking members name
     *
     * @return void
     * @throws \VGirol\JsonApiStructure\Exception\ValidationException
     */
    public function validateResourceLinksObject($json, bool $strict): void
    {
        $this->validateLinksObject($json, $this->getRule('ResourceObject.LinksObject.Allowed'), $strict);

It seems like validateLinksObject() must be provided by classes using this trait. How about adding it as abstract method to this trait?

    }

    /**
     * Asserts that a resource object has valid fields (i.e., resource object’s attributes and its relationships).
     *
     * It will do the following checks :
     * 1) asserts that each attributes member and each relationship name is valid
     * (@see isNotForbiddenResourceFieldName)
     *
     * @param array $resource
     *
     * @return void
     * @throws \VGirol\JsonApiStructure\Exception\ValidationException
     */
    public function validateFields($resource): void
    {
        if (\array_key_exists(Members::ATTRIBUTES, $resource)) {
            foreach (\array_keys($resource[Members::ATTRIBUTES]) as $name) {
                $this->isNotForbiddenResourceFieldName($name);
            }
        }

        if (array_key_exists(Members::RELATIONSHIPS, $resource)) {
            foreach (\array_keys($resource[Members::RELATIONSHIPS]) as $name) {
                $this->isNotForbiddenResourceFieldName($name);

                if (\array_key_exists(Members::ATTRIBUTES, $resource)
                    && \array_key_exists($name, $resource[Members::ATTRIBUTES])
                ) {
                    $this->throw(Messages::RESOURCE_FIELDS_CAN_NOT_HAVE_SAME_NAME, 403);
                }
            }
        }
    }

    /**
     * Asserts that a resource field name is not a forbidden name (like "type" or "id").
     *
     * @param string $name
     *
     * @return void
     * @throws \VGirol\JsonApiStructure\Exception\ValidationException
     */
    public function isNotForbiddenResourceFieldName(string $name): void
    {
        if (\in_array($name, $this->getRule('ResourceObject.FieldName.Forbidden'))) {
            $this->throw(Messages::RESOURCE_FIELDS_NAME_NOT_ALLOWED, 403);
        }
    }
}