def __init__(self, schema, document_ast, variable_values):
self.schema = schema
self.operation_defs = {}
self.fragment_defs = {}
self.visited_fragments = set()
for defn in document_ast.definitions:
if isinstance(defn, ast.OperationDefinition):
root_type = get_operation_root_type(schema, defn)
definition_variables = defn.variable_definitions or []
if definition_variables:
def_var_names = {
v.variable.name.value
for v in definition_variables
}
var_names_diff = def_var_names.difference(
{k
for k in variable_values if k in def_var_names})
# check if we are missing some of the definition variables
if var_names_diff:
msg = (f'Please check your query variables. The '
f'following variables are missing: '
f'[{", ".join(var_names_diff)}]')
raise ValueError(msg)
self.operation_defs[getattr(defn.name, 'value', root_type)] = {
'definition':
defn,
'parent_type':
root_type,
'variables':
get_variable_values(schema, definition_variables,
variable_values),
}
elif isinstance(defn, ast.FragmentDefinition):
self.fragment_defs[defn.name.value] = defn
def return_all_errors_by_default():
result = get_variable_values(schema, variable_definitions, input_value)
assert result == [
_invalid_value_error(0, 0),
_invalid_value_error(1, 1),
_invalid_value_error(2, 2),
]
def when_max_errors_is_equal_to_number_of_errors():
result = get_variable_values(
schema, variable_definitions, input_value, max_errors=3
)
assert result == [
_invalid_value_error(0, 0),
_invalid_value_error(1, 1),
_invalid_value_error(2, 2),
]
def when_max_errors_is_less_than_number_of_errors():
result = get_variable_values(
schema, variable_definitions, input_value, max_errors=2
)
assert result == [
_invalid_value_error(0, 0),
_invalid_value_error(1, 1),
{
"message": "Too many errors processing variables,"
" error limit reached. Execution aborted."
},
]
def _execute(schema, root, query, context=None, variables=None, mutation=None):
try:
ast = parse(query)
validation_errors = validate(schema, ast)
if validation_errors:
return ExecutionResult(
errors=validation_errors,
invalid=True,
)
variable_definitions = [
variable_definition for definition in ast.definitions
if isinstance(definition, ast_types.OperationDefinition)
for variable_definition in (definition.variable_definitions or [])
]
variable_values = get_variable_values(schema, variable_definitions,
variables)
# The Python implementation of GraphQL currently lacks support
# for nulls, so we use the uncoerced variables when handling the
# request.
#
# See: https://github.com/graphql-python/graphql-core/issues/118
request = request_from_graphql_document(ast,
root,
mutation_root=mutation,
context=context,
variables=variables)
data = root.fetch(request.query, None)[0].value
if request.schema_query is not None:
schema_result = graphql_execute(
schema,
request.schema_query,
variable_values=variable_values,
)
if schema_result.invalid:
return schema_result
data.update(schema_result.data)
return ExecutionResult(data=data, errors=[])
except GraphQLError as error:
return ExecutionResult(errors=[error], invalid=True)
