use core::fmt;
use gql::{GraphQLError, Object, Value};
use serde::{Deserialize, Serialize};
use serde_json::{Map, Value as JsonValue};
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
pub struct GraphQLRequest {
#[serde(default, skip_serializing_if = "String::is_empty")]
pub query: String,
#[serde(
default,
alias = "doc_id",
alias = "documentId",
alias = "queryId",
skip_serializing_if = "Option::is_none"
)]
pub id: Option<String>,
#[serde(
rename = "operationName",
default,
skip_serializing_if = "Option::is_none"
)]
pub operation_name: Option<String>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub variables: Option<Map<String, JsonValue>>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub extensions: Option<Map<String, JsonValue>>,
}
impl GraphQLRequest {
#[must_use]
pub fn new(query: impl Into<String>) -> Self {
Self {
query: query.into(),
id: None,
operation_name: None,
variables: None,
extensions: None,
}
}
#[must_use]
pub fn persisted(id: impl Into<String>) -> Self {
Self {
query: String::new(),
id: Some(id.into()),
operation_name: None,
variables: None,
extensions: None,
}
}
#[must_use]
pub fn with_id(mut self, id: impl Into<String>) -> Self {
self.id = Some(id.into());
self
}
#[must_use]
pub fn prepared_id(&self) -> Option<&str> {
if let Some(id) = self.id.as_deref().filter(|id| !id.is_empty()) {
return Some(id);
}
let extensions = self.extensions.as_ref()?;
for key in ["id", "doc_id", "documentId", "queryId", "hash"] {
if let Some(id) = extensions
.get(key)
.and_then(JsonValue::as_str)
.filter(|id| !id.is_empty())
{
return Some(id);
}
}
let persisted = extensions.get("persistedQuery")?.as_object()?;
for key in ["sha256Hash", "hash", "id", "queryId", "documentId"] {
if let Some(id) = persisted
.get(key)
.and_then(JsonValue::as_str)
.filter(|id| !id.is_empty())
{
return Some(id);
}
}
None
}
pub fn from_json_slice(body: &[u8]) -> Result<Self, RequestError> {
serde_json::from_slice(body)
.map_err(|error| RequestError::new(format!("Invalid GraphQL request: {error}")))
}
pub fn from_json_str(body: &str) -> Result<Self, RequestError> {
serde_json::from_str(body)
.map_err(|error| RequestError::new(format!("Invalid GraphQL request: {error}")))
}
#[must_use]
pub fn operation_name(mut self, name: impl Into<String>) -> Self {
self.operation_name = Some(name.into());
self
}
#[must_use]
pub fn variables(mut self, variables: Map<String, JsonValue>) -> Self {
self.variables = Some(variables);
self
}
pub fn variables_object(&self) -> Result<Option<Object>, RequestError> {
self.variables
.as_ref()
.map(|variables| variables_to_object(variables, ""))
.transpose()
}
pub fn as_gql<'a>(&'a self, variables: Option<&'a Object>) -> gql::Request<'a> {
gql::Request {
query: &self.query,
operation_name: self.operation_name.as_deref(),
variables,
}
}
}
#[derive(Clone, Debug, PartialEq)]
pub enum RequestPayload {
Single(GraphQLRequest),
Batch(Vec<GraphQLRequest>),
}
impl RequestPayload {
#[cfg_attr(
feature = "tracing",
tracing::instrument(
skip_all,
level = "debug",
name = "suku.parse",
fields(body_bytes = body.len(), max_batch_size)
)
)]
pub fn from_json_slice(body: &[u8], max_batch_size: usize) -> Result<Self, RequestError> {
let is_batch = body
.iter()
.copied()
.find(|byte| !byte.is_ascii_whitespace())
.is_some_and(|byte| byte == b'[');
if is_batch {
let batch: Vec<GraphQLRequest> = serde_json::from_slice(body)
.map_err(|error| RequestError::new(format!("Invalid batch request: {error}")))?;
if batch.is_empty() {
return Err(RequestError::new(
"A batch request must contain at least one operation.",
));
}
if max_batch_size != 0 && batch.len() > max_batch_size {
return Err(RequestError::new(format!(
"A batch request may contain at most {max_batch_size} operations."
)));
}
Ok(Self::Batch(batch))
} else {
let request: GraphQLRequest = serde_json::from_slice(body)
.map_err(|error| RequestError::new(format!("Invalid GraphQL request: {error}")))?;
Ok(Self::Single(request))
}
}
#[must_use]
pub fn requests(&self) -> &[GraphQLRequest] {
match self {
Self::Single(request) => core::slice::from_ref(request),
Self::Batch(requests) => requests,
}
}
#[must_use]
pub const fn is_batch(&self) -> bool {
matches!(self, Self::Batch(_))
}
}
#[derive(Clone, Debug, PartialEq, Eq)]
pub struct RequestError {
message: String,
}
impl RequestError {
#[must_use]
pub fn new(message: impl Into<String>) -> Self {
Self {
message: message.into(),
}
}
#[must_use]
pub fn message(&self) -> &str {
&self.message
}
#[must_use]
pub fn into_response(self) -> gql::Response {
gql::Response::error(GraphQLError::new(self.message))
}
}
impl fmt::Display for RequestError {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
f.write_str(&self.message)
}
}
impl std::error::Error for RequestError {}
impl From<GraphQLError> for RequestError {
fn from(value: GraphQLError) -> Self {
Self::new(value.message().to_owned())
}
}
fn variables_to_object(
variables: &Map<String, JsonValue>,
path: &str,
) -> Result<Object, RequestError> {
let mut object = Object::with_capacity(variables.len());
for (key, value) in variables {
object.push_unchecked(
key.as_str(),
json_to_graphql(value, &format!("{path}.{key}"))?,
);
}
Ok(object)
}
pub fn json_to_graphql(value: &JsonValue, path: &str) -> Result<Value, RequestError> {
Ok(match value {
JsonValue::Null => Value::Null,
JsonValue::Bool(value) => Value::Boolean(*value),
JsonValue::Number(number) => {
if let Some(number) = number.as_i64() {
Value::integer(i128::from(number))
} else if let Some(number) = number.as_u64() {
Value::integer(i128::from(number))
} else if let Some(number) = number.as_f64() {
if number.is_finite() && number.fract() == 0.0 {
let integer = number as i128;
if integer as f64 == number {
Value::integer(integer)
} else {
Value::Float(number)
}
} else {
Value::Float(number)
}
} else {
return Err(RequestError::new(format!(
"Unsupported number at `{path}`."
)));
}
}
JsonValue::String(value) => Value::String(value.as_str().into()),
JsonValue::Array(values) => {
let mut list = Vec::with_capacity(values.len());
for (index, value) in values.iter().enumerate() {
list.push(json_to_graphql(value, &format!("{path}[{index}]"))?);
}
Value::List(list)
}
JsonValue::Object(values) => {
Value::Object(std::sync::Arc::new(variables_to_object(values, path)?))
}
})
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn parses_operation_name_alias() {
let request: GraphQLRequest =
serde_json::from_str(r#"{"query":"{ hello }","operationName":"Greeting"}"#)
.expect("valid request");
assert_eq!(request.operation_name.as_deref(), Some("Greeting"));
}
#[test]
fn preserves_64_bit_integers_as_bigints() {
let request: GraphQLRequest =
serde_json::from_str(r#"{"query":"{ echo(n: 1) }","variables":{"n":10000000000}}"#)
.expect("valid request");
let object = request
.variables_object()
.expect("variables")
.expect("object");
assert_eq!(object.get("n"), Some(&Value::integer(10_000_000_000)));
}
#[test]
fn rejects_empty_batches() {
let error = RequestPayload::from_json_slice(b"[]", 10).expect_err("empty batch");
assert!(error.message().contains("at least one"));
}
}