Single subscription for create, update, delete

[techknowfile]

I am new to GraphQL as a whole, so I'm sorry if this question is naive.

I was hoping to create a single subscription for CREATED, DELETED, and UPDATED so that it's simple for my client to stay in sync with an object or set of objects, but am not sure exactly how to pull this off. The thought was that the subscription would return another field that informs me of the operation that was executed so that my frontend knows how to handle it.

Any chance you could provide an example of how this could be accomplished if possible?

I'm ultimately going to be trying to create a CUD subscription for a set of different models related to a parent model.
e.g. If a BankAccount object has credit objects and debit objects, and there are many different BankAccounts, I'd want to be able to subscribe to CUD events of ALL of the related objects of a specific Bank Account

[shreyas44]

class Foo(graphene_subscriptions.ModelSubscription):
  class Arguments:
    # arguments for the query

  class Meta:
     model = YourModel

  payload = graphene.Field(YourObjectType)
  operation = graphene.String()

  def on_save(root, info, event):
    # do something
    return Foo(payload=event.instance, operation=event.operation)

  def on_update(root, info, event):
    # do something
    return Foo(payload=event.instance, operation=event.operation)

  def on_delete(root, info, event):
    # do something
    return Foo(payload=event.instance, operation=event.operation)

class Subscription(graphene.ObjectType):
  foo = Foo.Field()

Are you suggesting something like this?
This is not possible yet, but I was looking at implementing something like this and sending a PR (still have to look into the implementation of something like this).

[techknowfile]

Yeah, so I was seeing the graphcool documentation which shows a subscription to all changes to nodes.

If I used the code below, I could be informed of there being any type of operation on the Hires object, but I wouldn't know what type of operation it was.

    def resolve_hires_changed(root, info):
        return root.filter(
            lambda event:
            event.operation in (CREATED, DELETED, UPDATED) and
            isinstance(event.instance, HiresModel)
        ).map(lambda event: event.instance)

The next question is then how I could compose multiple subscriptions together into a single subscription. I will basically have a bunch of different "master models", each with lists of submodels. I'd want to be able to subscribe to a single subscription to get notifications of all events that occurred to submodels of the master model.

MasterModel1 {
    subModelAs: [SubModelA, SubModelA],
    subModelBs: [SubModelB, SubModelB],
    subModelCs: [SubModelC, SubModelC]
},
MasterModel2 {
    subModelAs: [SubModelA, SubModelA],
    subModelBs: [SubModelB, SubModelB],
    subModelCs: [SubModelC, SubModelC]
}

e.g. Subscribing to MasterModel2 would give me all CUD events that occur to its submodels, but not to MasterModel1's submodels

[shreyas44]

I'm not sure how to achieve that yet. The library seems to be using rxPy to run your code whenever a model event is triggered. Since I've never worked with the library, I will look into it and get back to you ASAP!

[shreyas44]

@techknowfile I'm really sorry for the late response. I just submitted a draft pull request which you can check out at #28 which lets you achieve what you're looking for without having to work around much and also lets your write cleaner code!

However to achieve what you're looking for right now you could do something like this:

def resolve_hires_changed(root, info, filter):
       def process_change(event):
              if event.operation in (CREATED, DELETED, UPDATED) and isinstance(event.instance, HiresModel):
                     instance = event.instance
                     operation = event.operation

                     # do whatever your application needs to do with the instance and operation
                     
                     return something # something referring to an object matching the structure of your Field Type which presumably contains an event attribute. 

       return root.map(lambda event: process_change(event))

I didn't completely get what you're trying to achieve so let me know if you have any further queries!

[techknowfile]

I'm just trying to create a single subscription for CREATE, DELETE, UPDATE. I was hoping the field name returned to the frontend could be changed based on the operation. Is the only way to get that information up to the frontend to create another field that stores the operation?

Update:
I've potentially accomplished what I need to with the following:

1. I created a new Field type that adds the mutation field

class HiresSubscriptionPayload(Hires):
    mutation = graphene.String(required=True)

    class Meta:
        model = HiresModel

2. Added the event operation to the model instance

class Subscription(graphene.ObjectType):
    hires_changed = graphene.Field(HiresSubscriptionPayload)

    def resolve_hires_changed(root, info):
        def process_change(event):
            print(event.instance)
            event.instance.mutation = event.operation
            return event.instance
        return root.filter(
            lambda event:
            event.operation in (CREATED, DELETED, UPDATED) and
            isinstance(event.instance, HiresModel)
        ).map(process_change)

3. Added the mutation field to my gql subselection

subscription {
	hiresChanged {
    mutation
    id
    date
    value
  }
}

I have yet to test how this might impact the mst-gql library I'm using on the frontend

Update 2: So this approach made my frontend consider "Hires" and "HiresSubscriptionPayload" as two different fields (makes sense). But I really need them to be a single field. Is it not possible to pass up additional information with the payload without modifying the field?

[shreyas44]

I'm just trying to create a single subscription for CREATE, DELETE, UPDATE. I was hoping the field name returned to the frontend could be changed based on the operation. Is the only way to get that information up to the frontend to create another field that stores the operation?

Do you mean you want to change the output based on what the operation is? And if you want different output for different operations, will the payload of 3 situation be of the Hire Type?

Update 2: So this approach made my frontend consider "Hires" and "HiresSubscriptionPayload" as two different fields (makes sense). But I really need them to be a single field. Is it not possible to pass up additional information with the payload without modifying the field?

The payload can only contain information what the output type can contain. So if your output type is Hires, you will not be able to query for the mutation field as mutation is not specified as a field in the Hires Type. There is no way to add an additional field without specifying a new type like HiresSubscriptionPayload.

[techknowfile]

Wanted to stop by to provide the solution that I landed on.

First off, I didn't like how the graphene_subscription signals were separated for post_save_subscription and post_delete_subscription, where the only purpose of those different signals was to set the operation. Instead, I created a single signal that can handle all three cases:

@receiver([post_save, post_delete], sender=Area)    
def master_subscription(sender, **kwargs):    
    if 'created' in kwargs:    
       operation = CREATED if kwargs['created'] else UPDATED    
    else:    
       operation = DELETED    
    event = MasterSubscriptionEvent(    
       operation=operation,    
       instance=kwargs['instance']    
    )    
    event.send()

Moreover, by using the signal function definition, I'm able to use the @receiver decorator and just append new decorators for each model type. Even better, I'll be able to create a NEW decorator that wraps @receiver, and have that new decorator take just a list of models, so I'll then only need a single decorator and a single list of the models that I want to subscribe to the CUD operations of, and graphene_subscriptions will then be prepared to create subscriptions for any changes to those objects.

You'll notice I also created my own event class, which inherits the ModelSubscriptionEvent class. Because I needed to be able to subscribe to all descendent models of a specified master model instance (in this case, by the name of the master instance), each descendent model instance needed to be able to determine the master instance that it belongs to (either via attribute [a direct foreign key]) or a property (to query up the tree).

Just as the ModelSubscriptionEvent confirms that the object observing it is a Django model, my MasterSubscriptionEvent does all of that, and then also confirms that the master attribute/property exists.

 MasterSubscriptionEvent(ModelSubscriptionEvent):    
    def __init__(self, distribution_center=None, operation=None, instance=None):    
        super(MasterSubscriptionEvent, self).__init__(operation, instance)    
                
        # Get root (master) model corresponding to current model  instance
        try:    
            self.master = self.instance.master.name
        except AttributeError:    
            raise ValueError("Django Model must have 'master' attribute or property to determine its master (root) ancestor!")    
                                                    
    def to_dict(self):                                     
        _dict = super(MasterSubscriptionEvent, self).to_dict()    
                                                                 
        _dict["master"] = self.master    
                               
        return _dict   

Finally, I needed to create a GraphQL subscription for any CUD operations performed on a specific model type (say, SubSubModel) for SubSubModel instances that are descendants of a specified Master instance:

class SubSubModelPayload(graphene.ObjectType):
    master = graphene.String()
    mutation = graphene.String()
    data = graphene.Field(SubSubModelType)

class SubSubModelSubscription(graphene.ObjectType):
    subsubmodel_by_master = graphene.Field(SubSubModelPayload, master=graphene.String())

    def resolve_subsubmodel_by_master(root, info, master):
        return root.filter(
            lambda event:
            isinstance(event.instance, SubSubModel) and
            master == event.master
        ).map(lambda event: {"master": event.master, "mutation": event.operation, "data": event.instance})

Note that I don't need to filter by operation (because currently the only three operations are CREATE, UPDATE, DELETE, and I'm interested in all three), and instead just add the name of the master instance and the mutation to my PayloadObjectType so that the frontend knows which master model the subscription event is for and what kind of mutation (operation) occurred.

When I initially asked this question, I was hoping to create a single subscription for a master model which would return all different kinds of ObjectTypes depending on what kind of object instance was modified. This turned out to be a bad idea, because you then have to wrestle with creating a GraphQL object type that can contain any of the different object types that subscription might contain. Any way you approach this, whether it be Union types or payloads that have a field for each possible objecttype, it would be a nightmare.

Instead, I settled on creating one subscription per model type, each with a parameter of the master instance. I can then have my frontend programmatically subscribe to all the necessary subscription (a subscription per descendent model of the Master model) if I want to.