rails-graphql 0.1.0

data/lib/rails/graphql/type.rb

@@ -0,0 +1,138 @@
+# frozen_string_literal: true
+
+module Rails # :nodoc:
+  module GraphQL # :nodoc:
+    # = GraphQL Type
+    #
+    # This is the most pure object from GraphQL. Anything that a schema can
+    # define will be an extension of this class
+    # See: http://spec.graphql.org/June2018/#sec-Types
+    class Type
+      extend ActiveSupport::Autoload
+      extend Helpers::WithDirectives
+      extend Helpers::Registerable
+
+      # A direct representation of the spec types
+      KINDS = %w[Scalar Object Interface Union Enum Input].freeze
+      eager_autoload { KINDS.each { |kind| autoload kind.to_sym } }
+
+      delegate :base_type, :kind, :kind_enum, :input_type?, :output_type?,
+        :leaf_type?, to: :class, prefix: :gql
+
+      # A +base_object+ helps to identify what methods are actually available
+      # to work as resolvers
+      class_attribute :base_object, instance_writer: false, default: false
+
+      self.spec_object = true
+      self.base_object = true
+      self.abstract = true
+
+      class << self
+        alias internal? spec_object?
+
+        # Returns the base type of the class. It will be one of the classes
+        # defined on +Type::KINDS+
+        def base_type
+          nil
+        end
+
+        # Check if the other type is equivalent
+        def =~(other)
+          (other.is_a?(Module) ? other : other.class) <= self
+        end
+
+        alias of_type? =~
+
+        # Return the base type in a symbolized way
+        def kind
+          base_type.name.demodulize.underscore.to_sym
+        end
+
+        # Return the specific value for the __TypeKind of this class
+        def kind_enum
+          kind.to_s.upcase
+        end
+
+        # Defines if the current type is a valid input type
+        def input_type?
+          false
+        end
+
+        # Defines if the current type is a valid output type
+        def output_type?
+          false
+        end
+
+        # Defines if the current type is a leaf output type
+        def leaf_type?
+          false
+        end
+
+        # A little helper to instanteate the type if necessary
+        def decorate(value)
+          value
+        end
+
+        # Checks if a given method can act as resolver
+        def gql_resolver?(method_name)
+          ref_object = self
+          ref_object = ref_object.superclass until ref_object.base_object?
+          (instance_methods - ref_object.instance_methods).include?(method_name)
+        end
+
+        # Defines a series of question methods based on the kind
+        KINDS.each { |kind| define_method("#{kind.downcase}?") { false } }
+
+        def eager_load! # :nodoc:
+          super
+
+          # Due to inheritance
+          return unless eql?(GraphQL::Type)
+
+          Type::Enum.eager_load!
+          Type::Object.eager_load!
+          Type::Scalar.eager_load!
+
+          Source.eager_load!
+          TypeMap.loaded! :Type
+        end
+
+        protected
+
+          # Provide a list of settings to setup the current child class
+          def setup!(**options)
+            return unless superclass.eql?(GraphQL::Type)
+
+            redefine_singleton_method(:kind) { options[:kind] } if options.key?(:kind)
+            self.directive_location = kind
+
+            redefine_singleton_method(:leaf_type?)   { true } if options[:leaf]
+            redefine_singleton_method(:input_type?)  { true } if options[:input]
+            redefine_singleton_method(:output_type?) { true } if options[:output]
+          end
+
+        private
+
+          # Reset some class attributes, meaning that they are not cascade
+          def inherited(subclass)
+            if subclass.superclass.eql?(GraphQL::Type)
+              subclass.redefine_singleton_method(:base_type) { subclass }
+
+              question_method = "#{subclass.name.demodulize.underscore}?"
+              subclass.redefine_singleton_method(question_method) { true }
+
+              subclass.spec_object = true
+              subclass.base_object = true
+              subclass.abstract = true
+            else
+              subclass.spec_object = false
+              subclass.base_object = false
+              subclass.abstract = false
+            end
+
+            super if defined? super
+          end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,206 @@
+# frozen_string_literal: true
+
+module Rails # :nodoc:
+  module GraphQL # :nodoc:
+    class Type # :nodoc:
+      # = GraphQL EnumType
+      #
+      # Enum types, like scalar types, also represent leaf values in a GraphQL
+      # type system. However Enum types describe the set of possible values.
+      # See http://spec.graphql.org/June2018/#EnumTypeDefinition
+      class Enum < Type
+        extend ActiveSupport::Autoload
+
+        setup! leaf: true, input: true, output: true
+
+        eager_autoload do
+          autoload :DirectiveLocationEnum
+          autoload :TypeKindEnum
+        end
+
+        # Define the methods for accessing the values attribute
+        inherited_collection :values
+
+        # Define the methods for accessing the description of each enum value
+        inherited_collection :value_description, type: :hash
+
+        # Define the methods for accessing the directives of each enum value
+        inherited_collection :value_directives, type: :hash
+
+        class << self
+          # Mark the enum as indexed, allowing values being set by number
+          def indexed!
+            @indexed = true
+          end
+
+          # Checks if the enum was marked as indexed
+          def indexed?
+            defined?(@indexed) && @indexed.present?
+          end
+
+          # Check if a given value is a valid non-deserialized input
+          def valid_input?(value)
+            value.is_a?(String) && all_values.include?(value)
+          end
+
+          # Check if a given value is a valid non-serialized output
+          def valid_output?(value)
+            all_values.include?(as_json(value))
+          end
+
+          # Transforms the given value to its representation in a JSON string
+          def to_json(value)
+            as_json(value)&.inspect
+          end
+
+          # Transforms the given value to its representation in a Hash object
+          def as_json(value)
+            return if value.nil?
+            return value.to_s if value.is_a?(self)
+            return all_values.drop(value).first if indexed? && value.is_a?(Numeric)
+            value.to_s.underscore.upcase
+          end
+
+          # Turn a user input of this given type into an ruby object
+          def deserialize(value)
+            new(value) if valid_input?(value)
+          end
+
+          # Use the instance as decorator
+          def decorate(value)
+            deserialize(as_json(value))
+          end
+
+          # Use this method to add values to the enum type
+          #
+          # ==== Options
+          #
+          # * <tt>:desc</tt> - The description of the enum value (defaults to nil).
+          # * <tt>:directives</tt> - The list of directives associated with the value
+          #   (defaults to nil).
+          # * <tt>:deprecated</tt> - A shortcut that auto-attach a @deprecated
+          #   directive to the value. A +true+ value simple attaches the directive,
+          #   but provide a string so it can be used as the reason of the deprecation.
+          #   See {DeprecatedDirective}[rdoc-ref:Rails::GraphQL::Directive::DeprecatedDirective]
+          #   (defaults to false).
+          def add(value, desc: nil, directives: nil, deprecated: false)
+            raise ArgumentError, <<~MSG.squish unless value.is_a?(String) && value.present?
+              The "#{value}" is invalid.
+            MSG
+
+            value = value.upcase
+            raise ArgumentError, <<~MSG.squish if all_values.include?(value)
+              The "#{value}" is already defined for #{gql_name} enum.
+            MSG
+
+            directives = Array.wrap(directives)
+            directives << deprecated_klass.new(
+              reason: (deprecated.is_a?(String) ? deprecated : nil),
+            ) if deprecated.present?
+
+            directives = GraphQL.directives_to_set(directives,
+              location: :enum_value,
+              source: self,
+            )
+
+            values << value
+            value_description[value] = desc unless desc.nil?
+            value_directives[value] = directives
+          end
+
+          # Check if a given +value+ is using a +directive+
+          def value_using?(value, directive)
+            raise ArgumentError, <<~MSG.squish unless directive < GraphQL::Directive
+              The provided #{item_or_symbol.inspect} is not a valid directive.
+            MSG
+
+            !!value_directives[as_json(value)]&.any? { |item| item.is_a?(directive) }
+          end
+
+          # Build a hash with deprecated values and their respective reason for
+          # logging and introspection purposes
+          def all_deprecated_values
+            @all_deprecated_values ||= begin
+              all_value_directives.to_a.inject({}) do |list, (value, dirs)|
+                obj = dirs.find { |dir| dir.is_a?(deprecated_klass) }
+                obj ? list.merge(value => obj.args.reason) : list
+              end
+            end.freeze
+          end
+
+          # This returns the field directives and all value directives
+          def all_directives
+            all_value_directives.each_value.reduce(:+)
+          end
+
+          def inspect # :nodoc:
+            <<~INFO.squish + '>'
+              #<GraphQL::Enum #{gql_name}
+              (#{all_values.size})
+              {#{all_values.to_a.join(' | ')}}
+            INFO
+          end
+
+          private
+
+            def deprecated_klass
+              Directive::DeprecatedDirective
+            end
+        end
+
+        attr_reader :value
+
+        delegate :to_s, :inspect, to: :@value
+
+        def initialize(value)
+          @value = value
+        end
+
+        # Use lower case for symbolized value
+        def to_sym
+          @value.downcase.to_sym
+        end
+
+        # Allow finding the indexed position of the value
+        def to_i
+          self.class.all_values.find_index(@value)
+        end
+
+        # Checks if the current value is valid
+        def valid?
+          self.class.valid_output?(@value)
+        end
+
+        # Gets all the description of the current value
+        def description
+          @description ||= @value && self.class.all_value_description[@value]
+        end
+
+        # Gets all the directives associated with the current value
+        def directives
+          @directives ||= @value && self.class.all_value_directives[@value]
+        end
+
+        # Checks if the current value is marked as deprecated
+        def deprecated?
+          self.class.all_deprecated_values.include?(@value)
+        end
+
+        # Return the deprecated reason
+        def deprecated_reason
+          deprecated_directive&.args&.reason
+        end
+
+        private
+
+          # Find and store the directive that marked the current value as
+          # deprecated
+          def deprecated_directive
+            @deprecated_directive ||= directives.find do |dir|
+              dir.is_a?(Directive::DeprecatedDirective)
+            end
+          end
+      end
+    end
+  end
+end

data/lib/rails/graphql/type/enum/directive_location_enum.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+module Rails # :nodoc:
+  module GraphQL # :nodoc:
+    class Type # :nodoc:
+      # Bigint basically removes the limit of the value, but it serializes as
+      # a string so it won't go against the spec
+      class Enum::DirectiveLocationEnum < Enum
+        self.spec_object = true
+
+        rename! '__DirectiveLocation'
+
+        desc 'The valid locations that a directive may be placed.'
+
+        %w[QUERY MUTATION SUBSCRIPTION FIELD FRAGMENT_DEFINITION
+          FRAGMENT_SPREAD INLINE_FRAGMENT].each do |value|
+          desc = value.downcase.tr('_', ' ')
+          add(value, desc: "Mark as a executable directive usable on #{desc} objects.")
+        end
+
+        %w[SCHEMA SCALAR OBJECT FIELD_DEFINITION ARGUMENT_DEFINITION INTERFACE UNION
+          ENUM ENUM_VALUE INPUT_OBJECT INPUT_FIELD_DEFINITION].each do |value|
+          desc = value.downcase.tr('_', ' ')
+          desc = "Mark as a type system directive usable on #{desc} definitions."
+          add(value, desc: desc.gsub(/definition definitions\.$/, 'definitions.'))
+        end
+      end
+    end
+  end
+end

data/lib/rails/graphql/type/enum/type_kind_enum.rb

@@ -0,0 +1,57 @@
+# frozen_string_literal: true
+
+module Rails # :nodoc:
+  module GraphQL # :nodoc:
+    class Type # :nodoc:
+      # Bigint basically removes the limit of the value, but it serializes as
+      # a string so it won't go against the spec
+      class Enum::TypeKindEnum < Enum
+        self.spec_object = true
+
+        rename! '__TypeKind'
+
+        desc <<~DESC
+          The fundamental unit of any GraphQL Schema is the type.
+          This enum enlist all the valid base types.
+        DESC
+
+        add 'SCALAR', desc: <<~DESC
+          Scalar types represent primitive leaf values in a GraphQL type system.
+        DESC
+
+        add 'OBJECT', desc: <<~DESC
+          Objects represent a list of named fields, each of which yield a value of a
+          specific type.
+        DESC
+
+        add 'INTERFACE', desc: <<~DESC
+          Interfaces represent a list of named fields and their types.
+        DESC
+
+        add 'UNION', desc: <<~DESC
+          Unions represent an object that could be one of a list of GraphQL Object types.
+        DESC
+
+        add 'ENUM', desc: <<~DESC
+          Enum types, like scalar types, also represent leaf values in a GraphQL
+          type system. However Enum types describe the set of possible values.
+        DESC
+
+        add 'INPUT_OBJECT', desc: <<~DESC
+          Objects represent a list of named fields, each of which yield a value of
+          a specific type.
+        DESC
+
+        add 'LIST', desc: <<~DESC
+          A GraphQL list is a special collection type which declares the type of
+          each item in the List (referred to as the item type of the list).
+        DESC
+
+        add 'NON_NULL', desc: <<~DESC
+          This type wraps an underlying type, and this type acts identically to that wrapped
+          type, with the exception that null is not a valid response for the wrapping type.
+        DESC
+      end
+    end
+  end
+end

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

@@ -0,0 +1,134 @@
+# frozen_string_literal: true
+
+module Rails # :nodoc:
+  module GraphQL # :nodoc:
+    class Type # :nodoc:
+      # = GraphQL InputType
+      #
+      # Input defines a set of input fields; the input fields are either
+      # scalars, enums, or other input objects.
+      # See http://spec.graphql.org/June2018/#InputObjectTypeDefinition
+      class Input < Type
+        extend Helpers::WithAssignment
+        extend Helpers::WithFields
+
+        setup! kind: :input_object, input: true
+
+        self.field_type = Field::InputField
+        self.valid_field_types = [
+          Type::Enum,
+          Type::Input,
+          Type::Scalar,
+        ].freeze
+
+        class << self
+          # A little override on the name of the object due to the suffix config
+          def gql_name
+            return @gql_name if defined?(@gql_name)
+
+            suffix = GraphQL.config.auto_suffix_input_objects
+            return super if suffix.blank?
+
+            result = super
+            result += suffix if result && !result.end_with?(suffix)
+            @gql_name = result
+          end
+
+          # Check if a given value is a valid non-deserialized input
+          def valid_input?(value)
+            value = value.to_h if value.respond_to?(:to_h)
+            return false unless value.is_a?(Hash)
+
+            fields = enabled_fields
+            value = value.transform_keys { |key| key.to_s.camelize(:lower) }
+            value = build_defaults.merge(value)
+
+            return false unless value.size.eql?(fields.size)
+
+            fields.all? { |item| item.valid_input?(value[item.gql_name]) }
+          end
+
+          # Turn the given value into an isntance of the input object
+          def deserialize(value)
+            value = value.to_h if value.respond_to?(:to_h)
+            value = {} unless value.is_a?(Hash)
+            value = enabled_fields.map do |field|
+              next unless value.key?(field.gql_name) || value.key?(field.name)
+              [field.name, field.deserialize(value[field.gql_name] || value[field.name])]
+            end.compact.to_h
+
+            new(OpenStruct.new(value))
+          end
+
+          # Build a hash with the default values for each of the given fields
+          def build_defaults
+            enabled_fields.map { |field| [field.gql_name, field.default] }.to_h
+          end
+
+          def inspect # :nodoc:
+            args = fields.each_value.map(&:inspect)
+            args = args.presence && "(#{args.join(', ')})"
+            "#<GraphQL::Input #{gql_name}#{args}>"
+          end
+        end
+
+        attr_reader :args
+        attr_writer :resource
+
+        delegate :fields, to: :class
+        delegate :[], to: :args
+
+        delegate_missing_to :resource
+
+        def initialize(args = nil, **xargs)
+          @args = args || OpenStruct.new(xargs.transform_keys { |key| key.to_s.underscore })
+          @args.freeze
+
+          validate! if args.nil?
+        end
+
+        # If the input is assigned to a class, then initialize it with the
+        # received arguments. It also accepts extra arguments for inheritance
+        # purposes
+        def resource(*args, **xargs, &block)
+          @resource ||= (klass = safe_assigned_class).nil? ? nil : begin
+            xargs = xargs.reverse_merge(params)
+            klass.new(*args, **xargs, &block)
+          end
+        end
+
+        # Just return the arguments as an hash
+        def params
+          parametrize(self)
+        end
+
+        # Checks if all the values provided to the input instance are valid
+        def validate!(*)
+          errors = []
+          fields.each do |name, field|
+            field.validate_output!(@args[name.to_s])
+          rescue InvalidValueError => error
+            errors << error.message
+          end
+
+          return if errors.empty?
+          raise InvalidValueError, <<~MSG.squish
+            Invalid value provided to #{gql_name} field: #{errors.to_sentence}.
+          MSG
+        end
+
+        private
+
+          # Make sure to turn inputs into params
+          def parametrize(input)
+            case input
+            when Type::Input then parametrize(input.args.to_h)
+            when Array       then input.map(&method(:parametrize))
+            when Hash        then input.transform_values(&method(:parametrize))
+            else input
+            end
+          end
+      end
+    end
+  end
+end