Bakery\Types\EloquentMutationInputType

Complexity

Total Complexity

15

Size/Duplication

Total Lines	135
Duplicated Lines	0 %

Importance

Changes

0

5 Methods

Rating	Name	Duplication	Size	Complexity
A	getFillableFields()	0	5	2
A	getRelationFields()	0	15	3
A	getFieldsForPivot()	0	18	2
A	getFieldsForPolymorphicRelation()	0	18	3
A	getFieldsForRelation()	0	32	5

<?php

namespace Bakery\Types;

use Bakery\Utils\Utils;
use Bakery\Fields\Field;
use Illuminate\Support\Str;
use Bakery\Fields\EloquentField;
use Bakery\Support\Facades\Bakery;
use Illuminate\Support\Collection;
use Bakery\Fields\PolymorphicField;
use Bakery\Types\Definitions\EloquentInputType;
use Illuminate\Database\Eloquent\Relations\BelongsToMany;

abstract class EloquentMutationInputType extends EloquentInputType
{
    /**
     * Get the fillable fields for the input type.
     *
     * Here we grab the fillable fields from the model and filter out the
     * ones that are not a leaf type. Right now Bakery only supports passing
     * leaf types or list of leaf types as input. Complex, nested input only
     * work with relations.
     *
     * @return Collection
     */
    protected function getFillableFields(): Collection
    {
        return $this->modelSchema->getFillableFields()
            ->filter(function (Field $field) {
                return ! $field instanceof PolymorphicField && $field->setRegistry($this->registry)->getType()->isLeafType();
            });
    }

    /**
     * Get the fields for the relations of the model.
     *
     * @return Collection
     */
    protected function getRelationFields(): Collection
    {
        $relations = $this->modelSchema->getFillableRelationFields();

        return $relations->keys()->reduce(function (Collection $fields, $key) use ($relations) {
            $field = $relations[$key];

            if ($field instanceof EloquentField) {
                return $fields->merge($this->getFieldsForRelation($key, $field));
            } elseif ($field instanceof PolymorphicField) {
                return $fields->merge($this->getFieldsForPolymorphicRelation($key, $field));
            }

            return $fields;
        }, collect());
    }

    /**
     * Set the relation fields.
     *
     * @param string $relation
     * @param EloquentField $root
     * @return Collection
     */
    protected function getFieldsForRelation(string $relation, EloquentField $root): Collection
    {
        $fields = collect();
        $root->setRegistry($this->registry);
        $inputType = 'Create'.$root->getName().'Input';
        $relationship = $root->getRelation($this->model);

        if ($root->isList()) {
            $name = Str::singular($relation).'Ids';
            $field = $this->registry->field($this->registry->ID())->list()->nullable()->accessor($relation);
            $fields->put($name, $field);

            if ($this->registry->hasType($inputType)) {
                $field = $this->registry->field($inputType)->list()->nullable()->accessor($relation);
                $fields->put($relation, $field);
            }
        } else {
            $name = Str::singular($relation).'Id';
            $field = $this->registry->field($this->registry->ID())->nullable()->accessor($relation);
            $fields->put($name, $field);

            if ($this->registry->hasType($inputType)) {
                $field = $this->registry->field($inputType)->nullable()->accessor($relation);
                $fields->put($relation, $field);
            }
        }

        if ($relationship instanceof BelongsToMany) {
            $fields = $fields->merge($this->getFieldsForPivot($root, $relationship));
        }

        return $fields;
    }

    /**
     * Get the polymorphic relation fields.
     *
     * @param string $relation
     * @param \Bakery\Fields\PolymorphicField $field
     * @return Collection
     */
    protected function getFieldsForPolymorphicRelation(string $relation, PolymorphicField $field)
    {
        $fields = collect();
        $typename = Utils::typename($relation).'On'.$this->modelSchema->typename();
        $createInputType = 'Create'.$typename.'Input';
        $attachInputType = 'Attach'.$typename.'Input';

        if ($this->registry->hasType($createInputType)) {
            if ($field->isList()) {
                $fields->put($relation, $this->registry->field($createInputType)->list()->nullable());
                $fields->put($relation.'Ids', $this->registry->field($attachInputType)->list()->nullable());
            } else {
                $fields->put($relation, $this->registry->field($createInputType)->nullable());
                $fields->put($relation.'Id', $this->registry->field($attachInputType)->nullable());
            }
        }

        return $fields;
    }

    /**
     * Get the fields for a pivot relation.
     *
     * @param \Bakery\Fields\EloquentField $field
     * @param \Illuminate\Database\Eloquent\Relations\BelongsToMany $relation
     * @return Collection
     */
    protected function getFieldsForPivot(EloquentField $field, BelongsToMany $relation): Collection

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

    {
        $fields = collect();
        $pivot = $relation->getPivotClass();
        $relationName = $relation->getRelationName();

        if (! $this->registry->hasSchemaForModel($pivot)) {
            return collect();
        }

        $inputType = 'Create'.Utils::typename($relationName).'On'.$this->modelSchema->typename().'WithPivotInput';
        $fields->put($relationName, $this->registry->field($inputType)->list()->nullable());

        $name = Str::singular($relationName).'Ids';
        $inputType = Utils::pluralTypename($relationName).'PivotInput';
        $fields->put($name, $this->registry->field($inputType)->list()->nullable());

        return $fields;
    }
}