Wrap Types aren’t working correctly in the query

[ericsans]

Versions:

• graphql-laravel Version: 9.8.0
• Laravel Version: 10
• PHP Version: 8.3

Description:

I followed the example, but it still isn’t going as expected. (here)

MessageWrapper.php

<?php
declare(strict_types = 1);

namespace App\GraphQL\Types;


use GraphQL\Type\Definition\Type;
use Rebing\GraphQL\Support\Facades\GraphQL;

class MessageWrapper
{
    /**
     * @param string $typeName type graphql
     */
    public static function type(string $typeName): Type
    {
        return GraphQL::wrapType(
            $typeName,
            $typeName . 'Messages',
            WrapperType::class
        );
    }
}

WrapperType.php

<?php

declare(strict_types = 1);
namespace App\GraphQL\Types;

use GraphQL\Type\Definition\ObjectType;
use GraphQL\Type\Definition\Type as GraphQLType;
use Illuminate\Pagination\LengthAwarePaginator;
use Illuminate\Support\Collection;
use Rebing\GraphQL\Support\Facades\GraphQL;

class WrapperType extends ObjectType
{
    public function __construct(string $typeName, ?string $customName = null)
    {
        $name = $customName ?: $typeName . 'Wrapper';

        $underlyingType = GraphQL::type($typeName);

        $config = [
            'name' => $name,
            'fields' => $this->getMessagesFields($underlyingType),
        ];

        if (isset($underlyingType->config['model'])) {
            $config['model'] = $underlyingType->config['model'];
        }

        parent::__construct($config);
    }

    protected function getMessagesFields(GraphQLType $underlyingType): array
    {
        return [
            'data' => [
                'type' => GraphQLType::nonNull(GraphQLType::listOf(GraphQLType::nonNull($underlyingType))),
                'description' => 'List of items on the current page',
                'resolve' => function (LengthAwarePaginator $data): Collection {
                    return $data->getCollection();
                },
            ],
        ];
    }
}

OwnerQuery.php

<?php

declare(strict_types=1);

namespace App\GraphQL\Queries;

use App\GraphQL\Types\MessageWrapper;
use App\GraphQL\Types\WrapperType;
use App\Models\Owner;
use Closure;
use GraphQL\Type\Definition\ResolveInfo;
use GraphQL\Type\Definition\Type;
use Rebing\GraphQL\Support\Facades\GraphQL;
use Rebing\GraphQL\Support\Query;
use Rebing\GraphQL\Support\SelectFields;

class OwnersQuery extends Query
{
    protected $attributes = [
        'name' => 'owners',
        'description' => 'Display a listing of the Owner resources',
    ];

    public function type(): Type
    {
        return MessageWrapper::type('Owner');
        // return GraphQL::paginate('Owner');
    }

    public function args(): array
    {
        return [
            
        ];
    }

    public function resolve($root, array $args, $context, ResolveInfo $resolveInfo, Closure $getSelectFields)
    {
        /** @var SelectFields $fields */
        $fields = $getSelectFields();
        $select = $fields->getSelect();
        $with = $fields->getRelations();

        $owners = Owner::query()
            ->with($with)
            ->select($select)
            ->paginate(2);

        return $owners;
    }
}

Query

query Owners {
    owners {
        data {
            id
            full_name
        }
    }
}

Problem

I always get this SQL error:

SQLSTATE[42000]: Syntax error or access violation: 1064 You have an error in your SQL syntax; check the manual that corresponds to your MariaDB server version for the right syntax to use near 'from `owners` where `owners`.`deleted_at` is null limit 2 offset 0' at line 1 (Connection: mysql, SQL: select  from `owners` where `owners`.`deleted_at` is null limit 2 offset 0)

So the query ends up as select from owners... (with no fields selected).

But when I change the return type to use: GraphQL::paginate('Owner'); it works correctly and returns the result.

Best regards,
Eric Santoso

[mfn]

TBH I never used that wrapper myself, it was contributed 6 years ago and that's it.

It's best if you use a debugger and step through what's going on.

[ericsans]

After debugging, I found the issue originates from the SelectFields::handleFields method.

        foreach ($requestedFields['fields'] as $key => $field) {
            // Ignore __typename, as it's a special case
            if ('__typename' === $key) {
                continue;
            }

            // Always select foreign key
            if ($field === static::ALWAYS_RELATION_KEY) {
                static::addFieldToSelect($key, $select, $parentTable, false);

                continue;
            }

            // If field doesn't exist on definition we don't select it
            try {
                if (method_exists($parentType, 'getField')) {
                    $fieldObject = $parentType->getField($key);
                } else {
                    continue;
                }
            } catch (InvariantViolation $e) {
                continue;
            }

            $parentTypeUnwrapped = $parentType;

            if ($parentTypeUnwrapped instanceof WrappingType) {
                $parentTypeUnwrapped = $parentTypeUnwrapped->getInnermostType();
            }

            // First check if the field is even accessible
            $canSelect = static::validateField($fieldObject, $queryArgs, $ctx);

            if (true === $canSelect) {
                // Add a query, if it exists
                $customQuery = $fieldObject->config['query'] ?? null;

                // Check if the field is a relation that needs to be requested from the DB
                $queryable = static::isQueryable($fieldObject->config);

                // Pagination, adjust here add another section to check the wrapper class
                if (is_a($parentType, Config::get('graphql.pagination_type', PaginationType::class)) ||
                    is_a($parentType, Config::get('graphql.simple_pagination_type', SimplePaginationType::class))) {
                    /* @var GraphqlType $fieldType */
                    $fieldType = $fieldObject->config['type'];
                    static::handleFields(
                        $queryArgs,
                        $field,
                        $fieldType->getInnermostType(),
                        $select,
                        $with,
                        $ctx
                    );
                }
                // With

                elseif (\is_array($field['fields']) && !empty($field['fields']) && $queryable) {
                    if (isset($parentType->config['model'])) {
                        // Get the next parent type, so that 'with' queries could be made
                        // Both keys for the relation are required (e.g 'id' <-> 'user_id')
                        $relationsKey = $fieldObject->config['alias'] ?? $key;
                        $relation = \call_user_func([app($parentType->config['model']), $relationsKey]);

                        static::handleRelation($select, $relation, $parentTable, $field);

                        // New parent type, which is the relation
                        $newParentType = $parentType->getField($key)->config['type'];

                        static::addAlwaysFields($fieldObject, $field, $parentTable, true);

                        $with[$relationsKey] = static::getSelectableFieldsAndRelations(
                            $queryArgs,
                            $field,
                            $newParentType,
                            $customQuery,
                            false,
                            $ctx
                        );
                    } elseif (is_a($parentTypeUnwrapped, \GraphQL\Type\Definition\InterfaceType::class)) {
                        static::handleInterfaceFields(
                            $queryArgs,
                            $field,
                            $parentTypeUnwrapped,
                            $select,
                            $with,
                            $ctx,
                            $fieldObject,
                            $key,
                            $customQuery
                        );
                    } else {
                        // original
                        // static::handleFields($queryArgs, $field, $fieldObject->config['type'], $select, $with, $ctx);

                        // update here, will encountered another issue the relations can no longer be called
                        static::handleFields($queryArgs, $field, $fieldObject->config['type']->getInnermostType(), $select, $with, $ctx);
                    }
                }
                // Select
                else {
                    $key = $fieldObject->config['alias']
                        ?? $key;
                    $key = $key instanceof Closure ? $key() : $key;

                    static::addFieldToSelect($key, $select, $parentTable, false);

                    static::addAlwaysFields($fieldObject, $select, $parentTable);
                }
            }
            // If privacy does not allow the field, return it as null
            elseif (null === $canSelect) {
                $fieldObject->resolveFn = function (): void {
                };
            }

            static::addAlwaysFields($fieldObject, $select, $parentTable);
        }

When using the paginate class, it calls static::handleFields.
In your implementation, you set $parentType with $fieldType->getInnermostType().
However, after adding ->getInnermostType(), I encountered another issue the relations can no longer be called.
Another possible approach would be to adjust the WrapperType class to behave similarly to paginate.

And I plan to test it by implementing the WrappingType interface, and also look for alternatives without modifying the
SelectFields::handleFields

Best regards,
Eric Santoso