bluejay 0.1.0.alpha.2-x86_64-linux

data/lib/bluejay/base_input_type.rb

@@ -0,0 +1,13 @@
+# typed: strict
+# frozen_string_literal: true
+
+module Bluejay
+  BaseInputType = T.type_alias do
+    T.any(
+      Scalar,
+      Base::InputObjectType::ClassMethods,
+      Base::EnumType::ClassMethods,
+      Base::CustomScalarType::ClassMethods,
+    )
+  end
+end

data/lib/bluejay/base_output_type.rb

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

data/lib/bluejay/builtin/directives/deprecated.rb

@@ -0,0 +1,34 @@
+# typed: strict
+# frozen_string_literal: true
+
+module Bluejay
+  module Builtin
+    module Directives
+      class Deprecated < Directive
+        class << self
+          extend(T::Sig)
+
+          sig { override.returns(String) }
+          def graphql_name
+            "deprecated"
+          end
+
+          sig { override.returns(T::Array[InputValueDefinition]) }
+          def argument_definitions
+            [
+              InputValueDefinition.new(name: "reason", type: it(Scalar::String)),
+            ]
+          end
+
+          sig { override.returns(T::Array[DirectiveLocation]) }
+          def locations
+            [
+              DirectiveLocation::FIELD_DEFINITION,
+              DirectiveLocation::ENUM_VALUE,
+            ]
+          end
+        end
+      end
+    end
+  end
+end

data/lib/bluejay/builtin/directives/include.rb

@@ -0,0 +1,35 @@
+# typed: strict
+# frozen_string_literal: true
+
+module Bluejay
+  module Builtin
+    module Directives
+      class Include < Directive
+        class << self
+          extend(T::Sig)
+
+          sig { override.returns(String) }
+          def graphql_name
+            "include"
+          end
+
+          sig { override.returns(T::Array[InputValueDefinition]) }
+          def argument_definitions
+            [
+              InputValueDefinition.new(name: "if", type: it!(Scalar::Boolean), ruby_name: "if_arg"),
+            ]
+          end
+
+          sig { override.returns(T::Array[DirectiveLocation]) }
+          def locations
+            [
+              DirectiveLocation::FIELD,
+              DirectiveLocation::FRAGMENT_SPREAD,
+              DirectiveLocation::INLINE_FRAGMENT,
+            ]
+          end
+        end
+      end
+    end
+  end
+end

data/lib/bluejay/builtin/directives/skip.rb

@@ -0,0 +1,35 @@
+# typed: strict
+# frozen_string_literal: true
+
+module Bluejay
+  module Builtin
+    module Directives
+      class Skip < Directive
+        class << self
+          extend(T::Sig)
+
+          sig { override.returns(String) }
+          def graphql_name
+            "skip"
+          end
+
+          sig { override.returns(T::Array[InputValueDefinition]) }
+          def argument_definitions
+            [
+              InputValueDefinition.new(name: "if", type: it!(Scalar::Boolean), ruby_name: "if_arg"),
+            ]
+          end
+
+          sig { override.returns(T::Array[DirectiveLocation]) }
+          def locations
+            [
+              DirectiveLocation::FIELD,
+              DirectiveLocation::FRAGMENT_SPREAD,
+              DirectiveLocation::INLINE_FRAGMENT,
+            ]
+          end
+        end
+      end
+    end
+  end
+end

data/lib/bluejay/builtin/directives/specified_by.rb

@@ -0,0 +1,33 @@
+# typed: strict
+# frozen_string_literal: true
+
+module Bluejay
+  module Builtin
+    module Directives
+      class SpecifiedBy < Directive
+        class << self
+          extend(T::Sig)
+
+          sig { override.returns(String) }
+          def graphql_name
+            "specifiedBy"
+          end
+
+          sig { override.returns(T::Array[InputValueDefinition]) }
+          def argument_definitions
+            [
+              InputValueDefinition.new(name: "url", type: it!(Scalar::String)),
+            ]
+          end
+
+          sig { override.returns(T::Array[DirectiveLocation]) }
+          def locations
+            [
+              DirectiveLocation::SCALAR,
+            ]
+          end
+        end
+      end
+    end
+  end
+end

data/lib/bluejay/builtin/enum_types/directive_location.rb

@@ -0,0 +1,44 @@
+# typed: strict
+# frozen_string_literal: true
+
+module Bluejay
+  module Builtin
+    module EnumTypes
+      class DirectiveLocation < EnumType
+        class << self
+          extend(T::Sig)
+
+          sig { override.returns(String) }
+          def graphql_name
+            "__DirectiveLocation"
+          end
+
+          sig { override.returns(T::Array[EnumValueDefinition]) }
+          def enum_value_definitions
+            [
+              EnumValueDefinition.new(name: "QUERY"),
+              EnumValueDefinition.new(name: "MUTATION"),
+              EnumValueDefinition.new(name: "SUBSCRIPTION"),
+              EnumValueDefinition.new(name: "FIELD"),
+              EnumValueDefinition.new(name: "FRAGMENT_DEFINITION"),
+              EnumValueDefinition.new(name: "FRAGMENT_SPREAD"),
+              EnumValueDefinition.new(name: "INLINE_FRAGMENT"),
+              EnumValueDefinition.new(name: "VARIABLE_DEFINITION"),
+              EnumValueDefinition.new(name: "SCHEMA"),
+              EnumValueDefinition.new(name: "SCALAR"),
+              EnumValueDefinition.new(name: "OBJECT"),
+              EnumValueDefinition.new(name: "FIELD_DEFINITION"),
+              EnumValueDefinition.new(name: "ARGUMENT_DEFINITION"),
+              EnumValueDefinition.new(name: "INTERFACE"),
+              EnumValueDefinition.new(name: "UNION"),
+              EnumValueDefinition.new(name: "ENUM"),
+              EnumValueDefinition.new(name: "ENUM_VALUE"),
+              EnumValueDefinition.new(name: "INPUT_OBJECT"),
+              EnumValueDefinition.new(name: "INPUT_FIELD_DEFINITION"),
+            ]
+          end
+        end
+      end
+    end
+  end
+end

data/lib/bluejay/builtin/enum_types/type_kind.rb

@@ -0,0 +1,33 @@
+# typed: strict
+# frozen_string_literal: true
+
+module Bluejay
+  module Builtin
+    module EnumTypes
+      class TypeKind < EnumType
+        class << self
+          extend(T::Sig)
+
+          sig { override.returns(String) }
+          def graphql_name
+            "__TypeKind"
+          end
+
+          sig { override.returns(T::Array[EnumValueDefinition]) }
+          def enum_value_definitions
+            [
+              EnumValueDefinition.new(name: "SCALAR"),
+              EnumValueDefinition.new(name: "OBJECT"),
+              EnumValueDefinition.new(name: "INTERFACE"),
+              EnumValueDefinition.new(name: "UNION"),
+              EnumValueDefinition.new(name: "ENUM"),
+              EnumValueDefinition.new(name: "INPUT_OBJECT"),
+              EnumValueDefinition.new(name: "LIST"),
+              EnumValueDefinition.new(name: "NON_NULL"),
+            ]
+          end
+        end
+      end
+    end
+  end
+end

data/lib/bluejay/builtin/object_types/directive.rb

@@ -0,0 +1,34 @@
+# typed: strict
+# frozen_string_literal: true
+
+module Bluejay
+  module Builtin
+    module ObjectTypes
+      class Directive < ObjectType
+        class << self
+          extend(T::Sig)
+
+          sig { override.returns(String) }
+          def graphql_name
+            "__Directive"
+          end
+
+          sig { override.returns(T::Array[FieldDefinition]) }
+          def field_definitions
+            [
+              FieldDefinition.new(name: "name", type: ot!(Scalar::String)),
+              FieldDefinition.new(name: "description", type: ot(Scalar::String)),
+              FieldDefinition.new(name: "locations", type: lot!(ot!(EnumTypes::DirectiveLocation))),
+              FieldDefinition.new(name: "args", type: lot!(ot!(InputValue))),
+              FieldDefinition.new(
+                name: "isRepeatable",
+                type: ot!(Scalar::Boolean),
+                resolver_method_name: "repeatable?",
+              ),
+            ]
+          end
+        end
+      end
+    end
+  end
+end

data/lib/bluejay/builtin/object_types/enum_value.rb

@@ -0,0 +1,33 @@
+# typed: strict
+# frozen_string_literal: true
+
+module Bluejay
+  module Builtin
+    module ObjectTypes
+      class EnumValue < ObjectType
+        class << self
+          extend(T::Sig)
+
+          sig { override.returns(String) }
+          def graphql_name
+            "__EnumValue"
+          end
+
+          sig { override.returns(T::Array[FieldDefinition]) }
+          def field_definitions
+            [
+              FieldDefinition.new(name: "name", type: ot!(Scalar::String)),
+              FieldDefinition.new(name: "description", type: ot(Scalar::String)),
+              FieldDefinition.new(
+                name: "isDeprecated",
+                type: ot!(Scalar::Boolean),
+                resolver_method_name: "deprecated?",
+              ),
+              FieldDefinition.new(name: "deprecationReason", type: ot(Scalar::String)),
+            ]
+          end
+        end
+      end
+    end
+  end
+end

data/lib/bluejay/builtin/object_types/field.rb

@@ -0,0 +1,35 @@
+# typed: strict
+# frozen_string_literal: true
+
+module Bluejay
+  module Builtin
+    module ObjectTypes
+      class Field < ObjectType
+        class << self
+          extend(T::Sig)
+
+          sig { override.returns(String) }
+          def graphql_name
+            "__Field"
+          end
+
+          sig { override.returns(T::Array[FieldDefinition]) }
+          def field_definitions
+            [
+              FieldDefinition.new(name: "name", type: ot!(Scalar::String), resolver_method_name: "name"),
+              FieldDefinition.new(name: "description", type: ot(Scalar::String)),
+              FieldDefinition.new(name: "args", type: lot!(ot!(InputValue))),
+              FieldDefinition.new(name: "type", type: ot!(Type)),
+              FieldDefinition.new(
+                name: "isDeprecated",
+                type: ot!(Scalar::Boolean),
+                resolver_method_name: "deprecated?",
+              ),
+              FieldDefinition.new(name: "deprecationReason", type: ot(Scalar::String)),
+            ]
+          end
+        end
+      end
+    end
+  end
+end

data/lib/bluejay/builtin/object_types/input_value.rb

@@ -0,0 +1,29 @@
+# typed: strict
+# frozen_string_literal: true
+
+module Bluejay
+  module Builtin
+    module ObjectTypes
+      class InputValue < ObjectType
+        class << self
+          extend(T::Sig)
+
+          sig { override.returns(String) }
+          def graphql_name
+            "__InputValue"
+          end
+
+          sig { override.returns(T::Array[FieldDefinition]) }
+          def field_definitions
+            [
+              FieldDefinition.new(name: "description", type: ot(Scalar::String)),
+              FieldDefinition.new(name: "name", type: ot(Scalar::String)),
+              FieldDefinition.new(name: "type", type: ot!(Type)),
+              FieldDefinition.new(name: "defaultValue", type: ot(Scalar::String)),
+            ]
+          end
+        end
+      end
+    end
+  end
+end

data/lib/bluejay/builtin/object_types/schema.rb

@@ -0,0 +1,31 @@
+# typed: strict
+# frozen_string_literal: true
+
+module Bluejay
+  module Builtin
+    module ObjectTypes
+      class Schema < ObjectType
+        class << self
+          extend(T::Sig)
+
+          sig { override.returns(String) }
+          def graphql_name
+            "__Schema"
+          end
+
+          sig { override.returns(T::Array[FieldDefinition]) }
+          def field_definitions
+            [
+              FieldDefinition.new(name: "description", type: ot(Scalar::String)),
+              FieldDefinition.new(name: "types", type: lot!(ot!(Type))),
+              FieldDefinition.new(name: "queryType", type: ot!(Type)),
+              FieldDefinition.new(name: "mutationType", type: ot(Type)),
+              FieldDefinition.new(name: "subscriptionType", type: ot(Type)),
+              FieldDefinition.new(name: "directives", type: lot!(ot!(Directive))),
+            ]
+          end
+        end
+      end
+    end
+  end
+end

data/lib/bluejay/builtin/object_types/type.rb

@@ -0,0 +1,57 @@
+# typed: strict
+# frozen_string_literal: true
+
+module Bluejay
+  module Builtin
+    module ObjectTypes
+      class Type < ObjectType
+        class << self
+          extend(T::Sig)
+
+          sig { override.returns(String) }
+          def graphql_name
+            "__Type"
+          end
+
+          sig { override.returns(T::Array[FieldDefinition]) }
+          def field_definitions
+            [
+              FieldDefinition.new(name: "kind", type: ot!(EnumTypes::TypeKind)),
+              FieldDefinition.new(name: "name", type: ot(Scalar::String)),
+              FieldDefinition.new(name: "description", type: ot(Scalar::String)),
+              FieldDefinition.new(
+                name: "fields",
+                argument_definitions: [InputValueDefinition.new(
+                  name: "includeDeprecated",
+                  type: it(Scalar::Boolean),
+                  default_value: false,
+                )],
+                type: lot(ot!(Field)),
+              ),
+              FieldDefinition.new(name: "interfaces", type: lot(ot!(Type))),
+              FieldDefinition.new(name: "possibleTypes", type: lot(ot!(Type))),
+              FieldDefinition.new(
+                name: "enumValues",
+                argument_definitions: [InputValueDefinition.new(
+                  name: "includeDeprecated",
+                  type: it(Scalar::Boolean),
+                  default_value: false,
+                )],
+                type: lot(ot!(EnumValue)),
+              ),
+              FieldDefinition.new(
+                name: "inputFields",
+                type: lot(ot!(InputValue)),
+              ),
+              FieldDefinition.new(name: "ofType", type: ot(Type)),
+              FieldDefinition.new(
+                name: "specifiedByURL",
+                type: ot(Scalar::String),
+              ),
+            ]
+          end
+        end
+      end
+    end
+  end
+end

data/lib/bluejay/builtin.rb

@@ -0,0 +1,25 @@
+# typed: strict
+# frozen_string_literal: true
+
+module Bluejay
+  module Builtin
+    class << self
+      extend(T::Sig)
+
+      sig { returns(FieldDefinition) }
+      def typename_field_definition
+        @typename_field_definition ||= T.let(
+          FieldDefinition.new(
+            name: "__typename",
+            type: OutputType.new(
+              type: Scalar::String,
+              required: true,
+            ),
+            resolver_method_name: "resolve_typename",
+          ),
+          T.nilable(FieldDefinition),
+        )
+      end
+    end
+  end
+end

data/lib/bluejay/custom_scalar_type.rb

@@ -0,0 +1,69 @@
+# typed: strict
+# frozen_string_literal: true
+
+module Bluejay
+  class CustomScalarType
+    extend(T::Generic)
+    include(Base::CustomScalarType)
+
+    InternalRepresentation = type_template
+
+    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 { overridable.returns(T::Array[Directive]) }
+      def directives
+        []
+      end
+
+      sig { overridable.returns(T.nilable(String)) }
+      def specified_by_url
+        nil
+      end
+
+      sig { overridable.params(value: InternalRepresentation).returns(Result[T.untyped, String]) }
+      def coerce_result(value)
+        Result.ok(value)
+      end
+
+      sig { abstract.params(value: T.untyped).returns(Result[InternalRepresentation, String]) }
+      def coerce_input(value); end
+
+      sig { overridable.returns(String) }
+      def internal_representation_sorbet_type_name
+        const_get(:InternalRepresentation).name
+      end
+
+      private
+
+      sig(:final) { override.returns(CustomScalarTypeDefinition) }
+      def definition
+        @definition ||= T.let(
+          CustomScalarTypeDefinition.new(
+            name: graphql_name,
+            description:,
+            directives:,
+            specified_by_url:,
+            ruby_class: self,
+            internal_representation_sorbet_type_name:,
+          ),
+          T.nilable(CustomScalarTypeDefinition),
+        )
+      end
+    end
+  end
+end

data/lib/bluejay/directive.rb

@@ -0,0 +1,71 @@
+# typed: strict
+# frozen_string_literal: true
+
+module Bluejay
+  class Directive
+    include(Base::Directive)
+
+    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 argument_definitions; end
+
+      sig { abstract.returns(T::Array[DirectiveLocation]) }
+      def locations; end
+
+      sig { overridable.returns(T::Boolean) }
+      def repeatable?
+        false
+      end
+
+      private
+
+      sig(:final) { override.returns(DirectiveDefinition) }
+      def definition
+        @definition ||= T.let(nil, T.nilable(DirectiveDefinition))
+        @definition ||= begin
+          argument_definitions = self.argument_definitions
+          argument_definitions.each { |ivd| attr_reader(ivd.ruby_name) }
+          DirectiveDefinition.new(
+            name: graphql_name,
+            argument_definitions:,
+            description:,
+            locations:,
+            is_repeatable: repeatable?,
+            ruby_class: self,
+          )
+        end
+      end
+    end
+
+    define_method(:initialize) do |**kwargs|
+      self.class.send(:definition).argument_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).argument_definitions.all? do |ivd|
+        send(ivd.ruby_name) == other.send(ivd.ruby_name)
+      end
+    end
+  end
+end

data/lib/bluejay/enum_type.rb

@@ -0,0 +1,48 @@
+# typed: strict
+# frozen_string_literal: true
+
+module Bluejay
+  class EnumType
+    include(Base::EnumType)
+
+    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
+
+      sig { overridable.returns(T::Array[Directive]) }
+      def directives
+        []
+      end
+
+      private
+
+      sig(:final) { override.returns(EnumTypeDefinition) }
+      def definition
+        @definition ||= T.let(nil, T.nilable(EnumTypeDefinition))
+        @definition ||= EnumTypeDefinition.new(
+          name: graphql_name,
+          enum_value_definitions:,
+          description:,
+          directives:,
+          ruby_class: self,
+        )
+      end
+    end
+  end
+end