graphql 2.0.16 → 2.0.18

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

@@ -11,6 +11,7 @@ module GraphQL
         def self.extended(cls)
           cls.extend(ArgumentClassAccessor)
           cls.include(ArgumentObjectLoader)
+          cls.extend(ClassConfigured)
         end
 
         # @see {GraphQL::Schema::Argument#initialize} for parameters
@@ -109,14 +110,6 @@ module GraphQL
 
         # @return [Hash<String => GraphQL::Schema::Argument] Arguments defined on this thing, keyed by name. Includes inherited definitions
         def arguments(context = GraphQL::Query::NullContext)
-          inherited_arguments = if self.is_a?(Class) && superclass.respond_to?(:arguments)
-            superclass.arguments(context)
-          elsif defined?(@resolver_class) && @resolver_class
-            @resolver_class.field_arguments(context)
-          else
-            nil
-          end
-          # Local definitions override inherited ones
           if own_arguments.any?
             own_arguments_that_apply = {}
             own_arguments.each do |name, args_entry|
@@ -125,47 +118,107 @@ module GraphQL
               end
             end
           end
+          # might be nil if there are actually no arguments
+          own_arguments_that_apply || own_arguments
+        end
 
-          if inherited_arguments
-            if own_arguments_that_apply
-              inherited_arguments.merge(own_arguments_that_apply)
-            else
-              inherited_arguments
+        module ClassConfigured
+          def inherited(child_class)
+            super
+            child_class.extend(InheritedArguments)
+          end
+
+          module InheritedArguments
+            def arguments(context = GraphQL::Query::NullContext)
+              own_arguments = super
+              inherited_arguments = superclass.arguments(context)
+
+              if own_arguments.any?
+                if inherited_arguments.any?
+                  # Local definitions override inherited ones
+                  inherited_arguments.merge(own_arguments)
+                else
+                  own_arguments
+                end
+              else
+                inherited_arguments
+              end
+            end
+
+            def all_argument_definitions
+              all_defns = {}
+              ancestors.reverse_each do |ancestor|
+                if ancestor.respond_to?(:own_arguments)
+                  all_defns.merge!(ancestor.own_arguments)
+                end
+              end
+              all_defns = all_defns.values
+              all_defns.flatten!
+              all_defns
+            end
+
+
+            def get_argument(argument_name, context = GraphQL::Query::NullContext)
+              warden = Warden.from_context(context)
+              for ancestor in ancestors
+                if ancestor.respond_to?(:own_arguments) &&
+                  (a = ancestor.own_arguments[argument_name]) &&
+                  (a = Warden.visible_entry?(:visible_argument?, a, context, warden))
+                  return a
+                end
+              end
+              nil
             end
-          else
-            # might be nil if there are actually no arguments
-            own_arguments_that_apply || own_arguments
           end
         end
 
-        def all_argument_definitions
-          if self.is_a?(Class)
-            all_defns = {}
-            ancestors.reverse_each do |ancestor|
-              if ancestor.respond_to?(:own_arguments)
-                all_defns.merge!(ancestor.own_arguments)
+        module FieldConfigured
+          def arguments(context = GraphQL::Query::NullContext)
+            own_arguments = super
+            if defined?(@resolver_class) && @resolver_class
+              inherited_arguments = @resolver_class.field_arguments(context)
+              if own_arguments.any?
+                if inherited_arguments.any?
+                  inherited_arguments.merge(own_arguments)
+                else
+                  own_arguments
+                end
+              else
+                inherited_arguments
               end
+            else
+              own_arguments
             end
-          elsif defined?(@resolver_class) && @resolver_class
-            all_defns = {}
-            @resolver_class.all_field_argument_definitions.each do |arg_defn|
-              key = arg_defn.graphql_name
-              case (current_value = all_defns[key])
-              when nil
-                all_defns[key] = arg_defn
-              when Array
-                current_value << arg_defn
-              when GraphQL::Schema::Argument
-                all_defns[key] = [current_value, arg_defn]
-              else
-                raise "Invariant: Unexpected argument definition, #{current_value.class}: #{current_value.inspect}"
+          end
+
+          def all_argument_definitions
+            if defined?(@resolver_class) && @resolver_class
+              all_defns = {}
+              @resolver_class.all_field_argument_definitions.each do |arg_defn|
+                key = arg_defn.graphql_name
+                case (current_value = all_defns[key])
+                when nil
+                  all_defns[key] = arg_defn
+                when Array
+                  current_value << arg_defn
+                when GraphQL::Schema::Argument
+                  all_defns[key] = [current_value, arg_defn]
+                else
+                  raise "Invariant: Unexpected argument definition, #{current_value.class}: #{current_value.inspect}"
+                end
               end
+              all_defns.merge!(own_arguments)
+              all_defns = all_defns.values
+              all_defns.flatten!
+              all_defns
+            else
+              super
             end
-            all_defns.merge!(own_arguments)
-          else
-            all_defns = own_arguments
           end
-          all_defns = all_defns.values
+        end
+
+        def all_argument_definitions
+          all_defns = own_arguments.values
           all_defns.flatten!
           all_defns
         end
@@ -173,22 +226,11 @@ module GraphQL
         # @return [GraphQL::Schema::Argument, nil] Argument defined on this thing, fetched by name.
         def get_argument(argument_name, context = GraphQL::Query::NullContext)
           warden = Warden.from_context(context)
-          if !self.is_a?(Class)
-            if (arg_config = own_arguments[argument_name]) && (visible_arg = Warden.visible_entry?(:visible_argument?, arg_config, context, warden))
-              visible_arg
-            elsif defined?(@resolver_class) && @resolver_class
-              @resolver_class.get_field_argument(argument_name, context)
-            else
-              nil
-            end
+          if (arg_config = own_arguments[argument_name]) && (visible_arg = Warden.visible_entry?(:visible_argument?, arg_config, context, warden))
+            visible_arg
+          elsif defined?(@resolver_class) && @resolver_class
+            @resolver_class.get_field_argument(argument_name, context)
           else
-            for ancestor in ancestors
-              if ancestor.respond_to?(:own_arguments) &&
-                (a = ancestor.own_arguments[argument_name]) &&
-                (a = Warden.visible_entry?(:visible_argument?, a, context, warden))
-                return a
-              end
-            end
             nil
           end
         end
@@ -209,7 +251,7 @@ module GraphQL
         # @return [Interpreter::Arguments, Execution::Lazy<Interpeter::Arguments>]
         def coerce_arguments(parent_object, values, context, &block)
           # Cache this hash to avoid re-merging it
-          arg_defns = self.arguments(context)
+          arg_defns = context.warden.arguments(self)
           total_args_count = arg_defns.size
 
           finished_args = nil
@@ -223,7 +265,7 @@ module GraphQL
               argument_values = {}
               resolved_args_count = 0
               raised_error = false
-              arg_defns.each do |arg_name, arg_defn|
+              arg_defns.each do |arg_defn|
                 context.dataloader.append_job do
                   begin
                     arg_defn.coerce_into_values(parent_object, values, context, argument_values)
@@ -265,7 +307,12 @@ module GraphQL
         # but not for directives.
         # TODO apply static validations on schema definitions?
         def validate_directive_argument(arg_defn, value)
-          if arg_defn.owner.is_a?(Class) && arg_defn.owner < GraphQL::Schema::Directive
+          # this is only implemented on directives.
+          nil
+        end
+
+        module HasDirectiveArguments
+          def validate_directive_argument(arg_defn, value)
             if value.nil? && arg_defn.type.non_null?
               raise ArgumentError, "#{arg_defn.path} is required, but no value was given"
             end

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

@@ -5,17 +5,16 @@ module GraphQL
     class Member
       module HasDeprecationReason
         # @return [String, nil] Explains why this member was deprecated (if present, this will be marked deprecated in introspection)
-        def deprecation_reason
-          dir = self.directives.find { |d| d.is_a?(GraphQL::Schema::Directive::Deprecated) }
-          dir && dir.arguments[:reason] # rubocop:disable Development/ContextIsPassedCop -- definition-related
-        end
+        attr_reader :deprecation_reason
 
         # Set the deprecation reason for this member, or remove it by assigning `nil`
         # @param text [String, nil]
         def deprecation_reason=(text)
+          @deprecation_reason = text
           if text.nil?
             remove_directive(GraphQL::Schema::Directive::Deprecated)
           else
+            # This removes a previously-attached directive, if there is one:
             directive(GraphQL::Schema::Directive::Deprecated, reason: text)
           end
         end

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

@@ -72,7 +72,12 @@ module GraphQL
         def add_field(field_defn, method_conflict_warning: field_defn.method_conflict_warning?)
           # Check that `field_defn.original_name` equals `resolver_method` and `method_sym` --
           # that shows that no override value was given manually.
-          if method_conflict_warning && CONFLICT_FIELD_NAMES.include?(field_defn.resolver_method) && field_defn.original_name == field_defn.resolver_method && field_defn.original_name == field_defn.method_sym && field_defn.hash_key.nil? && field_defn.dig_keys.nil?
+          if method_conflict_warning &&
+              CONFLICT_FIELD_NAMES.include?(field_defn.resolver_method) &&
+              field_defn.original_name == field_defn.resolver_method &&
+              field_defn.original_name == field_defn.method_sym &&
+              field_defn.hash_key == NOT_CONFIGURED &&
+              field_defn.dig_keys.nil?
             warn(conflict_field_name_warning(field_defn))
           end
           prev_defn = own_fields[field_defn.name]
@@ -129,12 +134,19 @@ module GraphQL
 
         private
 
+        def inherited(subclass)
+          super
+          subclass.class_eval do
+            @own_fields ||= nil
+          end
+        end
+
         # If `type` is an interface, and `self` has a type membership for `type`, then make sure it's visible.
         def visible_interface_implementation?(type, context, warden)
           if type.respond_to?(:kind) && type.kind.interface?
             implements_this_interface = false
             implementation_is_visible = false
-            interface_type_memberships.each do |tm|
+            warden.interface_type_memberships(self, context).each do |tm|
               if tm.abstract_type == type
                 implements_this_interface ||= true
                 if warden.visible_type_membership?(tm, context)

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

@@ -55,7 +55,38 @@ module GraphQL
         end
 
         def interface_type_memberships
-          own_interface_type_memberships + ((self.is_a?(Class) && superclass.respond_to?(:interface_type_memberships)) ? superclass.interface_type_memberships : [])
+          own_interface_type_memberships
+        end
+
+        module ClassConfigured
+          # This combination of extended -> inherited -> extended
+          # means that the base class (`Schema::Object`) *won't*
+          # have the superclass-related code in `InheritedInterfaces`,
+          # but child classes of `Schema::Object` will have it.
+          # That way, we don't need a `superclass.respond_to?(...)` check.
+          def inherited(child_class)
+            super
+            child_class.extend(InheritedInterfaces)
+          end
+
+          module InheritedInterfaces
+            def interfaces(context = GraphQL::Query::NullContext)
+              visible_interfaces = super
+              visible_interfaces.concat(superclass.interfaces(context))
+              visible_interfaces.uniq!
+              visible_interfaces
+            end
+
+            def interface_type_memberships
+              own_tms = super
+              inherited_tms = superclass.interface_type_memberships
+              if inherited_tms.size > 0
+                own_tms + inherited_tms
+              else
+                own_tms
+              end
+            end
+          end
         end
 
         # param context [Query::Context] If omitted, skip filtering.
@@ -63,24 +94,34 @@ module GraphQL
           warden = Warden.from_context(context)
           visible_interfaces = []
           own_interface_type_memberships.each do |type_membership|
-            # During initialization, `type_memberships` can hold late-bound types
             case type_membership
-            when String, Schema::LateBoundType
-              visible_interfaces << type_membership
             when Schema::TypeMembership
               if warden.visible_type_membership?(type_membership, context)
                 visible_interfaces << type_membership.abstract_type
               end
+            when String, Schema::LateBoundType
+              # During initialization, `type_memberships` can hold late-bound types
+              visible_interfaces << type_membership
             else
               raise "Invariant: Unexpected type_membership #{type_membership.class}: #{type_membership.inspect}"
             end
           end
+          visible_interfaces.uniq!
 
-          if self.is_a?(Class) && superclass <= GraphQL::Schema::Object
-            visible_interfaces.concat(superclass.interfaces(context))
-          end
+          visible_interfaces
+        end
 
-          visible_interfaces.uniq
+        private
+
+        def self.extended(child_class)
+          child_class.extend(ClassConfigured)
+        end
+
+        def inherited(subclass)
+          super
+          subclass.class_eval do
+            @own_interface_type_memberships ||= nil
+          end
         end
       end
     end

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

@@ -18,12 +18,38 @@ module GraphQL
 
         # @return [Array<GraphQL::Schema::Validator>]
         def validators
-          own_validators = @own_validators || EMPTY_ARRAY
-          if self.is_a?(Class) && superclass.respond_to?(:validators) && (inherited_validators = superclass.validators).any?
-            inherited_validators + own_validators
-          else
-            own_validators
+          @own_validators || EMPTY_ARRAY
+        end
+
+        module ClassConfigured
+          def inherited(child_cls)
+            super
+            child_cls.extend(ClassValidators)
           end
+
+          module ClassValidators
+            include Schema::FindInheritedValue::EmptyObjects
+
+            def validators
+              inherited_validators = superclass.validators
+              if inherited_validators.any?
+                if @own_validators.nil?
+                  inherited_validators
+                else
+                  inherited_validators + @own_validators
+                end
+              elsif @own_validators.nil?
+                EMPTY_ARRAY
+              else
+                @own_validators
+              end
+            end
+          end
+        end
+
+        def self.extended(child_cls)
+          super
+          child_cls.extend(ClassConfigured)
         end
       end
     end

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

@@ -4,6 +4,13 @@ module GraphQL
   class Schema
     class Member
       module TypeSystemHelpers
+        def initialize(*args, &block)
+          super
+          @to_non_null_type ||= nil
+          @to_list_type ||= nil
+        end
+        ruby2_keywords :initialize if respond_to?(:ruby2_keywords, true)
+
         # @return [Schema::NonNull] Make a non-null-type representation of this type
         def to_non_null_type
           @to_non_null_type ||= GraphQL::Schema::NonNull.new(self)
@@ -32,6 +39,16 @@ module GraphQL
         def kind
           raise GraphQL::RequiredImplementationMissingError, "No `.kind` defined for #{self}"
         end
+
+        private
+
+        def inherited(subclass)
+          super
+          subclass.class_eval do
+            @to_non_null_type ||= nil
+            @to_list_type ||= nil
+          end
+        end
       end
     end
   end

data/lib/graphql/schema/object.rb

@@ -48,9 +48,7 @@ module GraphQL
         # @return [GraphQL::Schema::Object, GraphQL::Execution::Lazy]
         # @raise [GraphQL::UnauthorizedError] if the user-provided hook returns `false`
         def authorized_new(object, context)
-          trace_payload = { context: context, type: self, object: object, path: context[:current_path] }
-
-          maybe_lazy_auth_val = context.query.trace("authorized", trace_payload) do
+          maybe_lazy_auth_val = context.query.current_trace.authorized(query: context.query, type: self, object: object) do
             begin
               authorized?(object, context)
             rescue GraphQL::UnauthorizedError => err
@@ -62,7 +60,7 @@ module GraphQL
 
           auth_val = if context.schema.lazy?(maybe_lazy_auth_val)
             GraphQL::Execution::Lazy.new do
-              context.query.trace("authorized_lazy", trace_payload) do
+              context.query.current_trace.authorized_lazy(query: context.query, type: self, object: object) do
                 context.schema.sync_lazy(maybe_lazy_auth_val)
               end
             end

data/lib/graphql/schema/resolver/has_payload_type.rb

@@ -89,16 +89,16 @@ module GraphQL
         def generate_payload_type
           resolver_name = graphql_name
           resolver_fields = all_field_definitions
-          Class.new(object_class) do
-            graphql_name("#{resolver_name}Payload")
-            description("Autogenerated return type of #{resolver_name}.")
-            resolver_fields.each do |f|
-              # Reattach the already-defined field here
-              # (The field's `.owner` will still point to the mutation, not the object type, I think)
-              # Don't re-warn about a method conflict. Since this type is generated, it should be fixed in the resolver instead.
-              add_field(f, method_conflict_warning: false)
-            end
+          pt = Class.new(object_class)
+          pt.graphql_name("#{resolver_name}Payload")
+          pt.description("Autogenerated return type of #{resolver_name}.")
+          resolver_fields.each do |f|
+            # Reattach the already-defined field here
+            # (The field's `.owner` will still point to the mutation, not the object type, I think)
+            # Don't re-warn about a method conflict. Since this type is generated, it should be fixed in the resolver instead.
+            pt.add_field(f, method_conflict_warning: false)
           end
+          pt
         end
       end
     end

data/lib/graphql/schema/timeout.rb

@@ -33,60 +33,56 @@ module GraphQL
     #   end
     #
     class Timeout
-      def self.use(schema, **options)
-        tracer = new(**options)
-        schema.tracer(tracer)
+      def self.use(schema, max_seconds: nil)
+        timeout = self.new(max_seconds: max_seconds)
+        schema.trace_with(self::Trace, timeout: timeout)
       end
 
-      # @param max_seconds [Numeric] how many seconds the query should be allowed to resolve new fields
       def initialize(max_seconds:)
         @max_seconds = max_seconds
       end
 
-      def trace(key, data)
-        case key
-        when 'execute_multiplex'
-          data.fetch(:multiplex).queries.each do |query|
-            timeout_duration_s = max_seconds(query)
+      module Trace
+        # @param max_seconds [Numeric] how many seconds the query should be allowed to resolve new fields
+        def initialize(timeout:, **rest)
+          @timeout = timeout
+          super
+        end
+
+        def execute_multiplex(multiplex:)
+          multiplex.queries.each do |query|
+            timeout_duration_s = @timeout.max_seconds(query)
             timeout_state = if timeout_duration_s == false
               # if the method returns `false`, don't apply a timeout
               false
             else
               now = Process.clock_gettime(Process::CLOCK_MONOTONIC, :millisecond)
-              timeout_at = now + (max_seconds(query) * 1000)
+              timeout_at = now + (timeout_duration_s * 1000)
               {
                 timeout_at: timeout_at,
                 timed_out: false
               }
             end
-            query.context.namespace(self.class)[:state] = timeout_state
+            query.context.namespace(@timeout)[:state] = timeout_state
           end
+          super
+        end
 
-          yield
-        when 'execute_field', 'execute_field_lazy'
-          query_context = data[:context] || data[:query].context
-          timeout_state = query_context.namespace(self.class).fetch(:state)
+        def execute_field(query:, field:, **_rest)
+          timeout_state = query.context.namespace(@timeout).fetch(:state)
           # If the `:state` is `false`, then `max_seconds(query)` opted out of timeout for this query.
           if timeout_state != false && Process.clock_gettime(Process::CLOCK_MONOTONIC, :millisecond) > timeout_state.fetch(:timeout_at)
-            error = if data[:context]
-              GraphQL::Schema::Timeout::TimeoutError.new(query_context.parent_type, query_context.field)
-            else
-              field = data.fetch(:field)
-              GraphQL::Schema::Timeout::TimeoutError.new(field.owner, field)
-            end
-
+            error = GraphQL::Schema::Timeout::TimeoutError.new(field)
             # Only invoke the timeout callback for the first timeout
             if !timeout_state[:timed_out]
               timeout_state[:timed_out] = true
-              handle_timeout(error, query_context.query)
+              @timeout.handle_timeout(error, query)
             end
 
             error
           else
             yield
           end
-        else
-          yield
         end
       end
 
@@ -114,8 +110,8 @@ module GraphQL
       # to take this error and raise a new one which _doesn't_ descend from {GraphQL::ExecutionError},
       # such as `RuntimeError`.
       class TimeoutError < GraphQL::ExecutionError
-        def initialize(parent_type, field)
-          super("Timeout on #{parent_type.graphql_name}.#{field.graphql_name}")
+        def initialize(field)
+          super("Timeout on #{field.path}")
         end
       end
     end

data/lib/graphql/schema/warden.rb

@@ -80,6 +80,8 @@ module GraphQL
           def visible_type?(type, ctx); type.visible?(ctx); end
           def visible_enum_value?(ev, ctx); ev.visible?(ctx); end
           def visible_type_membership?(tm, ctx); tm.visible?(ctx); end
+          def interface_type_memberships(obj_t, ctx); obj_t.interface_type_memberships; end
+          def arguments(owner, ctx); owner.arguments(ctx); end
         end
       end
 
@@ -94,6 +96,13 @@ module GraphQL
         @subscription = @schema.subscription
         @context = context
         @visibility_cache = read_through { |m| filter.call(m, context) }
+        # Initialize all ivars to improve object shape consistency:
+        @types = @visible_types = @reachable_types = @visible_parent_fields =
+          @visible_possible_types = @visible_fields = @visible_arguments = @visible_enum_arrays =
+          @visible_enum_values = @visible_interfaces = @type_visibility = @type_memberships =
+          @visible_and_reachable_type = @unions = @unfiltered_interfaces = @references_to =
+          @reachable_type_set =
+            nil
       end
 
       # @return [Hash<String, GraphQL::BaseType>] Visible types in the schema
@@ -174,14 +183,20 @@ module GraphQL
 
       # @param argument_owner [GraphQL::Field, GraphQL::InputObjectType]
       # @return [Array<GraphQL::Argument>] Visible arguments on `argument_owner`
-      def arguments(argument_owner)
-        @visible_arguments ||= read_through { |o| o.arguments(@context).each_value.select { |a| visible_argument?(a) } }
+      def arguments(argument_owner, ctx = nil)
+        @visible_arguments ||= read_through { |o| o.arguments(@context).each_value.select { |a| visible_argument?(a, @context) } }
         @visible_arguments[argument_owner]
       end
 
       # @return [Array<GraphQL::EnumType::EnumValue>] Visible members of `enum_defn`
       def enum_values(enum_defn)
-        @visible_enum_arrays ||= read_through { |e| e.enum_values(@context) }
+        @visible_enum_arrays ||= read_through { |e|
+          values = e.enum_values(@context)
+          if values.size == 0
+            raise GraphQL::Schema::Enum::MissingValuesError.new(e)
+          end
+          values
+        }
         @visible_enum_arrays[enum_defn]
       end
 
@@ -233,6 +248,13 @@ module GraphQL
         visible?(type_membership)
       end
 
+      def interface_type_memberships(obj_type, _ctx = nil)
+        @type_memberships ||= read_through do |obj_t|
+          obj_t.interface_type_memberships
+        end
+        @type_memberships[obj_type]
+      end
+
       private
 
       def visible_and_reachable_type?(type_defn)
@@ -332,7 +354,7 @@ module GraphQL
       end
 
       def reachable_type_set
-        return @reachable_type_set if defined?(@reachable_type_set)
+        return @reachable_type_set if @reachable_type_set
 
         @reachable_type_set = Set.new
         rt_hash = {}