Laravel\Forge\ApiResource

Complexity

Total Complexity

25

Size/Duplication

Total Lines	273
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	5

Importance

Changes

0

19 Methods

Rating	Name	Duplication	Size	Complexity
	resourceType()	0	1	?
	resourcePath()	0	1	?
A	__construct()	0	6	1
A	createFromResponse()	0	11	2
A	throwNotFoundException()	0	4	1
A	hasResourceOwner()	0	4	1
A	resourceOwner()	0	4	1
A	getApi()	0	4	1
A	getHttpClient()	0	4	1
A	getData()	0	4	1
A	getFullData()	0	4	1
A	apiUrl()	0	11	4
A	id()	0	4	1
A	name()	0	4	1
A	status()	0	4	1
A	createdAt()	0	4	1
A	update()	0	22	3
A	delete()	0	10	2
A	throwResourceException()	0	12	2

<?php

namespace Laravel\Forge;

use ArrayAccess;
use InvalidArgumentException;
use GuzzleHttp\ClientInterface;
use Psr\Http\Message\ResponseInterface;
use GuzzleHttp\Exception\RequestException;
use Laravel\Forge\Traits\ArrayAccessTrait;
use Laravel\Forge\Contracts\ResourceContract;
use Laravel\Forge\Exceptions\Resources\DeleteResourceException;
use Laravel\Forge\Exceptions\Resources\UpdateResourceException;

abstract class ApiResource implements ArrayAccess, ResourceContract
{
    use ArrayAccessTrait;

    /**
     * @var \Laravel\Forge\ApiProvider
     */
    protected $api;

    /**
     * @var array
     */
    protected $data = [];

    /**
     * @var \Laravel\Forge\Contracts\ResourceContract
     */
    protected $owner;

    /**
     * Create new resource instance.
     *
     * @param \Laravel\Forge\ApiProvider                $api   = null
     * @param array                                     $data  = []
     * @param \Laravel\Forge\Contracts\ResourceContract $owner
     */
    public function __construct(ApiProvider $api = null, array $data = [], ResourceContract $owner = null)
    {
        $this->api = $api;
        $this->data = $data;
        $this->owner = $owner;
    }

    /**
     * Resource type.
     *
     * @return string
     */
    abstract public static function resourceType();

    /**
     * Resource path (relative to owner or API root).
     *
     * @return string
     */
    abstract public function resourcePath();

    /**
     * Create new Resource instance from HTTP response.
     *
     * @param \Psr\Http\Message\ResponseInterface       $response
     * @param \Laravel\Forge\ApiProvider                $api
     * @param \Laravel\Forge\Contracts\ResourceContract $owner    = null
     *
     * @return static
     */
    public static function createFromResponse(ResponseInterface $response, ApiProvider $api, ResourceContract $owner = null)
    {
        $json = json_decode((string) $response->getBody(), true);
        $resourceType = static::resourceType();

        if (empty($json[$resourceType])) {
            static::throwNotFoundException();
        }

        return new static($api, $json[$resourceType], $owner);
    }

    /**
     * Throw HTTP Not Found exception.
     *
     * @throws \InvalidArgumentException
     */
    protected static function throwNotFoundException()
    {
        throw new InvalidArgumentException('Given response is not a '.static::resourceType().' response.');
    }

    /**
     * Determines if current resource has an owner.
     *
     * @return bool
     */
    public function hasResourceOwner(): bool
    {
        return !is_null($this->owner);
    }

    /**
     * Get current resource owner.
     *
     * @return \Laravel\Forge\Contracts\ResourceContract|null
     */
    public function resourceOwner()
    {
        return $this->owner;
    }

    /**
     * Get API provider.
     *
     * @return \Laravel\Forge\ApiProvider
     */
    public function getApi(): ApiProvider
    {
        return $this->api;
    }

    /**
     * Get underlying API provider's HTTP client.
     *
     * @return \GuzzleHttp\ClientInterface
     */
    public function getHttpClient(): ClientInterface
    {
        return $this->api->getClient();
    }

    /**
     * Get resource data.
     *
     * @param string|int $key
     * @param mixed      $default = null
     *
     * @return mixed|null
     */
    public function getData($key, $default = null)
    {
        return $this->data[$key] ?? $default;
    }

    /**
     * Get full resource data.
     *
     * @return array
     */
    public function getFullData()
    {
        return $this->data;
    }

    /**
     * Resource API URL.
     *
     * @param string $path            = ''
     * @param bool   $withPropagation = true
     *
     * @return string
     */
    public function apiUrl(string $path = '', bool $withPropagation = true): string
    {
        $path = ($path ? '/'.ltrim($path, '/') : '');
        $resourcePath = rtrim($this->resourcePath(), '/').'/'.$this->id().$path;

        if (!$this->hasResourceOwner() || !$withPropagation) {
            return $resourcePath;
        }

        return $this->resourceOwner()->apiUrl($resourcePath);
    }

    /**
     * Resource ID.
     *
     * @return int
     */
    public function id(): int
    {
        return intval($this->getData('id', 0));
    }

    /**
     * Resource name.
     *
     * @return string|null
     */
    public function name()
    {
        return $this->getData('name');
    }

    /**
     * Resource status.
     *
     * @return string|null
     */
    public function status()
    {
        return $this->getData('status');
    }

    /**
     * Get resource creation date.
     *
     * @return string|null
     */
    public function createdAt()
    {
        return $this->getData('created_at');
    }

    /**
     * Update resource data.
     *
     * @param array $payload
     *
     * @throws UpdateResourceException
     *
     * @return bool
     */
    public function update(array $payload): bool
    {
        $resourceType = static::resourceType();

        try {
            $response = $this->getHttpClient()->request('PUT', $this->apiUrl(), [
                'json' => $payload,
            ]);
        } catch (RequestException $e) {
            $this->throwResourceException($e->getResponse(), 'update', UpdateResourceException::class);

It seems like $e->getResponse() can be null; however, throwResourceException() does not accept null, maybe add an additional type check?

        }

        $json = json_decode((string) $response->getBody(), true);

        if (empty($json[$resourceType])) {
            return false;
        }

        $this->data = $json[$resourceType];

        return true;
    }

    /**
     * Delete current resource.
     *
     * @throws \Laravel\Forge\Exceptions\Resources\DeleteResourceException
     *
     * @return bool
     */
    public function delete()
    {
        try {
            $this->getHttpClient()->request('DELETE', $this->apiUrl());
        } catch (RequestException $e) {
            $this->throwResourceException($e->getResponse(), 'delete', DeleteResourceException::class);

It seems like $e->getResponse() can be null; however, throwResourceException() does not accept null, maybe add an additional type check?

        }

        return true;
    }

    /**
     * Throw resource exception.
     *
     * @param \Psr\Http\Message\ResponseInterface $response
     * @param string                              $action
     * @param string                              $exceptionClass
     *
     * @throws \Exception
     */
    protected function throwResourceException(ResponseInterface $response, string $action, string $exceptionClass)
    {
        $message = 'Unable to '.$action.' resource (type: '.static::resourceType().', ID: '.$this->id().').';

        if (is_null($response)) {
            throw new InvalidArgumentException($message);
        }

        $message .= ' Server response: "'.((string) $response->getBody()).'".';

        throw new $exceptionClass($message, $response->getStatusCode());
    }
}