rails-graphql 0.2.1 → 1.0.0.beta

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

@@ -1,8 +1,8 @@
 # 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 Enum::DirectiveLocationEnum < Enum
@@ -12,17 +12,17 @@ module Rails # :nodoc:
 
         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.")
+        Directive::EXECUTION_LOCATIONS.each do |value|
+          name = value.to_s.upcase
+          desc = value.to_s.tr('_', ' ')
+          add(name, 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('_', ' ')
+        Directive::DEFINITION_LOCATIONS.each do |value|
+          name = value.to_s.upcase
+          desc = value.to_s.tr('_', ' ')
           desc = "Mark as a type system directive usable on #{desc} definitions."
-          add(value, desc: desc.gsub(/definition definitions\.$/, 'definitions.'))
+          add(name, desc: desc.sub('definition definitions.', 'definitions.'))
         end
       end
     end

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

@@ -1,8 +1,8 @@
 # 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 Enum::TypeKindEnum < Enum

data/lib/rails/graphql/type/enum.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 EnumType
       #
       # Enum types, like scalar types, also represent leaf values in a GraphQL
@@ -13,10 +13,8 @@ module Rails # :nodoc:
 
         setup! leaf: true, input: true, output: true
 
-        eager_autoload do
-          autoload :DirectiveLocationEnum
-          autoload :TypeKindEnum
-        end
+        autoload :DirectiveLocationEnum
+        autoload :TypeKindEnum
 
         # Define the methods for accessing the values attribute
         inherited_collection :values
@@ -25,7 +23,7 @@ module Rails # :nodoc:
         inherited_collection :value_description, type: :hash
 
         # Define the methods for accessing the directives of each enum value
-        inherited_collection :value_directives, type: :hash
+        inherited_collection :value_directives, type: :hash_set
 
         class << self
           # Mark the enum as indexed, allowing values being set by number
@@ -40,7 +38,8 @@ module Rails # :nodoc:
 
           # Check if a given value is a valid non-deserialized input
           def valid_input?(value)
-            value.is_a?(String) && all_values.include?(value)
+            (valid_token?(value, :enum) && all_values.include?(value.to_s)) ||
+              (value.is_a?(String) && all_values.include?(value))
           end
 
           # Check if a given value is a valid non-serialized output
@@ -63,7 +62,7 @@ module Rails # :nodoc:
 
           # Turn a user input of this given type into an ruby object
           def deserialize(value)
-            new(value) if valid_input?(value)
+            new(value.is_a?(::GQLParser::Token) ? value.to_s : value) if valid_input?(value)
           end
 
           # Use the instance as decorator
@@ -84,17 +83,18 @@ module Rails # :nodoc:
           #   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?
+            value = value&.to_s
+            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)
+            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(
+            directives = ::Array.wrap(directives)
+            directives << Directive::DeprecatedDirective.new(
               reason: (deprecated.is_a?(String) ? deprecated : nil),
             ) if deprecated.present?
 
@@ -105,47 +105,38 @@ module Rails # :nodoc:
 
             values << value
             value_description[value] = desc unless desc.nil?
-            value_directives[value] = directives
+            value_directives[value] = directives if directives
           end
 
           # Check if a given +value+ is using a +directive+
           def value_using?(value, directive)
-            raise ArgumentError, <<~MSG.squish unless directive < GraphQL::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) }
+            all_value_directives.try(:[], as_json(value))&.any?(directive) || false
           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
+              all_value_directives&.each&.with_object({}) do |(value, dirs), hash|
+                obj = dirs&.find { |dir| dir.is_a?(Directive::DeprecatedDirective) }
+                hash[value] = obj.args.reason || true unless obj.nil?
               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 + '>'
+          def inspect
+            return super if self.eql?(Type::Enum)
+            (+<<~INFO).squish << '>'
               #<GraphQL::Enum #{gql_name}
               (#{all_values.size})
               {#{all_values.to_a.join(' | ')}}
+              #{inspect_directives}
             INFO
           end
-
-          private
-
-            def deprecated_klass
-              Directive::DeprecatedDirective
-            end
         end
 
         attr_reader :value
@@ -163,7 +154,7 @@ module Rails # :nodoc:
 
         # Allow finding the indexed position of the value
         def to_i
-          self.class.all_values.find_index(@value)
+          values.find_index(@value)
         end
 
         # Checks if the current value is valid
@@ -173,33 +164,28 @@ module Rails # :nodoc:
 
         # Gets all the description of the current value
         def description
-          @description ||= @value && self.class.all_value_description[@value]
+          return unless @value
+          @description ||= all_value_description.try(:[], @value)
         end
 
         # Gets all the directives associated with the current value
         def directives
-          @directives ||= @value && self.class.all_value_directives[@value]
+          return unless @value
+          @directives ||= all_value_directives.try(:[], @value)
         end
 
         # Checks if the current value is marked as deprecated
         def deprecated?
-          self.class.all_deprecated_values.include?(@value)
+          directives&.any?(Directive::DeprecatedDirective) || false
         end
 
         # Return the deprecated reason
         def deprecated_reason
-          deprecated_directive&.args&.reason
+          return unless deprecated?
+          directives.find do |dir|
+            dir.is_a?(Directive::DeprecatedDirective)
+          end.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

data/lib/rails/graphql/type/input.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 InputType
       #
       # Input defines a set of input fields; the input fields are either
@@ -34,49 +34,82 @@ module Rails # :nodoc:
             @gql_name = result
           end
 
+          # Transforms the given value to its representation in a JSON string
+          def as_json(value)
+            parse_arguments(value, using: :as_json, key: :gql_name)
+          end
+
+          # Transforms the given value to its representation in a Hash object
+          def to_json(value)
+            as_json(value).to_json
+          end
+
           # Check if a given value is a valid non-deserialized input
           def valid_input?(value)
+            value = GraphQL.config.literal_input_parser.call(value) \
+              if valid_token?(value, :hash)
+
             value = value.to_h if value.respond_to?(:to_h)
-            return false unless value.is_a?(Hash)
+            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)
+            return false unless value.size.eql?(fields&.count || 0)
 
-            fields.all? { |item| item.valid_input?(value[item.gql_name]) }
+            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))
+          # Turn the given value into an instance of the input object
+          def deserialize(value = nil, **value_as_hash)
+            value = value_as_hash if value.nil?
+            new(OpenStruct.new(parse_arguments(value, using: :deserialize)))
           end
 
+          alias build deserialize
+
           # 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
+            return {} unless fields?
+            enabled_fields.each.with_object({}) do |field, hash|
+              hash[field.gql_name] = field.default
+            end
           end
 
-          def inspect # :nodoc:
-            args = fields.each_value.map(&:inspect)
-            args = args.presence && "(#{args.join(', ')})"
-            "#<GraphQL::Input #{gql_name}#{args}>"
+          def inspect
+            return super if self.eql?(Type::Input)
+            args = fields.values.map(&:inspect)
+            args = args.presence && +"(#{args.join(', ')})"
+
+            directives = inspect_directives
+            directives.prepend(' ') if directives.present?
+            +"#<GraphQL::Input #{gql_name}#{args}#{directives}>"
           end
+
+          private
+
+            def parse_arguments(value, using:, key: :name)
+              value = GraphQL.config.literal_input_parser.call(value) \
+                if valid_token?(value, :hash)
+
+              value = value.to_h if value.respond_to?(:to_h)
+              value = {} unless value.is_a?(::Hash)
+              value = value.stringify_keys
+
+              enabled_fields.each.with_object({}) do |field, hash|
+                next unless value.key?(field.gql_name) || value.key?(field.name.to_s)
+                result = value[field.gql_name] || value[field.name.to_s]
+                hash[field.public_send(key)] = field.public_send(using, result)
+              end.compact
+            end
         end
 
         attr_reader :args
         attr_writer :resource
 
         delegate :fields, to: :class
-        delegate :[], to: :args
+        delegate :to_h, :[], to: :args
 
         delegate_missing_to :resource
 
@@ -102,6 +135,18 @@ module Rails # :nodoc:
           parametrize(self)
         end
 
+        # Corretly turn all the arguments into their +as_json+ version and
+        # return a hash of them
+        def args_as_json
+          self.class.as_json(@args.to_h)
+        end
+
+        # Corretly turn all the arguments into their +to_json+ version and
+        # return a hash of them
+        def args_to_json
+          self.class.to_json(@args.to_h)
+        end
+
         # Checks if all the values provided to the input instance are valid
         def validate!(*)
           errors = []
@@ -112,11 +157,17 @@ module Rails # :nodoc:
           end
 
           return if errors.empty?
-          raise InvalidValueError, <<~MSG.squish
+          raise InvalidValueError, (+<<~MSG).squish
             Invalid value provided to #{gql_name} field: #{errors.to_sentence}.
           MSG
         end
 
+        %i[to_global_id to_gid to_gid_param].each do |method_name|
+          define_method(method_name) do
+            self.class.public_send(method_name, args_as_json.compact)
+          end
+        end
+
         private
 
           # Make sure to turn inputs into params

data/lib/rails/graphql/type/interface.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 InterfaceType
       #
       # Interfaces represent a list of named fields and their types.
@@ -16,30 +16,16 @@ module Rails # :nodoc:
         extend Helpers::WithAssignment
         extend Helpers::WithFields
 
+        include Helpers::Instantiable
+
         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
+        # Define the methods for accessing the types attribute
+        inherited_collection :types, instance_reader: false
 
         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)
@@ -53,7 +39,7 @@ module Rails # :nodoc:
             fields.each do |name, field|
               defined = object.field?(name)
               invalid = defined && object.fields[name] !~ field
-              raise ArgumentError, <<~MSG.squish if invalid
+              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
@@ -64,10 +50,14 @@ module Rails # :nodoc:
             types << object
           end
 
-          def inspect # :nodoc:
-            fields = @fields.values.map(&:inspect)
-            fields = fields.presence && " {#{fields.join(', ')}}"
-            "#<GraphQL::Interface #{gql_name}#{fields}>"
+          def inspect
+            return super if self.eql?(Type::Interface)
+            fields = @fields.values.map(&:inspect) if defined?(@fields)
+            fields = fields.presence && +" {#{fields.join(', ')}}"
+
+            directives = inspect_directives
+            directives.prepend(' ') if directives.present?
+            +"#<GraphQL::Interface #{gql_name}#{fields}#{directives}>"
           end
 
           # Check if the given object is properly implementing this interface

data/lib/rails/graphql/type/object/directive_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
       # The introspection object for directives
       class Object::DirectiveObject < Object
         self.assigned_to = 'Rails::GraphQL::Directive'
@@ -14,7 +14,7 @@ module Rails # :nodoc:
           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
+          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.

data/lib/rails/graphql/type/object/enum_value_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
       # The introspection object for an enum value
       class Object::EnumValueObject < Object
         self.spec_object = true

data/lib/rails/graphql/type/object/field_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
       # The introspection object for a field on objects and interfaces
       class Object::FieldObject < Object
         self.assigned_to = 'Rails::GraphQL::Field'
@@ -25,6 +25,14 @@ module Rails # :nodoc:
         field :is_deprecated,      :boolean,       null: false, method_name: :deprecated?
         field :deprecation_reason, :string
 
+        def description
+          if current.method(:description).arity == 0
+            current.description
+          else
+            current.description(schema.namespace)
+          end
+        end
+
         def build_type
           result = current.type_klass
 
@@ -38,16 +46,26 @@ module Rails # :nodoc:
         end
 
         def args
-          all_arguments.values
+          all_arguments&.values || EMPTY_ARRAY
         end
 
         def deprecated?
-          current.using?(deprecated_directive)
+          !deprecated_instance.nil?
         end
 
         def deprecation_reason
-          current.all_directives.find { |item| item.is_a?(deprecated_directive) }&.args&.reason
+          deprecated_instance&.args&.reason
         end
+
+        private
+
+          def deprecated_instance
+            current.all_directives&.reverse_each do |item|
+              return item if item.class <= deprecated_directive
+            end
+
+            nil
+          end
       end
     end
   end

data/lib/rails/graphql/type/object/input_value_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
       # The introspection object for a input object
       class Object::InputValueObject < Object
         self.assigned_to = 'Rails::GraphQL::Field::InputField'

data/lib/rails/graphql/type/object/schema_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
       # The introspection object for a schema object
       class Object::SchemaObject < Object
         self.assigned_to = 'Rails::GraphQL::Schema'
@@ -11,8 +11,8 @@ module Rails # :nodoc:
         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
+          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.
@@ -24,14 +24,11 @@ module Rails # :nodoc:
         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