def _convert_primitive_type(self, type, **kwargs):
"""
A helper for converting primitive types to Graphene.
"""
if in_kwargs_and_true(kwargs, "input"):
return type
if in_kwargs_and_true(kwargs, "input_field"):
return get_field_as(type, _as=graphene.InputField)
return get_field_as(type, _as=graphene.Field)
def _generate_default_filters(
cls, model,
field_filters: 'Dict[str, Union[Iterable[str], Any]]') -> dict:
"""
Generate GraphQL fields from SQLAlchemy model columns.
Args:
model: SQLAlchemy model.
field_filters: Filters for fields.
Returns:
GraphQL fields dictionary:
field name (key) - field instance (value).
"""
graphql_filters = {}
filters_map = cls.ALLOWED_FILTERS
model_fields = {
c.name: {
'column': c,
'type': c.type,
'nullable': c.nullable
}
for c in model.__table__.columns if c.name in field_filters
}
for field_name, field_object in model_fields.items():
column_type = field_object['type']
expressions = field_filters[field_name]
if expressions == cls.ALL:
type_class = column_type.__class__
try:
expressions = filters_map[type_class].copy()
except KeyError:
for type_, exprs in filters_map.items():
if issubclass(type_class, type_):
expressions = exprs.copy()
break
else:
raise KeyError('Unsupported column type. '
'Hint: use EXTRA_ALLOWED_FILTERS.')
if field_object['nullable']:
expressions.append(cls.IS_NULL)
field_type = convert_sqlalchemy_type(column_type,
field_object['column'])
fields = cls._generate_filter_fields(expressions, field_name,
field_type,
field_object['nullable'])
for name, field in fields.items():
graphql_filters[name] = get_field_as(field,
graphene.InputField)
return graphql_filters
def extend(cls, fname, ftype, fresolver):
if fname in cls._meta.fields:
raise ValueError('Resolver for field {}.{} already exists!'.format(
cls.__name__, fname))
field = {fname: get_field_as(ftype, graphene.Field)}
cls._meta.local_fields.update(field)
cls._meta.fields.update(field)
setattr(cls, 'resolve_' + fname, fresolver)
def _generate_default_filters(
cls, model,
field_filters: 'Dict[str, Union[Iterable[str], Any]]') -> dict:
"""
Generate GraphQL fields from SQLAlchemy model columns.
Args:
model: SQLAlchemy model.
field_filters: Filters for fields.
Returns:
GraphQL fields dictionary:
field name (key) - field instance (value).
"""
graphql_filters = {}
filters_map = cls.ALLOWED_FILTERS
model_fields = {
c.name: {
'column': c,
'type': c.type,
'nullable': c.nullable
}
for c in model.__table__.columns if c.name in field_filters
}
for field_name, field_object in model_fields.items():
column_type = field_object['type']
expressions = field_filters[field_name]
if expressions == cls.ALL:
expressions = filters_map[column_type.__class__].copy()
if field_object['nullable']:
expressions.append(cls.IS_NULL)
field_type = convert_sqlalchemy_type(column_type,
field_object['column'])
fields = cls._generate_filter_fields(expressions, field_name,
field_type,
field_object['nullable'])
for name, field in fields.items():
graphql_filters[name] = get_field_as(field,
graphene.InputField)
return graphql_filters
def __new__(cls, name, bases, attrs):
if not is_base_type(bases, SerializerMutationMeta):
return type.__new__(cls, name, bases, attrs)
options = Options(
attrs.pop('Meta', None),
name=name,
description=attrs.pop('__doc__', None),
serializer_class=None,
local_fields=None,
only_fields=(),
exclude_fields=(),
interfaces=(),
registry=None
)
if not options.serializer_class:
raise Exception('Missing serializer_class')
cls = ObjectTypeMeta.__new__(
cls, name, bases, dict(attrs, _meta=options)
)
serializer_fields = cls.fields_for_serializer(options)
options.serializer_fields = yank_fields_from_attrs(
serializer_fields,
_as=Field,
)
options.fields = merge(
options.interface_fields, options.serializer_fields,
options.base_fields, options.local_fields,
{'errors': get_field_as(cls.errors, Field)}
)
cls.Input = convert_serializer_to_input_type(options.serializer_class)
cls.Field = partial(
Field,
cls,
resolver=cls.mutate,
input=Argument(cls.Input, required=True)
)
return cls
def get_base_fields(bases, _as=None):
'''
Get all the fields in the given bases
same as graphene.types.utils.get_base_fields but with SQLAlchemyInterface check
'''
fields = OrderedDict()
from graphene.types import AbstractType, Interface
from .schema import SQLAlchemyInterface
# We allow inheritance in AbstractTypes and Interfaces but not ObjectTypes
inherited_bases = (AbstractType, Interface, SQLAlchemyInterface)
for base in bases:
if base in inherited_bases or not issubclass(base, inherited_bases):
continue
for name, field in base._meta.fields.items():
if name in fields:
continue
fields[name] = get_field_as(field, _as=_as)
return fields
def get_base_fields(bases, _as=None):
'''
Get all the fields in the given bases
same as graphene.types.utils.get_base_fields but with SQLAlchemyInterface
check
'''
fields = OrderedDict()
from graphene.types import AbstractType
from .types import SQLAlchemyInterface
# We allow inheritance in AbstractTypes and Interfaces but not ObjectTypes
inherited_bases = (AbstractType, Interface, SQLAlchemyInterface)
for base in bases:
if base in inherited_bases or not issubclass(base, inherited_bases):
continue
for name, field in base._meta.fields.items():
if name in fields:
continue
fields[name] = get_field_as(field, _as=_as)
return fields
def __new__(cls, name, bases, attrs):
if not is_base_type(bases, SerializerMutationMeta):
return type.__new__(cls, name, bases, attrs)
options = Options(attrs.pop('Meta', None),
name=name,
description=attrs.pop('__doc__', None),
serializer_class=None,
local_fields=None,
only_fields=(),
exclude_fields=(),
interfaces=(),
registry=None)
if not options.serializer_class:
raise Exception('Missing serializer_class')
cls = ObjectTypeMeta.__new__(cls, name, bases,
dict(attrs, _meta=options))
serializer_fields = cls.fields_for_serializer(options)
options.serializer_fields = yank_fields_from_attrs(
serializer_fields,
_as=Field,
)
options.fields = merge(options.interface_fields,
options.serializer_fields, options.base_fields,
options.local_fields,
{'errors': get_field_as(cls.errors, Field)})
cls.Input = convert_serializer_to_input_type(options.serializer_class)
cls.Field = partial(Field,
cls,
resolver=cls.mutate,
input=Argument(cls.Input, required=True))
return cls
def composite_type(self, type, **kwargs):
attrs = {}
for name, return_type in type.field_map.items():
attrs[name] = get_instantiated_type(return_type).convert(
self,
input=in_kwargs_and_true(kwargs, "input"),
input_field=in_kwargs_and_true(kwargs, "input_field"))
if in_kwargs_and_true(kwargs, "input") or in_kwargs_and_true(
kwargs, "input_field"):
input_class = create_class(
"{}Input".format(type.type_name),
(graphene.InputObjectType, ),
attrs,
)(required=type.kwargs["required"])
if in_kwargs_and_true(kwargs, "input"):
return input_class
return get_field_as(input_class, _as=graphene.InputField)
type_class = create_class("{}ObjectType".format(type.type_name),
(graphene.ObjectType, ), attrs)
return graphene.Field(type_class)