shape/

graphql.rs

//! Helper functions and impls for creating [`Shape`]s from [`apollo_compiler`] types.

use apollo_compiler::ast::FieldDefinition;
use apollo_compiler::ast::Type;
use apollo_compiler::collections::IndexMap;
use apollo_compiler::parser::SourceSpan;
use apollo_compiler::schema::Component;
use apollo_compiler::schema::EnumType;
use apollo_compiler::schema::ExtendedType;
use apollo_compiler::schema::InputObjectType;
use apollo_compiler::schema::InterfaceType;
use apollo_compiler::schema::ObjectType;
use apollo_compiler::schema::UnionType;
use apollo_compiler::Name;
use apollo_compiler::Node;
use apollo_compiler::Schema;
use indexmap::IndexSet;

use crate::location::Location;
use crate::location::SourceId;
use crate::name::Name as CrateName;
use crate::name::Namespace;
use crate::name::NotFinal;
use crate::Shape;

/// Computes a [`Namespace<NotFinal>`] from a GraphQL `&Schema`, allowing for
/// mutual type references and recursive self-references.
#[must_use]
pub fn namespace_from_schema(schema: &Schema) -> Namespace<NotFinal> {
    GraphQLSchemaWalker::new(schema).compute_namespace()
}

#[derive(Debug)]
struct GraphQLSchemaWalker<'a> {
    schema: &'a Schema,
    visited: IndexSet<&'a str>,
}

impl<'a> GraphQLSchemaWalker<'a> {
    fn new(schema: &'a Schema) -> Self {
        Self {
            schema,
            visited: IndexSet::new(),
        }
    }

    fn compute_namespace(mut self) -> Namespace<NotFinal> {
        let mut namespace = Namespace::new();

        // Predefine all GraphQL built-in types.
        namespace.insert("String", Shape::string([]));
        namespace.insert("Int", Shape::int([]));
        namespace.insert("Float", Shape::float([]));
        namespace.insert("Boolean", Shape::bool([]));
        namespace.insert("ID", Shape::one([Shape::string([]), Shape::int([])], []));

        for (name, extended) in &self.schema.types {
            if namespace.has(name.as_str()) {
                debug_assert!(extended.is_built_in());
            } else if !extended.is_built_in() {
                namespace.insert(name.as_str(), self.shape_from_extended_type(extended));
            }
        }

        namespace
    }

    fn shape_from_type(&mut self, ty: &Type) -> Shape {
        let inner_name = ty.inner_named_type();
        let inner_shape = if let Some(inner_type) = self.schema.types.get(inner_name) {
            self.shape_from_extended_type(inner_type)
        } else {
            Shape::unknown(span(ty.inner_named_type().location()))
        };

        match ty {
            Type::Named(_) => Self::nullable(inner_shape),
            Type::NonNullNamed(_) => inner_shape,
            Type::List(_) => Self::nullable(Shape::list(inner_shape, [])),
            Type::NonNullList(_) => Shape::list(inner_shape, []),
        }
    }

    fn nullable(shape: Shape) -> Shape {
        let locations = shape.locations().cloned().collect::<Vec<_>>();
        Shape::one([shape, Shape::null([])], locations)
    }

    fn shape_from_extended_type(&mut self, extended: &'a ExtendedType) -> Shape {
        self.shape_from_extended_type_with_context(extended, false)
    }

    fn shape_from_extended_type_with_context(
        &mut self,
        extended: &'a ExtendedType,
        in_abstract_context: bool,
    ) -> Shape {
        let type_name = extended.name().as_str();

        // Check for cycles - if we're already visiting this type, return a name reference
        if self.visited.contains(type_name) {
            return Shape::name(type_name, span(extended.location()));
        }

        // Mark this type as being visited
        self.visited.insert(type_name);

        let result = match extended {
            ExtendedType::Scalar(node) => Shape::unknown(span(node.location())),

            ExtendedType::Object(node) => {
                // Add __typename field based on context
                let typename_shape = if in_abstract_context {
                    // In abstract context (interface/union), __typename is just the concrete type name
                    Shape::string_value(type_name, span(node.location()))
                } else {
                    // In concrete context, __typename includes None
                    Shape::one(
                        [
                            Shape::string_value(type_name, span(node.location())),
                            Shape::none(),
                        ],
                        span(node.location()),
                    )
                };

                let fields = node
                    .fields
                    .iter()
                    .map(|(name, field)| (name.to_string(), self.shape_from_type(&field.ty)))
                    .chain(std::iter::once(("__typename".to_string(), typename_shape)))
                    .collect();

                Shape::record(fields, span(node.location()))
            }

            ExtendedType::Interface(node) => {
                // When processing an interface, we need to create a union of implementing types
                // where each type knows it's in an abstract context for __typename generation
                let implementing_types: Vec<Shape> = self
                    .schema
                    .types
                    .iter()
                    .filter_map(|(_name, extended)| {
                        if let ExtendedType::Object(obj) = extended {
                            if obj.implements_interfaces.contains(&node.name) {
                                // Get the implementing type shape with abstract context
                                let mut impl_shape =
                                    self.shape_from_extended_type_with_context(extended, true);

                                // Assign the concrete type name to preserve field aliasing
                                let concrete_type_name = extended.name().as_str();
                                let concrete_name =
                                    CrateName::base(concrete_type_name, span(extended.location()));
                                impl_shape = impl_shape.with_name(&concrete_name);

                                Some(impl_shape)
                            } else {
                                None
                            }
                        } else {
                            None
                        }
                    })
                    .collect();

                Shape::one(implementing_types, span(node.location()))
            }

            ExtendedType::Union(node) => Shape::one(
                node.members.iter().filter_map(|member| {
                    self.schema.types.get(&member.name).map(|extended| {
                        // Get the member type shape with abstract context
                        let mut member_shape =
                            self.shape_from_extended_type_with_context(extended, true);

                        // Assign the concrete type name to preserve field aliasing
                        let concrete_type_name = extended.name().as_str();
                        let concrete_name =
                            CrateName::base(concrete_type_name, span(extended.location()));
                        member_shape = member_shape.with_name(&concrete_name);

                        member_shape
                    })
                }),
                span(node.location()),
            ),

            ExtendedType::Enum(node) => Shape::one(
                node.values
                    .iter()
                    .map(|(name, _)| Shape::string_value(name.as_str(), span(name.location()))),
                span(node.location()),
            ),

            ExtendedType::InputObject(node) => Shape::record(
                node.fields
                    .iter()
                    .map(|(name, field)| (name.to_string(), self.shape_from_type(&field.ty)))
                    .collect(),
                span(node.location()),
            ),
        };

        // Remove this type from visited set now that we're done processing it
        self.visited.shift_remove(type_name);

        result
    }
}

/// Get all the shapes for a GraphQL [`Schema`], keyed by their GraphQL [`Name`].
///
/// Locations will be automatically set with
#[must_use]
pub fn shapes_for_schema(schema: &Schema) -> IndexMap<String, Shape> {
    namespace_from_schema(schema).finalize().iter().collect()
}

#[must_use]
pub fn shape_for_arguments(field_definition: &Component<FieldDefinition>) -> Shape {
    // Accumulate the locations of all the arguments so they can be highlighted together
    let mut source_span = None;
    for next_source_span in field_definition.arguments.iter().map(Node::location) {
        source_span = SourceSpan::recompose(source_span, next_source_span);
    }
    Shape::record(
        field_definition
            .arguments
            .iter()
            .map(|arg| {
                (
                    arg.name.to_string(),
                    from_type(arg.ty.as_ref(), span(arg.location())),
                )
            })
            .collect(),
        span(source_span),
    )
}

impl From<&ExtendedType> for Shape {
    fn from(ext: &ExtendedType) -> Self {
        match ext {
            ExtendedType::Scalar(scalar) => Shape::unknown(span(scalar.location())),
            ExtendedType::Object(obj) => Self::from(obj),
            ExtendedType::Interface(intf) => Self::from(intf),
            ExtendedType::Union(union) => Self::from(union),
            ExtendedType::Enum(enm) => Self::from(enm),
            ExtendedType::InputObject(input) => Self::from(input),
        }
    }
}

impl From<&Name> for Shape {
    fn from(name: &Name) -> Self {
        let locations = span(name.location());
        match name.as_str() {
            "String" | "ID" => Self::string(locations),
            "Int" => Self::int(locations),
            "Float" => Self::float(locations),
            "Boolean" => Self::bool(locations),
            other => Self::name(other, locations),
        }
    }
}

impl From<&Node<ObjectType>> for Shape {
    fn from(object_type: &Node<ObjectType>) -> Self {
        record(&object_type.fields, span(object_type.location()))
    }
}

fn record(fields: &IndexMap<Name, Component<FieldDefinition>>, locations: Vec<Location>) -> Shape {
    let fields = fields
        .iter()
        .map(|(key, value)| (key.to_string(), Shape::from(value)))
        .collect();
    Shape::record(fields, locations)
}

fn nullable(shape: Shape, locations: Vec<Location>) -> Shape {
    Shape::one([shape, Shape::null(locations.clone())], locations)
}

impl From<&Component<FieldDefinition>> for Shape {
    fn from(field: &Component<FieldDefinition>) -> Self {
        let locations = span(field.location());
        from_type(&field.ty, locations)
    }
}

fn from_type(ty: &Type, locations: Vec<Location>) -> Shape {
    match ty {
        Type::Named(name) => nullable(Shape::from(name), locations),
        Type::NonNullNamed(name) => Shape::from(name),
        Type::List(ty) => nullable(
            Shape::list(from_type(ty.as_ref(), locations.clone()), locations.clone()),
            locations,
        ),
        Type::NonNullList(ty) => Shape::list(from_type(ty.as_ref(), locations.clone()), locations),
    }
}

impl From<&Node<InterfaceType>> for Shape {
    fn from(interface_type: &Node<InterfaceType>) -> Self {
        record(&interface_type.fields, span(interface_type.location()))
    }
}

impl From<&Node<UnionType>> for Shape {
    fn from(union_type: &Node<UnionType>) -> Self {
        Self::one(
            union_type
                .members
                .iter()
                .map(|member| Self::from(&member.name)),
            span(union_type.location()),
        )
    }
}

impl From<&Node<EnumType>> for Shape {
    fn from(enum_type: &Node<EnumType>) -> Self {
        Shape::one(
            enum_type
                .values
                .iter()
                .map(|(name, _)| Shape::string_value(name.as_str(), span(name.location()))),
            span(enum_type.location()),
        )
    }
}

impl From<&Node<InputObjectType>> for Shape {
    fn from(input_object_type: &Node<InputObjectType>) -> Self {
        Self::record(
            input_object_type
                .fields
                .iter()
                .map(|(name, input)| {
                    (
                        name.to_string(),
                        from_type(input.ty.as_ref(), span(input.location())),
                    )
                })
                .collect(),
            span(input_object_type.location()),
        )
    }
}

fn span(source_span: Option<SourceSpan>) -> Vec<Location> {
    source_span.into_iter().map(Location::from).collect()
}

impl From<SourceSpan> for Location {
    fn from(span: SourceSpan) -> Self {
        Location {
            source_id: SourceId::GraphQL(span.file_id()),
            span: span.offset()..span.end_offset(),
        }
    }
}