def build_schema(config, engine, subset=None):
"""
Build the object types for all the indexes. Subset is a list of
index names that the schema should include. If no subset is
provided, then all indexes are built and added to the schema.
"""
fields = {}
for i in Index.list_indexes(engine):
if not subset or i.name in subset:
try:
output_type, args = build_index_type(config, engine, i)
resolver = ql_resolver(config, engine, i)
# create the field for this table, with arguments and resolver
fields[f'{i.table.name}'] = graphql.GraphQLField(
graphql.GraphQLList(output_type),
args=args,
resolve=resolver,
)
except (ValueError, AssertionError) as ex:
logging.error('%s; skipping %s...', str(ex), i.name)
# construct the query object for the root object type
root = graphql.GraphQLObjectType('Query', fields)
# build the schema
return graphql.GraphQLSchema(query=root)
def __init__(self, **kwargs):
assert 'type' in kwargs, f'ListMixin requires "type" kwarg, kwargs={kwargs}'
self.many = kwargs.pop('many', False)
assert isinstance(
self.many, bool), f'many has to be of type bool, not {self.many}'
if self.many:
kwargs.update(type=graphql.GraphQLList(kwargs.get('type')))
super().__init__(**kwargs)
def generate_graphql_type(graph_type):
if graph_type == schema.Boolean:
return graphql.GraphQLNonNull(graphql.GraphQLBoolean)
elif graph_type == schema.Float:
return graphql.GraphQLNonNull(graphql.GraphQLFloat)
elif graph_type == schema.Int:
return graphql.GraphQLNonNull(graphql.GraphQLInt)
elif graph_type == schema.String:
return graphql.GraphQLNonNull(graphql.GraphQLString)
elif isinstance(graph_type, schema.EnumType):
# TODO: should enums map names or values?
values = iterables.to_dict(
(member.value, graphql.GraphQLEnumValue(member.value))
for member in graph_type.enum)
graphql_type = graphql.GraphQLEnumType(graph_type.name,
values=values)
return graphql.GraphQLNonNull(graphql_type)
elif isinstance(graph_type, schema.InputObjectType):
return graphql.GraphQLNonNull(
graphql.GraphQLInputObjectType(
name=graph_type.name,
fields=lambda: iterables.to_dict(
(snake_case_to_camel_case(field.name),
to_graphql_input_field(field))
for field in graph_type.fields),
))
elif isinstance(graph_type, schema.InterfaceType):
return graphql.GraphQLNonNull(
graphql.GraphQLInterfaceType(
name=graph_type.name,
fields=to_graphql_fields(graph_type.fields),
resolve_type=lambda: None,
))
elif isinstance(graph_type, schema.ListType):
return graphql.GraphQLNonNull(
graphql.GraphQLList(to_graphql_type(graph_type.element_type)))
elif isinstance(graph_type, schema.NullableType):
return to_graphql_type(graph_type.element_type).of_type
elif isinstance(graph_type, schema.ObjectType):
return graphql.GraphQLNonNull(
graphql.GraphQLObjectType(
name=graph_type.name,
fields=to_graphql_fields(graph_type.fields),
interfaces=tuple(
to_graphql_type(interface).of_type
for interface in graph_type.interfaces),
))
else:
raise ValueError("unsupported type: {}".format(graph_type))
def ql_type(parent_name, field, xs):
"""
Returns a Graphene field type for all values of xs. It assumes
every item in xs is the same type or None.
"""
all_types = set(
[type(x) for x in xs if x is not None and x is not float('nan')])
# handle a special case of floats being parsed as integers
if all_types == set([int, float]):
all_types = set([float])
# there should only be one type per field
if len(all_types) > 1:
assert False, f'Heterogenous field type: {parent_name}/{field} ({all_types})'
# get the only type
this_type = all_types.pop()
# dictionaries are an object type that needs defined
if this_type == dict:
return build_object_type(f'{parent_name}{field.capitalize()}', xs)
# if the base type is a list, wrap the base type
if this_type == list:
return graphql.GraphQLList(
ql_type(parent_name, field, [y for ys in xs for y in ys]))
# scalar type
if this_type == bool:
return graphql.GraphQLBoolean
elif this_type == int:
return graphql.GraphQLInt
elif this_type == float:
return graphql.GraphQLFloat
elif this_type == str:
return graphql.GraphQLString
# unknown, or can't be represented
raise ValueError(f'Cannot define GraphQL type for {field}')
def collection(self, cls: Type[Collection],
value_type: AnyType) -> TypeFactory[GraphQLTp]:
return TypeFactory(
lambda *_: graphql.GraphQLList(self.visit(value_type).type))
def NNList(t):
return graphql.GraphQLNonNull(
graphql.GraphQLList(graphql.GraphQLNonNull(t)))
import graphql
from graphql.utilities import print_schema
Person = graphql.GraphQLObjectType(
"Person",
lambda: {
"name":
graphql.GraphQLField(graphql.GraphQLNonNull(graphql.GraphQLString, )),
},
)
Query = graphql.GraphQLObjectType(
"Query",
lambda: {
"people":
graphql.GraphQLField(
graphql.GraphQLNonNull(graphql.GraphQLList(Person)))
},
)
schema = graphql.GraphQLSchema(Query)
print(print_schema(schema))
# or graphql.print_schema(schema)
import graphql as g
from handofcats import as_command
from minidb import Table
Person = g.GraphQLObjectType(
"Person",
lambda: {
"name": g.GraphQLField(g.GraphQLNonNull(g.GraphQLString)),
"age": g.GraphQLField(g.GraphQLNonNull(g.GraphQLInt)),
"nickname": g.GraphQLField(g.GraphQLString),
},
)
query_type = g.GraphQLObjectType(
"Query", lambda: {"people": g.GraphQLField(g.GraphQLList(Person))},
)
class Root:
def __init__(self, tables):
self.tables = tables
def people(self, info):
return self.tables["people"].find_all()
schema = g.GraphQLSchema(query_type)
@as_command
def _transform_list(t, ctx):
return graphql.GraphQLList(ctx.transformer.transform(t.__args__[0]))
Person = g.GraphQLObjectType(
"Person",
lambda: {
"name": g.GraphQLField(g.GraphQLNonNull(g.GraphQLString)),
"age": g.GraphQLField(g.GraphQLNonNull(g.GraphQLInt)),
"nickname": g.GraphQLField(g.GraphQLString),
},
)
query_type = g.GraphQLObjectType(
"Query",
lambda: {
"people":
g.GraphQLField(
g.GraphQLList(Person),
args={"order_by": g.GraphQLArgument(person_order_input_enum)},
)
},
)
class Root:
def __init__(self, data):
self.data = data
def people(self, info, *, order_by):
if order_by == "name_DESC":
return sorted(self.data["people"],
key=lambda d: d["name"],
reverse=True)
def collection(self, cls: Type[Collection],
value_type: AnyType) -> Thunk[graphql.GraphQLType]:
value_thunk = self.visit(value_type)
return lambda: graphql.GraphQLList(exec_thunk(value_thunk))
