def graphlayer_performance(): import graphlayer as g from graphlayer import graphql User = g.ObjectType("User", fields=( g.field("id", type=g.Int), g.field("name", type=g.String), )) Query = g.ObjectType("Query", fields=(g.field("users", type=g.ListType(User)), )) root_resolver = g.root_object_resolver(Query) @root_resolver.field(Query.fields.users) def root_resolve_users(graph, query, args): return graph.resolve(query) @g.resolver(g.ListType(User)) def resolve_users(graph, query): return [ query.element_query.create_object( dict((field_query.key, getattr(user, field_query.field.name)) for field_query in query.element_query.fields)) for user in users ] resolvers = (root_resolver, resolve_users) graph_definition = g.define_graph(resolvers=resolvers) graph = graph_definition.create_graph({}) return lambda document_text: graphql.execute( graph=graph, document_text=document_text, query_type=Query)
def test_can_query_schema_with_other_data(): Root = g.ObjectType("Root", fields=(g.field("value", g.String), )) root_resolver = g.root_object_resolver(Root) @root_resolver.field(Root.fields.value) def root_resolve_value(graph, query, args): return "resolved" graph_definition = g.define_graph(resolvers=(root_resolver, )) graph = graph_definition.create_graph({}) query = """ query { value __schema { queryType { name } } } """ result = graphql.execute(graph=graph, document_text=query, query_type=Root) assert_that( result, is_success(data=equal_to({ "value": "resolved", "__schema": { "queryType": { "name": "Root", }, }, })))
def test_typename(): Root = g.ObjectType("Root", fields=(g.field("value", g.String), )) root_resolver = g.root_object_resolver(Root) @root_resolver.field(Root.fields.value) def root_resolve_value(graph, query, args): return "resolved" graph_definition = g.define_graph(resolvers=(root_resolver, )) graph = graph_definition.create_graph({}) query = """ query { __typename value typename: __typename } """ result = graphql.execute(graph=graph, document_text=query, query_type=Root) assert_that( result, is_success(data=equal_to({ "__typename": "Root", "value": "resolved", "typename": "Root" })))
def test_when_resolution_raises_graph_error_then_result_is_invalid(): Root = g.ObjectType("Root", fields=( g.field("value", g.String), )) root_resolver = g.root_object_resolver(Root) @root_resolver.field(Root.fields.value) def root_resolve_value(graph, query, args): raise g.GraphError("BAD") graph_definition = g.define_graph(resolvers=(root_resolver, )) graph = graph_definition.create_graph({}) query = """ query { value } """ result = graphql.execute(graph=graph, document_text=query, query_type=Root) assert_that(result, is_invalid(errors=contains_exactly( all_of( is_instance(GraphQLError), has_str("BAD"), ), )))
def test_root_object_resolver_can_resolve_fields_with_dependencies(self): Root = g.ObjectType("Root", fields=(g.field("value", type=g.Int), )) resolve_root = g.root_object_resolver(Root) value_key = object() @resolve_root.field(Root.fields.value) @g.dependencies(value=value_key) def root_resolve_value(graph, query, args, *, value): return value graph_definition = g.define_graph(resolvers=(resolve_root, )) graph = graph_definition.create_graph({value_key: 42}) query = Root(g.key("value", Root.fields.value()), ) assert_that(graph.resolve(query), has_attrs(value=42))
def test_root_object_resolver_passes_arguments_to_field_resolvers(self): Root = g.ObjectType("Root", fields=(g.field("value", type=g.Int, params=(g.param("answer", type=g.Int), )), )) resolve_root = g.root_object_resolver(Root) @resolve_root.field(Root.fields.value) def root_resolve_value(graph, query, args): return args.answer graph_definition = g.define_graph(resolvers=(resolve_root, )) graph = graph_definition.create_graph({}) query = Root( g.key("value", Root.fields.value(Root.fields.value.params.answer(42))), ) assert_that(graph.resolve(query), has_attrs(value=42))
node_type=Book, select_by_cursor=select_books_by_id, cursor_encoding=graphlayer.connections.int_cursor_encoding, fetch_cursors=fetch_book_cursors, ) BooksConnection = books_connection.Connection BookEdge = books_connection.Edge PageInfo = graphlayer.connections.PageInfo Query = g.ObjectType( "Query", fields=lambda: (books_connection.field("books_connection"), ), ) resolve_query = g.root_object_resolver(Query) @resolve_query.field(Query.fields.books_connection) def resolve_query_field_books_connection(graph, query, args): return graph.resolve(books_connection.select_field(query, args=args)) resolvers = (resolve_books, books_connection.resolvers, resolve_query) graph_definition = g.define_graph(resolvers) def create_graph(books): return graph_definition.create_graph({"all_books": books})
Book, BookRecord, fields={ Book.fields.title: gsql.expression(BookRecord.title), Book.fields.author: g.single(gsql.sql_join({ BookRecord.author_id: AuthorRecord.id, })), }, ) Root = g.ObjectType("Root", fields=lambda: (g.field("books", type=g.ListType(Book)), )) root_resolver = g.root_object_resolver(Root) @root_resolver.field(Root.fields.books) def root_resolve_books(graph, query, args): return graph.resolve(gsql.select(query)) resolvers = (author_resolver, book_resolver, root_resolver) graph_definition = g.define_graph(resolvers=resolvers) def execute_query(query, *, variables=None, session): graph = graph_definition.create_graph({ sqlalchemy.orm.Session: session, })