use std::{marker::PhantomData, sync::Arc};
use gql::{Field, GraphQLError, Name, ObjectType, TypeRef, UnionType, Value};
use crate::{
registry::TypeRegistry,
traits::{IntoValue, OutputType},
};
pub trait ErrorUnionModel: Sized + Send + Sync + 'static {
fn members() -> &'static [&'static str];
fn into_value(self) -> Result<Value, GraphQLError>;
}
pub(crate) struct ResultSuccess {
data: Value,
}
impl ResultSuccess {
pub(crate) fn new(data: Value) -> Self {
Self { data }
}
}
struct SuccessMarker<T>(PhantomData<fn() -> T>);
struct UnionMarker<T, E>(PhantomData<fn() -> (T, E)>);
pub(crate) fn result_union_type_ref<T, E>(
registry: &mut TypeRegistry,
parent: &str,
field: &str,
) -> TypeRef
where
T: OutputType + IntoValue + Send + 'static,
E: ErrorUnionModel,
{
T::register_output(registry);
let suffix = pascal_case(field);
let success_name: Name = format!("{parent}{suffix}Success").into();
let union_name: Name = format!("{parent}{suffix}Result").into();
let data_type = if T::is_optional() {
T::output_type()
} else {
T::output_type().non_null()
};
let success = ObjectType::new(Arc::clone(&success_name))
.description(format!("The successful payload of `{parent}.{field}`."))
.is_type_of(|value| value.as_external::<ResultSuccess>().is_some())
.field(Field::new("data", data_type).resolve(|context| {
Box::pin(async move {
context
.parent
.as_external::<ResultSuccess>()
.map(|success| success.data.clone())
.ok_or_else(|| {
GraphQLError::new(format!(
"Internal error: `{}.{}` expected a result-union success payload.",
context.info.parent_type, context.info.field_name,
))
})
})
}));
registry.register_generated_object::<SuccessMarker<T>>(Arc::clone(&success_name), success);
let mut members: Vec<Name> = vec![success_name];
for member in E::members() {
registry.require_object(member, parent, field, "Error union member");
if !members.iter().any(|existing| existing.as_ref() == *member) {
members.push(Name::from(*member));
}
}
let mut union = UnionType::new(Arc::clone(&union_name)).description(format!(
"The result of `{parent}.{field}`: either its success payload or a typed error."
));
union.types = members;
registry.register_generated_union::<UnionMarker<T, E>>(Arc::clone(&union_name), union);
TypeRef::named(union_name).non_null()
}
pub(crate) fn pascal_case(field: &str) -> String {
let mut result = String::with_capacity(field.len());
let mut uppercase = true;
for character in field.chars() {
if character == '_' || character == '-' || character == ' ' {
uppercase = true;
continue;
}
if uppercase {
result.extend(character.to_uppercase());
uppercase = false;
} else {
result.push(character);
}
}
if result.is_empty() {
result.push_str("Field");
}
if result
.chars()
.next()
.is_some_and(|character| character.is_ascii_digit())
{
result.insert_str(0, "Field");
}
result
}
#[cfg(test)]
mod tests {
use super::pascal_case;
#[test]
fn field_names_become_type_name_fragments() {
assert_eq!(pascal_case("createUser"), "CreateUser");
assert_eq!(pascal_case("create_user"), "CreateUser");
assert_eq!(pascal_case("URL"), "URL");
assert_eq!(pascal_case("_id"), "Id");
assert_eq!(pascal_case("1st"), "Field1st");
assert_eq!(pascal_case("_"), "Field");
}
}