def mapping(self, cls: Type[Mapping], key_type: AnyType, value_type: AnyType) -> Thunk[graphql.GraphQLType]: try: name, description = self._ref_and_desc return graphql.GraphQLScalarType(name, description=description) except MissingRef: return JsonScalar
def factory(name: Optional[str], description: Optional[str]) -> graphql.GraphQLScalarType: assert cls is not NoneType if name is not None: return graphql.GraphQLScalarType(name, description=description) else: return GRAPHQL_PRIMITIVE_TYPES[cls]
def primitive(self, cls: Type) -> Thunk[graphql.GraphQLType]: if cls is NoneType: raise Nullable try: name, description = self._ref_and_desc return graphql.GraphQLScalarType(name, description=description) except MissingRef: return GRAPHQL_PRIMITIVE_TYPES[cls]
def graphql_schema( *, query: Iterable[Union[Callable, Query]] = (), mutation: Iterable[Union[Callable, Mutation]] = (), subscription: Iterable[Union[Callable[..., AsyncIterable], Subscription]] = (), types: Iterable[Type] = (), directives: Optional[Collection[graphql.GraphQLDirective]] = None, description: Optional[str] = None, extensions: Optional[Dict[str, Any]] = None, aliaser: Optional[Aliaser] = to_camel_case, enum_aliaser: Optional[Aliaser] = str.upper, enum_schemas: Optional[Mapping[Enum, Schema]] = None, id_types: Union[Collection[AnyType], IdPredicate] = (), id_encoding: Tuple[Optional[Callable[[str], Any]], Optional[Callable[[Any], str]]] = (None, None), # TODO deprecate union_ref parameter union_ref: UnionNameFactory = "Or".join, union_name: UnionNameFactory = "Or".join, default_deserialization: DefaultConversion = None, default_serialization: DefaultConversion = None, ) -> graphql.GraphQLSchema: if aliaser is None: aliaser = settings.aliaser if enum_aliaser is None: enum_aliaser = lambda s: s if default_deserialization is None: default_deserialization = settings.deserialization.default_conversion if default_serialization is None: default_serialization = settings.serialization.default_conversion query_fields: List[ResolverField] = [] mutation_fields: List[ResolverField] = [] subscription_fields: List[ResolverField] = [] for operations, op_class, fields in [ (query, Query, query_fields), (mutation, Mutation, mutation_fields), ]: for operation in operations: # type: ignore alias, resolver = operation_resolver(operation, op_class) resolver_field = ResolverField( alias, resolver, resolver.types(), resolver.parameters, resolver.parameters_metadata, ) fields.append(resolver_field) for sub_op in subscription: # type: ignore if not isinstance(sub_op, Subscription): sub_op = Subscription(sub_op) # type: ignore sub_parameters: Sequence[Parameter] if sub_op.resolver is not None: alias = sub_op.alias or sub_op.resolver.__name__ _, subscriber2 = operation_resolver(sub_op, Subscription) _, *sub_parameters = resolver_parameters(sub_op.resolver, check_first=False) resolver = Resolver( sub_op.resolver, sub_op.conversion, sub_op.schema, subscriber2.error_handler, sub_parameters, sub_op.parameters_metadata, ) sub_types = resolver.types() subscriber = replace(subscriber2, error_handler=None) subscribe = resolver_resolve( subscriber, subscriber.types(), aliaser, default_deserialization, default_serialization, serialized=False, ) else: alias, subscriber2 = operation_resolver(sub_op, Subscription) resolver = Resolver( lambda _: _, sub_op.conversion, sub_op.schema, subscriber2.error_handler, (), {}, ) subscriber = replace(subscriber2, error_handler=None) sub_parameters = subscriber.parameters sub_types = subscriber.types() if get_origin2(sub_types["return"]) not in async_iterable_origins: raise TypeError( "Subscriptions must return an AsyncIterable/AsyncIterator") event_type = get_args2(sub_types["return"])[0] subscribe = resolver_resolve( subscriber, sub_types, aliaser, default_deserialization, default_serialization, serialized=False, ) sub_types = { **sub_types, "return": resolver.return_type(event_type) } resolver_field = ResolverField( alias, resolver, sub_types, sub_parameters, sub_op.parameters_metadata, subscribe, ) subscription_fields.append(resolver_field) is_id = id_types.__contains__ if isinstance(id_types, Collection) else id_types if id_encoding == (None, None): id_type: graphql.GraphQLScalarType = graphql.GraphQLID else: id_deserializer, id_serializer = id_encoding id_type = graphql.GraphQLScalarType( name="ID", serialize=id_serializer or graphql.GraphQLID.serialize, parse_value=id_deserializer or graphql.GraphQLID.parse_value, parse_literal=graphql.GraphQLID.parse_literal, description=graphql.GraphQLID.description, ) output_builder = OutputSchemaBuilder( aliaser, enum_aliaser, enum_schemas or {}, default_serialization, id_type, is_id, union_name or union_ref, default_deserialization, ) def root_type( name: str, fields: Sequence[ResolverField] ) -> Optional[graphql.GraphQLObjectType]: if not fields: return None tp, type_name = type(name, (), {}), TypeName(graphql=name) return output_builder.object(tp, (), fields).merge( type_name, None).raw_type # type: ignore return graphql.GraphQLSchema( query=root_type("Query", query_fields), mutation=root_type("Mutation", mutation_fields), subscription=root_type("Subscription", subscription_fields), types=[output_builder.visit(cls).raw_type for cls in types], # type: ignore directives=directives, description=description, extensions=extensions, )
def factory(name: Optional[str], description: Optional[str]) -> graphql.GraphQLScalarType: if name is not None: return graphql.GraphQLScalarType(name, description=description) else: return JsonScalar
from apischema.utils import ( Lazy, context_setter, empty_dict, get_args2, get_origin2, get_origin_or_type, identity, is_union_of, sort_by_annotations_position, to_camel_case, ) JsonScalar = graphql.GraphQLScalarType( "JSON", specified_by_url= "http://www.ecma-international.org/publications/files/ECMA-ST/ECMA-404.pdf", ) GRAPHQL_PRIMITIVE_TYPES = { int: graphql.GraphQLInt, float: graphql.GraphQLFloat, str: graphql.GraphQLString, bool: graphql.GraphQLBoolean, } ID = NewType("ID", str) class MissingName(Exception): pass
ID = gql.GraphQLID Int = gql.GraphQLInt Float = gql.GraphQLFloat String = gql.GraphQLString Boolean = gql.GraphQLBoolean Currency = gql.GraphQLScalarType( name="Currency", description="Currency", serialize=serialize, parse_value=coerce, parse_literal=parse, ) def serialize_date(v): print("serialize date", v) return v def coerce_date(v): print("coerce date", v) return v
from datetime import time as PyTime import aniso8601 import graphql from graphql.language import ast def serialize(value: PyTime): return value.isoformat() def coerce(value: str): return aniso8601.parse_time(value) def parse_literal(ast_node, _variables=None): if isinstance(ast_node, ast.StringValueNode): return aniso8601.parse_time(ast_node.value) return graphql.INVALID GraphQLTime = graphql.GraphQLScalarType( name="Time", description="The `Time` scalar type represents ISO 8601 time.", serialize=serialize, parse_value=coerce, parse_literal=parse_literal, )
from uuid import UUID as PyUUID import graphql from graphql.language import ast def serialize(value: PyUUID): if not isinstance(value, PyUUID): value = PyUUID(value) return str(value) def coerce(value): return PyUUID(value) def parse_literal(ast_node, _variables=None): if isinstance(ast_node, ast.StringValueNode): return PyUUID(ast_node.value) return graphql.INVALID GraphQLUUID = graphql.GraphQLScalarType( name="UUID", description="The `UUID` scalar type.", serialize=serialize, parse_value=coerce, parse_literal=parse_literal, )
from decimal import Decimal as PyDecimal import graphql from graphql.language import ast def serialize(value): if not isinstance(value, PyDecimal): value = PyDecimal(value) return str(value) def coerce(value): return PyDecimal(value) def parse_literal(ast_node, _variables=None): if isinstance(ast_node, (ast.FloatValueNode, ast.IntValueNode, ast.StringValueNode)): return PyDecimal(ast_node.value) return graphql.INVALID GraphQLDecimal = graphql.GraphQLScalarType( name="Decimal", description="The `Decimal` scalar type.", serialize=serialize, parse_value=coerce, parse_literal=parse_literal, )
import graphql from graphql.language import ast from ..utils import NoneType def serialize(value: NoneType): return None def coerce(value: NoneType): return None def parse_literal(ast_node, _variables=None): return graphql.INVALID GraphQLNothing = graphql.GraphQLScalarType( name="Nothing", description="The `Nothing` scalar type represents NoneType.", serialize=serialize, parse_value=coerce, parse_literal=parse_literal, )
parts.append(f"{minutes:.0f}M") if seconds: if seconds.is_integer(): seconds = int(seconds) parts.append(f"{seconds}S") return "".join(parts) def serialize(value: PyDuration): return format_simple_iso8601_duration(value) def coerce(value: str): return aniso8601.parse_duration(value) def parse_literal(ast_node, _variables=None): if isinstance(ast_node, ast.StringValueNode): return aniso8601.parse_duration(ast_node.value) return graphql.INVALID GraphQLDuration = graphql.GraphQLScalarType( name="Duration", description="The `Duration` scalar type represents ISO8601 duration.", serialize=serialize, parse_value=coerce, parse_literal=parse_literal, )