bluejay 0.1.0.alpha.1

data/lib/bluejay/base_output_type_reference.rb

@@ -0,0 +1,15 @@
+# typed: strict
+# frozen_string_literal: true
+
+module Bluejay
+  BaseOutputTypeReference = T.type_alias do
+    T.any(
+      Scalar,
+      T.class_of(EnumType),
+      T.class_of(ObjectType),
+      T.class_of(UnionType),
+      T.class_of(InterfaceType),
+      T.class_of(CustomScalarType),
+    )
+  end
+end

data/lib/bluejay/custom_scalar_type.rb

@@ -0,0 +1,40 @@
+# typed: strict
+# frozen_string_literal: true
+
+module Bluejay
+  class CustomScalarType
+    extend(Finalize)
+
+    class << self
+      extend(T::Sig)
+      extend(T::Helpers)
+      include(NameFromClass)
+
+      abstract!
+
+      sig { overridable.returns(String) }
+      def graphql_name
+        name_from_class
+      end
+
+      sig { overridable.returns(T.nilable(String)) }
+      def description
+        nil
+      end
+
+      protected
+
+      sig(:final) { override.void }
+      def finalize
+        definition
+      end
+
+      private
+
+      sig(:final) { returns(CustomScalarTypeDefinition) }
+      def definition
+        @definition ||= T.let(CustomScalarTypeDefinition.new(name: graphql_name, description:), T.nilable(CustomScalarTypeDefinition))
+      end
+    end
+  end
+end

data/lib/bluejay/enum_type.rb

@@ -0,0 +1,44 @@
+# typed: strict
+# frozen_string_literal: true
+
+module Bluejay
+  class EnumType
+    extend(Finalize)
+
+    class << self
+      extend(T::Sig)
+      extend(T::Helpers)
+      include(NameFromClass)
+
+      abstract!
+
+      sig { overridable.returns(String) }
+      def graphql_name
+        name_from_class
+      end
+
+      sig { overridable.returns(T.nilable(String)) }
+      def description
+        nil
+      end
+
+      sig { abstract.returns(T::Array[EnumValueDefinition]) }
+      def enum_value_definitions; end
+
+      protected
+
+      sig(:final) { override.void }
+      def finalize
+        definition
+      end
+
+      private
+
+      sig(:final) { returns(EnumTypeDefinition) }
+      def definition
+        @definition ||= T.let(nil, T.nilable(EnumTypeDefinition))
+        @definition ||= EnumTypeDefinition.new(name: graphql_name, enum_value_definitions:, description:)
+      end
+    end
+  end
+end

data/lib/bluejay/finalize.rb

@@ -0,0 +1,27 @@
+# typed: strict
+# frozen_string_literal: true
+
+module Bluejay
+  module Finalize
+    extend(T::Sig)
+    extend(T::Helpers)
+  
+    abstract!
+  
+    sig { abstract.void }
+    def finalize; end
+  
+    sig { params(obj: Finalize).void }
+    def inherited(obj)
+      TracePoint.trace(:end) do |t|
+        if obj == t.self
+          obj.finalize
+          t.disable
+        end
+      end
+      super
+    end
+  end
+
+  private_constant(:Finalize)
+end

data/lib/bluejay/input_type.rb

@@ -0,0 +1,64 @@
+# typed: strict
+# frozen_string_literal: true
+
+module Bluejay
+  class InputType
+    extend(Finalize)
+
+    class << self
+      extend(T::Sig)
+      extend(T::Helpers)
+      include(InputTypeReferenceShorthands)
+      include(NameFromClass)
+
+      abstract!
+
+      sig { overridable.returns(String) }
+      def graphql_name
+        name_from_class
+      end
+
+      sig { overridable.returns(T.nilable(String)) }
+      def description
+        nil
+      end
+
+      sig { abstract.returns(T::Array[InputValueDefinition]) }
+      def input_field_definitions; end
+
+      sig { params(value: T.untyped).returns(Result[T.untyped, T::Array[CoercionError]]) }
+      def coerce_input(value)
+        definition.coerce_input(value)
+      end
+
+      protected
+
+      sig(:final) { override.void }
+      def finalize
+        definition
+      end
+
+      private
+
+      sig(:final) { returns(InputObjectTypeDefinition) }
+      def definition
+        @definition ||= T.let(nil, T.nilable(InputObjectTypeDefinition))
+        @definition ||= begin
+          self.define_method(:initialize) do |*args|
+            self.class.send(:definition).input_field_definitions.zip(args) do |ivd, arg|
+              self.instance_variable_set("@#{ivd.name}", arg)
+            end
+          end
+          self.define_method(:==) do |other|
+            self.class == other.class && self.class.send(:definition).input_field_definitions.all? do |ivd|
+              self.send(ivd.name) == other.send(ivd.name)
+            end
+          end
+          input_field_definitions = self.input_field_definitions
+          input_field_definitions.each { |ivd| self.attr_reader(ivd.name) }
+          InputObjectTypeDefinition.new(name: graphql_name, input_field_definitions:, description:, ruby_class: self)
+        end
+      end
+    end
+  end
+end

data/lib/bluejay/input_type_reference_shorthands.rb

@@ -0,0 +1,28 @@
+# typed: strict
+# frozen_string_literal: true
+
+module Bluejay
+  module InputTypeReferenceShorthands
+    extend(T::Sig)
+
+    sig { params(t: BaseInputTypeReference).returns(InputTypeReference) }
+    def it(t)
+      InputTypeReference.new(type: t, required: false)
+    end
+
+    sig { params(t: BaseInputTypeReference).returns(InputTypeReference) }
+    def it!(t)
+      InputTypeReference.new(type: t, required: true)
+    end
+
+    sig { params(t: InputTypeReference).returns(InputTypeReference) }
+    def lit(t)
+      InputTypeReference.list(type: t, required: false)
+    end
+
+    sig { params(t: InputTypeReference).returns(InputTypeReference) }
+    def lit!(t)
+      InputTypeReference.list(type: t, required: true)
+    end
+  end
+end

data/lib/bluejay/interface_type.rb

@@ -0,0 +1,60 @@
+# typed: strict
+# frozen_string_literal: true
+
+module Bluejay
+  class InterfaceType
+    extend(Finalize)
+
+    class << self
+      extend(T::Sig)
+      extend(T::Helpers)
+      include(OutputTypeReferenceShorthands)
+      include(InputTypeReferenceShorthands)
+      include(NameFromClass)
+
+      abstract!
+
+      sig { overridable.returns(String) }
+      def graphql_name
+        name_from_class
+      end
+
+      sig { overridable.returns(T.nilable(String)) }
+      def description
+        nil
+      end
+
+      sig { abstract.returns(T::Array[FieldDefinition]) }
+      def field_definitions; end
+
+      sig { overridable.returns(T::Array[InterfaceImplementation]) }
+      def interface_implementations
+        []
+      end
+
+      protected
+
+      sig(:final) { override.void }
+      def finalize
+        definition
+      end
+
+      private
+
+      sig { returns(InterfaceTypeDefinition) }
+      def definition
+        @definition ||= T.let(nil, T.nilable(InterfaceTypeDefinition))
+        @definition ||= begin
+          interface_implementations = self.interface_implementations
+          interface = Module.new do |mod|
+            interface_implementations.each do |interface_implementation|
+              mod.include(interface_implementation.interface.const_get(:Interface))
+            end
+          end
+          const_set(:Interface, interface)
+          InterfaceTypeDefinition.new(name: graphql_name, description:, field_definitions:, interface_implementations:)
+        end
+      end
+    end
+  end
+end

data/lib/bluejay/json_value.rb

@@ -0,0 +1,16 @@
+# typed: strict
+# frozen_string_literal: true
+
+module Bluejay
+  JsonValue = T.type_alias do
+    T.any(
+      NilClass,
+      Integer,
+      Float,
+      String,
+      T::Boolean,
+      T::Array[Object],
+      T::Hash[String, Object],
+    )
+  end
+end

data/lib/bluejay/name_from_class.rb

@@ -0,0 +1,18 @@
+# typed: strict
+# frozen_string_literal: true
+
+module Bluejay
+  module NameFromClass
+    extend(T::Sig)
+    extend(T::Helpers)
+    
+    requires_ancestor { Class }
+
+    private
+
+    sig { returns(String) }
+    def name_from_class
+      name&.split("::")&.last || "Anonymous"
+    end
+  end
+end

data/lib/bluejay/object_type.rb

@@ -0,0 +1,68 @@
+# typed: strict
+# frozen_string_literal: true
+
+module Bluejay
+  class ObjectType
+    extend(Finalize)
+
+    class << self
+      extend(T::Sig)
+      extend(T::Helpers)
+      include(OutputTypeReferenceShorthands)
+      include(InputTypeReferenceShorthands)
+      include(NameFromClass)
+
+      abstract!
+
+      sig { overridable.returns(String) }
+      def graphql_name
+        name_from_class
+      end
+
+      sig { overridable.returns(T.nilable(String)) }
+      def description
+        nil
+      end
+
+      sig { abstract.returns(T::Array[FieldDefinition]) }
+      def field_definitions; end
+
+      sig { overridable.returns(T::Array[InterfaceImplementation]) }
+      def interface_implementations
+        []
+      end
+
+      protected
+
+      sig(:final) { override.void }
+      def finalize
+        definition
+      end
+
+      private
+
+      sig { returns(ObjectTypeDefinition) }
+      def definition
+        @definition ||= T.let(nil, T.nilable(ObjectTypeDefinition))
+        @definition ||= begin
+          graphql_name = self.graphql_name
+          field_definitions = self.field_definitions
+          interface_implementations = self.interface_implementations
+          interface = Module.new do |mod|
+            field_definitions.each do |field_definition|
+              mod.define_method(field_definition.resolver_method_name) { graphql_name }
+            end
+
+            interface_implementations.each do |interface_implementation|
+              mod.include(interface_implementation.interface.const_get(:Interface))
+            end
+
+            mod.define_method(:resolve_typename) { graphql_name }
+          end
+          const_set(:Interface, interface)
+          ObjectTypeDefinition.new(name: graphql_name, description:, field_definitions:, interface_implementations:)
+        end
+      end
+    end
+  end
+end

data/lib/bluejay/output_type_reference_shorthands.rb

@@ -0,0 +1,28 @@
+# typed: strict
+# frozen_string_literal: true
+
+module Bluejay
+  module OutputTypeReferenceShorthands
+    extend(T::Sig)
+
+    sig { params(t: BaseOutputTypeReference).returns(OutputTypeReference) }
+    def ot(t)
+      OutputTypeReference.new(type: t, required: false)
+    end
+
+    sig { params(t: BaseOutputTypeReference).returns(OutputTypeReference) }
+    def ot!(t)
+      OutputTypeReference.new(type: t, required: true)
+    end
+
+    sig { params(t: OutputTypeReference).returns(OutputTypeReference) }
+    def lot(t)
+      OutputTypeReference.list(type: t, required: false)
+    end
+
+    sig { params(t: OutputTypeReference).returns(OutputTypeReference) }
+    def lot!(t)
+      OutputTypeReference.list(type: t, required: true)
+    end
+  end
+end

data/lib/bluejay/schema.rb

@@ -0,0 +1,63 @@
+# typed: strict
+# frozen_string_literal: true
+
+module Bluejay
+  class Schema
+    extend(Finalize)
+
+    class << self
+      extend(T::Sig)
+      extend(T::Helpers)
+
+      abstract!
+
+      sig { overridable.returns(T.nilable(String)) }
+      def description
+        nil
+      end
+
+      sig { abstract.returns(T.class_of(ObjectType)) }
+      def query; end
+
+      sig { overridable.returns(T.nilable(T.class_of(ObjectType))) }
+      def mutation
+        nil
+      end
+
+      sig { params(query: String, operation_name: T.nilable(String), initial_value: Object, variables: T::Hash[String, T.untyped]).returns(ExecutionResult) }
+      def execute(query:, operation_name:, initial_value:, variables: {})
+        definition.execute(query, operation_name, variables, initial_value)
+      end
+
+      sig { params(query: String).returns(T::Array[ValidationError]) }
+      def validate_query(query:)
+        definition.validate_query(query)
+      end
+
+      protected
+
+      sig(:final) { override.void }
+      def finalize
+        definition
+      end
+
+      private
+
+      sig { returns(SchemaDefinition) }
+      def definition
+        @definition ||= T.let(nil, T.nilable(SchemaDefinition))
+        @definition ||= begin
+          mutation = self.mutation
+          interface = Module.new do |mod|
+            mod.define_method(:query) {}
+            if mutation
+              mod.define_method(:mutation) {}
+            end
+          end
+          const_set(:Root, interface)
+          SchemaDefinition.new(description:, query:, mutation:)
+        end
+      end
+    end
+  end
+end

data/lib/bluejay/union_type.rb

@@ -0,0 +1,43 @@
+# typed: strict
+# frozen_string_literal: true
+
+module Bluejay
+  class UnionType
+    extend(Finalize)
+
+    class << self
+      extend(T::Sig)
+      extend(T::Helpers)
+      include(NameFromClass)
+
+      abstract!
+
+      sig { overridable.returns(String) }
+      def graphql_name
+        name_from_class
+      end
+
+      sig { overridable.returns(T.nilable(String)) }
+      def description
+        nil
+      end
+
+      sig { abstract.returns(T::Array[UnionMemberType]) }
+      def member_types; end
+
+      protected
+
+      sig(:final) { override.void }
+      def finalize
+        definition
+      end
+
+      private
+
+      sig { returns(UnionTypeDefinition) }
+      def definition
+        @definition ||= T.let(UnionTypeDefinition.new(name: graphql_name, description:, member_types:), T.nilable(UnionTypeDefinition))
+      end
+    end
+  end
+end

data/lib/bluejay/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module Bluejay
+  VERSION = "0.1.0.alpha.1"
+end

data/lib/bluejay.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+require_relative "bluejay/version"
+require "sorbet-runtime"
+require_relative "bluejay/finalize"
+require_relative "bluejay/name_from_class"
+require_relative "bluejay/base_input_type_reference"
+require_relative "bluejay/base_output_type_reference"
+require_relative "bluejay/input_type_reference_shorthands"
+require_relative "bluejay/output_type_reference_shorthands"
+require_relative "bluejay/json_value"
+require_relative "bluejay/custom_scalar_type"
+require_relative "bluejay/enum_type"
+require_relative "bluejay/interface_type"
+require_relative "bluejay/input_type"
+require_relative "bluejay/object_type"
+require_relative "bluejay/schema"
+require_relative "bluejay/union_type"
+
+begin
+  RUBY_VERSION =~ /(\d+\.\d+)/
+  require "bluejay/#{Regexp.last_match(1)}/ext"
+rescue LoadError
+  require "bluejay/ext"
+end
+
+module Bluejay
+end

data/lib/rbi_ext/model.rb

@@ -0,0 +1,64 @@
+# typed: strict
+# frozen_string_literal: true
+
+module RBI
+  class Tree
+    extend T::Sig
+
+    # originally from:
+    # https://github.com/Shopify/tapioca/blob/7ea79ff61ac418ee2f5f573eec8a1f005db13ebd/lib/tapioca/rbi_ext/model.rb#L79-L106
+    sig do
+      params(
+        name: String,
+        return_type: T.nilable(String),
+        parameters: T::Array[TypedParam],
+        class_method: T::Boolean,
+        visibility: RBI::Visibility,
+        comments: T::Array[RBI::Comment],
+        is_final: T::Boolean,
+        is_abstract: T::Boolean,
+      ).void
+    end
+    def custom_create_method(name, return_type:, parameters: [], class_method: false, visibility: RBI::Public.new,
+        comments: [], is_final: false, is_abstract: false)
+      return unless Tapioca::RBIHelper.valid_method_name?(name)
+
+      sig = RBI::Sig.new(return_type:, is_final:, is_abstract:)
+      method = RBI::Method.new(
+        name,
+        sigs: [sig],
+        is_singleton: class_method,
+        visibility:,
+        comments:,
+      )
+      parameters.each do |param|
+        method << param.param
+        sig << RBI::SigParam.new(param.param.name, param.type)
+      end
+      self << method
+    end
+
+    sig { void }
+    def mark_abstract
+      add_helper("abstract")
+    end
+
+    sig { void }
+    def mark_interface
+      add_helper("interface")
+    end
+
+    sig { params(name: String).void }
+    def create_include(name)
+      self << RBI::Include.new(name)
+    end
+
+    private
+
+    sig { params(name: String).void }
+    def add_helper(name)
+      helper = RBI::Helper.new(name)
+      self << helper
+    end
+  end
+end

data/lib/tapioca/dsl/compilers/input_type.rb

@@ -0,0 +1,34 @@
+# typed: strict
+# frozen_string_literal: true
+
+require_relative "../../../rbi_ext/model"
+
+module Tapioca
+  module Compilers
+    class InputType < Tapioca::Dsl::Compiler
+      extend T::Sig
+
+      ConstantType = type_member { { fixed: T.class_of(Bluejay::InputType) } }
+
+      sig { override.returns(T::Enumerable[Module]) }
+      def self.gather_constants
+        all_classes.select { |c| c < Bluejay::InputType }
+      end
+
+      sig { override.void }
+      def decorate
+        root.create_path(constant) do |klass|
+          parameters = constant.input_field_definitions.map do |input_field_definition|
+            create_param(input_field_definition.ruby_name, type: input_field_definition.type.sorbet_type)
+          end
+
+          klass.custom_create_method("initialize", parameters:, return_type: nil)
+
+          constant.input_field_definitions.each do |input_field_definition|
+            klass.custom_create_method(input_field_definition.ruby_name, return_type: input_field_definition.type.sorbet_type)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/tapioca/dsl/compilers/interface_type.rb

@@ -0,0 +1,29 @@
+# typed: strict
+# frozen_string_literal: true
+
+require_relative "../../../rbi_ext/model"
+
+module Tapioca
+  module Compilers
+    class InterfaceType < Tapioca::Dsl::Compiler
+      extend T::Sig
+
+      ConstantType = type_member { { fixed: T.class_of(Bluejay::InterfaceType) } }
+
+      sig { override.returns(T::Enumerable[Module]) }
+      def self.gather_constants
+        all_classes.select { |c| c < Bluejay::InterfaceType }
+      end
+
+      sig { override.void }
+      def decorate
+        root.create_path(constant.const_get(:Interface)) do |klass|
+          constant.interface_implementations.each do |interface_implementation|
+            interface = interface_implementation.interface.const_get(:Interface)
+            klass.create_include(interface.name)
+          end
+        end
+      end
+    end
+  end
+end