Relay mutation to add edge to connection about lighthouse HOT 6 CLOSED

namespace App\Http\GraphQL\Edges;

use Nuwave\Lighthouse\Support\Interfaces\ConnectionEdge;

class CommentEdge implements ConnectionEdge
{
    /**
     * Name of edge.
     *
     * @return string
     */
    public function name()
    {
        return 'comment';
    }

    /**
     * Edge type.
     *
     * @return string
     */
    public function type()
    {
        return 'comment';
    }

    /**
     * Extract edge from payload.
     *
     * @param  mixed $payload
     * @return mixed
     */
    public function edge($payload)
    {
        return $payload['comment'];
    }

    /**
     * Resolve cursor.
     *
     * @param  mixed $payload
     * @return mixed
     */
    public function cursor($payload)
    {
        return $payload['game']->comments()->count();
    }
}

use GraphQL;
use GraphQL\Type\Definition\ResolveInfo;
use GraphQL\Type\Definition\Type;
use Hub\Game;
use Nuwave\Lighthouse\Support\Definition\GraphQLMutation;
use Nuwave\Lighthouse\Support\Interfaces\RelayMutation;

class CreateCommentMutation extends GraphQLMutation implements RelayMutation
{
    /**
     * Attributes of mutation.
     *
     * @var array
     */
    protected $attributes = [
        'description' => '',
        'name'        => 'createComment',
    ];

    /**
     * Available arguments on mutation.
     *
     * @return array
     */
    public function args()
    {
        return [
            'body'            => [
                'name'  => 'body',
                'type'  => Type::nonNull(Type::string()),
                'rules' => ['required'],
            ],
            'parentCommentId' => [
                'name' => 'parentCommentId',
                'type' => Type::ID(),
            ],
            'subjectId'       => [
                'name'  => 'subjectId',
                'type'  => Type::nonNull(Type::ID()),
                'rules' => ['required'],
            ],
            'subjectType'     => [
                'name'  => 'subjectType',
                'type'  => Type::nonNull(Type::string()),
                'rules' => ['required'],
            ],
        ];
    }

    /**
     * List of output fields.
     *
     * @return array
     */
    public function outputFields()
    {
        return [
            'commentEdge' => GraphQL::edge(new \App\Http\GraphQL\Edges\CommentEdge)->field(),
        ];
    }

    /**
     * Resolve the mutation.
     *
     * @param  array $args
     * @param  mixed $context
     * @param  ResolveInfo $info
     * @return mixed
     */
    public function mutateAndGetPayload(array $args, $context, ResolveInfo $info)
    {
        if ($args['subjectType'] == 'Game') {
            return $this->createGameComment($args);
        }
    }

    private function createGameComment($args)
    {
        $subjectId = $this->decodeRelayId($args['subjectId']);
        $parentCommentId = $args['parentCommentId'] ? $this->decodeRelayId($args['parentCommentId']) : null;
        $game = Game::findOrFail($subjectId); 

        $comment = $game->comments()->create([
            'body'        => $args['body'],
            'parent_id'   => $parentCommentId,
            'provider_id' => auth('providers')->id(),
            'user_id'     => auth('users')->id(),
        ]);

        return ['game' => $game, 'comment' => $comment];
    }
}

'comments' => GraphQL::connection('comment')
    ->resolve(function (Game $parent, array $args) {
        return $parent->comments()->whereNull('parent_id')->getConnection($args);
    })
    ->field(),

class CommentEdge implements ConnectionEdge
{
    /**
     * Name of edge.
     *
     * @return string
     */
    public function name()
    {
        return 'gameComments';
    }

    // ...
}

/**
 * List of output fields.
 *
 * @return array
 */
public function outputFields()
{
    return [
        'commentEdge' => [
            'name' => 'GameCommentsEdge',
            'description' => '',
            'fields' => [
                'node' => [
                    'type' => GraphQL::type('comment'),
                    'resolve' => function ($payload) {
                        return $payload['comment']
                    }
                ],
                'cursor' => [
                    'type' => Type::nonNull(Type::string()),
                    'resolve' => function ($payload) {
                        return $this->encodeGlobalId('arrayconnection', $payload['game']->comments()->count());
                    }
                ]
            ],
        ],
    ];
}