use core::fmt;
use std::{any::Any, future::Future, sync::Arc, time::Duration};
use futures::StreamExt as _;
use gql::{
Authorizer, ExecutionOptions, GraphQLError, Response, Schema, SubscriptionResponse, Value,
ast::OperationKind,
prepared::{PreparedQuery, PreparedQueryRegistry},
};
use crate::{
error::{ErrorContext, ErrorFormatter, ErrorKind, ResponseMeta, format_response_errors},
prepared::{PreparedQueries, persisted_query_not_found, persisted_query_not_found_error},
request::GraphQLRequest,
};
pub const DEFAULT_MAX_BODY_BYTES: usize = 1024 * 1024;
pub const DEFAULT_MAX_BATCH_SIZE: usize = 16;
pub const DEFAULT_BATCH_CONCURRENCY: usize = 16;
#[derive(Clone)]
pub struct Context(Arc<dyn Any + Send + Sync>);
impl Default for Context {
fn default() -> Self {
Self::empty()
}
}
impl Context {
#[must_use]
pub fn new<T: Any + Send + Sync>(value: T) -> Self {
Self(Arc::new(value))
}
#[must_use]
pub fn empty() -> Self {
Self(Arc::new(()))
}
#[must_use]
pub fn from_arc(context: Arc<dyn Any + Send + Sync>) -> Self {
Self(context)
}
#[must_use]
pub fn as_arc(&self) -> &Arc<dyn Any + Send + Sync> {
&self.0
}
#[must_use]
pub fn into_arc(self) -> Arc<dyn Any + Send + Sync> {
self.0
}
#[must_use]
pub fn downcast_ref<T: Any>(&self) -> Option<&T> {
self.0.downcast_ref()
}
#[must_use]
pub fn is_empty(&self) -> bool {
self.0.is::<()>()
}
}
impl fmt::Debug for Context {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
f.debug_struct("Context")
.field("empty", &self.is_empty())
.finish()
}
}
impl From<Arc<dyn Any + Send + Sync>> for Context {
fn from(value: Arc<dyn Any + Send + Sync>) -> Self {
Self::from_arc(value)
}
}
impl<T: Any + Send + Sync> From<Arc<T>> for Context {
fn from(value: Arc<T>) -> Self {
Self(value)
}
}
impl From<Context> for Arc<dyn Any + Send + Sync> {
fn from(value: Context) -> Self {
value.into_arc()
}
}
#[derive(Clone)]
struct ServerInner {
schema: Schema,
introspection: bool,
max_depth: usize,
max_complexity: u32,
max_breadth: usize,
list_complexity: u32,
max_errors: usize,
max_concurrency: usize,
max_body_bytes: usize,
timeout: Option<Duration>,
max_batch_size: usize,
batch_concurrency: usize,
authorizer: Option<Arc<dyn Authorizer>>,
prepared: Option<PreparedQueryRegistry>,
require_prepared: bool,
error_formatter: Option<Arc<dyn ErrorFormatter>>,
}
#[derive(Clone)]
pub struct Server {
inner: Arc<ServerInner>,
}
impl fmt::Debug for Server {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
f.debug_struct("Server")
.field("schema", &self.inner.schema)
.field("introspection", &self.inner.introspection)
.field("max_depth", &self.inner.max_depth)
.field("max_complexity", &self.inner.max_complexity)
.field("max_breadth", &self.inner.max_breadth)
.field("max_errors", &self.inner.max_errors)
.field("max_concurrency", &self.inner.max_concurrency)
.field("max_body_bytes", &self.inner.max_body_bytes)
.field("timeout", &self.inner.timeout)
.field("max_batch_size", &self.inner.max_batch_size)
.field("batch_concurrency", &self.inner.batch_concurrency)
.field("authorizer", &self.inner.authorizer.is_some())
.field(
"prepared_queries",
&self.inner.prepared.as_ref().map_or(0, |r| r.len()),
)
.field("require_prepared", &self.inner.require_prepared)
.field("error_formatter", &self.inner.error_formatter.is_some())
.finish()
}
}
impl Server {
#[must_use]
pub fn new(schema: Schema) -> Self {
Self {
inner: Arc::new(ServerInner {
schema,
introspection: true,
max_depth: 32,
max_complexity: 100_000,
max_breadth: 1_000,
list_complexity: 10,
max_errors: 100,
max_concurrency: 16,
max_body_bytes: DEFAULT_MAX_BODY_BYTES,
timeout: Some(Duration::from_secs(30)),
max_batch_size: DEFAULT_MAX_BATCH_SIZE,
batch_concurrency: DEFAULT_BATCH_CONCURRENCY,
authorizer: None,
prepared: None,
require_prepared: false,
error_formatter: None,
}),
}
}
fn inner_mut(&mut self) -> &mut ServerInner {
Arc::make_mut(&mut self.inner)
}
#[must_use]
pub fn introspection(mut self, enabled: bool) -> Self {
self.inner_mut().introspection = enabled;
self
}
#[must_use]
pub fn max_depth(mut self, depth: usize) -> Self {
self.inner_mut().max_depth = depth;
self
}
#[must_use]
pub fn max_complexity(mut self, complexity: u32) -> Self {
self.inner_mut().max_complexity = complexity;
self
}
#[must_use]
pub fn max_errors(mut self, max_errors: usize) -> Self {
self.inner_mut().max_errors = max_errors;
self
}
#[must_use]
pub fn max_concurrency(mut self, concurrency: usize) -> Self {
self.inner_mut().max_concurrency = concurrency;
self
}
#[must_use]
pub fn max_breadth(mut self, breadth: usize) -> Self {
self.inner_mut().max_breadth = breadth;
self
}
#[must_use]
pub fn max_body_bytes(mut self, bytes: usize) -> Self {
self.inner_mut().max_body_bytes = bytes;
self
}
#[must_use]
pub fn timeout(mut self, timeout: Duration) -> Self {
self.inner_mut().timeout = Some(timeout);
self
}
#[must_use]
pub fn without_timeout(mut self) -> Self {
self.inner_mut().timeout = None;
self
}
#[must_use]
pub fn max_batch_size(mut self, size: usize) -> Self {
self.inner_mut().max_batch_size = size;
self
}
#[must_use]
pub fn batch_concurrency(mut self, concurrency: usize) -> Self {
self.inner_mut().batch_concurrency = concurrency.max(1);
self
}
#[must_use]
pub fn complexity_config(mut self, config: gql::complexity::ComplexityOptions) -> Self {
let inner = self.inner_mut();
inner.list_complexity = config.list_factor;
if config.max_depth != 0 {
inner.max_depth = config.max_depth;
}
if config.max_complexity != 0 {
inner.max_complexity = config.max_complexity;
}
if config.max_breadth != 0 {
inner.max_breadth = config.max_breadth;
}
self
}
#[must_use]
pub fn authorizer(mut self, authorizer: impl Authorizer + 'static) -> Self {
self.inner_mut().authorizer = Some(Arc::new(authorizer));
self
}
#[must_use]
pub fn prepared_queries(mut self, queries: PreparedQueries) -> Self {
self.inner_mut().prepared = Some(queries.into_registry());
self
}
#[must_use]
pub fn prepared_query_registry(mut self, registry: PreparedQueryRegistry) -> Self {
self.inner_mut().prepared = Some(registry);
self
}
#[must_use]
pub fn require_prepared(mut self, required: bool) -> Self {
self.inner_mut().require_prepared = required;
self
}
#[must_use]
pub fn prepared_query_registry_ref(&self) -> Option<&PreparedQueryRegistry> {
self.inner.prepared.as_ref()
}
#[must_use]
pub fn prepared_query(&self, id: &str) -> Option<&PreparedQuery> {
self.inner.prepared.as_ref()?.get(id)
}
pub fn prepared_query_for_current_schema(
&self,
id: &str,
) -> Result<Option<&PreparedQuery>, gql::GraphQLError> {
let Some(prepared) = self.prepared_query(id) else {
return Ok(None);
};
if !prepared.schema().ptr_eq(&self.inner.schema) {
return Err(GraphQLError::new(format!(
"Prepared query \"{id}\" was prepared against a different schema instance; prepare it with this server's schema."
)));
}
Ok(Some(prepared))
}
#[must_use]
pub fn requires_prepared_queries(&self) -> bool {
self.inner.require_prepared
}
#[must_use]
pub fn format_error<F>(mut self, formatter: F) -> Self
where
F: for<'a> Fn(&GraphQLError, &ErrorContext<'a>) -> GraphQLError + Send + Sync + 'static,
{
self.inner_mut().error_formatter = Some(Arc::new(formatter) as Arc<dyn ErrorFormatter>);
self
}
#[must_use]
pub fn format_error_with(mut self, formatter: Arc<dyn ErrorFormatter>) -> Self {
self.inner_mut().error_formatter = Some(formatter);
self
}
#[must_use]
pub fn has_error_formatter(&self) -> bool {
self.inner.error_formatter.is_some()
}
#[must_use]
pub fn schema(&self) -> &Schema {
&self.inner.schema
}
#[must_use]
pub fn max_body_bytes_limit(&self) -> usize {
self.inner.max_body_bytes
}
#[must_use]
pub fn max_batch_size_limit(&self) -> usize {
self.inner.max_batch_size
}
#[cfg_attr(
feature = "tracing",
tracing::instrument(
skip_all,
level = "debug",
name = "suku.execute",
fields(
operation = request.operation_name.as_deref().unwrap_or("<anonymous>"),
prepared = request.prepared_id().is_some(),
document_bytes = request.query.len(),
variable_count = request.variables.as_ref().map_or(0, serde_json::Map::len),
errors = tracing::field::Empty,
)
)
)]
pub async fn execute(&self, request: &GraphQLRequest, context: Context) -> gql::Response {
let variables = match request.variables_object() {
Ok(variables) => variables,
Err(error) => return self.request_response(request, error.into_response()),
};
let options = self.execution_options(context);
if let Some(id) = request.prepared_id() {
match self.prepared_query_for_current_schema(id) {
Ok(Some(prepared)) => {
if let Some(error) =
prepared_operation_name_error(prepared, request.operation_name.as_deref())
{
return self.request_response(request, Response::error(error));
}
let meta = ResponseMeta::from_request(request)
.with_operation_name(prepared.operation_name());
let future = prepared.execute(variables.as_ref(), &options);
return self.await_execute(meta, options.timeout, future).await;
}
Ok(None) => {}
Err(error) => {
return self.request_response(request, Response::error(error));
}
}
if self.inner.require_prepared || request.query.trim().is_empty() {
return self.request_response(request, persisted_query_not_found(id));
}
} else if self.inner.require_prepared {
return self.request_response(request, persisted_query_not_found(""));
} else if request.query.trim().is_empty() {
return self.request_response(request, missing_query_response());
}
let gql_request = request.as_gql(variables.as_ref());
let future = gql::execute(&self.inner.schema, gql_request, &options);
self.await_execute(ResponseMeta::from_request(request), options.timeout, future)
.await
}
#[cfg_attr(
feature = "tracing",
tracing::instrument(
skip_all,
level = "debug",
name = "suku.execute_batch",
fields(batch_size = requests.len(), concurrency = self.inner.batch_concurrency)
)
)]
pub async fn execute_batch(
&self,
requests: &[GraphQLRequest],
context: Context,
) -> Vec<gql::Response> {
let limit = self.inner.batch_concurrency.max(1);
let mut responses = Vec::with_capacity(requests.len());
for chunk in requests.chunks(limit) {
let futures = chunk
.iter()
.map(|request| self.execute(request, context.clone()));
responses.extend(futures::future::join_all(futures).await);
}
responses
}
#[cfg_attr(
feature = "tracing",
tracing::instrument(
skip_all,
level = "debug",
name = "suku.subscription",
fields(
operation = request.operation_name.as_deref().unwrap_or("<anonymous>"),
prepared = request.prepared_id().is_some(),
)
)
)]
pub async fn subscribe(
&self,
request: &GraphQLRequest,
context: Context,
) -> Result<SubscriptionResponse, gql::Response> {
let variables = match request.variables_object() {
Ok(variables) => variables,
Err(error) => return Err(self.request_response(request, error.into_response())),
};
let options = self.execution_options(context);
if let Some(id) = request.prepared_id() {
match self.prepared_query_for_current_schema(id) {
Ok(Some(prepared)) => {
if let Some(error) =
prepared_operation_name_error(prepared, request.operation_name.as_deref())
{
return Err(self.request_response(request, Response::error(error)));
}
let meta = ResponseMeta::from_request(request)
.with_operation_name(prepared.operation_name());
let future = prepared.subscribe(variables.as_ref(), &options);
return self.await_subscribe(meta, options.timeout, future).await;
}
Ok(None) => {}
Err(error) => {
return Err(self.request_response(request, Response::error(error)));
}
}
if self.inner.require_prepared || request.query.trim().is_empty() {
return Err(self.request_response(request, persisted_query_not_found(id)));
}
} else if self.inner.require_prepared {
return Err(self.request_response(request, persisted_query_not_found("")));
} else if request.query.trim().is_empty() {
return Err(self.request_response(request, missing_query_response()));
}
let gql_request = request.as_gql(variables.as_ref());
let future = gql::subscribe(&self.inner.schema, gql_request, &options);
self.await_subscribe(ResponseMeta::from_request(request), options.timeout, future)
.await
}
pub(crate) fn operation_kind(
&self,
request: &GraphQLRequest,
) -> Result<Option<OperationKind>, gql::GraphQLError> {
if let Some(id) = request.prepared_id() {
match self.prepared_query_for_current_schema(id) {
Ok(Some(prepared)) => {
if let Some(error) =
prepared_operation_name_error(prepared, request.operation_name.as_deref())
{
return Err(error);
}
return Ok(Some(prepared.kind()));
}
Ok(None) => {}
Err(error) => return Err(error),
}
if self.inner.require_prepared || request.query.trim().is_empty() {
return Err(persisted_query_not_found_error(id));
}
} else if self.inner.require_prepared {
return Err(persisted_query_not_found_error(""));
} else if request.query.trim().is_empty() {
return Err(missing_query_error());
}
operation_kind_from_text(request)
}
fn execution_options(&self, context: Context) -> ExecutionOptions {
let inner = &*self.inner;
ExecutionOptions {
context: context.into_arc(),
root_value: Value::Null,
introspection: inner.introspection,
authorizer: inner.authorizer.clone(),
max_depth: inner.max_depth,
max_complexity: inner.max_complexity,
max_breadth: inner.max_breadth,
list_complexity: inner.list_complexity,
max_errors: inner.max_errors,
max_concurrency: inner.max_concurrency,
timeout: inner.timeout,
}
}
pub(crate) fn format_response(
&self,
response: &mut gql::Response,
meta: ResponseMeta<'_>,
default_kind: ErrorKind,
) {
let Some(formatter) = self.inner.error_formatter.as_deref() else {
return;
};
format_response_errors(
formatter,
response,
meta.operation_name,
meta.request_id,
default_kind,
);
}
fn request_response(&self, request: &GraphQLRequest, response: gql::Response) -> gql::Response {
let mut response = response;
self.format_response(
&mut response,
ResponseMeta::from_request(request),
ErrorKind::Request,
);
response
}
async fn await_execute<F>(
&self,
meta: ResponseMeta<'_>,
timeout: Option<Duration>,
future: F,
) -> gql::Response
where
F: Future<Output = gql::Response>,
{
let (mut response, kind) = match timeout {
Some(timeout) => match timed(timeout, future).await {
Some(response) => (response, ErrorKind::Request),
None => (operation_timeout_response(timeout), ErrorKind::Execution),
},
None => (future.await, ErrorKind::Request),
};
self.format_response(&mut response, meta, kind);
response
}
#[allow(clippy::result_large_err)]
async fn await_subscribe<F>(
&self,
meta: ResponseMeta<'_>,
timeout: Option<Duration>,
future: F,
) -> Result<SubscriptionResponse, gql::Response>
where
F: Future<Output = Result<SubscriptionResponse, gql::Response>>,
{
let outcome = match timeout {
Some(timeout) => timed_subscribe(timeout, future).await,
None => future
.await
.map_err(|response| (response, ErrorKind::Request)),
};
match outcome {
Ok(subscription) => Ok(self.format_subscription(subscription, meta)),
Err((mut response, kind)) => {
self.format_response(&mut response, meta, kind);
Err(response)
}
}
}
fn format_subscription(
&self,
subscription: SubscriptionResponse,
meta: ResponseMeta<'_>,
) -> SubscriptionResponse {
let Some(formatter) = self.inner.error_formatter.clone() else {
return subscription;
};
let meta = meta.into_owned();
let stream = subscription
.stream
.map(move |mut response| {
format_response_errors(
formatter.as_ref(),
&mut response,
meta.operation_name.as_deref(),
meta.request_id.as_deref(),
ErrorKind::Execution,
);
response
})
.boxed();
SubscriptionResponse { stream }
}
}
fn missing_query_error() -> gql::GraphQLError {
gql::GraphQLError::new("Missing required `query` field.")
}
fn prepared_operation_name_error(
prepared: &PreparedQuery,
requested: Option<&str>,
) -> Option<gql::GraphQLError> {
let requested = requested?;
if prepared.operation_name() == Some(requested) {
return None;
}
Some(gql::GraphQLError::new(format!(
"Prepared query \"{}\" does not contain an operation named \"{requested}\".",
prepared.id()
)))
}
fn missing_query_response() -> gql::Response {
gql::Response::error(missing_query_error())
}
fn operation_kind_from_text(
request: &GraphQLRequest,
) -> Result<Option<OperationKind>, gql::GraphQLError> {
let document = gql::parser::parse_query(&request.query)?;
match request.operation_name.as_deref() {
Some(name) => document
.operations()
.find(|operation| operation.name == Some(name))
.map(|operation| Some(operation.kind))
.ok_or_else(|| gql::GraphQLError::new(format!("Unknown operation named \"{name}\"."))),
None => {
let mut operations = document.operations();
let Some(operation) = operations.next() else {
return Err(gql::GraphQLError::new(
"The document does not contain any executable operation.",
));
};
if operations.next().is_some() {
return Err(gql::GraphQLError::new(
"Must provide an operation name when the document contains multiple operations.",
));
}
Ok(Some(operation.kind))
}
}
}
#[cfg(feature = "axum")]
#[allow(clippy::result_large_err)]
async fn timed_subscribe<F>(
timeout: Duration,
future: F,
) -> Result<gql::SubscriptionResponse, (gql::Response, ErrorKind)>
where
F: std::future::Future<Output = Result<gql::SubscriptionResponse, gql::Response>>,
{
if tokio::runtime::Handle::try_current().is_err() {
return future
.await
.map_err(|response| (response, ErrorKind::Request));
}
match tokio::time::timeout(timeout, future).await {
Ok(response) => response.map_err(|response| (response, ErrorKind::Request)),
Err(_) => Err((subscribe_timeout_response(timeout), ErrorKind::Execution)),
}
}
#[cfg(not(feature = "axum"))]
#[allow(clippy::result_large_err)]
async fn timed_subscribe<F>(
_timeout: Duration,
future: F,
) -> Result<gql::SubscriptionResponse, (gql::Response, ErrorKind)>
where
F: std::future::Future<Output = Result<gql::SubscriptionResponse, gql::Response>>,
{
future
.await
.map_err(|response| (response, ErrorKind::Request))
}
#[cfg(feature = "axum")]
async fn timed<F>(timeout: Duration, future: F) -> Option<gql::Response>
where
F: std::future::Future<Output = gql::Response>,
{
if tokio::runtime::Handle::try_current().is_err() {
return Some(future.await);
}
tokio::time::timeout(timeout, future).await.ok()
}
#[cfg(not(feature = "axum"))]
async fn timed<F>(_timeout: Duration, future: F) -> Option<gql::Response>
where
F: std::future::Future<Output = gql::Response>,
{
Some(future.await)
}
fn operation_timeout_response(timeout: Duration) -> gql::Response {
gql::Response::error(gql::GraphQLError::new(format!(
"The operation timed out after {timeout:?}."
)))
}
#[cfg(feature = "axum")]
fn subscribe_timeout_response(timeout: Duration) -> gql::Response {
gql::Response::error(gql::GraphQLError::new(format!(
"The subscription timed out while starting after {timeout:?}."
)))
}