Default resolver not being called from ariadne

[krish7919]

I am doing something different not yet documented in the community and am blocked on the below scenario.

Context:

1. The end goal is to serve graphql requests via AWS lambda serverless framework.
2. The lambda would fetch the graphql schema from storage; this schema is generated using the postgraphile CLI as:

   postgraphile \
     --connection "postgres://user:password@pg_host:pg_port/pg_db" \
     --schema public \
     --port 5000 \
     --host localhost \
     --export-schema-graphql ./schema.gql \
     --sort-export
   

   Any way that this step can be optimised? Can we pickle the schema object in the lambda directly so that it does not have to re-parse and build the schema from string every time?
3. Once the schema file is fetched, I call the function make_executable_schema like so:

   query_type = QueryType()
   gql_schema = make_executable_schema(
               gql(
                   load_schema_from_path(
                       os.path.join(os.path.dirname(__file__), "<schema file name>")
                   )
               ),
               query_type,
               fallback_resolvers,
               snake_case_fallback_resolvers,
           )
   

4. Using this query to execute a test query for now:

           query_tpl = """
                   query asdfjkl($target: String!) {
                       metrics: asdfjkl(targetKpi: $targetKpi) {
                           nodes {
                               stats {
                                   timestamp
                                   numRadios
                               }
                           }
                       }
                   }
               """
           query = {
               "query": "{}".format(query_tpl),
               "variables": {"target": "dummy"},
           }
           errors = validate(gql_schema, parse(query_tpl))
           assert errors == []
           gql_context = {"session": <sqlalchemy session>}
           result = graphql_sync(
               schema=gql_schema,
               data=query,
               debug=True,
               context_value=gql_context,
               introspection=False,
           )
   

   This returns to me (True, {'data': {'metrics': None}}) every time.
5. I am unsure what is happening here. Shouldn't it error out saying that the query asdfjkl is invalid; I have no query by that name. Even when asdfjkl is replaced with a valid query, nothing changes.
6. Shouldn't the fallback_resolvers and snake_case_fallback_resolvers resolve the query and return a response when a valid query is passed?

In summary:

1. I have verified that the sqlalchemy session is valid and works fine.
2. How do I debug this situation?
3. I am not sure how to check if ariadne itself is behaving properly and the default resolvers are being called correctly.
4. Why does an invalid query and a valid query return the same response, instead of returning an error? How is a query checked against the schema?

[rafalp]

2.: Isn't this a question to postgraphile community? ;)

4.: I don't see any resolver being set on Query.metrics nor root value being passed to graphql_sync() call, so this field will always resolve to null.

5.: Can't repro, field aliases work correctly in graphql-core version Ariadne currently uses to execute queries.

6.: Fallback resolvers are only set for fields that don't have resolvers set on them. This de facto makes fallback_resolvers and snake_case_fallback_resolvers mutually exclusive, as first fallback passed to make_executable_schema will set resolvers, making other one noop.

[rafalp]

SDL files don't contain any data. Only data graph structure. You will need to write your own resolver functions, connect those functions to graph using QueryType, and within those resolver functions run database calls.

[krish7919]

If it helps, I should add that this entire workflow works fine with postgrahile; however, we are moving from JS to Python for perf/maintainence reasons, and this is my first stab at trying to get this done in Py3 with Ariadne.

[rafalp]

postgraphile is JS library that generates complete GraphQL server based on given PostgreSQL database.

Ariadne is lower-level library. You could use it to build package like postgraphile, but no such solution exists to my knowledge.

[krish7919]

Ok, that helps.. I was looking at ariadne assuming parity with postgraphile. Thanks for letting me know that such a lib does not exist.

I am a newbie to graphql, and assumed that the SDL is the source of truth and everything follows from that (just as it does in postgraphile), something like protobuf where the .proto files are the source of truth and all the language compilers generate the necessary code/bindings to work accordingly.

I think that this assumption that I started with was wrong. :)

We have schema files which are themselves maintained and versioned correctly, and I wouldn't want us to maintain the Python-ic definitions of the same schema again in code.

I will maybe stick with postgraphile for our use case then.

Thanks a lot @rafalp , really appreciate the quick responses, been banging my head over this today :)

[rafalp]

Yeah, GraphQL out of the box is "you write schema using SDL" and then "you write resolver functions that know where the data is".

Solutions like postgraphile work differently, they introspect existing data model (eg. PostgreSQL database) and they generate GraphQL API from that. This is same as writing your own REST API vs. generating one from database using existing solution.