How to implement a type definition with a field that could be one of several scalar types?

[gabrielalack]

I have a table that is a set of custom fields that people can configure, with an immutable type field that defines the data type of the value the field contains. The eloquent model has a couple of getters will return the correct field type based on the type specified as what the field is supposed to be, basically, string, float, carbon date, or boolean.

We have a default_value field on the custom_field table. We map them it to related records via a BelongsToMany relationship with a pivot table that has a pivot field event_value that relates directly to that data (in our case, concert/events)

Our Eloquent Model:

class CustomField extends Model
{
    public $timestamps = false;
    protected $hidden = ['pivot'];
    protected $fillable = [
        'name',
        'description',
        'type',
        'default_value',
        'organization_id'
    ];

    /**
     * @return bool|false|float|Carbon|string|null
     */
    public function getDefaultValueAttribute()
    {
        return self::castValueByType($this->type, $this->attributes['default_value']);
    }

    /**
     * Returns the event level value, but only when accessed via BelongsToMany from Event
     * @return bool|float|Carbon|string|null
     */
    public function getEventValueAttribute()
    {
        if(!isset($this->pivot->event_value)) {
            return null;
        }
        return self::castValueByType($this->type, $this->pivot->event_value);
    }

    /**
     * @param string $type
     * @param mixed $value
     * @return bool|float|Carbon|string|null
     */
    private static function castValueByType(string $type, $value)
    {
        switch($type) {
            case CustomFieldType::CURRENCY_AMOUNT:
            case CustomFieldType::NUMBER:
                return (float)$value;
            case CustomFieldType::TEXT:
            case CustomFieldType::TEXTAREA:
                return (string)$value;
            case CustomFieldType::DATE:
                return Carbon::create($value);
            case CustomFieldType::TOGGLE:
                return filter_var($value,FILTER_VALIDATE_BOOLEAN,FILTER_NULL_ON_FAILURE);
        }
        return null;
    }

    public function toArray(): array
    {
        if(isset($this->pivot)) {
            $this->appends = ['event_value'];
        }
        return parent::toArray();
    }
}

As you can see, if my model is defined as a date type, it will give me a Carbon object when I access $record->default_value. If the model has a type of 'toggle' it will give me a boolean value, etc.

The problem comes in when I need to define the type for GraphQL, which doesn't seem to like mixed types on a single field definition. How can I configure this?

class CustomFieldType extends GraphQLType
{
    protected $attributes = [
        'name' => 'CustomField',
        'model' => CustomField::class,
    ];

    public function fields(): array
    {
        return [
            'id' => [
                'type' => Type::int(),
            ],
            'organization_id' => [
                'type' => Type::int(),
            ],
            'name' => [
                'type' => Type::string(),
            ],
            'description' => [
                'type' => Type::string(),
            ],
            'type' => [
                'type' => Type::string(),
            ],
            'default_value' => [
                'type' => ???  <---------------
            ],
        ];
    }
}

[mfn]

GraphQL itself supports unions, see https://graphql.org/learn/schema/#union-types

However it's only supported on "object types", you can't have unions for int|string or something like that, only like Cat|Dog. The reason is that the sub-field __typename is required to make this work, and discrete types like int or string don't provide this.

If you don't care about the GraphQL type-safety system, you can always just make it return string and encode the value on the server with json and decode it on the client.

But besides that, this isn't possible (per the spec; not a limitation of this library iself).