How does one invoke resolvers of queries associated with a sub schema?

[pliablepixels]

Hello, this may well be a basic GQL question. Consider the following (completely made up names):

schemas/root.graphql:

type Query {
  _empty:String
}

schemas/subSchema.graphql:

extend type Query {
    compute_subSchema:SubSchema
}
type SubSchema {
    value:String
    object: SomeThingElse
}

type SomeThingElse {
    key: String
    value: Int
}

resolvers/subSchema.py:

...

class SubSchema:
   def __init__(self):
         self.query = ObjectType('Query')
         self.query.set_field('compute_subSchema', self.resolve_subSchema)
   def get_resolver(self):
        return self.query
   def resolve_subSchema(self, obj, info):
         # do whatever

schemas/masterSchema.graphql

extend type Query {
         compute_masterSchema:MasterSchema
}
type MasterSchema {
   masterValue: Record
   subSchema:SubSchema
}
type Record {
    field1: Int
    field2: String
}

resolvers/masterSchema.py

...

class MasterSchema:
   def __init__(self):
         self.query = ObjectType('Query')
         self.query.set_field('compute_masterSchema', self.resolve_masterSchema)
   def get_resolver(self):
        return self.query
   def resolve_masterSchema(self, obj, info):
         # do whatever

main.py:

from ariadne import make_executable_schema, load_schema_from_path
from ariadne.asgi import GraphQL
from resolvers.subSchema import SubSchema
from resolvers.masterSchema import MasterSchema
list_of_resolvers = [SubSchema(), MasterSchema()]

types_list = load_schema_from_path ('./schemas/')
resolver_list = []
for item in list_of_ resolvers:
      resolver_list.append(item.get_resolver())

schema = make_executable_schema(types_list, resolver_list)
app = GraphQL (schema, debug=True)
      

Now, if I do

query {
    compute_subSchema {
         value
         object {
             value
         }
   }
}

Things are great. resolver of compute_subSchema is called

However if I did:

query {
    compute_masterSchema {
         subSchema {
           value
        }
   }
}

This does indeed call the resolver for compute_masterSchema, but I also want it to call the associated resolver for subSchema when I defined the associated query of subSchema but it doesn't

How do I go about making sure if I include a schema in another schema and ask for a field of the included schema, its query resolver is called?

[rafalp]

If I'm to be honest here, this is first time I see this. Where did you see those nested schemas?

[pliablepixels]

I created it myself - basically my requirement is:
a) Team a will build schema + resolver A
b) Team b will build schema + resolver B
c) Team c will build schema C and resolver for schema C. Schema C will include schema A and B inside it
d) team c wants to reuse the resolvers defined in A/B to populate those fields

[rafalp]

At glance I am curious how come either of those work, because those lines should raise name error;

         self.query.set_field('compute_masterSchema', resolve_masterSchema)
...
         self.query.set_field('compute_subSchema', resolve_subSchema)

This is because neither resolve_masterSchema or resolve_subSchema exist within the scope of __init__.

---

My question is why not have three separate GraphQL path's for schemas A, B and C, and just pass types and resolvers from A and B to make_executable_schema to get combined schema C? Seems much more elegant imho than having to start queries with schema name. Neither approach approach offers true separation to be hones, you will still need watch out to don't name types same way the other team did.

[pliablepixels]

My apologies, there was a typo - it should be
self.query.set_field('compute_masterSchema', self.resolve_masterSchema) and self.query.set_field('compute_subSchema', self.resolve_subSchema) which is why it works (part of the same class)

My question is why not have three separate GraphQL path's for schemas A, B and C, and just pass types and resolvers from A and B to make_executable_schema to get combined schema C? Seems much more elegant imho than having to start queries with schema name.

Schema 'C' combines A, B and some other aspects not in A and B. Furthermore, when people execute a query on Schema C (which is defined by team C), I want that resolver to invoke A's resolver, wait for the answer, pass the output of A's resolver to B's resolver as input. In other words, C's resolver needs to invoke in_sequence (not parallel) A's resolver then B's resolver

How does one do that?

[rafalp]

Ok, so if I understand correctly, when you run this query:

query {
    compute_masterSchema {
         subSchema {
           value
        }
   }
}

Then resolve_masterSchema is called but resolve_subSchema is not? If thats the case, are you returning anything from resolve_masterSchema? Per GraphQL spec query is resolved recursively as long as parent resolver returns value. If resolve_masterSchema returns nothing, this breaks recursion and subSchema is not resolved.

[pliablepixels]

Yes I am returning. I'll write up a small dummy repo for you tomorrow so I can show exactly what is going on. Thank you so much for your help!

[pliablepixels]

Here is a repo: https://github.com/pliablepixels/graphql_experiments/
See sample_queries

This may well be a basic GQL question, but any help would be appreciated. What I want is when SchemaA is invoked inside SchemaC, SchemaA's resolver is called after SchemaC's resolver is called. I think the problem is I've bound a resolver to a query of SchemaA but not sure how to call that query inside SchemaC

[pliablepixels]

Ah I think I have the answer. The trick is to code type resolvers. I added resolvers for schemaA and was able to invoke SchemaA inside SchemaC and the resolver was called! (link)