def assert_field_converted(self, nautilus_field, graphene_field):
# convert the nautilus field to the corresponding graphene type
test_graphene_type = convert_peewee_field(nautilus_field)
# make sure the converted type matches the graphene field
assert isinstance(test_graphene_type, graphene_field), (
"nautilus field was not properly coverted to %s" %
graphene_field.__class__)
def __new__(cls, name, bases, attributes, **kwds):
full_attr = {}
try:
# for each field in the table
for field in attributes['Meta'].model.fields():
# the name of the field in the schema
field_name = field.name[0].lower() + field.name[1:]
# add an entry for the field we were passed
full_attr[field_name] = convert_peewee_field(field)
# if there is no meta type defined
except KeyError:
# keep going
pass
# if there is no model defined
except AttributeError:
# yell loudly
raise ValueError("PeeweeObjectsTypes must have a model.")
# merge the given attributes ontop of the dynamic ones
full_attr.update(attributes)
# create the nex class records
return super().__new__(cls, name, bases, full_attr, **kwds)
def args_for_model(model):
# import the model field helper
from .util import fields_for_model
# figure use each field as a filter
args = fields_for_model(model)
# add the pk argument
args['pk'] = convert_peewee_field(model.primary_key())
# create a copy of the argument dict we can mutate
full_args = args.copy()
# todo: add type-specific filters
# go over the arguments
for arg, field_type in args.items():
# add the list member filter
full_args[arg + '_in'] = List(field_type)
# add integer valued model filters
for arg in ['first', 'last', 'offset']:
# add the arg to the dict
full_args[arg] = Int()
# add the list of string values model filters
for arg in ['order_by']:
# add the arg to the dict
full_args[arg] = List(GraphQLString)
# return the complete dictionary of arguments
return full_args
def assert_field_converted(self, nautilus_field, graphene_field):
# convert the nautilus field to the corresponding graphene type
test_graphene_type = convert_peewee_field(nautilus_field)
# make sure the converted type matches the graphene field
assert isinstance(test_graphene_type, graphene_field), (
"nautilus field was not properly coverted to %s" % graphene_field.__class__
)
def args_for_model(model):
# import the model field helper
from .util import fields_for_model
# figure use each field as a filter
args = fields_for_model(model)
# add the pk argument
args['pk'] = convert_peewee_field(model.primary_key())
# create a copy of the argument dict we can mutate
full_args = args.copy()
# todo: add type-specific filters
# go over the arguments
for arg, field_type in args.items():
# add the list member filter
full_args[arg + '_in'] = List(field_type)
# add integer valued model filters
for arg in ['first', 'last', 'offset']:
# add the arg to the dict
full_args[arg] = Int()
# add the list of string values model filters
for arg in ['order_by']:
# add the arg to the dict
full_args[arg] = List(GraphQLString)
# return the complete dictionary of arguments
return full_args
def _summarize_object_type(model):
"""
This function returns the summary for a given model
"""
# the fields for the service's model
model_fields = {field.name: field for field in list(model.fields())}
# summarize the model
return {
'fields': [{
'name': key,
'type': type(convert_peewee_field(value)).__name__
} for key, value in model_fields.items()]
}
def _summarize_object_type(model):
"""
This function returns the summary for a given model
"""
# the fields for the service's model
model_fields = {field.name: field for field in list(model.fields())}
# summarize the model
return {
'fields': [{
'name': key,
'type': type(convert_peewee_field(value)).__name__
} for key, value in model_fields.items()
]
}
def fields_for_model(model):
"""
This function returns the fields for a schema that matches the provided
nautilus model.
Args:
model (nautilus.model.BaseModel): The model to base the field list on
Returns:
(dict<field_name: str, graphqlType>): A mapping of field names to
graphql types
"""
# the attribute arguments (no filters)
args = {field.name.lower() : convert_peewee_field(field) \
for field in model.fields()}
# use the field arguments, without the segments
return args
def fields_for_model(model):
"""
This function returns the fields for a schema that matches the provided
nautilus model.
Args:
model (nautilus.model.BaseModel): The model to base the field list on
Returns:
(dict<field_name: str, graphqlType>): A mapping of field names to
graphql types
"""
# the attribute arguments (no filters)
args = {field.name.lower() : convert_peewee_field(field) \
for field in model.fields()}
# use the field arguments, without the segments
return args
def summarize(self, **extra_fields):
# the fields for the service's model
model_fields = {field.name: field for field in list(self.model.fields())} \
if self.model \
else {}
# add the model fields to the dictionary
return dict(
**super().summarize(),
fields=[{
'name': key,
'type': type(convert_peewee_field(value)).__name__
} for key, value in model_fields.items()
],
mutations=[
summarize_crud_mutation(model=self, method='create'),
summarize_crud_mutation(model=self, method='update'),
summarize_crud_mutation(model=self, method='delete'),
],
**extra_fields
)
def create_model_schema(target_model):
""" This function creates a graphql schema that provides a single model """
from nautilus.database import db
# create the schema instance
schema = graphene.Schema(auto_camelcase=False)
# grab the primary key from the model
primary_key = target_model.primary_key()
primary_key_type = convert_peewee_field(primary_key)
# create a graphene object
class ModelObjectType(PeeweeObjectType):
class Meta:
model = target_model
pk = Field(primary_key_type, description="The primary key for this object.")
@graphene.resolve_only_args
def resolve_pk(self):
return getattr(self, self.primary_key().name)
class Query(graphene.ObjectType):
""" the root level query """
all_models = List(ModelObjectType, args=args_for_model(target_model))
@graphene.resolve_only_args
def resolve_all_models(self, **args):
# filter the model query according to the arguments
# print(filter_model(target_model, args)[0].__dict__)
return filter_model(target_model, args)
# add the query to the schema
schema.query = Query
return schema
def create_model_schema(target_model):
""" This function creates a graphql schema that provides a single model """
from nautilus.database import db
# create the schema instance
schema = graphene.Schema(auto_camelcase=False)
# grab the primary key from the model
primary_key = target_model.primary_key()
primary_key_type = convert_peewee_field(primary_key)
# create a graphene object
class ModelObjectType(PeeweeObjectType):
class Meta:
model = target_model
pk = Field(primary_key_type,
description="The primary key for this object.")
@graphene.resolve_only_args
def resolve_pk(self):
return getattr(self, self.primary_key().name)
class Query(graphene.ObjectType):
""" the root level query """
all_models = List(ModelObjectType, args=args_for_model(target_model))
@graphene.resolve_only_args
def resolve_all_models(self, **args):
# filter the model query according to the arguments
# print(filter_model(target_model, args)[0].__dict__)
return filter_model(target_model, args)
# add the query to the schema
schema.query = Query
return schema
def _graphql_type_string(value):
return type(convert_peewee_field(value)).__name__
def _graphql_type_string(value):
return type(convert_peewee_field(value)).__name__
def serialize_native_type(native_type):
"""
This function serializes the native object type for summaries
"""
return type(convert_peewee_field(native_type)).__name__
