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,
})