rails-graphql 0.2.1 → 1.0.0.rc1

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_reader :args, :assignment_error
         attr_writer :resource
 
         delegate :fields, to: :class
-        delegate :[], to: :args
+        delegate :to_h, :[], to: :args
 
         delegate_missing_to :resource
 
@@ -91,7 +124,10 @@ module Rails # :nodoc:
         # received arguments. It also accepts extra arguments for inheritance
         # purposes
         def resource(*args, **xargs, &block)
-          @resource ||= (klass = safe_assigned_class).nil? ? nil : begin
+          return @resource if defined?(@resource)
+          return if (klass = safe_assigned_class).nil?
+
+          @resource = begin
             xargs = xargs.reverse_merge(params)
             klass.new(*args, **xargs, &block)
           end
@@ -102,6 +138,22 @@ module Rails # :nodoc:
           parametrize(self)
         end
 
+        # Correctly 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
+
+        alias as_json args_as_json
+
+        # Correctly 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
+
+        alias to_json args_to_json
+
         # Checks if all the values provided to the input instance are valid
         def validate!(*)
           errors = []
@@ -112,11 +164,26 @@ 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
 
+        # Override this method to save any errors that could happen with loading
+        # the assigned class
+        def safe_assigned_class
+          assigned_class
+        rescue ::ArgumentError, ::NameError => error
+          @assignment_error = error
+          nil
+        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,28 +16,19 @@ 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)
+          # Figure out which one of the types is compatible with the provided +value+
+          def type_for(value, *)
+            all_types&.reverse_each&.find { |t| t.valid_member?(value) }
           end
 
           # Check if the other type is equivalent, by checking if the other is
@@ -49,25 +40,35 @@ module Rails # :nodoc:
           # 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)
+          def implemented(object, import_fields: true)
+            import_fields = false if abstract?
+
             fields.each do |name, field|
-              defined = object.field?(name)
-              invalid = defined && object.fields[name] !~ field
-              raise ArgumentError, <<~MSG.squish if invalid
+              defined = object[field.name]
+              raise ArgumentError, (+<<~MSG).squish unless defined || import_fields
+                The "#{object.gql_name}" object must have a "#{field.gql_name}" field.
+              MSG
+
+              invalid = defined && defined !~ 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
+              object.proxy_field(field) if import_fields && !defined
             end
 
             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,19 +14,20 @@ 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.
         DESC
 
-        field :name,        :string,               null: false, method_name: :gql_name
-        field :description, :string
-        field :locations,   '__DirectiveLocation', full: true
-        field :args,        '__InputValue',        full: true
+        field :name,          :string,               null: false, method_name: :gql_name
+        field :description,   :string
+        field :locations,     '__DirectiveLocation', full: true
+        field :args,          '__InputValue',        full: true
+        field :is_repeatable, :boolean,              null: false, method_name: :repeatable?
 
         def args
-          all_arguments.values
+          all_arguments.each_value
         end
       end
     end

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'
@@ -17,10 +17,9 @@ module Rails # :nodoc:
         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.
+          Arguments provided to Fields or Directives and the input fields of an
+          InputObject are represented as Input Values which describe their type
+          and optionally a default value.
         DESC
 
         field :name,          :string,  null: false, method_name: :gql_name

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

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

@@ -1,24 +1,30 @@
 # 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,
             kind_enum: 'LIST',
             name: 'List',
+            gql_name: nil,
             object?: true,
             description: nil,
+            of_type: nil,
           },
           non_null: {
             kind: :non_null,
             kind_enum: 'NON_NULL',
             name: 'Non-Null',
+            gql_name: nil,
             object?: true,
             description: nil,
+            of_type: nil,
           },
         }.freeze
 
@@ -30,7 +36,7 @@ module Rails # :nodoc:
         end
 
         def self.fake_type_object(type, subtype)
-          OpenStruct.new(**FAKE_TYPES[type].merge(of_type: subtype))
+          FAKE_TYPES[type].merge(of_type: subtype)
         end
 
         rename! '__Type'
@@ -57,13 +63,15 @@ module Rails # :nodoc:
           the schema to define exactly what data is expected.
         DESC
 
-        field :kind,           '__TypeKind',   null: false,
+        field :kind,             '__TypeKind',   null: false,
           method_name: :kind_enum
 
-        field :name,           :string,
+        field :name,             :string,
           method_name: :gql_name
 
-        field :description,    :string
+        field :description,      :string
+
+        field :specified_by_url, :string
 
         field :fields,         '__Field',      array: true, nullable: false do
           desc 'OBJECT and INTERFACE only'
@@ -87,48 +95,77 @@ module Rails # :nodoc:
         field :of_type,        '__Type',
           desc: 'NON_NULL and LIST only'
 
+        def specified_by_url
+          return if fake_type? || !current.scalar?
+
+          current.all_directives&.find do |dir|
+            dir.is_a?(Directive::SpecifiedByDirective)
+          end&.args&.url
+        end
+
         def fields(include_deprecated:)
-          return [] unless current.object? || current.interface?
+          return if fake_type? || !(current.object? || current.interface?)
+
+          list =
+            if current.respond_to?(:enabled_fields)
+              current.enabled_fields
+            else
+              current.fields.values.select(&:enabled?)
+            end
 
-          list = current.fields.enum_for(:each_value)
-          list = list.reject { |field| field.using?(deprecated_directive) } \
-            unless include_deprecated
+          unless include_deprecated
+            list = list.reject { |field| field.using?(deprecated_directive) }
+          end
 
-          list
+          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 if fake_type? || !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.try(:[], 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 || []
+          return if fake_type? || !current.object?
+          current.all_interfaces || EMPTY_ARRAY
         end
 
         def possible_types
-          return all_types if current.interface?
-          current.union? ? all_members : []
+          return if fake_type?
+
+          if current.interface?
+            current.all_types || EMPTY_ARRAY
+          elsif current.union?
+            current.all_members || EMPTY_ARRAY
+          end
         end
 
         def input_fields
-          current.input? ? current.fields.enum_for(:each_value) : []
+          return if fake_type? || !current.input?
+          current.enabled_fields || EMPTY_ARRAY
+        end
+
+        private
+
+        def fake_type?
+          Hash === current
         end
       end
     end