def bake(self, schema: "GraphQLSchema") -> None:
"""
Bakes the GraphQLObjectType and computes all the necessary stuff for
execution.
:param schema: the GraphQLSchema instance linked to the engine
:type schema: GraphQLSchema
"""
if self.interfaces_names:
for interface_name in self.interfaces_names:
interface = schema.find_type(interface_name)
self.interfaces.append(interface)
interface.add_possible_type(self)
# Directives
directives_definition = compute_directive_nodes(
schema, self.directives
)
self.introspection_directives = wraps_with_directives(
directives_definition=directives_definition,
directive_hook="on_introspection",
)
self.pre_output_coercion_directives = wraps_with_directives(
directives_definition=directives_definition,
directive_hook="on_pre_output_coercion",
with_default=True,
)
# Coercers
self.output_coercer = partial(
output_directives_coercer,
coercer=partial(object_coercer, object_type=self),
directives=self.pre_output_coercion_directives,
)
def bake(self, schema: "GraphQLSchema") -> None:
"""
Bakes the GraphQLInterfaceType and computes all the necessary stuff for
execution.
:param schema: the GraphQLSchema instance linked to the engine
:type schema: GraphQLSchema
"""
# Directives
directives_definition = compute_directive_nodes(
schema, self.directives)
self.introspection_directives = wraps_with_directives(
directives_definition=directives_definition,
directive_hook="on_introspection",
)
# Coercers
self.output_coercer = partial(
output_directives_coercer,
coercer=partial(abstract_coercer, abstract_type=self),
directives=wraps_with_directives(
directives_definition=directives_definition,
directive_hook="on_pre_output_coercion",
with_default=True,
),
)
def bake(self, schema: "GraphQLSchema") -> None:
"""
Bakes the GraphQLUnionType and computes all the necessary stuff for
execution.
:param schema: the GraphQLSchema instance linked to the engine
:type schema: GraphQLSchema
"""
for type_name in self.types:
schema_type = schema.find_type(type_name)
self._possible_types.append(schema_type)
self._possible_types_set.add(type_name)
# Directives
directives_definition = compute_directive_nodes(
schema, self.directives)
self.introspection_directives = wraps_with_directives(
directives_definition=directives_definition,
directive_hook="on_introspection",
)
# Coercers
self.output_coercer = partial(
output_directives_coercer,
coercer=partial(abstract_coercer, abstract_type=self),
directives=wraps_with_directives(
directives_definition=directives_definition,
directive_hook="on_pre_output_coercion",
with_default=True,
),
)
def bake(self, schema: "GraphQLSchema") -> None:
"""
Bakes the GraphQLInputObject and computes all the necessary stuff for execution.
:param schema: the GraphQLSchema schema instance linked to the engine
:type schema: GraphQLSchema
"""
# Directives
directives_definition = compute_directive_nodes(
schema, self.directives)
self.introspection_directives = wraps_with_directives(
directives_definition=directives_definition,
directive_hook="on_introspection",
)
post_input_coercion_directives = wraps_with_directives(
directives_definition=directives_definition,
directive_hook="on_post_input_coercion",
)
# Coercers
self.input_coercer = partial(
input_directives_coercer,
coercer=partial(input_input_object_coercer,
input_object_type=self),
directives=post_input_coercion_directives,
)
self.literal_coercer = partial(
literal_directives_coercer,
coercer=partial(literal_input_object_coercer,
input_object_type=self),
directives=post_input_coercion_directives,
)
def bake(self, schema: "GraphQLSchema") -> None:
"""
Bakes the GraphQLArgument and computes all the necessary stuff for
execution.
:param schema: the GraphQLSchema instance linked to the engine
:type schema: GraphQLSchema
"""
self.graphql_type = get_graphql_type(schema, self.gql_type)
if isinstance(self.gql_type, GraphQLType):
self.type = self.gql_type
else:
self.type["name"] = self.gql_type
self.type["kind"] = self.graphql_type.kind
self.defaultValue = (str(self.default_value)
if self.default_value is not None else None)
# Directives
directives_definition = compute_directive_nodes(
schema, self.directives)
self.introspection_directives = wraps_with_directives(
directives_definition=directives_definition,
directive_hook="on_introspection",
)
# Coercers
self.literal_coercer = get_literal_coercer(self.graphql_type)
self.coercer = partial(
argument_coercer,
directives=wraps_with_directives(
directives_definition=directives_definition,
directive_hook="on_argument_execution",
),
)
def bake(
self,
schema: "GraphQLSchema",
custom_default_resolver: Optional[Callable],
) -> None:
"""
Bakes the GraphQLField and computes all the necessary stuff for
execution.
:param schema: the GraphQLSchema instance linked to the engine
:param custom_default_resolver: callable that will replace the builtin
default_resolver
:type schema: GraphQLSchema
:type custom_default_resolver: Optional[Callable]
"""
self.graphql_type = get_graphql_type(schema, self.gql_type)
# Directives
directives_definition = compute_directive_nodes(
schema, self.directives
)
self.on_post_bake = partial(
wraps_with_directives(
directives_definition=directives_definition,
directive_hook="on_post_bake",
with_default=True,
),
self,
)
self.introspection_directives = wraps_with_directives(
directives_definition=directives_definition,
directive_hook="on_introspection",
)
# Resolvers
self.resolver = partial(
resolve_field,
field_definition=self,
resolver=wraps_with_directives(
directives_definition=directives_definition,
directive_hook="on_field_execution",
func=(
self.raw_resolver
or custom_default_resolver
or default_field_resolver
),
is_resolver=True,
with_default=True,
),
output_coercer=get_output_coercer(self.graphql_type),
)
for argument in self.arguments.values():
argument.bake(schema)
self.args.append(argument)
def bake_execute(self, func_query, func_subscription):
directives = compute_directive_nodes(self, self._schema_directives)
func_query = wraps_with_directives(
directives, "on_schema_execution", func_query, is_resolver=True
)
func_subscription = wraps_with_directives(
directives,
"on_schema_subscription",
func_subscription,
is_async_generator=True,
)
return func_query, func_subscription
async def should_include_node(
execution_context: "ExecutionContext",
node: Union["FragmentSpreadNode", "FieldNode", "InlineFragmentNode"],
) -> bool:
"""
Determines if a field should be included based on the @include and @skip
directives, where @skip has higher precedence than @include.
:param execution_context: instance of the query execution context
:param node: the selection node to collect or skip
:type execution_context: ExecutionContext
:type node: Union[FragmentSpreadNode, FieldNode, InlineFragmentNode]
:return: whether or not the node should be collected or skipped
:rtype: bool
"""
if not node.directives:
return True
hook_name = ("on_field_collection" if isinstance(
node, FieldNode) else ("on_fragment_spread_collection" if isinstance(
node, FragmentSpreadNode) else "on_inline_fragment_collection"))
try:
await wraps_with_directives(
directives_definition=compute_directive_nodes(
execution_context.schema,
node.directives,
execution_context.variable_values,
),
directive_hook=hook_name,
with_default=True,
)(
node,
execution_context.context,
context_coercer=execution_context.context,
)
except SkipCollection:
return False
except Exception: # pylint: disable=broad-except
# TODO: we should store unexpected exception in order to treat them as
# field result on execution to handle them the same way as resolved
# value and having the bubble up error and so on.
return False
return True
def bake(self, schema: "GraphQLSchema") -> None:
"""
Bakes the GraphQLEnumValue and computes all the necessary stuff for
execution.
:param schema: the GraphQLSchema instance linked to the engine
:type schema: GraphQLSchema
"""
# Directives
directives_definition = compute_directive_nodes(
schema, self.directives
)
self.on_post_bake = partial(
wraps_with_directives(
directives_definition=directives_definition,
directive_hook="on_post_bake",
with_default=True,
),
self,
)
self.introspection_directives = wraps_with_directives(
directives_definition=directives_definition,
directive_hook="on_introspection",
)
post_input_coercion_directives = wraps_with_directives(
directives_definition=directives_definition,
directive_hook="on_post_input_coercion",
with_default=True,
)
# Coercers
self.input_coercer = post_input_coercion_directives
self.literal_coercer = post_input_coercion_directives
self.output_coercer = wraps_with_directives(
directives_definition=directives_definition,
directive_hook="on_pre_output_coercion",
with_default=True,
)
async def resolve_field_value_or_error(
execution_context: "ExecutionContext",
field_definition: "GraphQLField",
field_nodes: List["FieldNode"],
resolver: Callable,
source: Any,
info: "ResolveInfo",
) -> Union[Exception, Any]:
"""
Coerce the field's arguments and then try to resolve the field.
:param execution_context: instance of the query execution context
:param field_definition: GraphQLField instance of the resolved field
:param field_nodes: AST nodes related to the resolved field
:param resolver: callable to use to resolve the field
:param source: default root value or field parent value
:param info: information related to the execution and the resolved field
:type execution_context: ExecutionContext
:type field_definition: GraphQLField
:type field_nodes: List[FieldNode]
:type resolver: Callable
:type source: Any
:type info: ResolveInfo
:return: the resolved field value
:rtype: Union[Exception, Any]
"""
# pylint: disable=too-many-locals
try:
computed_directives = []
for field_node in field_nodes:
computed_directives.extend(
compute_directive_nodes(
execution_context.schema,
field_node.directives,
execution_context.variable_values,
)
)
resolver = wraps_with_directives(
directives_definition=computed_directives,
directive_hook="on_field_execution",
func=resolver,
is_resolver=True,
with_default=True,
)
result = await resolver(
source,
await coerce_arguments(
field_definition.arguments,
field_nodes[0],
execution_context.variable_values,
execution_context.context,
),
execution_context.context,
info,
context_coercer=execution_context.context,
)
if info.is_introspection:
return await introspection_directives_executor(
result,
execution_context.context,
info,
context_coercer=execution_context.context,
)
return result
except Exception as e: # pylint: disable=broad-except
return e
