Huntie\JsonApi\Support\JsonApiTransforms

Complexity

Total Complexity

15

Size/Duplication

Total Lines	168
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	3

Importance

Changes	5
Bugs	0	Features	1

7 Methods

Rating	Name	Duplication	Size	Complexity
B	transformRecord()	0	37	6
A	transformRecordSimple()	0	13	1
A	transformRecordIdentifier()	0	9	1
A	transformCollection()	0	17	2
A	transformCollectionSimple()	0	8	1
A	transformCollectionIdentifiers()	0	8	1
A	transformRelationship()	0	12	3

<?php

namespace Huntie\JsonApi\Support;

use Illuminate\Database\Eloquent\Model;
use Illuminate\Pagination\LengthAwarePaginator;
use Illuminate\Support\Collection;

/**
 * Transform Eloquent models and collections into JSON API objects.
 */
trait JsonApiTransforms
{
    /**
     * Transform a model instance into a JSON API object.
     *
     * @param Model      $record
     * @param array|null $fields  Field subset to return
     * @param array|null $include Relations to include
     *
     * @return array
     */
    protected function transformRecord($record, array $fields = [], array $include = [])
    {
        $relations = array_unique(array_merge($record->getRelations(), $include));
        $record = $record->load($relations);

        $attributes = $record->toArray();
        $relationships = [];
        $included = [];

        foreach ($relations as $relation) {
            $relationships[$relation] = $this->transformRelationship($record, $relation);

            if (in_array($relation, $include)) {
                if ($record->{$relation} instanceof Collection) {
                    $included = array_merge($included, $this->transformCollectionSimple($record->{$relation})['data']);
                } else if ($record->{$relation} instanceof Model) {
                    $included = array_merge($included, $this->transformRecordSimple($record->{$relation})['data']);
                }
            }
        }

        array_forget($attributes, $relations);
        $included = array_filter($included);

        if (!empty($fields)) {
            $attributes = array_only($attributes, $fields);
        }

        $data = array_filter([
            'type' => $record->getTable(),
            'id' => $record->id,
            'attributes' => array_except($attributes, ['id']),
            'relationships' => $relationships,
        ]);

        return array_filter(compact('data', 'included'));
    }

    /**
     * Transform a model instance into a JSON API object without additonal data.
     *
     * @param Model $record
     *
     * @return array
     */
    protected function transformRecordSimple($record)
    {
        $attributes = array_diff_key($record->toArray(), $record->getRelations());
        $attributes = array_except($attributes, ['id']);

        return [
            'data' => [
                'type' => $record->getTable(),
                'id' => $record->id,
                'attributes' => $attributes,
            ]
        ];
    }

    /**
     * Transform a model instance into a JSON API resource identifier.
     *
     * @param Model $record
     *
     * @return array
     */
    protected function transformRecordIdentifier($record)

The parameter $record is not used and could be removed.

    {
        return [
            'data' => [
                'type' => $relatedRecord->getTable(),

The variable $relatedRecord does not exist. Did you mean $record?

                'id' => $relatedRecord->id,

The variable $relatedRecord does not exist. Did you mean $record?

            ]
        ];
    }

    /**
     * Transform a set of models into a JSON API collection.
     *
     * @param Collection|LengthAwarePaginator $records
     * @param array                           $fields
     *
     * @return array
     */
    protected function transformCollection($records, array $fields = [])
    {
        $data = $records->map(function ($record) use ($fields) {

The method map does only exist in Illuminate\Support\Collection, but not in Illuminate\Pagination\LengthAwarePaginator.

            return $this->transformRecord($record, $fields)['data'];
        })->toArray();

        $links = [];

        if ($records instanceof LengthAwarePaginator) {
            $links['first'] = $records->url(1);
            $links['last'] = $records->url($records->lastPage());
            $links['prev'] = $records->previousPageUrl();
            $links['next'] = $records->nextPageUrl();
        }

        return array_merge(compact('data'), array_filter(compact('links')));
    }

    /**
     * Transform a set of models into a JSON API collection without additional data.
     *
     * @param Collection $records
     *
     * @return array
     */
    protected function transformCollectionSimple($records)
    {
        $data = $records->map(function ($record) {
            return $this->transformRecordSimple($record)['data'];
        })->toArray();

        return compact('data');
    }

    /**
     * Transform a set of models into a collection of JSON API resource
     * identifier objects.
     *
     * @param Collection $records
     *
     * @return array
     */
    protected function transformCollectionIdentifiers($records)
    {
        $data = $records->map(function ($record) {
            return $this->transformRecordIdentifier($record)['data'];
        });

        return compact('data');
    }

    /**
     * Transform a model relationship into a single, or collection of, JSON API
     * resource identifier objects.
     *
     * @param Model  $record
     * @param string $relation
     *
     * @return array
     */
    protected function transformRelationship($record, $relation)
    {
        $data = null;

        if ($record->{$relation} instanceof Collection) {
            return $this->transformCollectionIdentifiers($record->{$relation});
        } else if ($record->{$relation} instanceof Model) {
            return $this->transformRecordIdentifier($record->{$relation});
        }

        return compact('data');
    }
}