bluejay 0.1.0.alpha.1

data/ext/src/ruby_api/input_value_definition.rs

@@ -0,0 +1,98 @@
+use magnus::{function, Error, Module, Object, scan_args::get_kwargs, RHash, Value, TypedData, DataTypeFunctions, method};
+use convert_case::{Casing, Case};
+use super::{root, input_type_reference::InputTypeReference, coerce_input::CoerceInput, coercion_error::CoercionError, json_value::{JsonValue, JsonValueInner}};
+use crate::helpers::WrappedStruct;
+
+#[derive(Debug, TypedData)]
+#[magnus(class = "Bluejay::InputValueDefinition", mark)]
+pub struct InputValueDefinition {
+    name: String,
+    description: Option<String>,
+    r#type: WrappedStruct<InputTypeReference>,
+    default_value: Option<JsonValue>,
+    ruby_name: String,
+}
+
+impl InputValueDefinition {
+    pub fn new(kw: RHash) -> Result<Self, Error> {
+        let args = get_kwargs(kw, &["name", "type"], &["description", "default_value"])?;
+        let (name, r#type): (String, WrappedStruct<InputTypeReference>) = args.required;
+        let (description, default_value): (Option<Option<String>>, Option<JsonValue>) = args.optional;
+        let description = description.unwrap_or_default();
+        let _: () = args.splat;
+        let ruby_name = name.to_case(Case::Snake);
+        Ok(Self { name, description, r#type, default_value, ruby_name })
+    }
+
+    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 r#type(&self) -> &InputTypeReference {
+        self.r#type.get()
+    }
+
+    pub fn default_value(&self) -> Option<Value> {
+        self.default_value.as_ref().map(|v| v.to_owned().into())
+    }
+
+    pub fn is_required(&self) -> bool {
+        if self.default_value.is_some() {
+            false
+        } else {
+            self.r#type.get().is_required()
+        }
+    }
+
+    fn ruby_name(&self) -> &str {
+        self.ruby_name.as_str()
+    }
+}
+
+impl DataTypeFunctions for InputValueDefinition {
+    fn mark(&self) {
+        self.r#type.mark();
+    }
+}
+
+impl CoerceInput for InputValueDefinition {
+    fn coerce_input(&self, value: Value, path: &[String]) -> Result<Result<Value, Vec<CoercionError>>, Error> {
+        self.r#type.get().coerce_input(value, path)
+    }
+}
+
+impl bluejay_core::definition::InputValueDefinition for InputValueDefinition {
+    type InputTypeReference = InputTypeReference;
+    type Value = JsonValueInner;
+
+    fn name(&self) -> &str {
+        self.name.as_str()
+    }
+
+    fn description(&self) -> Option<&str> {
+        self.description.as_ref().map(String::as_str)
+    }
+
+    fn r#type(&self) -> &Self::InputTypeReference {
+        self.r#type.get()
+    }
+
+    fn default_value(&self) -> Option<&Self::Value> {
+        self.default_value.as_ref().map(AsRef::as_ref)
+    }
+}
+
+pub fn init() -> Result<(), Error> {
+    let class = root().define_class("InputValueDefinition", Default::default())?;
+
+    class.define_singleton_method("new", function!(InputValueDefinition::new, 1))?;
+    class.define_method("name", method!(InputValueDefinition::name, 0))?;
+    class.define_method("type", method!(|ivd: &InputValueDefinition| ivd.r#type, 0))?;
+    class.define_method("ruby_name", method!(InputValueDefinition::ruby_name, 0))?;
+
+    Ok(())
+}

data/ext/src/ruby_api/interface_implementation.rs

@@ -0,0 +1,42 @@
+use super::{root, interface_type_definition::InterfaceTypeDefinition};
+use magnus::{RClass, function, Error, Module, Object, TypedData, DataTypeFunctions, method};
+use crate::helpers::{WrappedDefinition, WrappedStruct};
+
+#[derive(Clone, Debug, TypedData)]
+#[magnus(class = "Bluejay::InterfaceImplementation", mark)]
+pub struct InterfaceImplementation {
+    interface: WrappedDefinition<InterfaceTypeDefinition>,
+}
+
+impl InterfaceImplementation {
+    pub fn new(interface: RClass) -> Result<Self, Error> {
+        WrappedDefinition::new(interface).map(|interface| Self { interface })
+    }
+
+    pub fn interface(&self) -> WrappedStruct<InterfaceTypeDefinition> {
+        *self.interface.get()
+    }
+}
+
+impl DataTypeFunctions for InterfaceImplementation {
+    fn mark(&self) {
+        self.interface.mark();
+    }
+}
+
+impl bluejay_core::definition::InterfaceImplementation for InterfaceImplementation {
+    type InterfaceTypeDefinition = InterfaceTypeDefinition;
+
+    fn interface(&self) -> &Self::InterfaceTypeDefinition {
+        self.interface.as_ref()
+    }
+}
+
+pub fn init() -> Result<(), Error> {
+    let class = root().define_class("InterfaceImplementation", Default::default())?;
+
+    class.define_singleton_method("new", function!(InterfaceImplementation::new, 1))?;
+    class.define_method("interface", method!(|ii: &InterfaceImplementation| ii.interface.class(), 0))?;
+
+    Ok(())
+}

data/ext/src/ruby_api/interface_implementations.rs

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

data/ext/src/ruby_api/interface_type_definition.rs

@@ -0,0 +1,82 @@
+use magnus::{function, Error, Module, Object, scan_args::get_kwargs, RHash, memoize, TypedData, RArray, DataTypeFunctions, RClass, gc};
+use super::{root, interface_implementations::InterfaceImplementations, fields_definition::FieldsDefinition};
+use crate::helpers::HasDefinitionWrapper;
+
+#[derive(Debug, TypedData)]
+#[magnus(class = "Bluejay::InterfaceTypeDefinition", mark)]
+pub struct InterfaceTypeDefinition {
+    name: String,
+    description: Option<String>,
+    fields_definition: FieldsDefinition,
+    interface_implementations: InterfaceImplementations,
+}
+
+impl InterfaceTypeDefinition {
+    fn new(kw: RHash) -> Result<Self, Error> {
+        let args = get_kwargs(kw, &["name", "field_definitions", "interface_implementations", "description"], &[])?;
+        let (name, field_definitions, interface_implementations, description): (String, RArray, RArray, Option<String>) = args.required;
+        let _: () = args.optional;
+        let _: () = args.splat;
+        let fields_definition = FieldsDefinition::new(field_definitions)?;
+        let interface_implementations = InterfaceImplementations::new(interface_implementations)?;
+        Ok(Self { name, description, fields_definition, interface_implementations })
+    }
+
+    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 fields_definition(&self) -> &FieldsDefinition {
+        &self.fields_definition
+    }
+
+    pub fn interface_implementations(&self) -> &InterfaceImplementations {
+        &self.interface_implementations
+    }
+}
+
+impl DataTypeFunctions for InterfaceTypeDefinition {
+    fn mark(&self) {
+        gc::mark(self.fields_definition);
+        gc::mark(self.interface_implementations);
+    }
+}
+
+impl HasDefinitionWrapper for InterfaceTypeDefinition {
+    fn wrapping_class() -> RClass {
+        *memoize!(RClass: root().define_class("InterfaceType", Default::default()).unwrap())
+    }
+}
+
+impl bluejay_core::definition::InterfaceTypeDefinition for InterfaceTypeDefinition {
+    type FieldsDefinition = FieldsDefinition;
+    type InterfaceImplementations = InterfaceImplementations;
+
+    fn description(&self) -> Option<&str> {
+        self.description.as_ref().map(String::as_str)
+    }
+
+    fn name(&self) -> &str {
+        self.name.as_str()
+    }
+
+    fn fields_definition(&self) -> &Self::FieldsDefinition {
+        &self.fields_definition
+    }
+
+    fn interface_impelementations(&self) -> &Self::InterfaceImplementations {
+        &self.interface_implementations
+    }
+}
+
+pub fn init() -> Result<(), Error> {
+    let class = root().define_class("InterfaceTypeDefinition", Default::default())?;
+
+    class.define_singleton_method("new", function!(InterfaceTypeDefinition::new, 1))?;
+
+    Ok(())
+}

data/ext/src/ruby_api/json_value.rs

@@ -0,0 +1,111 @@
+use magnus::{Value, TryConvert, Error, Integer, Float, value::{Qtrue, Qfalse}, RString, RArray, RHash, r_hash::ForEach, exception, QNIL};
+
+pub type JsonValueInner = bluejay_core::Value<true, String, i32, f64, String, bool, (), String, ListValue, ObjectValue>;
+
+#[derive(Clone, Debug)]
+pub struct ListValue(Vec<JsonValueInner>);
+
+impl AsRef<[JsonValueInner]> for ListValue {
+    fn as_ref(&self) -> &[JsonValueInner] {
+        &self.0
+    }
+}
+
+impl bluejay_core::ListValue<JsonValueInner> for ListValue {}
+
+impl Into<Value> for ListValue {
+    fn into(self) -> Value {
+        *RArray::from_iter(self.0.iter().map(|v| core_value_to_value(v.clone())))
+    }
+}
+
+#[derive(Clone, Debug)]
+pub struct ObjectValue(Vec<(String, JsonValueInner)>);
+
+impl bluejay_core::ObjectValue<JsonValueInner> for ObjectValue {
+    type Key = String;
+
+    fn fields(&self) -> &[(Self::Key, JsonValueInner)] {
+        &self.0
+    }
+}
+
+impl Into<Value> for ObjectValue {
+    fn into(self) -> Value {
+        *RHash::from_iter(self.0.iter().map(|(k, v)| (k.as_str(), core_value_to_value(v.clone()))))
+    }
+}
+
+#[derive(Clone, Debug)]
+pub struct JsonValue(JsonValueInner);
+
+impl AsRef<JsonValueInner> for JsonValue {
+    fn as_ref(&self) -> &JsonValueInner {
+        &self.0
+    }
+}
+
+impl TryConvert for JsonValue {
+    fn try_convert(val: Value) -> Result<Self, Error> {
+        // TODO: support BigDecimal or even better, Numeric
+        if let Some(i) = Integer::from_value(val) {
+            // TODO: reconcile if we need to handle integers bigger than 32 bits
+            // and if not, produce a better error for the user
+            Ok(JsonValue(JsonValueInner::Integer(i.to_i32()?)))
+        } else if let Some(f) = Float::from_value(val) {
+            Ok(JsonValue(JsonValueInner::Float(f.to_f64())))
+        } else if Qtrue::from_value(val).is_some() {
+            Ok(JsonValue(JsonValueInner::Boolean(true)))
+        } else if Qfalse::from_value(val).is_some() {
+            Ok(JsonValue(JsonValueInner::Boolean(false)))
+        } else if let Some(s) = RString::from_value(val) {
+            Ok(JsonValue(JsonValueInner::String(s.to_string()?)))
+        } else if val.is_nil() {
+            Ok(JsonValue(JsonValueInner::Null(())))
+        } else if let Some(arr) = RArray::from_value(val) {
+            let mut v: Vec<JsonValueInner> = Vec::new();
+            for el in arr.each() {
+                let json_value: Self = el?.try_convert()?;
+                v.push(json_value.0);
+            }
+            Ok(JsonValue(JsonValueInner::List(ListValue(v))))
+        } else if let Some(h) = RHash::from_value(val) {
+            let mut v: Vec<(String, JsonValueInner)> = Vec::new();
+            h.foreach(|key: String, value: Value| {
+                let json_value: Self = value.try_convert()?;
+                v.push((key, json_value.0));
+                Ok(ForEach::Continue)
+            })?;
+            Ok(JsonValue(JsonValueInner::Object(ObjectValue(v))))
+        } else {
+            Err(Error::new(
+                exception::type_error(),
+                format!(
+                    "no implicit conversion of {} into JsonValue",
+                    unsafe { val.classname() },
+                ),
+            ))
+        }
+    }
+}
+
+// TODO: get rid of this once input coercion is done by core crate
+impl Into<Value> for JsonValue {
+    fn into(self) -> Value {
+        core_value_to_value(self.0)
+    }
+}
+
+fn core_value_to_value(core_value: JsonValueInner) -> Value {
+    match core_value {
+        JsonValueInner::Boolean(b) => b.into(),
+        JsonValueInner::String(s) => s.into(),
+        JsonValueInner::Integer(i) => i.into(),
+        JsonValueInner::Float(f) => f.into(),
+        JsonValueInner::Enum(e) => e.into(),
+        JsonValueInner::List(l) => l.into(),
+        JsonValueInner::Object(o) => o.into(),
+        JsonValueInner::Variable(_) => unreachable!(),
+        JsonValueInner::Null(_) => *QNIL,
+    }
+}

data/ext/src/ruby_api/object_type_definition.rs

@@ -0,0 +1,100 @@
+use bluejay_core::AsIter;
+use magnus::{function, Error, Module, Object, scan_args::get_kwargs, RHash, memoize, TypedData, RArray, DataTypeFunctions, RClass, method, gc};
+use super::{root, field_definition::FieldDefinition, interface_implementations::InterfaceImplementations, interface_type_definition::InterfaceTypeDefinition, fields_definition::FieldsDefinition};
+use crate::helpers::HasDefinitionWrapper;
+
+#[derive(Debug, TypedData)]
+#[magnus(class = "Bluejay::ObjectTypeDefinition", mark)]
+pub struct ObjectTypeDefinition {
+    name: String,
+    description: Option<String>,
+    fields_definition: FieldsDefinition,
+    interface_implementations: InterfaceImplementations,
+}
+
+impl ObjectTypeDefinition {
+    fn new(kw: RHash) -> Result<Self, Error> {
+        let args = get_kwargs(kw, &["name", "field_definitions", "interface_implementations", "description"], &[])?;
+        let (name, field_definitions, interface_implementations, description): (String, RArray, RArray, Option<String>) = args.required;
+        let _: () = args.optional;
+        let _: () = args.splat;
+        field_definitions.push(FieldDefinition::typename())?;
+        let fields_definition = FieldsDefinition::new(field_definitions)?;
+        let interface_implementations = InterfaceImplementations::new(interface_implementations)?;
+        Ok(Self { name, description, fields_definition, interface_implementations })
+    }
+}
+
+impl DataTypeFunctions for ObjectTypeDefinition {
+    fn mark(&self) {
+        gc::mark(self.fields_definition);
+        gc::mark(self.interface_implementations);
+    }
+}
+
+impl HasDefinitionWrapper for ObjectTypeDefinition {
+    fn wrapping_class() -> RClass {
+        *memoize!(RClass: root().define_class("ObjectType", Default::default()).unwrap())
+    }
+}
+
+impl ObjectTypeDefinition {
+    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 fields_definition(&self) -> &FieldsDefinition {
+        &self.fields_definition
+    }
+
+    pub fn interface_implementations(&self) -> &InterfaceImplementations {
+        &self.interface_implementations
+    }
+
+    pub fn implements_interface(&self, interface: &InterfaceTypeDefinition) -> bool {
+        self.interface_implementations
+            .iter()
+            .any(|ii| ii.interface().get().name() == interface.name())
+    }
+
+    pub fn field_definition(&self, name: &str) -> Option<&FieldDefinition> {
+        self.fields_definition
+            .iter()
+            .find(|fd| fd.name() == name)
+    }
+}
+
+impl bluejay_core::definition::ObjectTypeDefinition for ObjectTypeDefinition {
+    type FieldsDefinition = FieldsDefinition;
+    type InterfaceImplementations = InterfaceImplementations;
+
+    fn description(&self) -> Option<&str> {
+        self.description.as_ref().map(String::as_str)
+    }
+
+    fn name(&self) -> &str {
+        self.name.as_str()
+    }
+
+    fn fields_definition(&self) -> &Self::FieldsDefinition {
+        &self.fields_definition
+    }
+
+    fn interface_impelementations(&self) -> &Self::InterfaceImplementations {
+        &self.interface_implementations
+    }
+}
+
+pub fn init() -> Result<(), Error> {
+    let class = root().define_class("ObjectTypeDefinition", Default::default())?;
+
+    class.define_singleton_method("new", function!(ObjectTypeDefinition::new, 1))?;
+    class.define_method("name", method!(ObjectTypeDefinition::name, 0))?;
+    class.define_method("field_definitions", method!(|otd: &ObjectTypeDefinition| -> RArray { (*otd.fields_definition()).into() }, 0))?;
+
+    Ok(())
+}

data/ext/src/ruby_api/output_type_reference.rs

@@ -0,0 +1,238 @@
+use magnus::{Error, Value, exception, TypedData, DataTypeFunctions, Module, scan_args::get_kwargs, RHash, Object, function, method};
+use super::{root, enum_type_definition::EnumTypeDefinition, object_type_definition::ObjectTypeDefinition, union_type_definition::UnionTypeDefinition, custom_scalar_type_definition::CustomScalarTypeDefinition, scalar::Scalar, interface_type_definition::InterfaceTypeDefinition};
+use crate::helpers::{WrappedStruct, WrappedDefinition};
+use bluejay_core::definition::{OutputTypeReference as CoreOutputTypeReference};
+
+#[derive(Clone, Debug)]
+pub enum BaseOutputTypeReference {
+    BuiltinScalarType(bluejay_core::BuiltinScalarDefinition),
+    EnumType(WrappedDefinition<EnumTypeDefinition>),
+    ObjectType(WrappedDefinition<ObjectTypeDefinition>),
+    UnionType(WrappedDefinition<UnionTypeDefinition>),
+    InterfaceType(WrappedDefinition<InterfaceTypeDefinition>),
+    CustomScalarType(WrappedDefinition<CustomScalarTypeDefinition>),
+}
+
+impl bluejay_core::definition::AbstractBaseOutputTypeReference for BaseOutputTypeReference {
+    type CustomScalarTypeDefinition = CustomScalarTypeDefinition;
+    type EnumTypeDefinition = EnumTypeDefinition;
+    type ObjectTypeDefinition = ObjectTypeDefinition;
+    type InterfaceTypeDefinition = InterfaceTypeDefinition;
+    type UnionTypeDefinition = UnionTypeDefinition;
+    type WrappedCustomScalarTypeDefinition = WrappedStruct<CustomScalarTypeDefinition>;
+    type WrappedEnumTypeDefinition = WrappedStruct<EnumTypeDefinition>;
+    type WrappedObjectTypeDefinition = WrappedStruct<ObjectTypeDefinition>;
+    type WrappedInterfaceTypeDefinition = WrappedStruct<InterfaceTypeDefinition>;
+    type WrappedUnionTypeDefinition = WrappedStruct<UnionTypeDefinition>;
+
+    fn to_concrete(&self) -> bluejay_core::definition::BaseOutputTypeReferenceFromAbstract<Self> {
+        match self {
+            Self::BuiltinScalarType(bsd) => bluejay_core::definition::BaseOutputTypeReference::BuiltinScalarType(*bsd),
+            Self::EnumType(etd) => bluejay_core::definition::BaseOutputTypeReference::EnumType(*etd.get(), Default::default()),
+            Self::CustomScalarType(cstd) => bluejay_core::definition::BaseOutputTypeReference::CustomScalarType(*cstd.get(), Default::default()),
+            Self::ObjectType(otd) => bluejay_core::definition::BaseOutputTypeReference::ObjectType(*otd.get(), Default::default()),
+            Self::InterfaceType(itd) => bluejay_core::definition::BaseOutputTypeReference::InterfaceType(*itd.get(), Default::default()),
+            Self::UnionType(utd) => bluejay_core::definition::BaseOutputTypeReference::UnionType(*utd.get(), Default::default()),
+        }
+    }
+
+    fn name(&self) -> &str {
+        self.name()
+    }
+}
+
+impl BaseOutputTypeReference {
+    pub fn new(value: Value) -> Result<Self, Error> {
+        if let Ok(wrapped_struct) = value.try_convert::<WrappedStruct<Scalar>>() {
+            Ok(Self::BuiltinScalarType(wrapped_struct.get().to_owned().into()))
+        } else if let Ok(wrapped_definition) = value.try_convert() {
+            Ok(Self::EnumType(wrapped_definition))
+        } else if let Ok(wrapped_definition) = value.try_convert() {
+            Ok(Self::ObjectType(wrapped_definition))
+        } else if let Ok(wrapped_definition) = value.try_convert() {
+            Ok(Self::UnionType(wrapped_definition))
+        } else if let Ok(wrapped_definition) = value.try_convert() {
+            Ok(Self::InterfaceType(wrapped_definition))
+        } else if let Ok(wrapped_definition) = value.try_convert() {
+            Ok(Self::CustomScalarType(wrapped_definition))
+        } else {
+            Err(Error::new(
+                exception::type_error(),
+                format!(
+                    "{} is not a valid output type",
+                    value
+                ),
+            ))
+        }
+    }
+
+    pub fn mark(&self) {
+        match self {
+            Self::BuiltinScalarType(_) => {},
+            Self::ObjectType(wd) => wd.mark(),
+            Self::EnumType(wd) => wd.mark(),
+            Self::UnionType(wd) => wd.mark(),
+            Self::InterfaceType(wd) => wd.mark(),
+            Self::CustomScalarType(wd) => wd.mark(),
+        }
+    }
+
+    pub fn name(&self) -> &str {
+        match self {
+            Self::BuiltinScalarType(bstd) => bstd.name(),
+            Self::CustomScalarType(cstd) => cstd.as_ref().name(),
+            Self::EnumType(etd) => etd.as_ref().name(),
+            Self::InterfaceType(itd) => itd.as_ref().name(),
+            Self::ObjectType(otd) => otd.as_ref().name(),
+            Self::UnionType(utd) => utd.as_ref().name(),
+        }
+    }
+
+    fn sorbet_type(&self) -> String {
+        match self {
+            Self::BuiltinScalarType(bstd) => Scalar::from(*bstd).sorbet_type_fully_qualified_name().to_owned(),
+            Self::CustomScalarType(_) => "T.untyped".to_string(),
+            Self::EnumType(_) => "String".to_string(),
+            Self::InterfaceType(itd) => format!("{}::Interface", itd.fully_qualified_name()),
+            Self::ObjectType(otd) => format!("{}::Interface", otd.fully_qualified_name()),
+            Self::UnionType(utd) => utd.as_ref().sorbet_type()
+        }
+    }
+}
+
+#[derive(Clone, Debug, TypedData)]
+#[magnus(class = "Bluejay::OutputTypeReference", mark)]
+#[repr(transparent)]
+pub struct OutputTypeReference(CoreOutputTypeReference<BaseOutputTypeReference, WrappedOutputTypeReference>);
+
+impl AsRef<CoreOutputTypeReference<BaseOutputTypeReference, WrappedOutputTypeReference>> for OutputTypeReference {
+    fn as_ref(&self) -> &CoreOutputTypeReference<BaseOutputTypeReference, WrappedOutputTypeReference> {
+        &self.0
+    }
+}
+
+impl bluejay_core::definition::AbstractOutputTypeReference for OutputTypeReference {
+    type BaseOutputTypeReference = BaseOutputTypeReference;
+    type Wrapper = WrappedOutputTypeReference;
+}
+
+impl DataTypeFunctions for OutputTypeReference {
+    fn mark(&self) {
+        match &self.0 {
+            CoreOutputTypeReference::List(inner, _) => inner.mark(),
+            CoreOutputTypeReference::Base(inner, _) => inner.mark(),
+        }
+    }
+}
+
+impl From<CoreOutputTypeReference<BaseOutputTypeReference, WrappedOutputTypeReference>> for OutputTypeReference {
+    fn from(value: CoreOutputTypeReference<BaseOutputTypeReference, WrappedOutputTypeReference>) -> Self {
+        Self(value)
+    }
+}
+
+#[derive(Clone, Debug)]
+#[repr(transparent)]
+pub struct WrappedOutputTypeReference(WrappedStruct<OutputTypeReference>);
+
+impl AsRef<CoreOutputTypeReference<BaseOutputTypeReference, Self>> for WrappedOutputTypeReference {
+    fn as_ref(&self) -> &CoreOutputTypeReference<BaseOutputTypeReference, Self> {
+        self.0.get().as_ref()
+    }
+}
+
+impl WrappedOutputTypeReference {
+    fn mark(&self) {
+        self.0.mark()
+    }
+
+    pub fn get(&self) -> &OutputTypeReference {
+        self.0.get()
+    }
+}
+
+impl From<WrappedStruct<OutputTypeReference>> for WrappedOutputTypeReference {
+    fn from(value: WrappedStruct<OutputTypeReference>) -> Self {
+        Self(value)
+    }
+}
+
+impl From<OutputTypeReference> for WrappedOutputTypeReference {
+    fn from(value: OutputTypeReference) -> Self {
+        Self(WrappedStruct::wrap(value))
+    }
+}
+
+impl AsRef<WrappedStruct<OutputTypeReference>> for WrappedOutputTypeReference {
+    fn as_ref(&self) -> &WrappedStruct<OutputTypeReference> {
+        &self.0
+    }
+}
+
+impl OutputTypeReference {
+    pub fn new(kw: RHash) -> Result<Self, Error> {
+        let args = get_kwargs(kw, &["type", "required"], &[])?;
+        let (r#type, required): (Value, bool) = args.required;
+        let _: () = args.optional;
+        let _: () = args.splat;
+        let base = BaseOutputTypeReference::new(r#type)?;
+        Ok(Self(CoreOutputTypeReference::Base(base, required)))
+    }
+
+    pub fn list(kw: RHash) -> Result<Self, Error> {
+        let args = get_kwargs(kw, &["type", "required"], &[])?;
+        let (r#type, required): (WrappedStruct<Self>, bool) = args.required;
+        let _: () = args.optional;
+        let _: () = args.splat;
+        Ok(Self(CoreOutputTypeReference::List(r#type.into(), required)))
+    }
+
+    fn is_list(&self) -> bool {
+        matches!(&self.0, CoreOutputTypeReference::List(_, _))
+    }
+
+    fn is_base(&self) -> bool {
+        matches!(&self.0, CoreOutputTypeReference::Base(_, _))
+    }
+
+    fn is_required(&self) -> bool {
+        self.0.is_required()
+    }
+
+    fn unwrap_list(&self) -> Result<WrappedStruct<OutputTypeReference>, Error> {
+        match &self.0 {
+            CoreOutputTypeReference::List(inner, _) => Ok(*inner.as_ref()),
+            CoreOutputTypeReference::Base(_, _) => Err(Error::new(
+                exception::runtime_error(),
+                "Tried to unwrap a non-list OutputTypeReference".to_owned(),
+            )),
+        }
+    }
+
+    fn sorbet_type(&self) -> String {
+        let is_required = self.0.is_required();
+        let inner = match &self.0 {
+            CoreOutputTypeReference::List(inner, _) => format!("T::Array[{}]", inner.get().sorbet_type()),
+            CoreOutputTypeReference::Base(base, _) => base.sorbet_type(),
+        };
+        if is_required {
+            inner
+        } else {
+            format!("T.nilable({})", inner)
+        }
+    }
+}
+
+pub fn init() -> Result<(), Error> {
+    let class = root().define_class("OutputTypeReference", Default::default())?;
+
+    class.define_singleton_method("new", function!(OutputTypeReference::new, 1))?;
+    class.define_singleton_method("list", function!(OutputTypeReference::list, 1))?;
+    class.define_method("list?", method!(OutputTypeReference::is_list, 0))?;
+    class.define_method("base?", method!(OutputTypeReference::is_base, 0))?;
+    class.define_method("required?", method!(OutputTypeReference::is_required, 0))?;
+    class.define_method("sorbet_type", method!(OutputTypeReference::sorbet_type, 0))?;
+    class.define_method("unwrap_list", method!(OutputTypeReference::unwrap_list, 0))?;
+
+    Ok(())
+}