rails-graphql 0.1.0

data/lib/rails/graphql/type/interface.rb

@@ -0,0 +1,82 @@
+# frozen_string_literal: true
+
+module Rails # :nodoc:
+  module GraphQL # :nodoc:
+    class Type # :nodoc:
+      # = GraphQL InterfaceType
+      #
+      # Interfaces represent a list of named fields and their types.
+      # See http://spec.graphql.org/June2018/#InterfaceTypeDefinition
+      #
+      # This class doesn't implements +valid_output?+ nor any of the output like
+      # methods because the Object class that uses interface already fetches
+      # all the fields for its composition and does the validating and
+      # serializing process.
+      class Interface < Type
+        extend Helpers::WithAssignment
+        extend Helpers::WithFields
+
+        setup! output: true
+
+        self.field_type = Field::OutputField
+
+        # The purpose of instantiating an interface is to have access to its
+        # public methods. It then runs from the strategy perspective, pointing
+        # out any other methods to the manually set event
+        delegate_missing_to :event
+        attr_reader :event
+
+        class << self
+          # TODO: Use inherited attribute for types
+
+          # Stores the list of types associated with the interface so it can
+          # be used during the execution step to find the right object type
+          def types
+            @types ||= Set.new
+          end
+
+          # Get the list of all inherited-aware associated types
+          def all_types
+            (superclass.try(:all_types) || Set.new) + (defined?(@types) ? @types : Set.new)
+          end
+
+          # Check if the other type is equivalent, by checking if the other is
+          # an object and the object implements this interface
+          def =~(other)
+            super || (other.object? && other.implements?(self))
+          end
+
+          # When attaching an interface to an object, copy the fields and add to
+          # the list of types. Pre-existing same-named fields with are not
+          # equivalent produces an exception.
+          def implemented(object)
+            fields.each do |name, field|
+              defined = object.field?(name)
+              invalid = defined && object.fields[name] !~ field
+              raise ArgumentError, <<~MSG.squish if invalid
+                The "#{object.gql_name}" object already has a "#{field.gql_name}" field and it
+                is not equivalent to the one defined on the "#{gql_name}" interface.
+              MSG
+
+              object.proxy_field(field) unless defined
+            end
+
+            types << object
+          end
+
+          def inspect # :nodoc:
+            fields = @fields.values.map(&:inspect)
+            fields = fields.presence && " {#{fields.join(', ')}}"
+            "#<GraphQL::Interface #{gql_name}#{fields}>"
+          end
+
+          # Check if the given object is properly implementing this interface
+          def validate(*)
+            # Don't validate interfaces since the fields are copied and
+            # the interface might have broken field types due to namespaces
+          end
+        end
+      end
+    end
+  end
+end

data/lib/rails/graphql/type/object.rb

@@ -0,0 +1,111 @@
+# frozen_string_literal: true
+
+module Rails # :nodoc:
+  module GraphQL # :nodoc:
+    class Type # :nodoc:
+      # = GraphQL ObjectType
+      #
+      # Objects represent a list of named fields, each of which yield a value of
+      # a specific type.
+      # See http://spec.graphql.org/June2018/#ObjectTypeDefinition
+      class Object < Type
+        extend ActiveSupport::Autoload
+        extend Helpers::WithAssignment
+        extend Helpers::WithFields
+
+        setup! output: true
+
+        self.field_type = Field::OutputField
+        self.valid_field_types = [
+          Type::Enum,
+          Type::Interface,
+          Type::Object,
+          Type::Scalar,
+          Type::Union,
+        ].freeze
+
+        eager_autoload do
+          autoload :DirectiveObject
+          autoload :EnumValueObject
+          autoload :FieldObject
+          autoload :InputValueObject
+          autoload :SchemaObject
+          autoload :TypeObject
+        end
+
+        # Define the methods for accessing the interfaces of the object
+        inherited_collection :interfaces, instance_reader: false
+
+        # The purpose of instantiating an object is to have access to its
+        # public methods. It then runs from the strategy perspective, pointing
+        # out any other methods to the manually set event
+        delegate_missing_to :event
+        attr_reader :event
+
+        class << self
+          # Plain objects can check if a given value is a valid member
+          def valid_member?(value)
+            return true if valid_assignment?(value)
+            checker = value.is_a?(Hash) ? :key? : :respond_to?
+            value = value.with_indifferent_access if value.is_a?(Hash)
+            fields.values.all? { |field| value.public_send(checker, field.method_name) }
+          end
+
+          # Check if the other type is equivalent, by checking if the other is
+          # an interface that the current object implements
+          def =~(other)
+            super || (other.interface? && implements?(other))
+          end
+
+          # Use this method to assign interfaces to the object
+          def implements(*others)
+            return if others.blank?
+
+            cache = all_interfaces.dup
+            others.flat_map do |item|
+              item = find_interface!(item)
+              next if cache.include?(item)
+
+              item.implemented(self)
+              interfaces << item
+              cache << item
+            end
+          end
+
+          # Check if the object implements the given +interface+
+          def implements?(interface)
+            (object = find_interface(interface)).present? && all_interfaces.include?(object)
+          end
+
+          private
+
+            # Soft find an object as an +interface+
+            def find_interface(object)
+              find_interface!(object)
+            rescue ArgumentError
+              # The object was not found as an actual interface
+            end
+
+            # Find a given +object+ and ensures it is an interface
+            def find_interface!(object)
+              object = GraphQL.type_map.fetch!(object,
+                namespaces: namespaces,
+                prevent_register: self,
+              ) unless object.is_a?(Module) && object < Type::Interface
+
+              return object if object.try(:interface?)
+              raise ArgumentError, <<~MSG.squish
+                The given "#{object}" is not a valid interface.
+              MSG
+            end
+        end
+
+        protected
+
+          def deprecated_directive
+            GraphQL::Directive::DeprecatedDirective
+          end
+      end
+    end
+  end
+end

data/lib/rails/graphql/type/object/directive_object.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+module Rails # :nodoc:
+  module GraphQL # :nodoc:
+    class Type # :nodoc:
+      # The introspection object for directives
+      class Object::DirectiveObject < Object
+        self.assigned_to = 'Rails::GraphQL::Directive'
+        self.spec_object = true
+
+        rename! '__Directive'
+
+        desc <<~DESC
+          Directives provide a way to describe alternate runtime execution
+          and type validation behavior in a GraphQL document.
+
+          In some cases, you need to provide options to alter GraphQL’s execution
+          behavior in ways field arguments will not suffice, such as conditionally
+          including or skipping a field. Directives provide this by describing
+          additional information to the executor.
+        DESC
+
+        field :name,        :string,               null: false, method_name: :gql_name
+        field :description, :string
+        field :locations,   '__DirectiveLocation', full: true
+        field :args,        '__InputValue',        full: true
+
+        def args
+          all_arguments.values
+        end
+      end
+    end
+  end
+end

data/lib/rails/graphql/type/object/enum_value_object.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+module Rails # :nodoc:
+  module GraphQL # :nodoc:
+    class Type # :nodoc:
+      # The introspection object for an enum value
+      class Object::EnumValueObject < Object
+        self.spec_object = true
+
+        rename! '__EnumValue'
+
+        desc <<~DESC
+          One of the values of an Enum object. It is unique within the Enum set
+          of values. It's a string representation, not a numeric representation,
+          of a value kept as all caps (ie. ONE_VALUE).
+        DESC
+
+        field :name,               :string,  null: false
+        field :description,        :string
+        field :is_deprecated,      :boolean, null: false
+        field :deprecation_reason, :string
+      end
+    end
+  end
+end

data/lib/rails/graphql/type/object/field_object.rb

@@ -0,0 +1,54 @@
+# frozen_string_literal: true
+
+module Rails # :nodoc:
+  module GraphQL # :nodoc:
+    class Type # :nodoc:
+      # The introspection object for a field on objects and interfaces
+      class Object::FieldObject < Object
+        self.assigned_to = 'Rails::GraphQL::Field'
+        self.spec_object = true
+
+        delegate :fake_type_object, to: 'Object::TypeObject'
+
+        rename! '__Field'
+
+        desc <<~DESC
+          Fields are the elements that compose both Objects and Interfaces. Each
+          field in these other objects may contain arguments and always yields
+          a value of a specific type.
+        DESC
+
+        field :name,               :string,        null: false, method_name: :gql_name
+        field :description,        :string
+        field :args,               '__InputValue', full: true
+        field :type,               '__Type',       null: false, method_name: :build_type
+        field :is_deprecated,      :boolean,       null: false, method_name: :deprecated?
+        field :deprecation_reason, :string
+
+        def build_type
+          result = current.type_klass
+
+          if current.array?
+            result = fake_type_object(:non_null, result) unless current.nullable?
+            result = fake_type_object(:list,     result)
+          end
+
+          result = fake_type_object(:non_null, result) unless current.null?
+          result
+        end
+
+        def args
+          all_arguments.values
+        end
+
+        def deprecated?
+          current.using?(deprecated_directive)
+        end
+
+        def deprecation_reason
+          current.all_directives.find { |item| item.is_a?(deprecated_directive) }&.args&.reason
+        end
+      end
+    end
+  end
+end

data/lib/rails/graphql/type/object/input_value_object.rb

@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+
+module Rails # :nodoc:
+  module GraphQL # :nodoc:
+    class Type # :nodoc:
+      # The introspection object for a input object
+      class Object::InputValueObject < Object
+        self.assigned_to = 'Rails::GraphQL::Field::InputField'
+        self.spec_object = true
+
+        def self.valid_member?(value)
+          value.is_a?(GraphQL::Argument) || super
+        end
+
+        delegate :fake_type_object, to: 'Object::TypeObject'
+
+        rename! '__InputValue'
+
+        desc <<~DESC
+          Alongside with scalars and enums, input value objects allow the user
+          to provide values to arguments on fields and directives. Different
+          from those, input values accepts a list of keyed values, instead of
+          a single value.
+        DESC
+
+        field :name,          :string,  null: false, method_name: :gql_name
+        field :description,   :string
+        field :type,          '__Type', null: false, method_name: :build_type
+        field :default_value, :string
+
+        def default_value
+          current.to_json if current.default_value?
+        end
+
+        def build_type
+          result = current.type_klass
+
+          if current.array?
+            result = fake_type_object(:non_null, result) unless current.nullable?
+            result = fake_type_object(:list,     result)
+          end
+
+          result = fake_type_object(:non_null, result) unless current.null?
+          result
+        end
+      end
+    end
+  end
+end

data/lib/rails/graphql/type/object/schema_object.rb

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+module Rails # :nodoc:
+  module GraphQL # :nodoc:
+    class Type # :nodoc:
+      # The introspection object for a schema object
+      class Object::SchemaObject < Object
+        self.assigned_to = 'Rails::GraphQL::Schema'
+        self.spec_object = true
+
+        rename! '__Schema'
+
+        desc <<~DESC
+          A GraphQL service’s collective type system capabilities are referred
+          to as that service’s "schema". A schema is defined in terms of the
+          types and directives it supports as well as the root operation types
+          for each kind of operation: query, mutation, and subscription; this
+          determines the place in the type system where those operations begin.
+        DESC
+
+        field :types,             '__Type',      full: true, method_name: :read_types
+        field :query_type,        '__Type',      null: false
+        field :mutation_type,     '__Type'
+        field :subscription_type, '__Type'
+        field :directives,        '__Directive', full: true, method_name: :read_directives
+
+        # TODO: make it work for lazy enumerator
+        def read_types
+          event.schema.types(base_class: :Type).force
+        end
+
+        # TODO: it only works after eager_load!
+        def read_directives
+          Directive.eager_load!
+          event.schema.types(base_class: :Directive).force
+        end
+      end
+    end
+  end
+end

data/lib/rails/graphql/type/object/type_object.rb

@@ -0,0 +1,136 @@
+# frozen_string_literal: true
+
+module Rails # :nodoc:
+  module GraphQL # :nodoc:
+    class Type # :nodoc:
+      # The introspection object for any kind of type
+      class Object::TypeObject < Object
+        FAKE_TYPES = {
+          list: {
+            kind: :list,
+            kind_enum: 'LIST',
+            name: 'List',
+            object?: true,
+            description: nil,
+          },
+          non_null: {
+            kind: :non_null,
+            kind_enum: 'NON_NULL',
+            name: 'Non-Null',
+            object?: true,
+            description: nil,
+          },
+        }.freeze
+
+        self.assigned_to = 'Rails::GraphQL::Type'
+        self.spec_object = true
+
+        def self.valid_member?(value)
+          value.is_a?(OpenStruct) ? value.try(:object?) : super
+        end
+
+        def self.fake_type_object(type, subtype)
+          OpenStruct.new(**FAKE_TYPES[type].merge(of_type: subtype))
+        end
+
+        rename! '__Type'
+
+        desc <<~DESC
+          The fundamental unit of any GraphQL Schema is the type. There are six
+          kinds of named type definitions in GraphQL, and two wrapping types.
+
+          The most basic type is a +Scalar+. A scalar represents a primitive value,
+          like a string or an integer.
+
+          +Scalars+ and +Enums+ form the leaves in response trees; the intermediate
+          levels are +Object+ types, which define a set of fields.
+
+          An +Interface+ defines a list of fields; +Object+ types that implement
+          that interface are guaranteed to implement those fields.
+
+          A +Union+ defines a list of possible types; similar to interfaces,
+          whenever the type system claims a union will be returned, one of the
+          possible types will be returned.
+
+          Finally, oftentimes it is useful to provide complex structs as inputs
+          to GraphQL field arguments or variables; the +Input Object+ type allows
+          the schema to define exactly what data is expected.
+        DESC
+
+        field :kind,           '__TypeKind',   null: false,
+          method_name: :kind_enum
+
+        field :name,           :string,
+          method_name: :gql_name
+
+        field :description,    :string
+
+        field :fields,         '__Field',      array: true, nullable: false do
+          desc 'OBJECT and INTERFACE only'
+          argument :include_deprecated, :boolean, default: false
+        end
+
+        field :interfaces,     '__Type',       array: true, nullable: false,
+          desc: 'OBJECT only'
+
+        field :possible_types, '__Type',       array: true, nullable: false,
+          desc: 'INTERFACE and UNION only'
+
+        field :enum_values,    '__EnumValue',  array: true, nullable: false do
+          desc 'ENUM only'
+          argument :include_deprecated, :boolean, default: false
+        end
+
+        field :input_fields,   '__InputValue', array: true, nullable: false,
+          desc: 'INPUT_OBJECT only'
+
+        field :of_type,        '__Type',
+          desc: 'NON_NULL and LIST only'
+
+        def fields(include_deprecated:)
+          return [] unless current.object? || current.interface?
+
+          list = current.fields.enum_for(:each_value)
+          list = list.reject { |field| field.using?(deprecated_directive) } \
+            unless include_deprecated
+
+          list
+        end
+
+        def enum_values(include_deprecated:)
+          return [] unless current.enum?
+
+          descs = all_value_description
+          deprecated = all_deprecated_values
+
+          list = all_values.lazy
+          list = list.reject { |value| deprecated.key?(value) } \
+            unless include_deprecated
+
+          list.map do |value|
+            OpenStruct.new(
+              name: value,
+              description: descs[value],
+              is_deprecated: deprecated.key?(value),
+              deprecation_reason: deprecated[value],
+            )
+          end
+        end
+
+        def interfaces
+          return [] unless current.object?
+          current.all_interfaces || []
+        end
+
+        def possible_types
+          return all_types if current.interface?
+          current.union? ? all_members : []
+        end
+
+        def input_fields
+          current.input? ? current.fields.enum_for(:each_value) : []
+        end
+      end
+    end
+  end
+end