rails-graphql 0.2.1 → 1.0.0.rc1

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

@@ -1,8 +1,8 @@
 # frozen_string_literal: true
 
-module Rails # :nodoc:
-  module GraphQL # :nodoc:
-    class Type # :nodoc:
+module Rails
+  module GraphQL
+    class Type
       # = GraphQL ObjectType
       #
       # Objects represent a list of named fields, each of which yield a value of
@@ -13,6 +13,8 @@ module Rails # :nodoc:
         extend Helpers::WithAssignment
         extend Helpers::WithFields
 
+        include Helpers::Instantiable
+
         setup! output: true
 
         self.field_type = Field::OutputField
@@ -24,31 +26,28 @@ module Rails # :nodoc:
           Type::Union,
         ].freeze
 
-        eager_autoload do
-          autoload :DirectiveObject
-          autoload :EnumValueObject
-          autoload :FieldObject
-          autoload :InputValueObject
-          autoload :SchemaObject
-          autoload :TypeObject
-        end
+        autoload :DirectiveObject
+        autoload :EnumValueObject
+        autoload :FieldObject
+        autoload :InputValueObject
+        autoload :SchemaObject
+        autoload :TypeObject
 
         # 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) }
+
+            check_hash = value.is_a?(::Hash)
+            checker = check_hash ? :key? : :respond_to?
+
+            fields.values.all? do |field|
+              value.public_send(checker, field.method_name) ||
+                (check_hash && (field.null? || value.key?(field.gql_name)))
+            end
           end
 
           # Check if the other type is equivalent, by checking if the other is
@@ -58,17 +57,16 @@ module Rails # :nodoc:
           end
 
           # Use this method to assign interfaces to the object
-          def implements(*others)
+          def implements(*others, import_fields: true)
             return if others.blank?
 
-            cache = all_interfaces.dup
+            current = all_interfaces&.dup
             others.flat_map do |item|
               item = find_interface!(item)
-              next if cache.include?(item)
+              next if current&.include?(item) || interfaces.include?(item)
 
-              item.implemented(self)
+              item.implemented(self, import_fields: import_fields)
               interfaces << item
-              cache << item
             end
           end
 
@@ -77,6 +75,16 @@ module Rails # :nodoc:
             (object = find_interface(interface)).present? && all_interfaces.include?(object)
           end
 
+          def inspect
+            return super if self.eql?(Type::Object)
+            fields = @fields.values.map(&:inspect)
+            fields = fields.presence && +" {#{fields.join(', ')}}"
+
+            directives = inspect_directives
+            directives.prepend(' ') if directives.present?
+            +"#<GraphQL::Object #{gql_name}#{fields}#{directives}>"
+          end
+
           private
 
             # Soft find an object as an +interface+
@@ -94,7 +102,7 @@ module Rails # :nodoc:
               ) unless object.is_a?(Module) && object < Type::Interface
 
               return object if object.try(:interface?)
-              raise ArgumentError, <<~MSG.squish
+              raise ArgumentError, (+<<~MSG).squish
                 The given "#{object}" is not a valid interface.
               MSG
             end

data/lib/rails/graphql/type/scalar/any_scalar.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+module Rails
+  module GraphQL
+    class Type
+      # Handles any type of data for both input and output
+      class Scalar::AnyScalar < Scalar
+        desc 'The Any scalar type allows anything for both input and output.'
+
+        class << self
+          def valid_input?(value)
+            true
+          end
+
+          def valid_output?(value)
+            true
+          end
+
+          def to_json(value)
+            value.to_json
+          end
+
+          def as_json(value)
+            value.as_json
+          end
+        end
+      end
+    end
+  end
+end

data/lib/rails/graphql/type/scalar/bigint_scalar.rb

@@ -1,14 +1,14 @@
 # frozen_string_literal: true
 
-module Rails # :nodoc:
-  module GraphQL # :nodoc:
-    class Type # :nodoc:
+module Rails
+  module GraphQL
+    class Type
       # Bigint basically removes the limit of the value, but it serializes as
       # a string so it won't go against the spec
       class Scalar::BigintScalar < Scalar
         desc <<~DESC
-          The Bigint scalar type represents a signed numeric non‐fractional value.
-          It can go beyond the Int 32‐bit limit, but it's exchanged as a string.
+          The Bigint scalar type represents a signed numeric non-fractional value.
+          It can go beyond the Int 32-bit limit, but it's exchanged as a string.
         DESC
 
         class << self

data/lib/rails/graphql/type/scalar/binary_scalar.rb

@@ -1,8 +1,8 @@
 # frozen_string_literal: true
 
-module Rails # :nodoc:
-  module GraphQL # :nodoc:
-    class Type # :nodoc:
+module Rails
+  module GraphQL
+    class Type
       # Binary basically allows binary data to be shared using Base64 strings,
       # ensuring the UTF-8 encoding and performing the necessary conversion.
       #
@@ -15,6 +15,8 @@ module Rails # :nodoc:
           Normally used to share files and uploads.
         DESC
 
+        use :specified_by, url: 'https://www.rfc-editor.org/rfc/rfc3548'
+
         class << self
           def as_json(value)
             Base64.encode64(value.to_s).chomp

data/lib/rails/graphql/type/scalar/boolean_scalar.rb

@@ -1,8 +1,8 @@
 # frozen_string_literal: true
 
-module Rails # :nodoc:
-  module GraphQL # :nodoc:
-    class Type # :nodoc:
+module Rails
+  module GraphQL
+    class Type
       # The Boolean scalar type represents +true+ or +false+.
       #
       # See http://spec.graphql.org/June2018/#sec-Boolean
@@ -16,19 +16,19 @@ module Rails # :nodoc:
 
         class << self
           def valid_input?(value)
-            value === true || value === false
+            valid_token?(value) || value === true || value === false
           end
 
-          def valid_output?(value)
-            value.respond_to?(:present?)
+          def valid_output?(*)
+            true # Pretty much anything can be turned into a boolean
           end
 
           def as_json(value)
-            value.present?
+            !(value.nil? || FALSE_VALUES.include?(value))
           end
 
           def deserialize(value)
-            !FALSE_VALUES.include?(value)
+            as_json(value)
           end
         end
       end

data/lib/rails/graphql/type/scalar/date_scalar.rb

@@ -1,12 +1,14 @@
 # frozen_string_literal: true
 
-module Rails # :nodoc:
-  module GraphQL # :nodoc:
-    class Type # :nodoc:
+module Rails
+  module GraphQL
+    class Type
       # Date uses a ISO 8601 string to exchange the value.
       class Scalar::DateScalar < Scalar
         desc 'The Date scalar type represents a ISO 8601 string value.'
 
+        use :specified_by, url: 'https://www.rfc-editor.org/rfc/rfc3339'
+
         class << self
           def valid_input?(value)
             super && !!Date.iso8601(value)

data/lib/rails/graphql/type/scalar/date_time_scalar.rb

@@ -1,14 +1,16 @@
 # frozen_string_literal: true
 
-module Rails # :nodoc:
-  module GraphQL # :nodoc:
-    class Type # :nodoc:
+module Rails
+  module GraphQL
+    class Type
       # DateTime uses a ISO 8601 string to exchange the value.
       class Scalar::DateTimeScalar < Scalar
         aliases :datetime
 
         desc 'The DateTime scalar type represents a ISO 8601 string value.'
 
+        use :specified_by, url: 'https://www.rfc-editor.org/rfc/rfc3339'
+
         class << self
           def valid_input?(value)
             super && !!(Time.iso8601(value) rescue false)

data/lib/rails/graphql/type/scalar/decimal_scalar.rb

@@ -1,8 +1,8 @@
 # frozen_string_literal: true
 
-module Rails # :nodoc:
-  module GraphQL # :nodoc:
-    class Type # :nodoc:
+module Rails
+  module GraphQL
+    class Type
       # Similar to float, but implies extra precision, making sure that all the
       # decimal-point numbers are kept. As Bigint, it uses a string so it won't
       # go against the spec.
@@ -12,6 +12,8 @@ module Rails # :nodoc:
           The values are exchange as string.
         DESC
 
+        use :specified_by, url: 'https://en.wikipedia.org/wiki/IEEE_754-2008_revision'
+
         class << self
           def valid_input?(value)
             super && value.match?(/\A[+-]?\d+\.\d+\z/)

data/lib/rails/graphql/type/scalar/float_scalar.rb

@@ -1,8 +1,8 @@
 # frozen_string_literal: true
 
-module Rails # :nodoc:
-  module GraphQL # :nodoc:
-    class Type # :nodoc:
+module Rails
+  module GraphQL
+    class Type
       # The Float scalar type represents signed double-precision fractional
       # values as specified by
       # {IEEE 754}[http://en.wikipedia.org/wiki/IEEE_floating_point].
@@ -11,11 +11,11 @@ module Rails # :nodoc:
       class Scalar::FloatScalar < Scalar
         self.spec_object = true
 
-        desc 'The Float scalar type represents signed double‐precision fractional values.'
+        desc 'The Float scalar type represents signed double-precision fractional values.'
 
         class << self
           def valid_input?(value)
-            value.is_a?(Float)
+            valid_token?(value) || value.is_a?(Float)
           end
 
           def valid_output?(value)

data/lib/rails/graphql/type/scalar/id_scalar.rb

@@ -1,8 +1,8 @@
 # frozen_string_literal: true
 
-module Rails # :nodoc:
-  module GraphQL # :nodoc:
-    class Type # :nodoc:
+module Rails
+  module GraphQL
+    class Type
       # The ID scalar type represents a unique identifier, often used to
       # refetch an object or as the key for a cache. The ID type is serialized
       # in the same way as a +StringScalar+.
@@ -20,7 +20,8 @@ module Rails # :nodoc:
 
         class << self
           def valid_input?(value)
-            super || value.is_a?(Integer)
+            valid_token?(value, :string) || valid_token?(value, :int) ||
+              value.is_a?(String) || value.is_a?(Integer)
           end
 
           def as_json(value)
@@ -30,7 +31,7 @@ module Rails # :nodoc:
           end
 
           def deserialize(value)
-            value.to_s
+            valid_token?(value, :string) ? value[1..-2] : value
           end
         end
       end

data/lib/rails/graphql/type/scalar/int_scalar.rb

@@ -1,8 +1,8 @@
 # frozen_string_literal: true
 
-module Rails # :nodoc:
-  module GraphQL # :nodoc:
-    class Type # :nodoc:
+module Rails
+  module GraphQL
+    class Type
       # The Int scalar type represents a signed 32-bit numeric
       # non-fractional value.
       #
@@ -11,14 +11,15 @@ module Rails # :nodoc:
         self.spec_object = true
         aliases :integer
 
-        desc 'The Int scalar type represents a signed 32‐bit numeric non‐fractional value.'
+        desc 'The Int scalar type represents a signed 32-bit numeric non-fractional value.'
 
         max_value = (1 << 31)
         RANGE = (-max_value...max_value).freeze
 
         class << self
           def valid_input?(value)
-            value.is_a?(Integer) && RANGE.cover?(value)
+            (valid_token?(value) && RANGE.cover?(value.to_i)) ||
+              (value.is_a?(Integer) && RANGE.cover?(value))
           end
 
           def valid_output?(value)

data/lib/rails/graphql/type/scalar/json_scalar.rb

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+module Rails
+  module GraphQL
+    class Type
+      # Handles an unstructured JSON data
+      class Scalar::JsonScalar < Scalar
+        rename! 'JSON'
+
+        desc <<~DESC
+          The JSON scalar type represents an unstructured JSON data
+          with all its available keys and values.
+        DESC
+
+        use :specified_by, url: 'https://www.rfc-editor.org/rfc/rfc8259'
+
+        class << self
+          def valid_input?(value)
+            valid_token?(value, :hash) || value.is_a?(::Hash)
+          end
+
+          def valid_output?(value)
+            value.is_a?(::Hash)
+          end
+
+          def to_json(value)
+            value.to_json
+          end
+
+          def as_json(value)
+            value.as_json
+          end
+
+          def deserialize(value)
+            value.is_a?(::GQLParser::Token) ? JSON.parse(value) : value
+          end
+        end
+      end
+    end
+  end
+end

data/lib/rails/graphql/type/scalar/string_scalar.rb

@@ -1,8 +1,8 @@
 # frozen_string_literal: true
 
-module Rails # :nodoc:
-  module GraphQL # :nodoc:
-    class Type # :nodoc:
+module Rails
+  module GraphQL
+    class Type
       # The String scalar type represents textual data, represented as UTF-8
       # character sequences.
       #
@@ -11,16 +11,30 @@ module Rails # :nodoc:
         self.spec_object = true
 
         desc <<~DESC
-          The String scalar type represents textual data, represented as UTF‐8 character
+          The String scalar type represents textual data, represented as UTF-8 character
           sequences.
         DESC
 
         class << self
+          def valid_input?(value)
+            super || valid_token?(value, :heredoc)
+          end
+
           def as_json(value)
             value = value.to_s unless value.is_a?(String)
             value = value.encode(Encoding::UTF_8) unless value.encoding.eql?(Encoding::UTF_8)
             value
           end
+
+          def deserialize(value)
+            if valid_token?(value, :string)
+              value[1..-2] # Remove the quotes
+            elsif valid_token?(value, :heredoc)
+              value[3..-4].strip_heredoc # Remove the quotes and fix indentation
+            else
+              value
+            end
+          end
         end
       end
     end

data/lib/rails/graphql/type/scalar/time_scalar.rb

@@ -1,8 +1,8 @@
 # frozen_string_literal: true
 
-module Rails # :nodoc:
-  module GraphQL # :nodoc:
-    class Type # :nodoc:
+module Rails
+  module GraphQL
+    class Type
       # Uses as a float extension in order to transmit times (hours, minutes,
       # and seconds) as a numeric representation of seconds and milliseconds.
       class Scalar::TimeScalar < Scalar::FloatScalar
@@ -10,12 +10,14 @@ module Rails # :nodoc:
 
         desc <<~MSG
           The Time scalar type that represents a distance in time using hours,
-          minutes, seconds, and miliseconds.
+          minutes, seconds, and milliseconds.
         MSG
 
+        use :specified_by, url: 'https://www.rfc-editor.org/rfc/rfc3339'
+
         # A +base_object+ helps to identify what methods are actually available
         # to work as resolvers
-        class_attribute :precision, instance_writer: false, default: 6
+        class_attribute :precision, instance_accessor: false, default: 6
 
         class << self
           def valid_input?(value)
@@ -31,7 +33,7 @@ module Rails # :nodoc:
           end
 
           def deserialize(value)
-            "#{EPOCH.to_date.iso8601} #{value} UTC".to_time
+            (+"#{EPOCH.to_date.iso8601} #{value} UTC").to_time
           end
         end
       end

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

@@ -1,8 +1,8 @@
 # frozen_string_literal: true
 
-module Rails # :nodoc:
-  module GraphQL # :nodoc:
-    class Type # :nodoc:
+module Rails
+  module GraphQL
+    class Type
       # = GraphQL ScalarType
       #
       # Scalar types represent primitive leaf values in a GraphQL type system.
@@ -18,27 +18,27 @@ module Rails # :nodoc:
 
         setup! leaf: true, input: true, output: true
 
-        eager_autoload do
-          # Load all the default scalar types
-          autoload :IntScalar
-          autoload :FloatScalar
-          autoload :StringScalar
-          autoload :BooleanScalar
-          autoload :IdScalar
+        # Load all the default scalar types
+        autoload :IntScalar
+        autoload :FloatScalar
+        autoload :StringScalar
+        autoload :BooleanScalar
+        autoload :IdScalar
 
-          # Load all additional scalar types
-          autoload :BigintScalar
-          autoload :BinaryScalar
-          autoload :DateScalar
-          autoload :DateTimeScalar
-          autoload :DecimalScalar
-          autoload :TimeScalar
-        end
+        # Load all additional scalar types
+        autoload :AnyScalar
+        autoload :BigintScalar
+        autoload :BinaryScalar
+        autoload :DateScalar
+        autoload :DateTimeScalar
+        autoload :DecimalScalar
+        autoload :JsonScalar
+        autoload :TimeScalar
 
         class << self
           # Check if a given value is a valid non-deserialized input
           def valid_input?(value)
-            value.is_a?(String)
+            valid_token?(value) || value.is_a?(String)
           end
 
           # Check if a given value is a valid non-serialized output
@@ -56,13 +56,16 @@ module Rails # :nodoc:
             value.to_s
           end
 
-          # Turn a user input of this given type into an ruby object
+          # Turn a user input of this given type into a Ruby object
           def deserialize(value)
-            value
+            value.is_a?(::GQLParser::Token) ? as_json(value) : value
           end
 
-          def inspect # :nodoc:
-            "#<GraphQL::Scalar #{gql_name}>"
+          def inspect
+            return super if self.eql?(Type::Scalar)
+            directives = inspect_directives
+            directives.prepend(' ') if directives.present?
+            +"#<GraphQL::Scalar #{gql_name}#{directives}>"
           end
         end
       end

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

@@ -1,29 +1,30 @@
 # frozen_string_literal: true
 
-module Rails # :nodoc:
-  module GraphQL # :nodoc:
-    class Type # :nodoc:
+module Rails
+  module GraphQL
+    class Type
       # = GraphQL UnionType
       #
       # Unions represent an object that could be one of a list of GraphQL
       # Object types.
       # See http://spec.graphql.org/June2018/#UnionTypeDefinition
       class Union < Type
+        include Helpers::Instantiable
+
         setup! output: true
 
         # The list of accepted classes for members
         VALID_MEMBER_TYPES = [Type::Object].freeze
 
         # Define the methods for accessing the members attribute
-        inherited_collection :members
-
-        # 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
+        inherited_collection :members, instance_reader: false
 
         class << self
+          # Figure out which one of the members is compatible with the provided +value+
+          def type_for(value, *)
+            all_members&.reverse_each&.find { |t| t.valid_member?(value) }
+          end
+
           # Return the base type of the objects on this union
           def of_kind
             members.first.base_type
@@ -45,13 +46,13 @@ module Rails # :nodoc:
               GraphQL.type_map.fetch(item, namespaces: namespaces)
             end
 
-            checker = others.lazy.map { |item| item.try(:base_type) }.uniq.force
-            raise ArgumentError, <<~MSG.squish unless checker.size === 1
+            checker = others.map { |item| item.try(:base_type) }.uniq
+            raise ArgumentError, (+<<~MSG).squish unless checker.size === 1
               All the union members must be of the same base class.
             MSG
 
-            check_types = members? ? [members.first.base_type] : VALID_MEMBER_TYPES
-            raise ArgumentError, <<~MSG.squish unless (check_types & checker).size === 1
+            check_types = members? ? [of_kind] : VALID_MEMBER_TYPES
+            raise ArgumentError, (+<<~MSG).squish unless (check_types & checker).size === 1
               A union cannot contain members of different base classes.
             MSG
 
@@ -63,21 +64,23 @@ module Rails # :nodoc:
             super if defined? super
 
             members = all_members
-            raise ArgumentError, <<~MSG.squish unless members.size >= 1
+            raise ArgumentError, (+<<~MSG).squish unless members.size >= 1
               A union must contain at least one member.
             MSG
 
             size = members.lazy.map(&:base_type).uniq.force.size
-            raise ArgumentError, <<~MSG.squish unless size.eql?(1)
+            raise ArgumentError, (+<<~MSG).squish unless size.eql?(1)
               All the members of the union must contain the same base class.
             MSG
           end
 
-          def inspect # :nodoc:
-            <<~INFO.squish + '>'
+          def inspect
+            return super if self.eql?(Type::Union)
+            (+<<~INFO).squish << '>'
               #<GraphQL::Union #{gql_name}
               (#{all_members.size})
               {#{all_members.map(&:gql_name).join(' | ')}}
+              #{inspect_directives}
             INFO
           end
         end