bluejay 0.1.0.alpha.1

data/ext/src/ruby_api/r_result.rs

@@ -0,0 +1,84 @@
+use magnus::{function, Error, Module, Value, TypedData, gc, DataTypeFunctions, method, Object, exception, rb_sys::AsRawValue};
+use super::{root};
+use crate::helpers::WrappedStruct;
+
+#[derive(Clone, Debug, TypedData)]
+#[magnus(class = "Bluejay::Result", mark)]
+pub struct RResult(Result<Value, Value>);
+
+impl RResult {
+    fn is_ok(&self) -> bool {
+        self.0.is_ok()
+    }
+
+    fn is_err(&self) -> bool {
+        self.0.is_err()
+    }
+
+    fn unwrap_err(&self) -> Result<Value, Error> {
+        match self.0 {
+            Ok(_) => Err(Error::new(
+                exception::runtime_error(),
+                "Ok variant does not have an error value".to_owned(),
+            )),
+            Err(err) => Ok(err),
+        }
+    }
+
+    fn unwrap(&self) -> Result<Value, Error> {
+        match self.0 {
+            Ok(ok) => Ok(ok),
+            Err(_) => Err(Error::new(
+                exception::runtime_error(),
+                "Error variant does not have an ok value".to_owned(),
+            )),
+        }
+    }
+
+    fn inspect(rb_self: WrappedStruct<Self>) -> Result<String, Error> {
+        let rs_self = rb_self.get();
+
+        Ok(format!(
+            "#<Bluejay::Result:0x{:016x} @{}={:?}>",
+            rb_self.to_value().as_raw(),
+            match rs_self.0 {
+                Ok(_) => "ok_value",
+                Err(_) => "error_value"
+            },
+            match rs_self.0 {
+                Ok(val) => val,
+                Err(val) => val,
+            },
+        ))
+    }
+}
+
+impl DataTypeFunctions for RResult {
+    fn mark(&self) {
+        let value = match &self.0 {
+            Ok(ok) => ok,
+            Err(err) => err,
+        };
+        gc::mark(value)
+    }
+}
+
+impl<T: Into<Value>, E: Into<Value>> From<Result<T, E>> for RResult {
+    fn from(r: Result<T, E>) -> Self {
+        Self(r.map(Into::into).map_err(Into::into))
+    }
+}
+
+pub fn init() -> Result<(), Error> {
+    let class = root().define_class("Result", Default::default())?;
+
+    // class.define_singleton_method("new", function!(RResult::new, 1))?;
+    class.define_singleton_method("[]", function!(|_: Value, _: Value| RResult::class(), 2))?;
+    class.define_method("ok?", method!(RResult::is_ok, 0))?;
+    class.define_method("err?", method!(RResult::is_err, 0))?;
+    class.define_method("unwrap", method!(RResult::unwrap, 0))?;
+    class.define_method("unwrap_err", method!(RResult::unwrap_err, 0))?;
+    class.define_method("inspect", method!(RResult::inspect, 0))?;
+
+    Ok(())
+}

data/ext/src/ruby_api/scalar.rs

@@ -0,0 +1,45 @@
+use bluejay_core::BuiltinScalarDefinition;
+use magnus::{Error, Module, TypedData, DataTypeFunctions};
+use super::{root};
+
+#[derive(Clone, Debug, TypedData)]
+#[magnus(class = "Bluejay::Scalar", mark)]
+pub struct Scalar(BuiltinScalarDefinition);
+
+impl DataTypeFunctions for Scalar {}
+
+impl Into<BuiltinScalarDefinition> for Scalar {
+    fn into(self) -> BuiltinScalarDefinition {
+        self.0
+    }
+}
+
+impl From<BuiltinScalarDefinition> for Scalar {
+    fn from(value: BuiltinScalarDefinition) -> Self {
+        Self(value)
+    }
+}
+
+impl Scalar {
+    pub fn sorbet_type_fully_qualified_name(&self) -> &str {
+        match self.0 {
+            BuiltinScalarDefinition::Boolean => "T::Boolean",
+            BuiltinScalarDefinition::Float => "Float",
+            BuiltinScalarDefinition::ID => "T.any(String, Integer)",
+            BuiltinScalarDefinition::Int => "Integer",
+            BuiltinScalarDefinition::String => "String",
+        }
+    }
+}
+
+pub fn init() -> Result<(), Error> {
+    let class = root().define_class("Scalar", Default::default())?;
+
+    class.const_set("Int", Scalar(BuiltinScalarDefinition::Int))?;
+    class.const_set("Float", Scalar(BuiltinScalarDefinition::Float))?;
+    class.const_set("String", Scalar(BuiltinScalarDefinition::String))?;
+    class.const_set("Boolean", Scalar(BuiltinScalarDefinition::Boolean))?;
+    class.const_set("ID", Scalar(BuiltinScalarDefinition::ID))?;
+
+    Ok(())
+}

data/ext/src/ruby_api/schema_definition.rs

@@ -0,0 +1,270 @@
+use std::collections::{HashMap, hash_map::Entry};
+use super::object_type_definition::ObjectTypeDefinition;
+use super::input_object_type_definition::InputObjectTypeDefinition;
+use super::enum_type_definition::EnumTypeDefinition;
+use super::union_type_definition::UnionTypeDefinition;
+use super::interface_type_definition::InterfaceTypeDefinition;
+use super::custom_scalar_type_definition::CustomScalarTypeDefinition;
+use super::input_value_definition::InputValueDefinition;
+use super::field_definition::FieldDefinition;
+use super::input_fields_definition::InputFieldsDefinition;
+use super::arguments_definition::ArgumentsDefinition;
+use super::fields_definition::FieldsDefinition;
+use super::interface_implementation::InterfaceImplementation;
+use super::interface_implementations::InterfaceImplementations;
+use super::union_member_type::UnionMemberType;
+use super::union_member_types::UnionMemberTypes;
+use super::validation_error::ValidationError;
+use super::{root, ExecutionResult, BaseInputTypeReference, InputTypeReference, BaseOutputTypeReference, OutputTypeReference};
+use crate::helpers::{WrappedStruct, WrappedDefinition};
+use crate::execution::{Engine as ExecutionEngine};
+use magnus::{function, Error, Module, Object, scan_args::get_kwargs, RHash, RArray, Value, TypedData, DataTypeFunctions, method};
+use bluejay_core::validation::executable::Validator;
+use bluejay_core::{BuiltinScalarDefinition, IntoEnumIterator, AsIter};
+
+#[derive(Clone, Debug, TypedData)]
+#[magnus(class = "Bluejay::SchemaDefinition", mark)]
+pub struct SchemaDefinition {
+    description: Option<String>,
+    query: WrappedDefinition<ObjectTypeDefinition>,
+    mutation: Option<WrappedDefinition<ObjectTypeDefinition>>,
+    contained_types: HashMap<String, TypeDefinitionReference>,
+}
+
+impl SchemaDefinition {
+    pub fn new(kw: RHash) -> Result<Self, Error> {
+        let args = get_kwargs(kw, &["description", "query", "mutation"], &[])?;
+        let (description, query, mutation): (Option<String>, WrappedDefinition<ObjectTypeDefinition>, Option<WrappedDefinition<ObjectTypeDefinition>>) = args.required;
+        let _: () = args.optional;
+        let _: () = args.splat;
+        let contained_types = SchemaTypeVisitor::compute_contained_types(&query, mutation.as_ref());
+        Ok(Self { description, query, mutation, contained_types })
+    }
+
+    pub fn query(&self) -> WrappedStruct<ObjectTypeDefinition> {
+        *self.query.get()
+    }
+
+    pub fn r#type(&self, name: &str) -> Option<&TypeDefinitionReference> {
+        self.contained_types.get(name)
+    }
+
+    fn execute(&self, query: String, operation_name: Option<String>, variable_values: RHash, initial_value: Value) -> Result<ExecutionResult, Error> {
+        ExecutionEngine::execute_request(self, query.as_str(), operation_name.as_ref().map(String::as_str), variable_values, initial_value)
+    }
+
+    fn validate_query(&self, query: String) -> RArray {
+        let (document, _) = bluejay_parser::parse(query.as_str());
+
+        RArray::from_iter(
+            Validator::validate(&document, self)
+                .map(|error| -> WrappedStruct<ValidationError> {
+                    WrappedStruct::wrap(error.into())
+                })
+        )
+    }
+}
+
+impl DataTypeFunctions for SchemaDefinition {
+    fn mark(&self) {
+        self.query.mark();
+        if let Some(mutation) = &self.mutation {
+            mutation.mark();
+        }
+    }
+}
+
+pub type TypeDefinitionReference = bluejay_core::definition::TypeDefinitionReference<
+    CustomScalarTypeDefinition,
+    WrappedDefinition<CustomScalarTypeDefinition>,
+    ObjectTypeDefinition,
+    WrappedDefinition<ObjectTypeDefinition>,
+    InputObjectTypeDefinition,
+    WrappedDefinition<InputObjectTypeDefinition>,
+    EnumTypeDefinition,
+    WrappedDefinition<EnumTypeDefinition>,
+    UnionTypeDefinition,
+    WrappedDefinition<UnionTypeDefinition>,
+    InterfaceTypeDefinition,
+    WrappedDefinition<InterfaceTypeDefinition>,
+>;
+
+impl<'a> bluejay_core::definition::SchemaDefinition<'a> for SchemaDefinition {
+    type InputValueDefinition = InputValueDefinition;
+    type InputFieldsDefinition = InputFieldsDefinition;
+    type ArgumentsDefinition = ArgumentsDefinition;
+    type FieldDefinition = FieldDefinition;
+    type FieldsDefinition = FieldsDefinition;
+    type InterfaceImplementation = InterfaceImplementation;
+    type InterfaceImplementations = InterfaceImplementations;
+    type UnionMemberType = UnionMemberType;
+    type UnionMemberTypes = UnionMemberTypes;
+    type BaseInputTypeReference = BaseInputTypeReference;
+    type InputTypeReference = InputTypeReference;
+    type BaseOutputTypeReference = BaseOutputTypeReference;
+    type OutputTypeReference = OutputTypeReference;
+    type CustomScalarTypeDefinition = CustomScalarTypeDefinition;
+    type ObjectTypeDefinition = ObjectTypeDefinition;
+    type InterfaceTypeDefinition = InterfaceTypeDefinition;
+    type UnionTypeDefinition = UnionTypeDefinition;
+    type InputObjectTypeDefinition = InputObjectTypeDefinition;
+    type EnumTypeDefinition = EnumTypeDefinition;
+    type TypeDefinitionReference = TypeDefinitionReference;
+
+    fn description(&self) -> Option<&str> {
+        self.description.as_ref().map(String::as_str)
+    }
+
+    fn query(&self) -> &Self::ObjectTypeDefinition {
+        self.query.as_ref()
+    }
+
+    fn mutation(&self) -> Option<&Self::ObjectTypeDefinition> {
+        self.mutation.as_ref().map(AsRef::as_ref)
+    }
+
+    fn get_type(&self, name: &str) -> Option<&Self::TypeDefinitionReference> {
+        self.contained_types.get(name)
+    }
+}
+
+impl TryFrom<&BaseInputTypeReference> for TypeDefinitionReference {
+    type Error = ();
+
+    fn try_from(value: &BaseInputTypeReference) -> Result<Self, Self::Error> {
+        match value {
+            BaseInputTypeReference::BuiltinScalarType(_) => Err(()),
+            BaseInputTypeReference::CustomScalarType(cstd) => Ok(Self::CustomScalarType(cstd.clone(), Default::default())),
+            BaseInputTypeReference::EnumType(etd) => Ok(Self::EnumType(etd.clone(), Default::default())),
+            BaseInputTypeReference::InputObjectType(iotd) => Ok(Self::InputObjectType(iotd.clone(), Default::default())),
+        }
+    }
+}
+
+impl TryInto<BaseInputTypeReference> for &TypeDefinitionReference {
+    type Error = ();
+
+    fn try_into(self) -> Result<BaseInputTypeReference, Self::Error> {
+        match self {
+            TypeDefinitionReference::BuiltinScalarType(bstd) => Ok(BaseInputTypeReference::BuiltinScalarType(*bstd)),
+            TypeDefinitionReference::CustomScalarType(cstd, _) => Ok(BaseInputTypeReference::CustomScalarType(cstd.clone())),
+            TypeDefinitionReference::EnumType(etd, _) => Ok(BaseInputTypeReference::EnumType(etd.clone())),
+            TypeDefinitionReference::InputObjectType(iotd, _) => Ok(BaseInputTypeReference::InputObjectType(iotd.clone())),
+            TypeDefinitionReference::InterfaceType(_, _) | TypeDefinitionReference::ObjectType(_, _) | TypeDefinitionReference::UnionType(_, _) => Err(()),
+        }
+    }
+}
+
+impl TryFrom<&BaseOutputTypeReference> for TypeDefinitionReference {
+    type Error = ();
+
+    fn try_from(value: &BaseOutputTypeReference) -> Result<Self, Self::Error> {
+        match value {
+            BaseOutputTypeReference::BuiltinScalarType(_) => Err(()),
+            BaseOutputTypeReference::CustomScalarType(cstd) => Ok(Self::CustomScalarType(cstd.clone(), Default::default())),
+            BaseOutputTypeReference::EnumType(etd) => Ok(Self::EnumType(etd.clone(), Default::default())),
+            BaseOutputTypeReference::ObjectType(otd) => Ok(Self::ObjectType(otd.clone(), Default::default())),
+            BaseOutputTypeReference::InterfaceType(itd) => Ok(Self::InterfaceType(itd.clone(), Default::default())),
+            BaseOutputTypeReference::UnionType(utd) => Ok(Self::UnionType(utd.clone(), Default::default())),
+        }
+    }
+}
+
+struct SchemaTypeVisitor {
+    types: HashMap<String, TypeDefinitionReference>,
+}
+
+impl Into<HashMap<String, TypeDefinitionReference>> for SchemaTypeVisitor {
+    fn into(self) -> HashMap<String, TypeDefinitionReference> {
+        self.types
+    }
+}
+
+impl SchemaTypeVisitor {
+    pub fn compute_contained_types(query: &WrappedDefinition<ObjectTypeDefinition>, mutation: Option<&WrappedDefinition<ObjectTypeDefinition>>) -> HashMap<String, TypeDefinitionReference> {
+        let mut type_visitor = Self::new();
+        type_visitor.visit_type(TypeDefinitionReference::ObjectType(query.clone(), Default::default()));
+        if let Some(mutation) = mutation {
+            type_visitor.visit_type(TypeDefinitionReference::ObjectType(mutation.clone(), Default::default()));
+        }
+        type_visitor.visit_builtin_scalar_definitions();
+        type_visitor.into()
+    }
+
+    fn new() -> Self {
+        Self { types: HashMap::new() }
+    }
+
+    fn visit_object_type_definition(&mut self, otd: &ObjectTypeDefinition) {
+        self.visit_field_definitions(otd.fields_definition())
+    }
+
+    fn visit_union_type_definition(&mut self, utd: &UnionTypeDefinition) {
+        for union_member in utd.member_types().iter() {
+            let t = TypeDefinitionReference::ObjectType(union_member.r#type(), Default::default());
+            self.visit_type(t);
+        }
+    }
+
+    fn visit_interface_type_definition(&mut self, itd: &InterfaceTypeDefinition) {
+        self.visit_field_definitions(itd.fields_definition())
+    }
+
+    fn visit_input_object_type_definition(&mut self, iotd: &InputObjectTypeDefinition) {
+        self.visit_input_value_definitions(iotd.input_fields_definition())
+    }
+
+    fn visit_type(&mut self, t: TypeDefinitionReference) {
+        let name = t.name().to_owned();
+        match self.types.entry(name) {
+            Entry::Occupied(_) => {},
+            Entry::Vacant(entry) => {
+                entry.insert(t.clone());
+                match t {
+                    TypeDefinitionReference::BuiltinScalarType(_) | TypeDefinitionReference::CustomScalarType(_, _) | TypeDefinitionReference::EnumType(_, _) => {},
+                    TypeDefinitionReference::ObjectType(otd, _) => self.visit_object_type_definition(otd.as_ref()),
+                    TypeDefinitionReference::UnionType(utd, _) => self.visit_union_type_definition(utd.as_ref()),
+                    TypeDefinitionReference::InterfaceType(itd, _) => self.visit_interface_type_definition(itd.as_ref()),
+                    TypeDefinitionReference::InputObjectType(iotd, _) => self.visit_input_object_type_definition(iotd.as_ref()),
+                }
+            }
+        }
+    }
+
+    fn visit_field_definitions(&mut self, fields_definition: &FieldsDefinition) {
+        for field_definition in fields_definition.iter() {
+            self.visit_input_value_definitions(field_definition.argument_definitions());
+            let base_type = field_definition.r#type().as_ref().base();
+            let t: Result<TypeDefinitionReference, ()> = base_type.try_into();
+            if let Ok(t) = t {
+                self.visit_type(t);
+            }
+        }
+    }
+
+    fn visit_input_value_definitions(&mut self, input_fields_definition: &InputFieldsDefinition) {
+        for input_value_definition in input_fields_definition.iter() {
+            let base_type = input_value_definition.r#type().as_ref().base();
+            let t: Result<TypeDefinitionReference, ()> = base_type.try_into();
+            if let Ok(t) = t {
+                self.visit_type(t);
+            }
+        }
+    }
+
+    fn visit_builtin_scalar_definitions(&mut self) {
+        BuiltinScalarDefinition::iter().for_each(|bisd| {
+            self.visit_type(TypeDefinitionReference::BuiltinScalarType(bisd));
+        })
+    }
+}
+
+pub fn init() -> Result<(), Error> {
+    let class = root().define_class("SchemaDefinition", Default::default())?;
+
+    class.define_singleton_method("new", function!(SchemaDefinition::new, 1))?;
+    class.define_method("execute", method!(SchemaDefinition::execute, 4))?;
+    class.define_method("validate_query", method!(SchemaDefinition::validate_query, 1))?;
+
+    Ok(())
+}

data/ext/src/ruby_api/union_member_type.rs

@@ -0,0 +1,41 @@
+use super::{root, object_type_definition::ObjectTypeDefinition};
+use magnus::{RClass, function, Error, Module, Object, TypedData, DataTypeFunctions};
+use crate::helpers::WrappedDefinition;
+
+#[derive(Clone, Debug, TypedData)]
+#[magnus(class = "Bluejay::UnionMemberType", mark)]
+pub struct UnionMemberType {
+    r#type: WrappedDefinition<ObjectTypeDefinition>,
+}
+
+impl UnionMemberType {
+    pub fn new(r#type: RClass) -> Result<Self, Error> {
+        WrappedDefinition::new(r#type).map(|r#type| Self { r#type })
+    }
+
+    pub fn r#type(&self) -> WrappedDefinition<ObjectTypeDefinition> {
+        self.r#type.clone()
+    }
+}
+
+impl DataTypeFunctions for UnionMemberType {
+    fn mark(&self) {
+        self.r#type.mark();
+    }
+}
+
+impl bluejay_core::definition::UnionMemberType for UnionMemberType {
+    type ObjectTypeDefinition = ObjectTypeDefinition;
+
+    fn member_type(&self) -> &Self::ObjectTypeDefinition {
+        self.r#type.as_ref()
+    }
+}
+
+pub fn init() -> Result<(), Error> {
+    let class = root().define_class("UnionMemberType", Default::default())?;
+
+    class.define_singleton_method("new", function!(UnionMemberType::new, 1))?;
+
+    Ok(())
+}

data/ext/src/ruby_api/union_member_types.rs

@@ -0,0 +1,8 @@
+use super::{union_member_type::UnionMemberType};
+use crate::helpers::{WrappedStruct, TypedFrozenRArray};
+
+pub type UnionMemberTypes = TypedFrozenRArray<WrappedStruct<UnionMemberType>>;
+
+impl bluejay_core::definition::UnionMemberTypes for UnionMemberTypes {
+    type UnionMemberType = UnionMemberType;
+}

data/ext/src/ruby_api/union_type_definition.rs

@@ -0,0 +1,89 @@
+use magnus::{function, Error, Module, Object, scan_args::get_kwargs, RHash, memoize, TypedData, RArray, DataTypeFunctions, RClass, gc};
+use super::{root, object_type_definition::ObjectTypeDefinition, union_member_types::UnionMemberTypes};
+use crate::helpers::{HasDefinitionWrapper};
+use bluejay_core::AsIter;
+
+#[derive(Debug, TypedData)]
+#[magnus(class = "Bluejay::UnionTypeDefinition", mark)]
+pub struct UnionTypeDefinition {
+    name: String,
+    description: Option<String>,
+    member_types: UnionMemberTypes,
+}
+
+impl UnionTypeDefinition {
+    fn new(kw: RHash) -> Result<Self, Error> {
+        let args = get_kwargs(kw, &["name", "member_types", "description"], &[])?;
+        let (name, member_types, description): (String, RArray, Option<String>) = args.required;
+        let _: () = args.optional;
+        let _: () = args.splat;
+        let member_types = UnionMemberTypes::new(member_types)?;
+        Ok(Self { name, description, member_types })
+    }
+
+    pub fn name(&self) -> &str {
+        self.name.as_str()
+    }
+
+    pub fn description(&self) -> Option<&str> {
+        self.description.as_ref().map(String::as_str)
+    }
+
+    pub fn member_types(&self) -> &UnionMemberTypes {
+        &self.member_types
+    }
+
+    pub fn contains_type(&self, t: &ObjectTypeDefinition) -> bool {
+        self.member_types
+            .iter()
+            .any(|mt| mt.r#type().as_ref().name() == t.name())
+    }
+
+    pub fn sorbet_type(&self) -> String {
+        format!(
+            "T.any({})",
+            itertools::join(
+                self.member_types
+                    .iter()
+                    .map(|member_type| member_type.r#type().fully_qualified_name()),
+                ", ",
+            ),
+        )
+    }
+}
+
+impl DataTypeFunctions for UnionTypeDefinition {
+    fn mark(&self) {
+        gc::mark(self.member_types);
+    }
+}
+
+impl HasDefinitionWrapper for UnionTypeDefinition {
+    fn wrapping_class() -> RClass {
+        *memoize!(RClass: root().define_class("UnionType", Default::default()).unwrap())
+    }
+}
+
+impl bluejay_core::definition::UnionTypeDefinition for UnionTypeDefinition {
+    type UnionMemberTypes = UnionMemberTypes;
+
+    fn description(&self) -> Option<&str> {
+        self.description.as_ref().map(String::as_str)
+    }
+
+    fn name(&self) -> &str {
+        self.name.as_str()
+    }
+
+    fn union_member_types(&self) -> &Self::UnionMemberTypes {
+        &self.member_types
+    }
+}
+
+pub fn init() -> Result<(), Error> {
+    let class = root().define_class("UnionTypeDefinition", Default::default())?;
+
+    class.define_singleton_method("new", function!(UnionTypeDefinition::new, 1))?;
+
+    Ok(())
+}

data/ext/src/ruby_api/validation_error.rs

@@ -0,0 +1,63 @@
+use super::root;
+use crate::helpers::WrappedStruct;
+use bluejay_core::validation::executable::{Error as CoreError};
+use bluejay_parser::ast::executable::ExecutableDocument;
+use crate::ruby_api::SchemaDefinition;
+use magnus::{function, Error, Module, Object, Value, method, rb_sys::AsRawValue};
+
+#[derive(Clone, Debug, PartialEq)]
+#[magnus::wrap(class = "Bluejay::ValidationError", mark)]
+pub struct ValidationError {
+    message: String,
+}
+
+impl ValidationError {
+    pub fn new(message: String) -> Self {
+        Self { message }
+    }
+
+    pub fn message(&self) -> &str {
+        self.message.as_str()
+    }
+
+    pub fn eql(&self, other: Value) -> bool {
+        if let Ok(other) = other.try_convert::<&Self>() {
+            self == other
+        } else {
+            false
+        }
+    }
+
+    fn inspect(rb_self: WrappedStruct<Self>) -> Result<String, Error> {
+        let rs_self = rb_self.get();
+
+        Ok(format!(
+            "#<Bluejay::ValidationError:0x{:016x} @message={:?}>",
+            rb_self.to_value().as_raw(),
+            rs_self.message,
+        ))
+    }
+}
+
+impl<'a> From<CoreError<'a, ExecutableDocument<'a>, SchemaDefinition>> for ValidationError {
+    fn from(value: CoreError<'a, ExecutableDocument<'a>, SchemaDefinition>) -> Self {
+        match value {
+            CoreError::NotLoneAnonymousOperation { anonymous_operations: _ } => Self::new("Anonymous operations are not allowed when there is more than one operation".to_string()),
+            CoreError::NonUniqueOperationNames { name, operations: _ } => Self::new(format!("More than one operation named `{}`", name)),
+            CoreError::SubscriptionRootNotSingleField { operation: _ } => Self::new("Subscription operations can only select one field at the root".to_string()),
+            CoreError::FieldDoesNotExistOnType { field, r#type } => Self::new(format!("Field `{}` does not exist on `{}`", field.name(), r#type.name())),
+            CoreError::FieldSelectionsDoNotMerge { selection_set: _ } => Self::new("Field selections do not merge".to_string()),
+        }
+    }
+}
+
+pub fn init() -> Result<(), Error> {
+    let class = root().define_class("ValidationError", Default::default())?;
+
+    class.define_singleton_method("new", function!(ValidationError::new, 1))?;
+    class.define_method("message", method!(ValidationError::message, 0))?;
+    class.define_method("==", method!(ValidationError::eql, 1))?;
+    class.define_method("inspect", method!(ValidationError::inspect, 0))?;
+
+    Ok(())
+}

data/ext/src/ruby_api.rs

@@ -0,0 +1,75 @@
+use magnus::{define_module, memoize, Error, RModule, function};
+
+mod arguments_definition;
+mod coerce_input;
+mod coercion_error;
+mod custom_scalar_type_definition;
+mod enum_type_definition;
+mod enum_value_definition;
+mod enum_value_definitions;
+mod execution_error;
+mod execution_result;
+mod field_definition;
+mod fields_definition;
+mod input_fields_definition;
+mod input_type_reference;
+mod input_object_type_definition;
+mod input_value_definition;
+mod interface_implementation;
+mod interface_implementations;
+mod interface_type_definition;
+mod json_value;
+mod object_type_definition;
+mod output_type_reference;
+mod r_result;
+mod scalar;
+mod schema_definition;
+mod union_member_type;
+mod union_member_types;
+mod union_type_definition;
+mod validation_error;
+
+pub use schema_definition::{SchemaDefinition, TypeDefinitionReference};
+pub use execution_error::ExecutionError;
+pub use input_type_reference::{BaseInputTypeReference, InputTypeReference};
+pub use coerce_input::CoerceInput;
+pub use coercion_error::CoercionError;
+pub use execution_result::ExecutionResult;
+pub use object_type_definition::ObjectTypeDefinition;
+pub use output_type_reference::{BaseOutputTypeReference, OutputTypeReference};
+pub use input_value_definition::InputValueDefinition;
+pub use field_definition::FieldDefinition;
+pub use interface_type_definition::InterfaceTypeDefinition;
+pub use union_type_definition::UnionTypeDefinition;
+
+pub fn root() -> RModule {
+    *memoize!(RModule: define_module("Bluejay").unwrap())
+}
+
+pub fn init() -> Result<(), Error> {
+    let r = root();
+
+    coercion_error::init()?;
+    custom_scalar_type_definition::init()?;
+    enum_type_definition::init()?;
+    enum_value_definition::init()?;
+    execution_error::init()?;
+    execution_result::init()?;
+    field_definition::init()?;
+    input_object_type_definition::init()?;
+    input_type_reference::init()?;
+    input_value_definition::init()?;
+    interface_implementation::init()?;
+    interface_type_definition::init()?;
+    object_type_definition::init()?;
+    output_type_reference::init()?;
+    r_result::init()?;
+    scalar::init()?;
+    schema_definition::init()?;
+    union_member_type::init()?;
+    union_type_definition::init()?;
+    validation_error::init()?;
+    r.define_module_function("parse", function!(|s: String| { let (doc, errs) = bluejay_parser::parse(s.as_str()); (doc.operation_definitions().len() + doc.fragment_definitions().len()) > 0 && errs.is_empty() }, 1))?;
+
+    Ok(())
+}

data/lib/bluejay/base_input_type_reference.rb

@@ -0,0 +1,13 @@
+# typed: strict
+# frozen_string_literal: true
+
+module Bluejay
+  BaseInputTypeReference = T.type_alias do
+    T.any(
+      Scalar,
+      T.class_of(InputType),
+      T.class_of(EnumType),
+      T.class_of(CustomScalarType),
+    )
+  end
+end