use std::sync::OnceLock;
use crate::{
ast::{self, Field, InlineFragment, Selection, SelectionSet},
schema::Schema,
types::{Field as FieldDefinition, Type, TypeRef},
validation::ValidationOptions,
};
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub(crate) enum MetaField {
Typename,
Schema,
Type,
}
#[derive(Clone, Debug)]
pub(crate) struct FieldContext<'a> {
pub(crate) parent_type: Option<&'a Type>,
pub(crate) definition: Option<&'a FieldDefinition>,
pub(crate) meta: Option<MetaField>,
pub(crate) return_type: Option<&'a TypeRef>,
}
#[derive(Clone, Copy, Debug)]
pub(crate) struct ArgumentInfo<'a> {
pub(crate) ty: &'a TypeRef,
pub(crate) has_default: bool,
}
impl<'a> ArgumentInfo<'a> {
fn from_input(input: &'a crate::types::InputValue) -> Self {
Self {
ty: &input.ty,
has_default: input.default_value.is_some(),
}
}
}
fn meta_type(meta: MetaField) -> &'static TypeRef {
static TYPENAME: OnceLock<TypeRef> = OnceLock::new();
static SCHEMA: OnceLock<TypeRef> = OnceLock::new();
static TYPE: OnceLock<TypeRef> = OnceLock::new();
match meta {
MetaField::Typename => TYPENAME.get_or_init(|| TypeRef::string().non_null()),
MetaField::Schema => SCHEMA.get_or_init(|| TypeRef::named("__Schema").non_null()),
MetaField::Type => TYPE.get_or_init(|| TypeRef::named("__Type")),
}
}
pub(crate) fn type_ref_from_ast(ty: &ast::Type<'_>) -> TypeRef {
match ty {
ast::Type::Named(name) => TypeRef::named_str(name),
ast::Type::List(inner) => TypeRef::List(Box::new(type_ref_from_ast(inner))),
ast::Type::NonNull(inner) => TypeRef::NonNull(Box::new(type_ref_from_ast(inner))),
}
}
pub(crate) fn meta_field(
schema: &Schema,
options: &ValidationOptions,
parent: Option<&Type>,
name: &str,
) -> Option<MetaField> {
let parent = parent?;
match name {
"__typename" if parent.is_composite() => Some(MetaField::Typename),
"__schema" | "__type"
if options.introspection
&& parent.is_composite()
&& parent.name() == schema.query_name() =>
{
Some(if name == "__schema" {
MetaField::Schema
} else {
MetaField::Type
})
}
_ => None,
}
}
pub(crate) fn field_context<'a>(
schema: &'a Schema,
options: &ValidationOptions,
parent: Option<&'a Type>,
field: &'a Field<'a>,
) -> FieldContext<'a> {
let meta = meta_field(schema, options, parent, field.name);
let definition = if meta.is_some() {
None
} else {
parent.and_then(|parent| match parent {
Type::Object(object) => object.get_field(field.name),
Type::Interface(interface) => interface.get_field(field.name),
_ => None,
})
};
let return_type = match meta {
Some(meta) => Some(meta_type(meta)),
None => definition.map(|definition| &definition.ty),
};
FieldContext {
parent_type: parent,
definition,
meta,
return_type,
}
}
pub(crate) fn field_argument_info<'a>(
context: &FieldContext<'a>,
name: &str,
) -> Option<ArgumentInfo<'a>> {
if let Some(definition) = context.definition {
return crate::types::map_get(&definition.args, name).map(ArgumentInfo::from_input);
}
match context.meta {
Some(MetaField::Type) if name == "name" => Some(ArgumentInfo {
ty: meta_type(MetaField::Typename),
has_default: false,
}),
_ => None,
}
}
pub(crate) fn directive_argument_info<'a>(
definition: &'a crate::types::DirectiveDefinition,
name: &str,
) -> Option<ArgumentInfo<'a>> {
crate::types::map_get(&definition.args, name).map(ArgumentInfo::from_input)
}
pub(crate) trait Visitor<'a> {
fn field(&mut self, field: &'a Field<'a>, context: &FieldContext<'a>) {
let _ = (field, context);
}
fn inline_fragment(&mut self, fragment: &'a InlineFragment<'a>, parent: Option<&'a Type>) {
let _ = (fragment, parent);
}
fn fragment_spread(&mut self, spread: &'a ast::FragmentSpread<'a>, parent: Option<&'a Type>) {
let _ = (spread, parent);
}
}
pub(crate) fn walk<'a, V: Visitor<'a>>(
schema: &'a Schema,
options: &ValidationOptions,
parent: Option<&'a Type>,
selection_set: &'a SelectionSet<'a>,
visitor: &mut V,
) {
for selection in &selection_set.items {
match selection {
Selection::Field(field) => {
let context = field_context(schema, options, parent, field);
visitor.field(field, &context);
if let Some(child_set) = &field.selection_set {
let child = context
.return_type
.as_ref()
.and_then(|ty| schema.get_type(ty.named_type()))
.filter(|ty| ty.is_composite());
walk(schema, options, child, child_set, visitor);
}
}
Selection::InlineFragment(fragment) => {
visitor.inline_fragment(fragment, parent);
let condition = fragment
.type_condition
.and_then(|name| schema.get_type(name))
.filter(|ty| ty.is_composite())
.or(parent);
walk(schema, options, condition, &fragment.selection_set, visitor);
}
Selection::FragmentSpread(spread) => {
visitor.fragment_spread(spread, parent);
}
}
}
}