graphql 2.1.0 → 2.1.2

data/lib/graphql/schema/relay_classic_mutation.rb

@@ -21,6 +21,10 @@ module GraphQL
     # @see {GraphQL::Schema::Mutation} for an example, it's basically the same.
     #
     class RelayClassicMutation < GraphQL::Schema::Mutation
+      include GraphQL::Schema::HasSingleInputArgument
+
+      argument :client_mutation_id, String, "A unique identifier for the client performing the mutation.", required: false
+
       # The payload should always include this field
       field(:client_mutation_id, String, "A unique identifier for the client performing the mutation.")
       # Relay classic default:
@@ -31,34 +35,14 @@ module GraphQL
       def resolve_with_support(**inputs)
         input = inputs[:input].to_kwargs
 
-        new_extras = field ? field.extras : []
-        all_extras = self.class.extras + new_extras
-
-        # Transfer these from the top-level hash to the
-        # shortcutted `input:` object
-        all_extras.each do |ext|
-          # It's possible that the `extra` was not passed along by this point,
-          # don't re-add it if it wasn't given here.
-          if inputs.key?(ext)
-            input[ext] = inputs[ext]
-          end
-        end
-
         if input
           # This is handled by Relay::Mutation::Resolve, a bit hacky, but here we are.
           input_kwargs = input.to_h
           client_mutation_id = input_kwargs.delete(:client_mutation_id)
-        else
-          # Relay Classic Mutations with no `argument`s
-          # don't require `input:`
-          input_kwargs = {}
+          inputs[:input] = input_kwargs
         end
 
-        return_value = if input_kwargs.any?
-          super(**input_kwargs)
-        else
-          super()
-        end
+        return_value = super(**inputs)
 
         context.query.after_lazy(return_value) do |return_hash|
           # It might be an error
@@ -68,112 +52,6 @@ module GraphQL
           return_hash
         end
       end
-
-      class << self
-        def dummy
-          @dummy ||= begin
-            d = Class.new(GraphQL::Schema::Resolver)
-            d.argument_class(self.argument_class)
-            # TODO make this lazier?
-            d.argument(:input, input_type, description: "Parameters for #{self.graphql_name}")
-            d
-          end
-        end
-
-        def field_arguments(context = GraphQL::Query::NullContext)
-          dummy.arguments(context)
-        end
-
-        def get_field_argument(name, context = GraphQL::Query::NullContext)
-          dummy.get_argument(name, context)
-        end
-
-        def own_field_arguments
-          dummy.own_arguments
-        end
-
-        def all_field_argument_definitions
-          dummy.all_argument_definitions
-        end
-
-        # Also apply this argument to the input type:
-        def argument(*args, own_argument: false, **kwargs, &block)
-          it = input_type # make sure any inherited arguments are already added to it
-          arg = super(*args, **kwargs, &block)
-
-          # This definition might be overriding something inherited;
-          # if it is, remove the inherited definition so it's not confused at runtime as having multiple definitions
-          prev_args = it.own_arguments[arg.graphql_name]
-          case prev_args
-          when GraphQL::Schema::Argument
-            if prev_args.owner != self
-              it.own_arguments.delete(arg.graphql_name)
-            end
-          when Array
-            prev_args.reject! { |a| a.owner != self }
-            if prev_args.empty?
-              it.own_arguments.delete(arg.graphql_name)
-            end
-          end
-
-          it.add_argument(arg)
-          arg
-        end
-
-        # The base class for generated input object types
-        # @param new_class [Class] The base class to use for generating input object definitions
-        # @return [Class] The base class for this mutation's generated input object (default is {GraphQL::Schema::InputObject})
-        def input_object_class(new_class = nil)
-          if new_class
-            @input_object_class = new_class
-          end
-          @input_object_class || (superclass.respond_to?(:input_object_class) ? superclass.input_object_class : GraphQL::Schema::InputObject)
-        end
-
-        # @param new_input_type [Class, nil] If provided, it configures this mutation to accept `new_input_type` instead of generating an input type
-        # @return [Class] The generated {Schema::InputObject} class for this mutation's `input`
-        def input_type(new_input_type = nil)
-          if new_input_type
-            @input_type = new_input_type
-          end
-          @input_type ||= generate_input_type
-        end
-
-        private
-
-        # Generate the input type for the `input:` argument
-        # To customize how input objects are generated, override this method
-        # @return [Class] a subclass of {.input_object_class}
-        def generate_input_type
-          mutation_args = all_argument_definitions
-          mutation_class = self
-          Class.new(input_object_class) do
-            class << self
-              def default_graphql_name
-                "#{self.mutation.graphql_name}Input"
-              end
-
-              def description(new_desc = nil)
-                super || "Autogenerated input type of #{self.mutation.graphql_name}"
-              end
-            end
-            mutation(mutation_class)
-            # these might be inherited:
-            mutation_args.each do |arg|
-              add_argument(arg)
-            end
-            argument :client_mutation_id, String, "A unique identifier for the client performing the mutation.", required: false
-          end
-        end
-      end
-
-      private
-
-      def authorize_arguments(args, values)
-        # remove the `input` wrapper to match values
-        input_args = args["input"].type.unwrap.arguments(context)
-        super(input_args, values)
-      end
     end
   end
 end

data/lib/graphql/schema/resolver.rb

@@ -214,6 +214,10 @@ module GraphQL
           arguments(context)
         end
 
+        def any_field_arguments?
+          any_arguments?
+        end
+
         def get_field_argument(name, context = GraphQL::Query::NullContext)
           get_argument(name, context)
         end

data/lib/graphql/schema/scalar.rb

@@ -19,9 +19,9 @@ module GraphQL
 
         def specified_by_url(new_url = nil)
           if new_url
-            @specified_by_url = new_url
-          elsif defined?(@specified_by_url)
-            @specified_by_url
+            directive(GraphQL::Schema::Directive::SpecifiedBy, url: new_url)
+          elsif (directive = directives.find { |dir| dir.graphql_name == "specifiedBy" })
+            directive.arguments[:url] # rubocop:disable Development/ContextIsPassedCop
           elsif superclass.respond_to?(:specified_by_url)
             superclass.specified_by_url
           else

data/lib/graphql/schema/warden.rb

@@ -60,6 +60,7 @@ module GraphQL
           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
+          def loadable?(type, ctx); type.visible?(ctx); end
         end
       end
 
@@ -84,6 +85,7 @@ module GraphQL
         def fields(type_defn); type_defn.all_field_definitions; end # rubocop:disable Development/ContextIsPassedCop
         def get_field(parent_type, field_name); @schema.get_field(parent_type, field_name); end
         def reachable_type?(type_name); true; end
+        def loadable?(type, _ctx); true; end
         def reachable_types; @schema.types.values; end # rubocop:disable Development/ContextIsPassedCop
         def possible_types(type_defn); @schema.possible_types(type_defn); end
         def interfaces(obj_type); obj_type.interfaces; end
@@ -122,6 +124,11 @@ module GraphQL
         end
       end
 
+      # @return [Boolean] True if this type is used for `loads:` but not in the schema otherwise and not _explicitly_ hidden.
+      def loadable?(type, _ctx)
+        !reachable_type_set.include?(type) && visible_type?(type)
+      end
+
       # @return [GraphQL::BaseType, nil] The type named `type_name`, if it exists (else `nil`)
       def get_type(type_name)
         @visible_types ||= read_through do |name|
@@ -188,7 +195,16 @@ module GraphQL
       # @param argument_owner [GraphQL::Field, GraphQL::InputObjectType]
       # @return [Array<GraphQL::Argument>] Visible arguments on `argument_owner`
       def arguments(argument_owner, ctx = nil)
-        @visible_arguments ||= read_through { |o| o.arguments(@context).each_value.select { |a| visible_argument?(a, @context) } }
+        @visible_arguments ||= read_through { |o|
+          args = o.arguments(@context)
+          if args.any?
+            args = args.values
+            args.select! { |a| visible_argument?(a, @context) }
+            args
+          else
+            EmptyObjects::EMPTY_ARRAY
+          end
+        }
         @visible_arguments[argument_owner]
       end
 
@@ -211,7 +227,13 @@ module GraphQL
 
       # @return [Array<GraphQL::InterfaceType>] Visible interfaces implemented by `obj_type`
       def interfaces(obj_type)
-        @visible_interfaces ||= read_through { |t| t.interfaces(@context).select { |i| visible_type?(i) } }
+        @visible_interfaces ||= read_through { |t|
+          ints = t.interfaces(@context)
+          if ints.any?
+            ints.select! { |i| visible_type?(i) }
+          end
+          ints
+        }
         @visible_interfaces[obj_type]
       end
 
@@ -267,11 +289,19 @@ module GraphQL
           next true if root_type?(type_defn) || type_defn.introspection?
 
           if type_defn.kind.union?
-            visible_possible_types?(type_defn) && (referenced?(type_defn) || orphan_type?(type_defn))
+            possible_types(type_defn).any? && (referenced?(type_defn) || orphan_type?(type_defn))
           elsif type_defn.kind.interface?
-            visible_possible_types?(type_defn)
+            possible_types(type_defn).any?
           else
-            referenced?(type_defn) || visible_abstract_type?(type_defn)
+            if referenced?(type_defn)
+              true
+            elsif type_defn.kind.object?
+              # Show this object if it belongs to ...
+              interfaces(type_defn).any? { |t| referenced?(t) } ||  # an interface which is referenced in the schema
+                union_memberships(type_defn).any? { |t| referenced?(t) || orphan_type?(t) } # or a union which is referenced or added via orphan_types
+            else
+              false
+            end
           end
         end
 
@@ -338,23 +368,14 @@ module GraphQL
         @schema.orphan_types.include?(type_defn)
       end
 
-      def visible_abstract_type?(type_defn)
-        type_defn.kind.object? && (
-            interfaces(type_defn).any? ||
-            union_memberships(type_defn).any?
-          )
-      end
-
-      def visible_possible_types?(type_defn)
-        possible_types(type_defn).any? { |t| visible_and_reachable_type?(t) }
-      end
-
       def visible?(member)
         @visibility_cache[member]
       end
 
       def read_through
-        Hash.new { |h, k| h[k] = yield(k) }
+        h = Hash.new { |h, k| h[k] = yield(k) }
+        h.compare_by_identity
+        h
       end
 
       def reachable_type_set
@@ -385,54 +406,62 @@ module GraphQL
           end
         end
 
+        included_interface_possible_types_set = Set.new
+
         until unvisited_types.empty?
           type = unvisited_types.pop
-          if @reachable_type_set.add?(type)
-            type_by_name = rt_hash[type.graphql_name] ||= type
-            if type_by_name != type
-              raise DuplicateNamesError.new(
-                duplicated_name: type.graphql_name, duplicated_definition_1: type.inspect, duplicated_definition_2: type_by_name.inspect
-              )
+          visit_type(type, unvisited_types, @reachable_type_set, rt_hash, included_interface_possible_types_set, include_interface_possible_types: false)
+        end
+
+        @reachable_type_set
+      end
+
+      def visit_type(type, unvisited_types, visited_type_set, type_by_name_hash, included_interface_possible_types_set, include_interface_possible_types:)
+        if visited_type_set.add?(type) || (include_interface_possible_types && type.kind.interface? && included_interface_possible_types_set.add?(type))
+          type_by_name = type_by_name_hash[type.graphql_name] ||= type
+          if type_by_name != type
+            name_1, name_2 = [type.inspect, type_by_name.inspect].sort
+            raise DuplicateNamesError.new(
+              duplicated_name: type.graphql_name, duplicated_definition_1: name_1, duplicated_definition_2: name_2
+            )
+          end
+          if type.kind.input_object?
+            # recurse into visible arguments
+            arguments(type).each do |argument|
+              argument_type = argument.type.unwrap
+              unvisited_types << argument_type
             end
-            if type.kind.input_object?
-              # recurse into visible arguments
-              arguments(type).each do |argument|
-                argument_type = argument.type.unwrap
-                unvisited_types << argument_type
-              end
-            elsif type.kind.union?
-              # recurse into visible possible types
-              possible_types(type).each do |possible_type|
-                unvisited_types << possible_type
+          elsif type.kind.union?
+            # recurse into visible possible types
+            possible_types(type).each do |possible_type|
+              unvisited_types << possible_type
+            end
+          elsif type.kind.fields?
+            if type.kind.object?
+              # recurse into visible implemented interfaces
+              interfaces(type).each do |interface|
+                unvisited_types << interface
               end
-            elsif type.kind.fields?
-              if type.kind.interface?
-                # recurse into visible possible types
-                possible_types(type).each do |possible_type|
-                  unvisited_types << possible_type
-                end
-              elsif type.kind.object?
-                # recurse into visible implemented interfaces
-                interfaces(type).each do |interface|
-                  unvisited_types << interface
-                end
+            elsif include_interface_possible_types
+              possible_types(type).each do |pt|
+                unvisited_types << pt
               end
+            end
+            # Don't visit interface possible types -- it's not enough to justify visibility
 
-              # recurse into visible fields
-              fields(type).each do |field|
-                field_type = field.type.unwrap
-                unvisited_types << field_type
-                # recurse into visible arguments
-                arguments(field).each do |argument|
-                  argument_type = argument.type.unwrap
-                  unvisited_types << argument_type
-                end
+            # recurse into visible fields
+            fields(type).each do |field|
+              field_type = field.type.unwrap
+              # In this case, if it's an interface, we want to include
+              visit_type(field_type, unvisited_types, visited_type_set, type_by_name_hash, included_interface_possible_types_set, include_interface_possible_types: true)
+              # recurse into visible arguments
+              arguments(field).each do |argument|
+                argument_type = argument.type.unwrap
+                unvisited_types << argument_type
               end
             end
           end
         end
-
-        @reachable_type_set
       end
     end
   end

data/lib/graphql/schema.rb

@@ -37,10 +37,12 @@ require "graphql/schema/directive/skip"
 require "graphql/schema/directive/feature"
 require "graphql/schema/directive/flagged"
 require "graphql/schema/directive/transform"
+require "graphql/schema/directive/specified_by"
 require "graphql/schema/type_membership"
 
 require "graphql/schema/resolver"
 require "graphql/schema/mutation"
+require "graphql/schema/has_single_input_argument"
 require "graphql/schema/relay_classic_mutation"
 require "graphql/schema/subscription"
 
@@ -144,6 +146,19 @@ module GraphQL
         @subscriptions = new_implementation
       end
 
+      # @param new_mode [Symbol] If configured, this will be used when `context: { trace_mode: ... }` isn't set.
+      def default_trace_mode(new_mode = nil)
+        if new_mode
+          @default_trace_mode = new_mode
+        elsif defined?(@default_trace_mode)
+          @default_trace_mode
+        elsif superclass.respond_to?(:default_trace_mode)
+          superclass.default_trace_mode
+        else
+          :default
+        end
+      end
+
       def trace_class(new_class = nil)
         if new_class
           trace_mode(:default, new_class)
@@ -155,42 +170,66 @@ module GraphQL
       end
 
       # @return [Class] Return the trace class to use for this mode, looking one up on the superclass if this Schema doesn't have one defined.
-      def trace_class_for(mode)
-        @trace_modes ||= {}
-        @trace_modes[mode] ||= begin
-          case mode
-          when :default
-            superclass_base_class = if superclass.respond_to?(:trace_class_for)
-              superclass.trace_class_for(mode)
-            else
-              GraphQL::Tracing::Trace
-            end
-            Class.new(superclass_base_class)
-          when :default_backtrace
-            schema_base_class = trace_class_for(:default)
-            Class.new(schema_base_class) do
-              include(GraphQL::Backtrace::Trace)
-            end
-          else
-            mods = trace_modules_for(mode)
-            Class.new(trace_class_for(:default)) do
-              mods.any? && include(*mods)
-            end
-          end
-        end
+      def trace_class_for(mode, build: false)
+        own_trace_modes[mode] ||
+          (superclass.respond_to?(:trace_class_for) ? superclass.trace_class_for(mode) : nil)
       end
 
       # Configure `trace_class` to be used whenever `context: { trace_mode: mode_name }` is requested.
-      # `:default` is used when no `trace_mode: ...` is requested.
+      # {default_trace_mode} is used when no `trace_mode: ...` is requested.
+      #
+      # When a `trace_class` is added this way, it will _not_ receive other modules added with `trace_with(...)`
+      # unless `trace_mode` is explicitly given. (This class will not recieve any default trace modules.)
+      #
+      # Subclasses of the schema will use `trace_class` as a base class for this mode and those
+      # subclass also will _not_ receive default tracing modules.
+      #
       # @param mode_name [Symbol]
       # @param trace_class [Class] subclass of GraphQL::Tracing::Trace
       # @return void
       def trace_mode(mode_name, trace_class)
-        @trace_modes ||= {}
-        @trace_modes[mode_name] = trace_class
+        own_trace_modes[mode_name] = trace_class
         nil
       end
 
+      def own_trace_modes
+        @own_trace_modes ||= {}
+      end
+
+      module DefaultTraceClass
+      end
+
+      private_constant :DefaultTraceClass
+
+      def build_trace_mode(mode)
+        case mode
+        when :default
+          # Use the superclass's default mode if it has one, or else start an inheritance chain at the built-in base class.
+          base_class = (superclass.respond_to?(:trace_class_for) && superclass.trace_class_for(mode)) || GraphQL::Tracing::Trace
+          Class.new(base_class) do
+            include DefaultTraceClass
+          end
+        when :default_backtrace
+          schema_base_class = trace_class_for(:default)
+          Class.new(schema_base_class) do
+            include(GraphQL::Backtrace::Trace)
+          end
+        else
+          # First, see if the superclass has a custom-defined class for this.
+          # Then, if it doesn't, use this class's default trace
+          base_class = (superclass.respond_to?(:trace_class_for) && superclass.trace_class_for(mode)) || trace_class_for(:default)
+          # Prepare the default trace class if it hasn't been initialized yet
+          base_class ||= (own_trace_modes[:default] = build_trace_mode(:default))
+          mods = trace_modules_for(mode)
+          if base_class < DefaultTraceClass
+            mods = trace_modules_for(:default) + mods
+          end
+          Class.new(base_class) do
+            mods.any? && include(*mods)
+          end
+        end
+      end
+
       def own_trace_modules
         @own_trace_modules ||= Hash.new { |h, k| h[k] = [] }
       end
@@ -701,9 +740,10 @@ module GraphQL
 
       attr_writer :max_depth
 
-      def max_depth(new_max_depth = nil)
+      def max_depth(new_max_depth = nil, count_introspection_fields: true)
         if new_max_depth
           @max_depth = new_max_depth
+          @count_introspection_fields = count_introspection_fields
         elsif defined?(@max_depth)
           @max_depth
         else
@@ -711,6 +751,14 @@ module GraphQL
         end
       end
 
+      def count_introspection_fields
+        if defined?(@count_introspection_fields)
+          @count_introspection_fields
+        else
+          find_inherited_value(:count_introspection_fields, true)
+        end
+      end
+
       def disable_introspection_entry_points
         @disable_introspection_entry_points = true
         # TODO: this clears the cache made in `def types`. But this is not a great solution.
@@ -760,7 +808,16 @@ module GraphQL
           own_orphan_types.concat(new_orphan_types.flatten)
         end
 
-        find_inherited_value(:orphan_types, EMPTY_ARRAY) + own_orphan_types
+        inherited_ot = find_inherited_value(:orphan_types, nil)
+        if inherited_ot
+          if own_orphan_types.any?
+            inherited_ot + own_orphan_types
+          else
+            inherited_ot
+          end
+        else
+          own_orphan_types
+        end
       end
 
       def default_execution_strategy
@@ -864,8 +921,14 @@ module GraphQL
 
       def inherited(child_class)
         if self == GraphQL::Schema
+          child_class.own_trace_modes[:default] = child_class.build_trace_mode(:default)
           child_class.directives(default_directives.values)
         end
+        # Make sure the child class has these built out, so that
+        # subclasses can be modified by later calls to `trace_with`
+        own_trace_modes.each do |name, _class|
+          child_class.own_trace_modes[name] = child_class.build_trace_mode(name)
+        end
         child_class.singleton_class.prepend(ResolveTypeWithType)
         super
       end
@@ -962,7 +1025,12 @@ module GraphQL
           new_directives.flatten.each { |d| directive(d) }
         end
 
-        find_inherited_value(:directives, default_directives).merge(own_directives)
+        inherited_dirs = find_inherited_value(:directives, default_directives)
+        if own_directives.any?
+          inherited_dirs.merge(own_directives)
+        else
+          inherited_dirs
+        end
       end
 
       # Attach a single directive to this schema
@@ -978,11 +1046,13 @@ module GraphQL
           "skip" => GraphQL::Schema::Directive::Skip,
           "deprecated" => GraphQL::Schema::Directive::Deprecated,
           "oneOf" => GraphQL::Schema::Directive::OneOf,
+          "specifiedBy" => GraphQL::Schema::Directive::SpecifiedBy,
         }.freeze
       end
 
       def tracer(new_tracer)
-        if !(trace_class_for(:default) < GraphQL::Tracing::CallLegacyTracers)
+        default_trace = trace_class_for(:default)
+        if default_trace.nil? || !(default_trace < GraphQL::Tracing::CallLegacyTracers)
           trace_with(GraphQL::Tracing::CallLegacyTracers)
         end
 
@@ -1004,10 +1074,20 @@ module GraphQL
         if mode.is_a?(Array)
           mode.each { |m| trace_with(trace_mod, mode: m, **options) }
         else
-          tc = trace_class_for(mode)
+          tc = own_trace_modes[mode] ||= build_trace_mode(mode)
           tc.include(trace_mod)
-          if mode != :default
-            own_trace_modules[mode] << trace_mod
+          own_trace_modules[mode] << trace_mod
+
+          if mode == :default
+            # This module is being added as a default tracer. If any other mode classes
+            # have already been created, but get their default behavior from a superclass,
+            # Then mix this into this schema's subclass.
+            # (But don't mix it into mode classes that aren't default-based.)
+            own_trace_modes.each do |other_mode_name, other_mode_class|
+              if other_mode_class < DefaultTraceClass && !(other_mode_class < trace_mod)
+                other_mode_class.include(trace_mod)
+              end
+            end
           end
           t_opts = trace_options_for(mode)
           t_opts.merge!(options)
@@ -1030,6 +1110,8 @@ module GraphQL
 
       # Create a trace instance which will include the trace modules specified for the optional mode.
       #
+      # If no `mode:` is given, then {default_trace_mode} will be used.
+      #
       # @param mode [Symbol] Trace modules for this trade mode will be included
       # @param options [Hash] Keywords that will be passed to the tracing class during `#initialize`
       # @return [Tracing::Trace]
@@ -1040,14 +1122,19 @@ module GraphQL
         trace_mode = if mode
           mode
         elsif target && target.context[:backtrace]
-          :default_backtrace
+          if default_trace_mode != :default
+            raise ArgumentError, "Can't use `context[:backtrace]` with a custom default trace mode (`#{dm.inspect}`)"
+          else
+            own_trace_modes[:default_backtrace] ||= build_trace_mode(:default_backtrace)
+            :default_backtrace
+          end
         else
-          :default
+          default_trace_mode
         end
 
         base_trace_options = trace_options_for(trace_mode)
         trace_options = base_trace_options.merge(options)
-        trace_class_for_mode = trace_class_for(trace_mode)
+        trace_class_for_mode = trace_class_for(trace_mode) || raise(ArgumentError, "#{self} has no trace class for mode: #{trace_mode.inspect}")
         trace_class_for_mode.new(**trace_options)
       end
 

data/lib/graphql/static_validation/all_rules.rb

@@ -3,7 +3,7 @@ module GraphQL
   module StaticValidation
     # Default rules for {GraphQL::StaticValidation::Validator}
     #
-    # Order is important here. Some validators return {GraphQL::Language::Visitor::SKIP}
+    # Order is important here. Some validators skip later hooks.
     # which stops the visit on that node. That way it doesn't try to find fields on types that
     # don't exist, etc.
     ALL_RULES = [

data/lib/graphql/static_validation/base_visitor.rb

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 module GraphQL
   module StaticValidation
-    class BaseVisitor < GraphQL::Language::Visitor
+    class BaseVisitor < GraphQL::Language::StaticVisitor
       def initialize(document, context)
         @path = []
         @object_types = []