Wagtail Grapples and WebSocket

[VladimirLevadnij]

Hello, unfortunately I could not figure it out myself, so I ask you to give me an explanation on my question :-)

The description says:

This library is an abstraction upon and relies heavily on Graphene & Graphene Django.

Graphene
Graphene Django

Do I understand correctly that when using Wagtail Grapple, I can implement the ability from my front to work with the Wagtail backend via WebSocket?

Or do I need something else for this and Wagtail Grapple will not work for this?

[VladimirLevadnij]

Small additional details. I'm creating a project, for the backend one of the options was Django + Graphene, but I decided to use Wagtail 5 and Grapple in order to create a GraphQL API.

Front uses Quasar + Apollo. I have the functionality of various pages, including the user profile. And the functionality of a simple infinite canvas is created, on which the work of several users will be possible. I guess I need to use WebSocket for this. I'm trying to figure out how I can implement this on the side of the Wagtail 5 backend without wasting time.

So far, I have not quite understood how you can use Wagtail Grapple to implement WebSocket? If this is not possible, then I ask you to suggest what alternative solutions can be?

[VladimirLevadnij]

Can Wagtail Grapple work with Django Channels in the same way that Graphene does?

I'm just a little confused by this information:

This library is an abstraction upon and relies heavily on Graphene & Graphene Django.

Graphene
Graphene Django

I don't get it, does the fact that I'm using Wagtail Grapple mean that I can use the full power of Graphene / Graphene Django through Wagtail Grapple? 😺

[zerolab]

Prior to v0.20, we had support for websockets via graphql-ws. However that is currently unmaintained and incompatible with more recent versions of Graphene/ Graphene Django.

You could have a look at #336 to get an idea of what it was doing. And add your own implementation via the Subscription hook - https://wagtail-grapple.readthedocs.io/en/latest/general-usage/hooks.html#subscription.

I don't get it, does the fact that I'm using Wagtail Grapple mean that I can use the full power of Graphene / Graphene Django through Wagtail Grapple? 😺

Grapple provides the necessary abstractions for Wagtail-related code, but the hooks system should allow you to extend that to make more use of Graphene/Graphene Django (say via custom schema or mutations)

[VladimirLevadnij]

Thanks for your reply! I haven't figured out exactly how I can implement WebSocket using Wagtail Grapple yet, but I realized that I need to study the links you posted in more detail and then ask questions.

Now I would like to ask you, what is your opinion, what was the "ideal / best" use case for WebSocket using Wagtail Grapple and do you plan to implement such an "ideal / best" option? :-)

[VladimirLevadnij]

Prior to v0.20, we had support for websockets via graphql-ws. However, that is currently unmaintained and incompatible with more recent versions of Graphene/ Graphene Django.

Perhaps it was the best option and do you plan to bring it back in future releases? Or developers will no longer support the specified library? Do you plan to implement the use of its analogues or take this development under your own control?

[zerolab]

As far as I can tell, graphql-ws is no longer supported. There were some links in its issue queue for potential alternatives, but to be honest we had to draw a line somewhere as:

1. I don't have any active project that needs websockets
2. the maintenance overhead is too much.

So you will have to figure that bit on your own, I'm afraid. May I suggest you join the Wagtail Slack and use a thread in the #support or #headless channels. Perhaps others had a similar need

[VladimirLevadnij]

I'm still not good at this and would not like to be a person who just "pokes a finger in the sky", but perhaps there are libraries that you could / would like to integrate with Wagtail Grapple to get a full and convenient WebSocket functionality? :-)

Does this look like something suitable or is it something else and is not able to replace graphql-ws?

https://github.com/datadvance/DjangoChannelsGraphqlWs

[VladimirLevadnij]

To make my question clearer, perhaps I should phrase it like this:

Based on the assumption that DjangoChannelsGraphqlWs is currently the best solution for implementing WebSocket functionality, in this case, is there any clear mechanism, how can Wagtail Grapple be used to conveniently, quickly and reliably define GraphQL types and schemas, so that through DjangoChannelsGraphqlWs add support for GraphQL subscriptions via WebSocket, so that it would not be necessary to define types and schemas using Graphene Django in a more complicated way?

[VladimirLevadnij]

GPT-4 wrote this example, I tweaked it a bit, but I don’t know how well it works, I have replaced only the import so far. GPT-4 writes wagtail.core.models i corrected to wagtail.models.

Tell me, please, is this true?

---

Yes, you can use Wagtail Grapple for defining GraphQL types and schemas, and then use DjangoChannelsGraphqlWs for adding support for GraphQL subscriptions via WebSocket.

Here's an example of how you can do this:

1. Defining Types and Schemas with Wagtail Grapple

   In Wagtail Grapple, you can define GraphQL types for your Wagtail models using decorators and mixins provided by Wagtail Grapple. For instance, you can define a GraphQL type for a BlogPage model like this:

   from grapple.models import GraphQLString, GraphQLStreamfield
   from wagtail.core.models import Page
   
   class BlogPage(Page):
       content = StreamField(...)
       date_published = models.DateField(...)
       
       graphql_fields = [
           GraphQLString("title"),
           GraphQLStreamfield("content"),
           GraphQLString("date_published"),
       ]

   In this example, title, content, and date_published will be available in your GraphQL schema.

2. Adding Subscription Support with DjangoChannelsGraphqlWs

   After you've defined your GraphQL types with Wagtail Grapple, you can use DjangoChannelsGraphqlWs to add support for GraphQL subscriptions. You can define subscriptions in a separate file and then add them to your GraphQL schema. For example:

   from graphene import ObjectType, String, Field
   from rx import Observable
   
   class ObjectMoved(ObjectType):
       id = String()
       x = String()
       y = String()
   
   class Subscription(ObjectType):
       object_moved = Field(ObjectMoved)
   
       def resolve_object_moved(root, info):
           # Here you can subscribe to object move events
           # and return them via an Observable
           return Observable.create(lambda observer: None)

   In this example, Subscription is a GraphQL subscription that returns object_moved events. When an object is moved, the subscription sends a notification with the new coordinates of the object.

This allows you to leverage the conveniences and advantages of Wagtail Grapple for defining GraphQL types and schemas, and then add support for GraphQL subscriptions using DjangoChannelsGraphqlWs.

[zerolab]

Hey @VladimirLevadnij, I suggest you try and see what works.

DjangoChannelsGraphqlWs looks like it will work with Django 4.x and Graphene 3.x - https://github.com/datadvance/DjangoChannelsGraphqlWs/blob/master/pyproject.toml#L54-L56, which is encouraging.

Off the opt of my head, the one bit that you are likely missing here is the https://wagtail-grapple.readthedocs.io/en/latest/general-usage/hooks.html#subscription to register your custom subscription.

As before, I suggest you join the Wagtail Slack and start a thread in either #support or #headless channels.