bluejay 0.1.0.alpha.2-x86_64-linux

data/lib/bluejay/errors.rb

@@ -0,0 +1,20 @@
+# typed: strict
+# frozen_string_literal: true
+
+module Bluejay
+  module Errors
+    class BaseError < StandardError; end
+
+    class DefaultValueError < BaseError
+      extend(T::Sig)
+
+      sig { params(errors: T::Array[CoercionError], value: Object).void }
+      def initialize(errors, value)
+        @errors = errors
+        super("Invalid default value: #{value}. Errors:\n#{errors.map(&:message).join("\n")}")
+      end
+    end
+
+    class NonUniqueDefinitionNameError < BaseError; 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_object_type.rb

@@ -0,0 +1,73 @@
+# typed: strict
+# frozen_string_literal: true
+
+module Bluejay
+  class InputObjectType
+    extend(T::Sig)
+    include(Base::InputObjectType)
+
+    class << self
+      extend(T::Sig)
+      extend(T::Helpers)
+      include(InputTypeShorthands)
+      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 { overridable.returns(T::Array[Directive]) }
+      def directives
+        []
+      end
+
+      sig { params(value: T.untyped).returns(Result[T.untyped, T::Array[CoercionError]]) }
+      def coerce_input(value)
+        definition.coerce_input(value)
+      end
+
+      private
+
+      sig(:final) { override.returns(InputObjectTypeDefinition) }
+      def definition
+        @definition ||= T.let(nil, T.nilable(InputObjectTypeDefinition))
+        @definition ||= begin
+          input_field_definitions = self.input_field_definitions
+          input_field_definitions.each { |ivd| attr_reader(ivd.ruby_name) }
+          InputObjectTypeDefinition.new(
+            name: graphql_name,
+            input_field_definitions:,
+            description:,
+            directives:,
+            ruby_class: self,
+          )
+        end
+      end
+    end
+
+    define_method(:initialize) do |**kwargs|
+      self.class.send(:definition).input_field_definitions.each do |ivd|
+        arg = kwargs[ivd.ruby_name]
+        instance_variable_set("@#{ivd.ruby_name}", arg)
+      end
+      freeze
+    end
+
+    define_method(:==) do |other|
+      self.class == other.class && self.class.send(:definition).input_field_definitions.all? do |ivd|
+        send(ivd.ruby_name) == other.send(ivd.ruby_name)
+      end
+    end
+  end
+end

data/lib/bluejay/input_type_shorthands.rb

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

data/lib/bluejay/interface_type.rb

@@ -0,0 +1,74 @@
+# typed: strict
+# frozen_string_literal: true
+
+module Bluejay
+  class InterfaceType
+    include(Base::InterfaceType)
+
+    class << self
+      extend(T::Sig)
+      extend(T::Helpers)
+      include(OutputTypeShorthands)
+      include(InputTypeShorthands)
+      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
+
+      sig { overridable.returns(T::Array[Directive]) }
+      def directives
+        []
+      end
+
+      private
+
+      sig { params(name: Symbol).returns(T.untyped) }
+      def const_missing(name)
+        if name == :Interface
+          definition
+          const_get(:Interface)
+        else
+          super
+        end
+      end
+
+      sig { override.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(T.cast(interface_implementation.interface, T.class_of(InterfaceType)).const_get(:Interface))
+            end
+          end
+          const_set(:Interface, interface)
+          InterfaceTypeDefinition.new(
+            name: graphql_name,
+            description:,
+            field_definitions: field_definitions + [Builtin.typename_field_definition],
+            interface_implementations:,
+            directives:,
+          )
+        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 { Module }
+
+    private
+
+    sig { returns(String) }
+    def name_from_class
+      name&.split("::")&.last || "Anonymous"
+    end
+  end
+end

data/lib/bluejay/object_type.rb

@@ -0,0 +1,81 @@
+# typed: strict
+# frozen_string_literal: true
+
+module Bluejay
+  class ObjectType
+    include(Base::ObjectType)
+
+    class << self
+      extend(T::Sig)
+      extend(T::Helpers)
+      include(OutputTypeShorthands)
+      include(InputTypeShorthands)
+      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
+
+      sig { overridable.returns(T::Array[Directive]) }
+      def directives
+        []
+      end
+
+      private
+
+      sig { params(name: Symbol).returns(T.untyped) }
+      def const_missing(name)
+        if name == :Interface
+          definition
+          const_get(:Interface)
+        else
+          super
+        end
+      end
+
+      sig { override.returns(ObjectTypeDefinition) }
+      def definition
+        @definition ||= T.let(nil, T.nilable(ObjectTypeDefinition))
+        @definition ||= begin
+          graphql_name = self.graphql_name
+          field_definitions = self.field_definitions + [Builtin.typename_field_definition]
+          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(T.cast(interface_implementation.interface, T.class_of(InterfaceType)).const_get(:Interface))
+            end
+          end
+          const_set(:Interface, interface)
+          ObjectTypeDefinition.new(
+            name: graphql_name,
+            description:,
+            field_definitions:,
+            interface_implementations:,
+            directives:,
+            ruby_class: self,
+          )
+        end
+      end
+    end
+  end
+end

data/lib/bluejay/output_type_shorthands.rb

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

data/lib/bluejay/query_root.rb

@@ -0,0 +1,64 @@
+# typed: strict
+# frozen_string_literal: true
+
+module Bluejay
+  class QueryRoot < ObjectType
+    include(Base::QueryRoot)
+
+    class << self
+      extend(T::Sig)
+      extend(T::Helpers)
+
+      abstract!
+
+      private
+
+      sig { override.returns(ObjectTypeDefinition) }
+      def definition
+        @definition ||= T.let(nil, T.nilable(ObjectTypeDefinition))
+        @definition ||= begin
+          # TODO: reduce duplication with ObjectType.definition
+          graphql_name = self.graphql_name
+          field_definitions = self.field_definitions + [Builtin.typename_field_definition]
+          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(T.cast(interface_implementation.interface, T.class_of(InterfaceType)).const_get(:Interface))
+            end
+
+            mod.define_method(:resolve_schema) { |schema_class:| schema_class.send(:definition) }
+            mod.define_method(:resolve_type) do |name:, schema_class:|
+              schema_class.send(:definition).type(name)
+            end
+          end
+          const_set(:Interface, interface)
+          introspection_field_definitions = [
+            FieldDefinition.new(
+              name: "__schema",
+              type: ot!(Builtin::ObjectTypes::Schema),
+              resolver_method_name: "resolve_schema",
+            ),
+            FieldDefinition.new(
+              name: "__type",
+              argument_definitions: [InputValueDefinition.new(name: "name", type: it!(Scalar::String))],
+              type: ot(Builtin::ObjectTypes::Type),
+              resolver_method_name: "resolve_type",
+            ),
+          ]
+          ObjectTypeDefinition.new(
+            name: graphql_name,
+            description:,
+            field_definitions: field_definitions + introspection_field_definitions,
+            interface_implementations:,
+            directives:,
+            ruby_class: self,
+          )
+        end
+      end
+    end
+  end
+end

data/lib/bluejay/schema.rb

@@ -0,0 +1,91 @@
+# typed: strict
+# frozen_string_literal: true
+
+module Bluejay
+  class Schema
+    extend(Finalize)
+    include(Base::Schema)
+
+    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(QueryRoot)) }
+      def query; end
+
+      sig { overridable.returns(T.nilable(T.class_of(ObjectType))) }
+      def mutation
+        nil
+      end
+
+      sig { overridable.returns(T::Array[Directive]) }
+      def directives
+        []
+      end
+
+      sig do
+        params(
+          query: String,
+          initial_value: Object,
+          operation_name: T.nilable(String),
+          variables: T::Hash[String, T.untyped],
+        ).returns(ExecutionResult)
+      end
+      def execute(query:, initial_value:, operation_name: nil, 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
+
+      sig { returns(String) }
+      def to_definition
+        definition.to_definition
+      end
+
+      protected
+
+      sig(:final) { override.void }
+      def finalize
+        definition
+      end
+
+      private
+
+      sig { params(name: Symbol).returns(T.untyped) }
+      def const_missing(name)
+        if name == :Root
+          definition
+          const_get(:Root)
+        else
+          super
+        end
+      end
+
+      sig { override.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:, directives:, ruby_class: self)
+        end
+      end
+    end
+  end
+end

data/lib/bluejay/union_type.rb

@@ -0,0 +1,50 @@
+# typed: strict
+# frozen_string_literal: true
+
+module Bluejay
+  class UnionType
+    include(Base::UnionType)
+
+    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
+
+      sig { overridable.returns(T::Array[Directive]) }
+      def directives
+        []
+      end
+
+      private
+
+      sig { override.returns(UnionTypeDefinition) }
+      def definition
+        @definition ||= T.let(
+          UnionTypeDefinition.new(
+            name: graphql_name,
+            description:,
+            member_types:,
+            directives:,
+            field_definitions: [Builtin.typename_field_definition],
+          ),
+          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.2"
+end

data/lib/bluejay.rb

@@ -0,0 +1,45 @@
+# 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"
+require_relative "bluejay/base_input_type"
+require_relative "bluejay/base_output_type"
+require_relative "bluejay/input_type_shorthands"
+require_relative "bluejay/output_type_shorthands"
+require_relative "bluejay/json_value"
+require_relative "bluejay/custom_scalar_type"
+require_relative "bluejay/directive"
+require_relative "bluejay/enum_type"
+require_relative "bluejay/interface_type"
+require_relative "bluejay/input_object_type"
+require_relative "bluejay/object_type"
+require_relative "bluejay/query_root"
+require_relative "bluejay/schema"
+require_relative "bluejay/union_type"
+require_relative "bluejay/errors"
+require_relative "bluejay/builtin"
+require_relative "bluejay/builtin/directives/deprecated"
+require_relative "bluejay/builtin/directives/include"
+require_relative "bluejay/builtin/directives/skip"
+require_relative "bluejay/builtin/directives/specified_by"
+require_relative "bluejay/builtin/enum_types/directive_location"
+require_relative "bluejay/builtin/enum_types/type_kind"
+require_relative "bluejay/builtin/object_types/enum_value"
+require_relative "bluejay/builtin/object_types/type"
+require_relative "bluejay/builtin/object_types/input_value"
+require_relative "bluejay/builtin/object_types/field"
+require_relative "bluejay/builtin/object_types/directive"
+require_relative "bluejay/builtin/object_types/schema"
+
+begin
+  RUBY_VERSION =~ /(\d+\.\d+)/
+  require "bluejay/#{Regexp.last_match(1)}/bluejay_rb"
+rescue LoadError
+  require "bluejay/bluejay_rb"
+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