graphql 1.10.9 → 1.10.14

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: faf92321ef690867c10449792e3ac7a512b6c70a8cb98c4abe55701dbab68b5c
-  data.tar.gz: c0d7c15c4f74ec0dff027d1e1dbc102d8e0a99973e7d856e2ccb0dfb90dcf9cb
+  metadata.gz: e1d76918804bdeeba0c80bbcfcdde70d04132110aee8e4520dcba8480da390fc
+  data.tar.gz: c0e1954ae3f6d18bf03fc33807b94d482b83b4e4a6f8a392452e2f6e8297f241
 SHA512:
-  metadata.gz: '0380579063581e40b9c94c64e7c040c0e654e36608ec20079a6d53e34015e8f7aac7a1f4a718c6c9f2200ee0f4a5ce0a1226cf5c1c838aafebb82d1819ca4bb5'
-  data.tar.gz: 98a72e31dee880098191b2ad6e3fec2cacc459ee17d4a8e5dab380dd5bd9c2d08c7aa31b6164cce23999c557a78de02f7d0a2f3eb3e5a0ff007b46f032be3fea
+  metadata.gz: 3e945033f8657c252fcd99a18d4be5c9d267535753e88a94f3b589c968ca186e90f3368768ff2f3f7c7e1eff7a210bf57694bde763255ee0a91f1e46534b0b4d
+  data.tar.gz: de56338439eeb22b8484033c5acfb4ac027edee60ac30218c8a7516c5bc6d4bfa07b8be54ebd42a63fca5decdfbbcf85e4b96832bb8d7fcd304dc2fb98bc7625

data/lib/generators/graphql/object_generator.rb

@@ -15,20 +15,62 @@ module Graphql
       desc "Create a GraphQL::ObjectType with the given name and fields"
       source_root File.expand_path('../templates', __FILE__)
 
-      argument :fields,
-        type: :array,
-        default: [],
-        banner: "name:type name:type ...",
-        desc: "Fields for this object (type may be expressed as Ruby or GraphQL)"
+      argument :custom_fields,
+               type: :array,
+               default: [],
+               banner: "name:type name:type ...",
+               desc: "Fields for this object (type may be expressed as Ruby or GraphQL)"
 
       class_option :node,
-        type: :boolean,
-        default: false,
-        desc: "Include the Relay Node interface"
+                   type: :boolean,
+                   default: false,
+                   desc: "Include the Relay Node interface"
 
       def create_type_file
         template "object.erb", "#{options[:directory]}/types/#{type_file_name}.rb"
       end
+
+      def fields
+        columns = []
+        columns += klass.columns.map { |c| generate_column_string(c) } if class_exists?
+        columns + custom_fields
+      end
+
+      def self.normalize_type_expression(type_expression, mode:, null: true)
+        case type_expression
+        when "Text"
+          ["String", null]
+        when "DateTime", "Datetime"
+          ["GraphQL::Types::ISO8601DateTime", null]
+        when "Date"
+          ["GraphQL::Types::ISO8601Date", null]
+        else
+          super
+        end
+      end
+
+      private
+
+      def generate_column_string(column)
+        name = column.name
+        required = column.null ? "" : "!"
+        type = column_type_string(column)
+        "#{name}:#{required}#{type}"
+      end
+
+      def column_type_string(column)
+        column.name == "id" ? "ID" : column.type.to_s.camelize
+      end
+
+      def class_exists?
+        klass.is_a?(Class) && klass.ancestors.include?(ActiveRecord::Base)
+      rescue NameError
+        return false
+      end
+
+      def klass
+        @klass ||= Module.const_get(type_name.camelize)
+      end
     end
   end
 end

data/lib/graphql.rb

@@ -95,6 +95,9 @@ require "graphql/schema"
 require "graphql/query"
 require "graphql/directive"
 require "graphql/execution"
+require "graphql/runtime_type_error"
+require "graphql/unresolved_type_error"
+require "graphql/invalid_null_error"
 require "graphql/types"
 require "graphql/relay"
 require "graphql/boolean_type"
@@ -109,10 +112,7 @@ require "graphql/introspection"
 
 require "graphql/analysis_error"
 require "graphql/coercion_error"
-require "graphql/runtime_type_error"
-require "graphql/invalid_null_error"
 require "graphql/invalid_name_error"
-require "graphql/unresolved_type_error"
 require "graphql/integer_encoding_error"
 require "graphql/string_encoding_error"
 require "graphql/internal_representation"

data/lib/graphql/directive.rb

@@ -99,6 +99,10 @@ module GraphQL
     def type_class
       metadata[:type_class]
     end
+
+    def get_argument(argument_name)
+      arguments[argument_name]
+    end
   end
 end
 

data/lib/graphql/execution/instrumentation.rb

@@ -77,7 +77,7 @@ module GraphQL
         end
 
         def call_after_hooks(instrumenters, object, after_hook_name, ex)
-          instrumenters.reverse.each do |instrumenter|
+          instrumenters.reverse_each do |instrumenter|
             begin
               instrumenter.public_send(after_hook_name, object)
             rescue => e

data/lib/graphql/execution/interpreter/arguments.rb

@@ -21,15 +21,11 @@ module GraphQL
           @argument_values = argument_values
         end
 
-        # Yields `ArgumentValue` instances which contain detailed metadata about each argument.
-        def each_value
-          argument_values.each { |arg_v| yield(arg_v) }
-        end
-
         # @return [Hash{Symbol => ArgumentValue}]
         attr_reader :argument_values
 
         def_delegators :@keyword_arguments, :key?, :[], :keys, :each, :values
+        def_delegators :@argument_values, :each_value
 
         def inspect
           "#<#{self.class} @keyword_arguments=#{keyword_arguments.inspect}>"

data/lib/graphql/execution/interpreter/runtime.rb

@@ -182,8 +182,6 @@ module GraphQL
 
               kwarg_arguments = resolved_arguments.keyword_arguments
 
-              # It might turn out that making arguments for every field is slow.
-              # If we have to cache them, we'll need a more subtle approach here.
               field_defn.extras.each do |extra|
                 case extra
                 when :ast_node
@@ -256,7 +254,7 @@ module GraphQL
         def continue_value(path, value, field, is_non_null, ast_node)
           if value.nil?
             if is_non_null
-              err = GraphQL::InvalidNullError.new(field.owner, field, value)
+              err = field.owner::InvalidNullError.new(field.owner, field, value)
               write_invalid_null_in_response(path, err)
             else
               write_in_response(path, nil)
@@ -306,18 +304,21 @@ module GraphQL
             write_in_response(path, r)
             r
           when "UNION", "INTERFACE"
-            resolved_type_or_lazy = resolve_type(type, value, path)
+            resolved_type_or_lazy, resolved_value = resolve_type(type, value, path)
+            resolved_value ||= value
+
             after_lazy(resolved_type_or_lazy, owner: type, path: path, scoped_context: context.scoped_context, field: field, owner_object: owner_object, arguments: arguments, trace: false) do |resolved_type|
               possible_types = query.possible_types(type)
 
               if !possible_types.include?(resolved_type)
                 parent_type = field.owner
-                type_error = GraphQL::UnresolvedTypeError.new(value, field, parent_type, resolved_type, possible_types)
+                err_class = type::UnresolvedTypeError
+                type_error = err_class.new(resolved_value, field, parent_type, resolved_type, possible_types)
                 schema.type_error(type_error, context)
                 write_in_response(path, nil)
                 nil
               else
-                continue_field(path, value, field, resolved_type, ast_node, next_selections, is_non_null, owner_object, arguments)
+                continue_field(path, resolved_value, field, resolved_type, ast_node, next_selections, is_non_null, owner_object, arguments)
               end
             end
           when "OBJECT"
@@ -459,7 +460,14 @@ module GraphQL
         end
 
         def arguments(graphql_object, arg_owner, ast_node)
-          query.arguments_for(ast_node, arg_owner, parent_object: graphql_object)
+          # Don't cache arguments if field extras or extensions are requested since they can mutate the argument data structure
+          if arg_owner.arguments_statically_coercible? &&
+              (!arg_owner.is_a?(GraphQL::Schema::Field) || (arg_owner.extras.empty? && arg_owner.extensions.empty?))
+            query.arguments_for(ast_node, arg_owner)
+          else
+            # The arguments must be prepared in the context of the given object
+            query.arguments_for(ast_node, arg_owner, parent_object: graphql_object)
+          end
         end
 
         def write_invalid_null_in_response(path, invalid_null_error)
@@ -499,23 +507,11 @@ module GraphQL
         # at previous parts of the response.
         # This hash matches the response
         def type_at(path)
-          t = @types_at_paths
-          path.each do |part|
-            t = t[part] || (raise("Invariant: #{part.inspect} not found in #{t}"))
-          end
-          t = t[:__type]
-          t
+          @types_at_paths.fetch(path)
         end
 
         def set_type_at_path(path, type)
-          types = @types_at_paths
-          path.each do |part|
-            types = types[part] ||= {}
-          end
-          # Use this magic key so that the hash contains:
-          # - string keys for nested fields
-          # - :__type for the object type of a selection
-          types[:__type] ||= type
+          @types_at_paths[path] = type
           nil
         end
 
@@ -545,7 +541,7 @@ module GraphQL
 
         def resolve_type(type, value, path)
           trace_payload = { context: context, type: type, object: value, path: path }
-          resolved_type = query.trace("resolve_type", trace_payload) do
+          resolved_type, resolved_value = query.trace("resolve_type", trace_payload) do
             query.resolve_type(type, value)
           end
 
@@ -556,7 +552,7 @@ module GraphQL
               end
             end
           else
-            resolved_type
+            [resolved_type, resolved_value]
           end
         end
 

data/lib/graphql/field.rb

@@ -207,6 +207,10 @@ module GraphQL
       metadata[:type_class]
     end
 
+    def get_argument(argument_name)
+      arguments[argument_name]
+    end
+
     private
 
     def build_default_resolver

data/lib/graphql/input_object_type.rb

@@ -58,6 +58,10 @@ module GraphQL
       result
     end
 
+    def get_argument(argument_name)
+      arguments[argument_name]
+    end
+
     private
 
     def coerce_non_null_input(value, ctx)

data/lib/graphql/object_type.rb

@@ -88,7 +88,7 @@ module GraphQL
       interfaces.each do |iface|
         iface = BaseType.resolve_related_type(iface)
         if iface.is_a?(GraphQL::InterfaceType)
-          type_memberships << iface.type_membership_class.new(iface, self, options)
+          type_memberships << iface.type_membership_class.new(iface, self, **options)
         end
       end
     end

data/lib/graphql/schema.rb

@@ -1389,7 +1389,7 @@ module GraphQL
       # rubocop:disable Lint/DuplicateMethods
       module ResolveTypeWithType
         def resolve_type(type, obj, ctx)
-          first_resolved_type = if type.is_a?(Module) && type.respond_to?(:resolve_type)
+          first_resolved_type, resolved_value = if type.is_a?(Module) && type.respond_to?(:resolve_type)
             type.resolve_type(obj, ctx)
           else
             super
@@ -1397,7 +1397,11 @@ module GraphQL
 
           after_lazy(first_resolved_type) do |resolved_type|
             if resolved_type.nil? || (resolved_type.is_a?(Module) && resolved_type.respond_to?(:kind)) || resolved_type.is_a?(GraphQL::BaseType)
-              resolved_type
+              if resolved_value
+                [resolved_type, resolved_value]
+              else
+                resolved_type
+              end
             else
               raise ".resolve_type should return a type definition, but got #{resolved_type.inspect} (#{resolved_type.class}) from `resolve_type(#{type}, #{obj}, #{ctx})`"
             end
@@ -1506,7 +1510,11 @@ module GraphQL
 
       # @return [GraphQL::Execution::Errors, Class<GraphQL::Execution::Errors::NullErrorHandler>]
       def error_handler
-        @error_handler ||= GraphQL::Execution::Errors::NullErrorHandler
+        if defined?(@error_handler)
+          @error_handler
+        else
+          find_inherited_value(:error_handler, GraphQL::Execution::Errors::NullErrorHandler)
+        end
       end
 
       def lazy_resolve(lazy_class, value_method)

data/lib/graphql/schema/argument.rb

@@ -154,6 +154,12 @@ module GraphQL
         raise ArgumentError, "Couldn't build type for Argument #{@owner.name}.#{name}: #{err.class.name}: #{err.message}", err.backtrace
       end
 
+      def statically_coercible?
+        return @statically_coercible if defined?(@statically_coercible)
+
+        @statically_coercible = !@prepare.is_a?(String) && !@prepare.is_a?(Symbol)
+      end
+
       # Apply the {prepare} configuration to `value`, using methods from `obj`.
       # Used by the runtime.
       # @api private

data/lib/graphql/schema/enum.rb

@@ -23,6 +23,9 @@ module GraphQL
       extend GraphQL::Schema::Member::AcceptsDefinition
       extend GraphQL::Schema::Member::ValidatesInput
 
+      class UnresolvedValueError < GraphQL::EnumType::UnresolvedValueError
+      end
+
       class << self
         # Define a value for this enum
         # @param graphql_name [String, Symbol] the GraphQL value for this, usually `SCREAMING_CASE`
@@ -94,7 +97,7 @@ module GraphQL
           if enum_value
             enum_value.graphql_name
           else
-            raise(GraphQL::EnumType::UnresolvedValueError, "Can't resolve enum #{graphql_name} for #{value.inspect}")
+            raise(self::UnresolvedValueError, "Can't resolve enum #{graphql_name} for #{value.inspect}")
           end
         end
 
@@ -112,6 +115,11 @@ module GraphQL
           end
         end
 
+        def inherited(child_class)
+          child_class.const_set(:UnresolvedValueError, Class.new(Schema::Enum::UnresolvedValueError))
+          super
+        end
+
         private
 
         def own_values

data/lib/graphql/schema/field.rb

@@ -556,34 +556,36 @@ module GraphQL
         begin
           # Unwrap the GraphQL object to get the application object.
           application_object = object.object
-          if self.authorized?(application_object, args, ctx)
-            # Apply field extensions
-            with_extensions(object, args, ctx) do |extended_obj, extended_args|
-              field_receiver = if @resolver_class
-                resolver_obj = if extended_obj.is_a?(GraphQL::Schema::Object)
-                  extended_obj.object
+          ctx.schema.after_lazy(self.authorized?(application_object, args, ctx)) do |is_authorized|
+            if is_authorized
+              # Apply field extensions
+              with_extensions(object, args, ctx) do |extended_obj, extended_args|
+                field_receiver = if @resolver_class
+                  resolver_obj = if extended_obj.is_a?(GraphQL::Schema::Object)
+                    extended_obj.object
+                  else
+                    extended_obj
+                  end
+                  @resolver_class.new(object: resolver_obj, context: ctx, field: self)
                 else
                   extended_obj
                 end
-                @resolver_class.new(object: resolver_obj, context: ctx, field: self)
-              else
-                extended_obj
-              end
 
-              if field_receiver.respond_to?(@resolver_method)
-                # Call the method with kwargs, if there are any
-                if extended_args.any?
-                  field_receiver.public_send(@resolver_method, **extended_args)
+                if field_receiver.respond_to?(@resolver_method)
+                  # Call the method with kwargs, if there are any
+                  if extended_args.any?
+                    field_receiver.public_send(@resolver_method, **extended_args)
+                  else
+                    field_receiver.public_send(@resolver_method)
+                  end
                 else
-                  field_receiver.public_send(@resolver_method)
+                  resolve_field_method(field_receiver, extended_args, ctx)
                 end
-              else
-                resolve_field_method(field_receiver, extended_args, ctx)
               end
+            else
+              err = GraphQL::UnauthorizedFieldError.new(object: application_object, type: object.class, context: ctx, field: self)
+              ctx.schema.unauthorized_field(err)
             end
-          else
-            err = GraphQL::UnauthorizedFieldError.new(object: application_object, type: object.class, context: ctx, field: self)
-            ctx.schema.unauthorized_field(err)
           end
         rescue GraphQL::UnauthorizedFieldError => err
           err.field ||= self
@@ -672,6 +674,8 @@ module GraphQL
                 else
                   load_application_object(arg_defn, loads, value, field_ctx.query.context)
                 end
+              elsif arg_defn.type.list? && value.is_a?(Array)
+                field_ctx.schema.after_any_lazies(value, &:itself)
               else
                 value
               end

data/lib/graphql/schema/input_object.rb

@@ -21,10 +21,8 @@ module GraphQL
           @ruby_style_hash = @arguments.to_kwargs
         end
         # Apply prepares, not great to have it duplicated here.
-        @arguments_by_keyword = {}
         maybe_lazies = []
-        self.class.arguments.each do |name, arg_defn|
-          @arguments_by_keyword[arg_defn.keyword] = arg_defn
+        self.class.arguments.each_value do |arg_defn|
           ruby_kwargs_key = arg_defn.keyword
 
           if @ruby_style_hash.key?(ruby_kwargs_key)
@@ -168,10 +166,7 @@ module GraphQL
             return result
           end
 
-          # We're not actually _using_ the coerced result, we're just
-          # using these methods to make sure that the object will
-          # behave like a hash below, when we call `each` on it.
-          begin
+          input = begin
             input.to_h
           rescue
             begin
@@ -184,21 +179,25 @@ module GraphQL
             end
           end
 
-          visible_arguments_map = warden.arguments(self).reduce({}) { |m, f| m[f.name] = f; m}
-
-          # Items in the input that are unexpected
-          input.each do |name, value|
-            if visible_arguments_map[name].nil?
-              result.add_problem("Field is not defined on #{self.graphql_name}", [name])
+          # Inject missing required arguments
+          missing_required_inputs = self.arguments.reduce({}) do |m, (argument_name, argument)|
+            if !input.key?(argument_name) && argument.type.non_null? && warden.get_argument(self, argument_name)
+              m[argument_name] = nil
             end
+
+            m
           end
 
-          # Items in the input that are expected, but have invalid values
-          visible_arguments_map.map do |name, argument|
-            argument_result = argument.type.validate_input(input[name], ctx)
-            if !argument_result.valid?
-              result.merge_result!(name, argument_result)
+          input.merge(missing_required_inputs).each do |argument_name, value|
+            argument = warden.get_argument(self, argument_name)
+            # Items in the input that are unexpected
+            unless argument
+              result.add_problem("Field is not defined on #{self.graphql_name}", [argument_name])
+              next
             end
+            # Items in the input that are expected, but have invalid values
+            argument_result = argument.type.validate_input(value, ctx)
+            result.merge_result!(argument_name, argument_result) unless argument_result.valid?
           end
 
           result

data/lib/graphql/schema/interface.rb

@@ -14,6 +14,7 @@ module GraphQL
         include GraphQL::Schema::Member::RelayShortcuts
         include GraphQL::Schema::Member::Scoped
         include GraphQL::Schema::Member::HasAstNode
+        include GraphQL::Schema::Member::HasUnresolvedTypeError
 
         # Methods defined in this block will be:
         # - Added as class methods to this interface
@@ -74,6 +75,10 @@ module GraphQL
             if overridden_graphql_name
               child_class.graphql_name(overridden_graphql_name)
             end
+            # If interfaces are mixed into each other, only define this class once
+            if !child_class.const_defined?(:UnresolvedTypeError, false)
+              add_unresolved_type_error(child_class)
+            end
           elsif child_class < GraphQL::Schema::Object
             # This is being included into an object type, make sure it's using `implements(...)`
             backtrace_line = caller(0, 10).find { |line| line.include?("schema/object.rb") && line.include?("in `implements'")}

data/lib/graphql/schema/list.rb

@@ -44,7 +44,8 @@ module GraphQL
         if value.nil?
           nil
         else
-          ensure_array(value).map { |item| item.nil? ? item : of_type.coerce_input(item, ctx) }
+          coerced = ensure_array(value).map { |item| item.nil? ? item : of_type.coerce_input(item, ctx) }
+          ctx.schema.after_any_lazies(coerced, &:itself)
         end
       end
 

data/lib/graphql/schema/loader.rb

@@ -157,6 +157,7 @@ module GraphQL
               type: type_resolver.call(field_hash["type"]),
               description: field_hash["description"],
               null: true,
+              camelize: false,
             ) do
               if field_hash["args"].any?
                 loader.build_arguments(self, field_hash["args"], type_resolver)
@@ -171,6 +172,8 @@ module GraphQL
               type: type_resolver.call(arg["type"]),
               description: arg["description"],
               required: false,
+              method_access: false,
+              camelize: false,
             }
 
             if arg["defaultValue"]

data/lib/graphql/schema/member.rb

@@ -5,6 +5,7 @@ require 'graphql/schema/member/cached_graphql_definition'
 require 'graphql/schema/member/graphql_type_names'
 require 'graphql/schema/member/has_ast_node'
 require 'graphql/schema/member/has_path'
+require 'graphql/schema/member/has_unresolved_type_error'
 require 'graphql/schema/member/relay_shortcuts'
 require 'graphql/schema/member/scoped'
 require 'graphql/schema/member/type_system_helpers'

data/lib/graphql/schema/member/has_arguments.rb

@@ -58,6 +58,22 @@ module GraphQL
           end
         end
 
+        # @return [GraphQL::Schema::Argument, nil] Argument defined on this thing, fetched by name.
+        def get_argument(argument_name)
+          a = own_arguments[argument_name]
+
+          if a || !self.is_a?(Class)
+            a
+          else
+            for ancestor in ancestors
+              if ancestor.respond_to?(:own_arguments) && a = ancestor.own_arguments[argument_name]
+                return a
+              end
+            end
+            nil
+          end
+        end
+
         # @param new_arg_class [Class] A class to use for building argument definitions
         def argument_class(new_arg_class = nil)
           self.class.argument_class(new_arg_class)
@@ -135,6 +151,12 @@ module GraphQL
           end
         end
 
+        def arguments_statically_coercible?
+          return @arguments_statically_coercible if defined?(@arguments_statically_coercible)
+
+          @arguments_statically_coercible = arguments.each_value.all?(&:statically_coercible?)
+        end
+
         module ArgumentClassAccessor
           def argument_class(new_arg_class = nil)
             if new_arg_class

data/lib/graphql/schema/member/has_fields.rb

@@ -47,7 +47,7 @@ module GraphQL
         # A list of GraphQL-Ruby keywords.
         #
         # @api private
-        GRAPHQL_RUBY_KEYWORDS = [:context, :object, :method]
+        GRAPHQL_RUBY_KEYWORDS = [:context, :object, :method, :raw_value]
 
         # A list of field names that we should advise users to pick a different
         # resolve method name.

data/lib/graphql/schema/member/has_unresolved_type_error.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+module GraphQL
+  class Schema
+    class Member
+      # Set up a type-specific error to make debugging & bug tracker integration better
+      module HasUnresolvedTypeError
+        private
+        def add_unresolved_type_error(child_class)
+          child_class.const_set(:UnresolvedTypeError, Class.new(GraphQL::UnresolvedTypeError))
+        end
+      end
+    end
+  end
+end

data/lib/graphql/schema/object.rb

@@ -71,6 +71,13 @@ module GraphQL
       end
 
       class << self
+        # Set up a type-specific invalid null error to use when this object's non-null fields wrongly return `nil`.
+        # It should help with debugging and bug tracker integrations.
+        def inherited(child_class)
+          child_class.const_set(:InvalidNullError, Class.new(GraphQL::InvalidNullError))
+          super
+        end
+
         def implements(*new_interfaces, **options)
           new_memberships = []
           new_interfaces.each do |int|

data/lib/graphql/schema/union.rb

@@ -3,8 +3,14 @@ module GraphQL
   class Schema
     class Union < GraphQL::Schema::Member
       extend GraphQL::Schema::Member::AcceptsDefinition
+      extend GraphQL::Schema::Member::HasUnresolvedTypeError
 
       class << self
+        def inherited(child_class)
+          add_unresolved_type_error(child_class)
+          super
+        end
+
         def possible_types(*types, context: GraphQL::Query::NullContext, **options)
           if types.any?
             types.each do |t|

data/lib/graphql/schema/warden.rb

@@ -106,6 +106,12 @@ module GraphQL
         @visible_parent_fields[parent_type][field_name]
       end
 
+      # @return [GraphQL::Argument, nil] The argument named `argument_name` on `parent_type`, if it exists and is visible
+      def get_argument(parent_type, argument_name)
+        argument = parent_type.get_argument(argument_name)
+        return argument if argument && visible_argument?(argument)
+      end
+
       # @return [Array<GraphQL::BaseType>] The types which may be member of `type_defn`
       def possible_types(type_defn)
         @visible_possible_types ||= read_through { |type_defn|
@@ -166,7 +172,13 @@ module GraphQL
       end
 
       def visible_field?(owner_type, field_defn)
-        visible?(field_defn) && visible_type?(field_defn.type.unwrap) && field_on_visible_interface?(field_defn, owner_type)
+        # This field is visible in its own right
+        visible?(field_defn) &&
+          # This field's return type is visible
+          visible_type?(field_defn.type.unwrap) &&
+          # This field is either defined on this object type,
+          # or the interface it's inherited from is also visible
+          ((field_defn.respond_to?(:owner) && field_defn.owner == owner_type) || field_on_visible_interface?(field_defn, owner_type))
       end
 
       # We need this to tell whether a field was inherited by an interface

data/lib/graphql/static_validation/literal_validator.rb

@@ -95,16 +95,17 @@ module GraphQL
       def required_input_fields_are_present(type, ast_node)
         # TODO - would be nice to use these to create an error message so the caller knows
         # that required fields are missing
-        required_field_names = @warden.arguments(type)
-          .select { |f| f.type.kind.non_null? }
+        required_field_names = type.arguments.each_value
+          .select { |argument| argument.type.kind.non_null? && @warden.get_argument(type, argument.name) }
           .map(&:name)
+
         present_field_names = ast_node.arguments.map(&:name)
         missing_required_field_names = required_field_names - present_field_names
         if @context.schema.error_bubbling
           missing_required_field_names.empty? ? @valid_response : @invalid_response
         else
           results = missing_required_field_names.map do |name|
-            arg_type = @warden.arguments(type).find { |f| f.name == name }.type
+            arg_type = @warden.get_argument(type, name).type
             recursively_validate(GraphQL::Language::Nodes::NullValue.new(name: name), arg_type)
           end
           merge_results(results)
@@ -112,13 +113,12 @@ module GraphQL
       end
 
       def present_input_field_values_are_valid(type, ast_node)
-        field_map = @warden.arguments(type).reduce({}) { |m, f| m[f.name] = f; m}
         results = ast_node.arguments.map do |value|
-          field = field_map[value.name]
+          field = @warden.get_argument(type, value.name)
           # we want to call validate on an argument even if it's an invalid one
           # so that our raise exception is on it instead of the entire InputObject
-          type = field && field.type
-          recursively_validate(value.value, type)
+          field_type = field && field.type
+          recursively_validate(value.value, field_type)
         end
         merge_results(results)
       end

data/lib/graphql/static_validation/rules/arguments_are_defined.rb

@@ -5,7 +5,7 @@ module GraphQL
       def on_argument(node, parent)
         parent_defn = parent_definition(parent)
 
-        if parent_defn && context.warden.arguments(parent_defn).any? { |arg| arg.name == node.name }
+        if parent_defn && context.warden.get_argument(parent_defn, node.name)
           super
         elsif parent_defn
           kind_of_node = node_type(parent)

data/lib/graphql/static_validation/rules/required_arguments_are_present.rb

@@ -17,8 +17,8 @@ module GraphQL
 
       def assert_required_args(ast_node, defn)
         present_argument_names = ast_node.arguments.map(&:name)
-        required_argument_names = context.warden.arguments(defn)
-          .select { |a| a.type.kind.non_null? && !a.default_value? }
+        required_argument_names = defn.arguments.each_value
+          .select { |a| a.type.kind.non_null? && !a.default_value? && context.warden.get_argument(defn, a.name) }
           .map(&:name)
 
         missing_names = required_argument_names - present_argument_names

data/lib/graphql/static_validation/rules/required_input_object_attributes_are_present.rb

@@ -26,8 +26,7 @@ module GraphQL
           context.field_definition
         end
 
-        parent_type = context.warden.arguments(defn)
-          .find{|f| f.name == parent_name(parent, defn) }
+        parent_type = context.warden.get_argument(defn, parent_name(parent, defn))
         parent_type ? parent_type.type.unwrap : nil
       end
 

data/lib/graphql/subscriptions/subscription_root.rb

@@ -40,7 +40,7 @@ module GraphQL
             # for the backend to register:
             event = Subscriptions::Event.new(
               name: field.name,
-              arguments: arguments,
+              arguments: arguments_without_field_extras(arguments: arguments),
               context: context,
               field: field,
             )
@@ -48,7 +48,7 @@ module GraphQL
             value
           elsif context.query.subscription_topic == Subscriptions::Event.serialize(
               field.name,
-              arguments,
+              arguments_without_field_extras(arguments: arguments),
               field,
               scope: (field.subscription_scope ? context[field.subscription_scope] : nil),
             )
@@ -60,6 +60,14 @@ module GraphQL
             context.skip
           end
         end
+
+        private
+
+        def arguments_without_field_extras(arguments:)
+          arguments.dup.tap do |event_args|
+            field.extras.each { |k| event_args.delete(k) }
+          end
+        end
       end
     end
   end

data/lib/graphql/tracing/new_relic_tracing.rb

@@ -26,18 +26,7 @@ module GraphQL
         if key == "execute_query"
           set_this_txn_name =  data[:query].context[:set_new_relic_transaction_name]
           if set_this_txn_name == true || (set_this_txn_name.nil? && @set_transaction_name)
-            query = data[:query]
-            # Set the transaction name based on the operation type and name
-            selected_op = query.selected_operation
-            if selected_op
-              op_type = selected_op.operation_type
-              op_name = selected_op.name || "anonymous"
-            else
-              op_type = "query"
-              op_name = "anonymous"
-            end
-
-            NewRelic::Agent.set_transaction_name("GraphQL/#{op_type}.#{op_name}")
+            NewRelic::Agent.set_transaction_name(transaction_name(data[:query]))
           end
         end
 

data/lib/graphql/tracing/platform_tracing.rb

@@ -103,6 +103,20 @@ module GraphQL
       end
 
       private
+
+      # Get the transaction name based on the operation type and name
+      def transaction_name(query)
+        selected_op = query.selected_operation
+        if selected_op
+          op_type = selected_op.operation_type
+          op_name = selected_op.name || "anonymous"
+        else
+          op_type = "query"
+          op_name = "anonymous"
+        end
+        "GraphQL/#{op_type}.#{op_name}"
+      end
+
       attr_reader :options
 
       def platform_key_cache(ctx)

data/lib/graphql/tracing/scout_tracing.rb

@@ -16,12 +16,23 @@ module GraphQL
         "execute_query_lazy" => "execute.graphql",
       }
 
+      # @param set_transaction_name [Boolean] If true, the GraphQL operation name will be used as the transaction name.
+      #   This is not advised if you run more than one query per HTTP request, for example, with `graphql-client` or multiplexing.
+      #   It can also be specified per-query with `context[:set_scout_transaction_name]`.
       def initialize(options = {})
         self.class.include ScoutApm::Tracer
+        @set_transaction_name = options.fetch(:set_transaction_name, false)
         super(options)
       end
 
       def platform_trace(platform_key, key, data)
+        if key == "execute_query"
+          set_this_txn_name = data[:query].context[:set_scout_transaction_name]
+          if set_this_txn_name == true || (set_this_txn_name.nil? && @set_transaction_name)
+            ScoutApm::Transaction.rename(transaction_name(data[:query]))
+          end
+        end
+
         self.class.instrument("GraphQL", platform_key, INSTRUMENT_OPTS) do
           yield
         end

data/lib/graphql/types/iso_8601_date.rb

@@ -15,7 +15,7 @@ module GraphQL
     class ISO8601Date < GraphQL::Schema::Scalar
       description "An ISO 8601-encoded date"
 
-      # @param value [Date,DateTime,String]
+      # @param value [Date,Time,DateTime,String]
       # @return [String]
       def self.coerce_result(value, _ctx)
         Date.parse(value.to_s).iso8601
@@ -25,7 +25,7 @@ module GraphQL
       # @return [Date]
       def self.coerce_input(str_value, _ctx)
         Date.iso8601(str_value)
-      rescue ArgumentError
+      rescue ArgumentError, TypeError
         # Invalid input
         nil
       end

data/lib/graphql/types/iso_8601_date_time.rb

@@ -1,7 +1,9 @@
+require 'time'
+
 # frozen_string_literal: true
 module GraphQL
   module Types
-    # This scalar takes `DateTime`s and transmits them as strings,
+    # This scalar takes `Time`s and transmits them as strings,
     # using ISO 8601 format.
     #
     # Use it for fields or arguments as follows:
@@ -29,31 +31,33 @@ module GraphQL
         @time_precision = value
       end
 
-      # @param value [Date,DateTime,String]
+      # @param value [Time,Date,DateTime,String]
       # @return [String]
-      def self.coerce_result(value, _ctx)\
+      def self.coerce_result(value, _ctx)
         case value
-        when DateTime
-          return value.iso8601(time_precision)
         when Date
-          return DateTime.parse(value.to_s).iso8601(time_precision)
+          return value.to_time.iso8601(time_precision)
         when ::String
-          return DateTime.parse(value).iso8601(time_precision)
+          return Time.parse(value).iso8601(time_precision)
         else
-          # In case some other API-compliant thing is given: 
+          # Time, DateTime or compatible is given:
           return value.iso8601(time_precision)
-        end 
+        end
       rescue StandardError => error
-        raise GraphQL::Error, "An incompatible object (#{value.class}) was given to #{self}. Make sure that only Dates, DateTimes, and well-formatted Strings are used with this type. (#{error.message})"
+        raise GraphQL::Error, "An incompatible object (#{value.class}) was given to #{self}. Make sure that only Times, Dates, DateTimes, and well-formatted Strings are used with this type. (#{error.message})"
       end
 
       # @param str_value [String]
-      # @return [DateTime]
+      # @return [Time]
       def self.coerce_input(str_value, _ctx)
-        DateTime.iso8601(str_value)
-      rescue ArgumentError
-        # Invalid input
-        nil
+        Time.iso8601(str_value)
+      rescue ArgumentError, TypeError
+        begin
+          Date.iso8601(str_value).to_time
+        rescue ArgumentError, TypeError
+          # Invalid input
+          nil
+        end
       end
     end
   end

data/lib/graphql/version.rb

@@ -1,4 +1,4 @@
 # frozen_string_literal: true
 module GraphQL
-  VERSION = "1.10.9"
+  VERSION = "1.10.14"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: graphql
 version: !ruby/object:Gem::Version
-  version: 1.10.9
+  version: 1.10.14
 platform: ruby
 authors:
 - Robert Mosolgo
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2020-05-04 00:00:00.000000000 Z
+date: 2020-06-29 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: benchmark-ips
@@ -582,6 +582,7 @@ files:
 - lib/graphql/schema/member/has_ast_node.rb
 - lib/graphql/schema/member/has_fields.rb
 - lib/graphql/schema/member/has_path.rb
+- lib/graphql/schema/member/has_unresolved_type_error.rb
 - lib/graphql/schema/member/instrumentation.rb
 - lib/graphql/schema/member/relay_shortcuts.rb
 - lib/graphql/schema/member/scoped.rb