How to pass a model to the broadcast, to the fields of which field resolvers have already been applied?

[zabavnikov]

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

    public function fields(): array
    {
        return [
            'id' => [
                'type' => GraphQL::type('Int!'),
            ],
            'user_id' => [
                'type' => GraphQL::type('Int!'),
            ],
            'disk' => [
                'type' => GraphQL::type('String!'),
            ],
            'path' => [
                'type' => GraphQL::type('String!'),
            ],
            'image' => [
                'type' => GraphQL::type('String!'),
                'selectable' => false,
                'always' => ['disk', 'path'],
                'args' => [
                    'sizes' => [
                        'type' => GraphQL::type('String'),
                        'description' => 'Example: resize:fit:80:80',
                    ],
                ],
                'resolve' => function ($root, $args) {
                    if (isset($args['sizes'])) {
                        return Resize::resize($root->image, $args['sizes']);
                    }

                    return $root->image;
                }
            ],
        ];
    }
}

mutation ($image: Upload!) {
  createShot(image: $image) {
    id
    image(sizes: "resize:fit:80:160")
  }
}

Inside the mutation in the resolve method, I call broadcast(new ShotCreated($shot))->toOthers(), but it gets the raw fields of the model, which has not yet applied the resolver from ShotType.

[mfn]

which has not yet applied the resolver from ShotType

How to you "get" $shot? Please show the full code of the resolver.

[zabavnikov]

public function resolve($root, array $args, $context, ResolveInfo $resolveInfo, Closure $getSelectFields)
{
    \Illuminate\Support\Facades\Validator::make($args, [
        'images'    => ['array', 'min:1', 'max:1'],
        'images.*'  => [new ImageMimes, 'max:20480'],
    ])->validate();

    $fields = $getSelectFields();

    $insert = [];

    foreach ($args['images'] as $image) {
        $image = Image::make($image)->orientate();

        $f = [
            'user_id' => auth()->id(),
            'path'     => image_storage('shots'),
            'disk'  => config('filesystems.default'),
        ];

        if ($image->width() > 480) {
            $image->widen(480, function ($constraint) {
                $constraint->aspectRatio();
                $constraint->upsize();
            });
        }

        $isUploaded = Storage::put($f['path'], (string) $image->encode('jpg'));

        if ($isUploaded) {
            $insert = $f;
        }

        $image->destroy();
    }

    $shot = null;

    if (! empty($insert)) {
        DB::transaction(function () use ($insert, $fields, &$shot) {
            $shot = Shot::create($insert);

            $shot = Shot::select($fields->getSelect())
                ->with($fields->getRelations())
                ->find($shot->id);

            broadcast(new ShotPublished($shot))->toOthers();
        });
    }

    return $shot;
}

[zabavnikov]

Is there any way to run broadcast(new ShotPublished($shot))->toOthers(); after resolve and in ShotPublished, pass the model to which the resolve from ShotType has already been applied?

[zabavnikov]

Found a temporary solution, but maybe not temporary. :)

Created my MyGraphQLController.
In the query method after these lines

$data = Helpers::applyEach(
   function (BaseOperationParams $baseOperationParams) use ($schemaName, $graphql): array {
       $operationParams = new OperationParams($baseOperationParams);

       return $graphql->execute($schemaName, $operationParams);
   },
   $operations
);

added

$mutationName = array_keys($data['data'])[0];
$subscriptions = array_keys($config->get('graphql.subscriptions'));

if (in_array($mutationName, $subscriptions)) {
    $class = $config->get('graphql.subscriptions')[$mutationName];
    broadcast(new $class($data['data'][$mutationName]))->toOthers();
}

In graphql config added

'route' => [
    'controller' => Trevio\Common\GraphQL\MyGraphQLController::class . '@query',
],

'subscriptions' => [
    'createShot' => Trevio\Modules\Shots\GraphQL\Subscriptions\OnShotCreated::class
],

OnShotCreated

<?php

namespace Trevio\Modules\Shots\GraphQL\Subscriptions;

use Illuminate\Broadcasting\Channel;
use Illuminate\Broadcasting\InteractsWithSockets;
use Illuminate\Contracts\Broadcasting\ShouldBroadcast;
use Illuminate\Foundation\Events\Dispatchable;

class OnShotCreated implements ShouldBroadcast
{
    use Dispatchable, InteractsWithSockets;

    public $model;

    public function __construct($model)
    {
        $this->model = $model;
    }

    public function broadcastAs(): string
    {
        return 'shots.created';
    }

    public function broadcastOn(): Channel
    {
        return new Channel('public');
    }
}

Now the correct data is sent to the frontend in real time.

But perhaps there is a more elegant solution.

[mfn]

but it gets the raw fields of the model, which has not yet applied the resolver from ShotType.

Because you are fetching an Eloquent model: that particular code is unrelated to GraphQL and therefore your broadcaster receives Eloquent not GraphQL.

It's not a good separation to have your GraphQL shapes bleed into other parts, there should be a clear boundary.

I can take a guess it's about the image resolve which also performs a resize and returns the new path? I'd say that's the problem that the resolver performs this and this should be handled in a different way but I'm not sure I can give your more guidance here.

As for your workaround: if you want to stick to that approach, it's essentially a "post"-step into the whole "graphql execution middleware" used by this package. The use of subscriptions seems misused simply a config value holder.

I think what would be more idiomatic if you have to stick to the GraphQL data structure, is to just override \Rebing\GraphQL\GraphQL::appendGraphqlExecutionMiddleware and append your own middleware doing what you did in the query method: that would separate the concerns better. But I didn't try it and if it turns it doesn't fit your approach, then I think you found your solution already (overriding query; but I would definitely suggest not to misuse the supscriptions from the config for that).

[zabavnikov]

@mfn, thanks for the reply. I have to use a translator, as a result, a lot of meaning is lost. I'm not sure that I understood everything you wrote, but I tried. :)

With the help of your hints, I came up with the following solution:

I create my own GraphqlExecutionMiddleware and transfer a piece of code from GraphQLController to it

class GraphqlExecutionMiddleware extends AbstractExecutionMiddleware
{
    /** @var Repository */
    private $config;

    public function __construct(Repository $config)
    {
        $this->config = $config;
    }

    public function handle(string $schemaName, Schema $schema, OperationParams $params, $rootValue, $contextValue, Closure $next): ExecutionResult
    {
        $query = $params->getParsedQuery();

        $defaultFieldResolver = $this->config->get('graphql.defaultFieldResolver');

        $result = GraphQLBase::executeQuery($schema, $query, $rootValue, $contextValue, $params->variables, $params->operation, $defaultFieldResolver);

        $mutationName = array_keys($result->data)[0];
        $broadcast = array_keys(config('graphql.broadcast'));

        if (in_array($mutationName, $broadcast)) {
            $class = config('graphql.broadcast')[$mutationName];
            broadcast(new $class($result->data[$mutationName]))->toOthers();
        }

        return $result;
    }
}

graphql config

'schemas' => [
    'default' => [
        'execution_middleware' => [
            \Trevio\Common\GraphQL\GraphqlExecutionMiddleware::class,
        ],
    ],
],

'broadcast' => [
    'createShot' => Trevio\Modules\Shots\GraphQL\Events\OnShotCreated::class,
],

I like this solution better.

[zabavnikov]

Seems Graphql Execution Middleware is being executed twice, once mine and once from the package.

Upd:
I have read https://github.com/rebing/graphql-laravel#schemas. Now it is clear that the second option with GraphqlExecutionMiddleware is not correct.

[zabavnikov]

Option 3

MyGraphQLExecutionMiddleware:

<?php

declare(strict_types = 1);

namespace Trevio\Common\GraphQL;

use Closure;
use GraphQL\Executor\ExecutionResult;
use GraphQL\GraphQL as GraphQLBase;
use GraphQL\Type\Schema;
use Illuminate\Contracts\Config\Repository;
use Rebing\GraphQL\Support\OperationParams;
use Rebing\GraphQL\Support\ExecutionMiddleware\AbstractExecutionMiddleware;

/**
 * This middleware is always added via \Rebing\GraphQL\GraphQL::appendGraphqlExecutionMiddleware
 */
class MyGraphQLExecutionMiddleware extends AbstractExecutionMiddleware
{
    /** @var Repository */
    private $config;

    public function __construct(Repository $config)
    {
        $this->config = $config;
    }

    public function handle(string $schemaName, Schema $schema, OperationParams $params, $rootValue, $contextValue, Closure $next): ExecutionResult
    {
        $query = $params->getParsedQuery();

        $defaultFieldResolver = $this->config->get('graphql.defaultFieldResolver');

        $result = GraphQLBase::executeQuery($schema, $query, $rootValue, $contextValue, $params->variables, $params->operation, $defaultFieldResolver);

        $mutationName = array_keys($result->data)[0];
        $broadcast = array_keys(config('graphql.broadcast'));

        if (in_array($mutationName, $broadcast)) {
            $class = config('graphql.broadcast')[$mutationName];
            broadcast(new $class($result->data[$mutationName]))->toOthers();
        }

        return $result;
    }
}

MyGraphQL:

<?php

declare(strict_types = 1);

namespace Trevio\Common\GraphQL;

use Rebing\GraphQL\GraphQL;

class MyGraphQL extends GraphQL
{
    /**
     * @phpstan-param array<class-string> $middlewares
     * @phpstan-return array<class-string>
     */
    protected function appendGraphqlExecutionMiddleware(array $middlewares): array
    {
        $middlewares[] = MyGraphQLExecutionMiddleware::class;

        return $middlewares;
    }
}

@mfn am i on the right track? :)

Now the question is, where and how do I register MyGraphQL?

[mfn]

Now the question is, where and how do I register MyGraphQL?

Good question, haven't had the need for this in a long time.

Seems a bit involved… or maybe the easiest would be:

• use your own controller, extend/override \Rebing\GraphQL\GraphQLController::query
• and replace GraphQL $graphql with your own

But I guess you would need to respect/duplicate the registration done in \Rebing\GraphQL\GraphQLServiceProvider::registerGraphQL, not yet sure.

HTH

[zabavnikov]

@mfn, thx. For the first time, I will choose a solution with a controller.