rails-graphql 0.2.1 → 1.0.0.beta

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

@@ -1,10 +1,12 @@
 # frozen_string_literal: true
 
-module Rails # :nodoc:
-  module GraphQL # :nodoc:
-    class Type # :nodoc:
+module Rails
+  module GraphQL
+    class Type
       # The introspection object for any kind of type
       class Object::TypeObject < Object
+        # List and not null are not actually types, but they still need to
+        # some how exist for introspection purposes
         FAKE_TYPES = {
           list: {
             kind: :list,
@@ -88,47 +90,55 @@ module Rails # :nodoc:
           desc: 'NON_NULL and LIST only'
 
         def fields(include_deprecated:)
-          return [] unless current.object? || current.interface?
+          return EMPTY_ARRAY unless current.object? || current.interface?
 
-          list = current.fields.enum_for(:each_value)
-          list = list.reject { |field| field.using?(deprecated_directive) } \
-            unless include_deprecated
+          list =
+            if current.respond_to?(:enabled_fields)
+              current.enabled_fields
+            else
+              current.fields.values.select(&:enabled?)
+            end
 
-          list
+          unless include_deprecated
+            list = list.reject { |field| field.using?(deprecated_directive) }
+          end
+
+          list.reject(&:internal?).sort_by do |field|
+            (field.name == :id) ? '' : field.gql_name
+          end
         end
 
         def enum_values(include_deprecated:)
-          return [] unless current.enum?
+          return EMPTY_ARRAY unless current.enum?
 
-          descs = all_value_description
+          descriptions = all_value_description
           deprecated = all_deprecated_values
 
           list = all_values.lazy
           list = list.reject { |value| deprecated.key?(value) } \
-            unless include_deprecated
+            unless include_deprecated || deprecated.nil?
 
           list.map do |value|
             OpenStruct.new(
               name: value,
-              description: descs[value],
-              is_deprecated: deprecated.key?(value),
-              deprecation_reason: deprecated[value],
+              description: descriptions[value],
+              is_deprecated: (deprecated.nil? ? false : deprecated.key?(value)),
+              deprecation_reason: deprecated.try(:[], value),
             )
           end
         end
 
         def interfaces
-          return [] unless current.object?
-          current.all_interfaces || []
+          (current.object? && current.all_interfaces) || EMPTY_ARRAY
         end
 
         def possible_types
-          return all_types if current.interface?
-          current.union? ? all_members : []
+          (current.interface? && current.all_types) ||
+            (current.union? && current.all_members) || EMPTY_ARRAY
         end
 
         def input_fields
-          current.input? ? current.fields.enum_for(:each_value) : []
+          (current.input? && current.enabled_fields) || EMPTY_ARRAY
         end
       end
     end

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,30 +26,22 @@ 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)
+            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
 
@@ -61,14 +55,13 @@ module Rails # :nodoc:
           def implements(*others)
             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)
               interfaces << item
-              cache << item
             end
           end
 
@@ -77,6 +70,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 +97,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.
       #

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,8 +1,8 @@
 # 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.'

data/lib/rails/graphql/type/scalar/date_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
       # DateTime uses a ISO 8601 string to exchange the value.
       class Scalar::DateTimeScalar < Scalar
         aliases :datetime

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.

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,39 @@
+# 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 kyes and values.
+        DESC
+
+        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
@@ -15,7 +15,7 @@ module Rails # :nodoc:
 
         # 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 +31,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
@@ -58,11 +58,14 @@ module Rails # :nodoc:
 
           # Turn a user input of this given type into an 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