VGirol / JsonApi

src/Resources/HasRelationships.php

<?php

namespace VGirol\JsonApi\Resources;

use Illuminate\Support\Collection;
use Illuminate\Support\Str;

trait HasRelationships
{
    /**
     * Undocumented function
     * Could be overloaded, but it is not recommended.
     *
     * @param \Illuminate\Http\Request $request
     *
     * @return void
     */
    protected function setRelationships($request)
    {
        foreach ($this->includes->map->first()->filter() as $include) {
            // Get relationship
            $relationship = $this->getRelationship($request, $include);

Are you sure the assignment to $relationship is correct as $this->getRelationship($request, $include) targeting VGirol\JsonApi\Resources\HasRelationships::getRelationship() seems to always return null.

            // Add relationship
            $this->addResourceRelationship($include, $relationship);

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

        }
    }

    /**
     * Undocumented function
     *
     * @param \Illuminate\Http\Request $request
     * @param string $relationshipName
     *
     * @return void
     */
    private function getRelationship($request, string $relationshipName)
    {
        // Get relationship collection
        $elm = $this->resource->getRelation($relationshipName);

        if ($elm instanceof Collection) {
            $className = $this->aliases->getResourceIdentifierCollectionClassName(Str::plural($relationshipName));
        } else {
            $className = $this->aliases->getResourceIdentifierClassName(Str::plural($relationshipName));
        }

        return call_user_func_array(
            [$className, 'make'],
            [&$elm, $this->aliases]
        )->asRelationship($request, $this->resource, $relationshipName);
    }

    /**
     * Undocumented function
     * Could be overloaded, but it is not recommended.
     *
     * @param \Illuminate\Http\Request $request
     *
     * @return static
     */
    protected function setIncluded($request)
    {
        /** @var Collection $included A collection of ResourceObject objects */
        $included = $this->getAllIncludedResources();

        if ($included->isEmpty()) {
            return;
        }

        $this->addIncludedResources(

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

            $included->map->asIncluded($request)->toArray()
        );

        return $this;
    }

    /**
     * Undocumented function
     *
     * @return Collection
     */
    public function getAllIncludedResources()
    {
        $collection = collect([]);
        foreach ($this->includes as $include) {
            /** @var Collection $include */

            if ($include->isEmpty()) {
                continue;
            }

            // Retrieve included resources
            /** @var Collection $inc */
            $inc = $this->retrieveIncludedTree(clone $include);
            if ($inc->isEmpty()) {
                continue;
            }

            $collection = $collection->merge($inc);
        }

        return $collection->unique()->values();
    }

    /**
     * Returns a collection of ResourceObject objects.
     *
     * @param Collection $include
     *
     * @return Collection
     */
    private function retrieveIncludedTree($include)
    {
        // Get relationship name
        $relationshipName = $include->shift();

        // Get related collection
        if (!$this->resource->relationLoaded($relationshipName)) {
            $this->resource->load($relationshipName);
        }
        $elm = $this->resource->getRelation($relationshipName);
        if (!($elm instanceof Collection)) {
            $elm = collect([$elm]);
        }

        // Get resource class name
        $routeKey = Str::plural($relationshipName);
        $className = $this->aliases->getResourceClassName($routeKey);

        $inc = $elm->map(function ($item) use ($className, $include) {
            return call_user_func_array(
                [$className, 'make'],
                [$item, collect([$include])]
            );
        });

        if ($inc->isNotEmpty() && $include->isNotEmpty()) {
            $inc = $inc->merge(
                $inc->flatmap(
                    function ($item) use ($include) {
                        return $item->retrieveIncludedTree(clone $include);
                    }
                )
            );
        }

        return $inc->unique();
    }
}