示例#1
0
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(),
    )
示例#2
0
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(),
    )
示例#3
0
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(),
    )
示例#4
0
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(),
    )