def _on_value_in(self, element: _VisitorElement):
if hasattr(self._current_node, 'default_value'):
self._current_node.default_value = element.get_value()
return
self._current_node.arguments.update(
{self._current_argument_name: element.get_value()})
def _on_fragment_definition_in(self, element: _VisitorElement):
nfd = NodeFragmentDefinition(
self.path,
element.get_location(),
element.name,
type_condition=element.get_type_condition())
if element.name in self._fragments:
self.continue_child = 0
self.exception = TartifletteException(
"Fragment < %s > is already define" % element.name)
return
self._current_fragment_definition = nfd
self._fragments[element.name] = nfd
def _on_directive_out(self, element: _VisitorElement, *_args,
**_kwargs) -> None:
try:
directive = self.schema.find_directive(
self._internal_ctx.directive.name)
except KeyError:
self._internal_ctx.directive = None
return
for argument in directive.arguments.values():
if not argument.is_required:
continue
value = self._internal_ctx.directive.arguments.get(argument.name)
if value is None:
self._add_exception(
MissingRequiredArgument(
"Missing required < %s > argument on < @%s > directive."
% (argument.name, directive.name),
locations=[element.get_location()],
))
destination = (self._internal_ctx.inline_fragment_info
or self._internal_ctx.fragment_spread
or self._internal_ctx.node)
if destination:
destination.add_directive({
"callables": directive.implementation,
"args": {
x.name: x.value
for x in self._internal_ctx.directive.arguments.values()
},
})
self._internal_ctx.directive = None
def _on_field_in(self, element: _VisitorElement):
self.field_path.append(element.name)
self._depth = self._depth + 1
try:
parent_type = self._current_node.gql_type
except AttributeError:
parent_type = self._schema.types[self._schema.query_type]
field = self._schema.get_field_by_name(parent_type.name + '.' +
element.name)
try:
gql_type = reduce_type(field.gql_type)
except AttributeError:
self.continue_child = 0
self.exception = TartifletteException("No field %s in %s" %
(element.name, parent_type))
return
resolver = getattr(field, 'resolver', _default_resolver)
if resolver is None:
resolver = wrap_resolver(self._schema, field, _default_resolver)
node = NodeField(resolver, element.get_location(), self.field_path[:],
element.name, self._current_type_condition, gql_type,
field)
node.parent = self._current_node
self._current_node = node
self._add_node(node)
def _fragment_spread(self, ctx: InternalVisitorContext,
element: _VisitorElement) -> None:
_ctx = self._internal_ctx
self._internal_ctx = ctx
self._used_fragments.add(element.name)
try:
cfd = self._fragments[element.name]
except KeyError:
self._add_exception(
UndefinedFragment(
"Undefined fragment < %s >." % element.name,
locations=[element.get_location()],
))
return
depth = self._internal_ctx.depth
self._internal_ctx.type_condition = cfd.type_condition
self._in_fragment_spread_context = True
for saved_callback in cfd.callbacks:
saved_callback( # Simulate calling a the right place.
type_cond_depth=depth)
self._in_fragment_spread_context = False
self._internal_ctx.type_condition = None
self._internal_ctx = _ctx
def _on_variable_definition_in(
self, element: _VisitorElement, *_args, **_kwargs
) -> None:
node = NodeVariableDefinition(
self._internal_ctx.path, element.get_location(), element.name
)
node.set_parent(self._internal_ctx.node)
self._internal_ctx.node = node
def _on_directive_out(self, element: _VisitorElement, *_args,
**_kwargs) -> None:
try:
directive = self.schema.find_directive(
self._internal_ctx.directive.name)
except KeyError:
self._internal_ctx.directive = None
return
for argument in directive.arguments.values():
if not argument.is_required:
continue
value = self._internal_ctx.directive.arguments.get(argument.name)
if value is None:
self._add_exception(
MissingRequiredArgument(
"Missing required < %s > argument on < @%s > directive."
% (argument.name, directive.name),
locations=[element.get_location()],
))
self._internal_ctx.directive = None
def _fragment_spread(
self,
ctx: InternalVisitorContext,
element: _VisitorElement,
directives: [Dict[str, Any]],
) -> None:
_ctx = self._internal_ctx
self._internal_ctx = ctx
self._used_fragments.add(element.name)
try:
cfd = self._fragments[element.name]
except KeyError:
self._add_exception(
UndefinedFragment(
"Undefined fragment < %s >." % element.name,
locations=[element.get_location()],
)
)
return
depth = self._internal_ctx.depth
self._internal_ctx.type_condition = cfd.type_condition
self._in_fragment_spread_context = True
kwargs = {"type_cond_depth": depth}
for saved_callback in cfd.callbacks:
kwargs["directives"] = None
if depth == self._internal_ctx.depth:
kwargs["directives"] = directives
saved_callback(**kwargs) # Simulate calling a the right place.
self._in_fragment_spread_context = False
self._internal_ctx.type_condition = None
self._internal_ctx = _ctx
def _on_directive_in(self, element: _VisitorElement, *_args,
**_kwargs) -> None:
self._internal_ctx.directive = NodeDirective(self._internal_ctx.path,
element.get_location(),
element.name)
def _on_argument_in(self, element: _VisitorElement, *_args,
**_kwargs) -> None:
if not self._internal_ctx.directive:
parent_type = self._get_parent_type(self._internal_ctx.node.parent)
if element.name not in self._internal_ctx.current_field.arguments:
self._add_exception(
UndefinedFieldArgument(
"Undefined argument < %s > on field < %s > of type < "
"%s >." % (
element.name,
self._internal_ctx.node.name,
parent_type,
),
locations=[element.get_location()],
))
return
if element.name in self._internal_ctx.node.arguments:
self._add_exception(
UniqueArgumentNames(
"There can be only one argument named < %s >." %
element.name,
locations=[
self._internal_ctx.node.arguments[
element.name].location,
element.get_location(),
],
))
return
else:
try:
directive = self.schema.find_directive(
self._internal_ctx.directive.name)
except KeyError:
return
if element.name not in directive.arguments:
self._add_exception(
UndefinedDirectiveArgument(
"Undefined argument < %s > on directive < @%s >." %
(element.name, directive.name),
locations=[element.get_location()],
))
return
if element.name in self._internal_ctx.directive.arguments:
self._add_exception(
UniqueArgumentNames(
"There can be only one argument named < %s >." %
element.name,
locations=[
self._internal_ctx.directive.arguments[
element.name].location,
element.get_location(),
],
))
return
self._internal_ctx.argument = NodeArgument(self._internal_ctx.path,
element.get_location(),
element.name)
def _on_variable_definition_in(self, element: _VisitorElement):
node = NodeVariableDefinition(self.path, element.get_location(),
element.name)
node.parent = self._current_node
self._current_node = node
