async def execute(
self,
query: str,
variable_values: Optional[Dict[str, Any]] = None,
context_value: Optional[Any] = None,
root_value: Optional[Any] = None,
operation_name: Optional[str] = None,
validate_queries: bool = True,
) -> ExecutionResult:
result = await execute(
self._schema,
query,
variable_values=variable_values,
root_value=root_value,
context_value=context_value,
operation_name=operation_name,
additional_middlewares=self.middleware,
extensions=self.extensions,
execution_context_class=self.execution_context_class,
validate_queries=validate_queries,
)
if result.errors:
self.process_errors(result.errors)
return ExecutionResult(
data=result.data,
errors=result.errors,
extensions=result.extensions,
)
def execute_sync(
schema: GraphQLSchema,
query: str,
extensions: Sequence[Type[Extension]],
root_value: Any = None,
context_value: Any = None,
variable_values: Dict[str, Any] = None,
additional_middlewares: List[Any] = None,
operation_name: str = None,
) -> ExecutionResult:
result, extensions_runner = base_execute(
schema=schema,
query=query,
extensions=extensions,
root_value=root_value,
context_value=context_value,
variable_values=variable_values,
additional_middlewares=additional_middlewares,
operation_name=operation_name,
)
if isawaitable(result):
ensure_future(cast(Awaitable[GraphQLExecutionResult], result)).cancel()
raise RuntimeError(
"GraphQL execution failed to complete synchronously.")
result = cast(GraphQLExecutionResult, result)
return ExecutionResult(
data=result.data,
errors=result.errors,
extensions=extensions_runner.get_extensions_results(),
)
async def execute(
schema: GraphQLSchema,
query: str,
extensions: Sequence[Type[Extension]],
root_value: Any = None,
context_value: Any = None,
variable_values: Dict[str, Any] = None,
additional_middlewares: List[Any] = None,
operation_name: str = None,
) -> ExecutionResult:
result, extensions_runner = base_execute(
schema=schema,
query=query,
extensions=extensions,
root_value=root_value,
context_value=context_value,
variable_values=variable_values,
additional_middlewares=additional_middlewares,
operation_name=operation_name,
)
if isawaitable(result):
result = await cast(Awaitable[GraphQLExecutionResult], result)
result = cast(GraphQLExecutionResult, result)
return ExecutionResult(
data=result.data,
errors=result.errors,
extensions=extensions_runner.get_extensions_results(),
)
def execute_sync(
schema: GraphQLSchema,
query: str,
extensions: Sequence[Type[Extension]],
root_value: Any = None,
context_value: Any = None,
variable_values: Dict[str, Any] = None,
additional_middlewares: List[Any] = None,
operation_name: str = None,
execution_context_class: Optional[Type[GraphQLExecutionContext]] = None,
) -> ExecutionResult:
execution_context = ExecutionContext(
query=query,
context=context_value,
variables=variable_values,
operation_name=operation_name,
)
extensions_runner = ExtensionsRunner(
execution_context=execution_context,
extensions=[extension() for extension in extensions],
)
additional_middlewares = additional_middlewares or []
with extensions_runner.request():
# Note: In graphql-core the schema would be validated here but in
# Strawberry we are validating it at initialisation time instead
try:
with extensions_runner.parsing():
document = parse(query)
except GraphQLError as error:
return ExecutionResult(
data=None,
errors=[error],
extensions=extensions_runner.get_extensions_results(),
)
except Exception as error: # pragma: no cover
error = GraphQLError(str(error), original_error=error)
return ExecutionResult(
data=None,
errors=[error],
extensions=extensions_runner.get_extensions_results(),
)
with extensions_runner.validation():
validation_errors = validate(schema, document)
if validation_errors:
return ExecutionResult(data=None, errors=validation_errors)
result = original_execute(
schema,
document,
root_value=root_value,
middleware=extensions_runner.as_middleware_manager(*additional_middlewares),
variable_values=variable_values,
operation_name=operation_name,
context_value=context_value,
execution_context_class=execution_context_class,
)
if isawaitable(result):
ensure_future(cast(Awaitable[GraphQLExecutionResult], result)).cancel()
raise RuntimeError("GraphQL execution failed to complete synchronously.")
result = cast(GraphQLExecutionResult, result)
return ExecutionResult(
data=result.data,
errors=result.errors,
extensions=extensions_runner.get_extensions_results(),
)
async def execute(
schema: GraphQLSchema,
query: str,
extensions: Sequence[Type[Extension]],
root_value: Any = None,
context_value: Any = None,
variable_values: Dict[str, Any] = None,
additional_middlewares: List[Any] = None,
operation_name: str = None,
) -> ExecutionResult:
execution_context = ExecutionContext(
query=query,
context=context_value,
variables=variable_values,
operation_name=operation_name,
)
extensions_runner = ExtensionsRunner(
execution_context=execution_context,
extensions=[extension() for extension in extensions],
)
additional_middlewares = additional_middlewares or []
with extensions_runner.request():
schema_validation_errors = validate_schema(schema)
if schema_validation_errors:
return ExecutionResult(
data=None,
errors=schema_validation_errors,
extensions=extensions_runner.get_extensions_results(),
)
try:
with extensions_runner.parsing():
document = parse(query)
except GraphQLError as error:
return ExecutionResult(
data=None,
errors=[error],
extensions=extensions_runner.get_extensions_results(),
)
except Exception as error: # pragma: no cover
error = GraphQLError(str(error), original_error=error)
return ExecutionResult(
data=None,
errors=[error],
extensions=extensions_runner.get_extensions_results(),
)
with extensions_runner.validation():
validation_errors = validate(schema, document)
if validation_errors:
return ExecutionResult(data=None, errors=validation_errors)
result = original_execute(
schema,
document,
root_value=root_value,
middleware=extensions_runner.as_middleware_manager(
*additional_middlewares),
variable_values=variable_values,
operation_name=operation_name,
context_value=context_value,
)
if isawaitable(result):
result = await cast(Awaitable[GraphQLExecutionResult], result)
result = cast(GraphQLExecutionResult, result)
return ExecutionResult(
data=result.data,
errors=result.errors,
extensions=extensions_runner.get_extensions_results(),
)
async def execute(
schema: GraphQLSchema,
query: str,
extensions: Sequence[Union[Type[Extension], Extension]],
directives: Sequence[Any],
execution_context: ExecutionContext,
execution_context_class: Optional[Type[GraphQLExecutionContext]] = None,
) -> ExecutionResult:
extensions_runner = ExtensionsRunner(
execution_context=execution_context,
extensions=list(extensions),
)
additional_middlewares = [DirectivesMiddleware(directives)]
async with extensions_runner.request():
# Note: In graphql-core the schema would be validated here but in
# Strawberry we are validating it at initialisation time instead
try:
async with extensions_runner.parsing():
if not execution_context.graphql_document:
execution_context.graphql_document = parse_document(query)
except GraphQLError as error:
execution_context.errors = [error]
return ExecutionResult(
data=None,
errors=[error],
extensions=await extensions_runner.get_extensions_results(),
)
except Exception as error: # pragma: no cover
error = GraphQLError(str(error), original_error=error)
execution_context.errors = [error]
return ExecutionResult(
data=None,
errors=[error],
extensions=await extensions_runner.get_extensions_results(),
)
async with extensions_runner.validation():
_run_validation(execution_context)
if execution_context.errors:
return ExecutionResult(data=None,
errors=execution_context.errors)
result = original_execute(
schema,
execution_context.graphql_document,
root_value=execution_context.root_value,
middleware=extensions_runner.as_middleware_manager(
*additional_middlewares),
variable_values=execution_context.variables,
operation_name=execution_context.operation_name,
context_value=execution_context.context,
execution_context_class=execution_context_class,
)
if isawaitable(result):
result = await cast(Awaitable[GraphQLExecutionResult], result)
execution_context.result = cast(GraphQLExecutionResult, result)
result = cast(GraphQLExecutionResult, result)
return ExecutionResult(
data=result.data,
errors=result.errors,
extensions=await extensions_runner.get_extensions_results(),
)
def execute_sync(
schema: GraphQLSchema,
query: str,
extensions: Sequence[Union[Type[Extension], Extension]],
execution_context: ExecutionContext,
execution_context_class: Optional[Type[GraphQLExecutionContext]] = None,
) -> ExecutionResult:
extensions_runner = ExtensionsRunner(
execution_context=execution_context,
extensions=list(extensions),
)
with extensions_runner.request():
# Note: In graphql-core the schema would be validated here but in
# Strawberry we are validating it at initialisation time instead
with extensions_runner.parsing():
try:
if not execution_context.graphql_document:
execution_context.graphql_document = parse_document(query)
except GraphQLError as error:
execution_context.errors = [error]
return ExecutionResult(
data=None,
errors=[error],
extensions=extensions_runner.get_extensions_results_sync(),
)
except Exception as error: # pragma: no cover
error = GraphQLError(str(error), original_error=error)
execution_context.errors = [error]
return ExecutionResult(
data=None,
errors=[error],
extensions=extensions_runner.get_extensions_results_sync(),
)
with extensions_runner.validation():
_run_validation(execution_context)
if execution_context.errors:
return ExecutionResult(data=None,
errors=execution_context.errors)
with extensions_runner.executing():
if not execution_context.result:
result = original_execute(
schema,
execution_context.graphql_document,
root_value=execution_context.root_value,
middleware=extensions_runner.as_middleware_manager(),
variable_values=execution_context.variables,
operation_name=execution_context.operation_name,
context_value=execution_context.context,
execution_context_class=execution_context_class,
)
if isawaitable(result):
result = cast(Awaitable[GraphQLExecutionResult], result)
ensure_future(result).cancel()
raise RuntimeError(
"GraphQL execution failed to complete synchronously.")
result = cast(GraphQLExecutionResult, result)
execution_context.result = result
# Also set errors on the execution_context so that it's easier
# to access in extensions
if result.errors:
execution_context.errors = result.errors
return ExecutionResult(
data=execution_context.result.data,
errors=execution_context.result.errors,
extensions=extensions_runner.get_extensions_results_sync(),
)