graphql 2.5.4 → 2.5.11

data/lib/graphql/query.rb

@@ -10,12 +10,47 @@ module GraphQL
     autoload :Context, "graphql/query/context"
     autoload :Fingerprint, "graphql/query/fingerprint"
     autoload :NullContext, "graphql/query/null_context"
+    autoload :Partial, "graphql/query/partial"
     autoload :Result, "graphql/query/result"
     autoload :Variables, "graphql/query/variables"
     autoload :InputValidationResult, "graphql/query/input_validation_result"
     autoload :VariableValidationError, "graphql/query/variable_validation_error"
     autoload :ValidationPipeline, "graphql/query/validation_pipeline"
 
+    # Code shared with {Partial}
+    module Runnable
+      def after_lazy(value, &block)
+        if !defined?(@runtime_instance)
+          @runtime_instance = context.namespace(:interpreter_runtime)[:runtime]
+        end
+
+        if @runtime_instance
+          @runtime_instance.minimal_after_lazy(value, &block)
+        else
+          @schema.after_lazy(value, &block)
+        end
+      end
+
+      # Node-level cache for calculating arguments. Used during execution and query analysis.
+      # @param ast_node [GraphQL::Language::Nodes::AbstractNode]
+      # @param definition [GraphQL::Schema::Field]
+      # @param parent_object [GraphQL::Schema::Object]
+      # @return [Hash{Symbol => Object}]
+      def arguments_for(ast_node, definition, parent_object: nil)
+        arguments_cache.fetch(ast_node, definition, parent_object)
+      end
+
+      def arguments_cache
+        @arguments_cache ||= Execution::Interpreter::ArgumentsCache.new(self)
+      end
+
+      # @api private
+      def handle_or_reraise(err)
+        @schema.handle_or_reraise(context, err)
+      end
+    end
+
+    include Runnable
     class OperationNameMissingError < GraphQL::ExecutionError
       def initialize(name)
         msg = if name.nil?
@@ -198,19 +233,10 @@ module GraphQL
     # @return [GraphQL::Execution::Lookahead]
     def lookahead
       @lookahead ||= begin
-        ast_node = selected_operation
-        if ast_node.nil?
+        if selected_operation.nil?
           GraphQL::Execution::Lookahead::NULL_LOOKAHEAD
         else
-          root_type = case ast_node.operation_type
-          when nil, "query"
-            types.query_root # rubocop:disable Development/ContextIsPassedCop
-          when "mutation"
-            types.mutation_root # rubocop:disable Development/ContextIsPassedCop
-          when "subscription"
-            types.subscription_root # rubocop:disable Development/ContextIsPassedCop
-          end
-          GraphQL::Execution::Lookahead.new(query: self, root_type: root_type, ast_nodes: [ast_node])
+          GraphQL::Execution::Lookahead.new(query: self, root_type: root_type, ast_nodes: [selected_operation])
         end
       end
     end
@@ -236,6 +262,18 @@ module GraphQL
       with_prepared_ast { @operations }
     end
 
+    # Run subtree partials of this query and return their results.
+    # Each partial is identified with a `path:` and `object:`
+    # where the path references a field in the AST and the object will be treated
+    # as the return value from that field. Subfields of the field named by `path`
+    # will be executed with `object` as the starting point
+    # @param partials_hashes [Array<Hash{Symbol => Object}>] Hashes with `path:` and `object:` keys
+    # @return [Array<GraphQL::Query::Result>]
+    def run_partials(partials_hashes)
+      partials = partials_hashes.map { |partial_options| Partial.new(query: self, **partial_options) }
+      Execution::Interpreter.run_all(@schema, partials, context: @context)
+    end
+
     # Get the result for this query, executing it once
     # @return [GraphQL::Query::Result] A Hash-like GraphQL response, with `"data"` and/or `"errors"` keys
     def result
@@ -278,19 +316,6 @@ module GraphQL
       end
     end
 
-    # Node-level cache for calculating arguments. Used during execution and query analysis.
-    # @param ast_node [GraphQL::Language::Nodes::AbstractNode]
-    # @param definition [GraphQL::Schema::Field]
-    # @param parent_object [GraphQL::Schema::Object]
-    # @return [Hash{Symbol => Object}]
-    def arguments_for(ast_node, definition, parent_object: nil)
-      arguments_cache.fetch(ast_node, definition, parent_object)
-    end
-
-    def arguments_cache
-      @arguments_cache ||= Execution::Interpreter::ArgumentsCache.new(self)
-    end
-
     # A version of the given query string, with:
     # - Variables inlined to the query
     # - Strings replaced with `<REDACTED>`
@@ -357,17 +382,21 @@ module GraphQL
 
     def root_type_for_operation(op_type)
       case op_type
-      when "query"
+      when "query", nil
         types.query_root # rubocop:disable Development/ContextIsPassedCop
       when "mutation"
         types.mutation_root # rubocop:disable Development/ContextIsPassedCop
       when "subscription"
         types.subscription_root # rubocop:disable Development/ContextIsPassedCop
       else
-        raise ArgumentError, "unexpected root type name: #{op_type.inspect}; expected 'query', 'mutation', or 'subscription'"
+        raise ArgumentError, "unexpected root type name: #{op_type.inspect}; expected nil, 'query', 'mutation', or 'subscription'"
       end
     end
 
+    def root_type
+      root_type_for_operation(selected_operation.operation_type)
+    end
+
     def types
       @visibility_profile || warden.visibility_profile
     end
@@ -400,23 +429,6 @@ module GraphQL
       with_prepared_ast { @subscription }
     end
 
-    # @api private
-    def handle_or_reraise(err)
-      schema.handle_or_reraise(context, err)
-    end
-
-    def after_lazy(value, &block)
-      if !defined?(@runtime_instance)
-        @runtime_instance = context.namespace(:interpreter_runtime)[:runtime]
-      end
-
-      if @runtime_instance
-        @runtime_instance.minimal_after_lazy(value, &block)
-      else
-        @schema.after_lazy(value, &block)
-      end
-    end
-
     attr_reader :logger
 
     private

data/lib/graphql/schema/addition.rb

@@ -258,7 +258,9 @@ module GraphQL
                 # We can get these now; we'll have to get late-bound types later
                 if interface_type.is_a?(Module) && type.is_a?(Class)
                   implementers = @possible_types[interface_type] ||= []
-                  implementers << type
+                  if !implementers.include?(type)
+                    implementers << type
+                  end
                 end
               when String, Schema::LateBoundType
                 interface_type = interface_type_membership

data/lib/graphql/schema/argument.rb

@@ -212,6 +212,11 @@ module GraphQL
         @statically_coercible = !requires_parent_object
       end
 
+      def freeze
+        statically_coercible?
+        super
+      end
+
       # Apply the {prepare} configuration to `value`, using methods from `obj`.
       # Used by the runtime.
       # @api private

data/lib/graphql/schema/build_from_definition.rb

@@ -187,6 +187,10 @@ module GraphQL
 
             object_types.each do |t|
               t.interfaces.each do |int_t|
+                if int_t.is_a?(LateBoundType)
+                  int_t = types[int_t.graphql_name]
+                  t.implements(int_t)
+                end
                 int_t.orphan_types(t)
               end
             end
@@ -519,7 +523,7 @@ module GraphQL
 
         def define_field_resolve_method(owner, method_name, field_name)
           owner.define_method(method_name) { |**args|
-            field_instance = self.class.get_field(field_name)
+            field_instance = context.types.field(owner, field_name)
             context.schema.definition_default_resolve.call(self.class, field_instance, object, args, context)
           }
         end

data/lib/graphql/schema/directive.rb

@@ -9,6 +9,7 @@ module GraphQL
     class Directive < GraphQL::Schema::Member
       extend GraphQL::Schema::Member::HasArguments
       extend GraphQL::Schema::Member::HasArguments::HasDirectiveArguments
+      extend GraphQL::Schema::Member::HasValidators
 
       class << self
         # Directives aren't types, they don't have kinds.
@@ -75,6 +76,10 @@ module GraphQL
           yield
         end
 
+        def validate!(arguments, context)
+          Schema::Validator.validate!(validators, self, context, arguments)
+        end
+
         def on_field?
           locations.include?(FIELD)
         end
@@ -111,6 +116,9 @@ module GraphQL
       # @return [GraphQL::Interpreter::Arguments]
       attr_reader :arguments
 
+      class InvalidArgumentError < GraphQL::Error
+      end
+
       def initialize(owner, **arguments)
         @owner = owner
         assert_valid_owner
@@ -119,7 +127,31 @@ module GraphQL
         # - lazy resolution
         # Probably, those won't be needed here, since these are configuration arguments,
         # not runtime arguments.
-        @arguments = self.class.coerce_arguments(nil, arguments, Query::NullContext.instance)
+        context = Query::NullContext.instance
+        self.class.all_argument_definitions.each do |arg_defn|
+          if arguments.key?(arg_defn.keyword)
+            value = arguments[arg_defn.keyword]
+            # This is a Ruby-land value; convert it to graphql for validation
+            graphql_value = begin
+              arg_defn.type.unwrap.coerce_isolated_result(value)
+            rescue GraphQL::Schema::Enum::UnresolvedValueError
+              # Let validation handle this
+              value
+            end
+          else
+            value = graphql_value = nil
+          end
+
+          result = arg_defn.type.validate_input(graphql_value, context)
+          if !result.valid?
+            raise InvalidArgumentError, "@#{graphql_name}.#{arg_defn.graphql_name} on #{owner.path} is invalid (#{value.inspect}): #{result.problems.first["explanation"]}"
+          end
+        end
+        self.class.validate!(arguments, context)
+        @arguments = self.class.coerce_arguments(nil, arguments, context)
+        if @arguments.is_a?(GraphQL::ExecutionError)
+          raise @arguments
+        end
       end
 
       def graphql_name

data/lib/graphql/schema/field.rb

@@ -616,6 +616,14 @@ module GraphQL
         end
       end
 
+      def freeze
+        type
+        owner_type
+        arguments_statically_coercible?
+        connection?
+        super
+      end
+
       class MissingReturnTypeError < GraphQL::Error; end
       attr_writer :type
 

data/lib/graphql/schema/input_object.rb

@@ -176,30 +176,37 @@ module GraphQL
             return GraphQL::Query::InputValidationResult.from_problem(INVALID_OBJECT_MESSAGE % { object: JSON.generate(input, quirks_mode: true) })
           end
 
-          # Inject missing required arguments
-          missing_required_inputs = ctx.types.arguments(self).reduce({}) do |m, (argument)|
-            if !input.key?(argument.graphql_name) && argument.type.non_null? && !argument.default_value? && types.argument(self, argument.graphql_name)
-              m[argument.graphql_name] = nil
-            end
-
-            m
-          end
 
           result = nil
-          [input, missing_required_inputs].each do |args_to_validate|
-            args_to_validate.each do |argument_name, value|
-              argument = types.argument(self, argument_name)
-              # Items in the input that are unexpected
-              if argument.nil?
-                result ||= Query::InputValidationResult.new
-                result.add_problem("Field is not defined on #{self.graphql_name}", [argument_name])
-              else
-                # Items in the input that are expected, but have invalid values
-                argument_result = argument.type.validate_input(value, ctx)
+
+
+          input.each do |argument_name, value|
+            argument = types.argument(self, argument_name)
+            if argument.nil? && ctx.is_a?(Query::NullContext) && argument_name.is_a?(Symbol)
+              # Validating definition directive arguments which come in as Symbols
+              argument = types.arguments(self).find { |arg| arg.keyword == argument_name }
+            end
+            # Items in the input that are unexpected
+            if argument.nil?
+              result ||= Query::InputValidationResult.new
+              result.add_problem("Field is not defined on #{self.graphql_name}", [argument_name])
+            else
+              # Items in the input that are expected, but have invalid values
+              argument_result = argument.type.validate_input(value, ctx)
+              if !argument_result.valid?
                 result ||= Query::InputValidationResult.new
-                if !argument_result.valid?
-                  result.merge_result!(argument_name, argument_result)
-                end
+                result.merge_result!(argument_name, argument_result)
+              end
+            end
+          end
+
+          # Check for missing non-null arguments
+          ctx.types.arguments(self).each do |argument|
+            if !input.key?(argument.graphql_name) && argument.type.non_null? && !argument.default_value?
+              result ||= Query::InputValidationResult.new
+              argument_result = argument.type.validate_input(nil, ctx)
+              if !argument_result.valid?
+                result.merge_result!(argument.graphql_name, argument_result)
               end
             end
           end

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

@@ -370,8 +370,8 @@ module GraphQL
                   end
 
                   passes_possible_types_check = if context.types.loadable?(arg_loads_type, context)
-                    if arg_loads_type.kind.union?
-                      # This union is used in `loads:` but not otherwise visible to this query
+                    if arg_loads_type.kind.abstract?
+                      # This union/interface is used in `loads:` but not otherwise visible to this query
                       context.types.loadable_possible_types(arg_loads_type, context).include?(application_object_type)
                     else
                       true

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

@@ -8,8 +8,8 @@ module GraphQL
           new_memberships = []
           new_interfaces.each do |int|
             if int.is_a?(Module)
-              unless int.include?(GraphQL::Schema::Interface)
-                raise "#{int} cannot be implemented since it's not a GraphQL Interface. Use `include` for plain Ruby modules."
+              unless int.include?(GraphQL::Schema::Interface) && !int.is_a?(Class)
+                raise "#{int.respond_to?(:graphql_name) ? "#{int.graphql_name} (#{int})" : int.inspect} cannot be implemented since it's not a GraphQL Interface. Use `include` for plain Ruby modules."
               end
 
               new_memberships << int.type_membership_class.new(int, self, **options)

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

@@ -12,12 +12,26 @@ module GraphQL
 
         # @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)
+          @to_non_null_type || begin
+            t = GraphQL::Schema::NonNull.new(self)
+            if frozen?
+              t
+            else
+              @to_non_null_type = t
+            end
+          end
         end
 
         # @return [Schema::List] Make a list-type representation of this type
         def to_list_type
-          @to_list_type ||= GraphQL::Schema::List.new(self)
+          @to_list_type || begin
+            t = GraphQL::Schema::List.new(self)
+            if frozen?
+              t
+            else
+              @to_list_type = t
+            end
+          end
         end
 
         # @return [Boolean] true if this is a non-nullable type. A nullable list of non-nullables is considered nullable.

data/lib/graphql/schema/ractor_shareable.rb

@@ -0,0 +1,79 @@
+# frozen_string_literal: true
+module GraphQL
+  class Schema
+    module RactorShareable
+      def self.extended(schema_class)
+        schema_class.extend(SchemaExtension)
+        schema_class.freeze_schema
+      end
+
+      module SchemaExtension
+
+        def freeze_error_handlers(handlers)
+          handlers[:subclass_handlers].default_proc = nil
+          handlers[:subclass_handlers].each do |_class, subclass_handlers|
+            freeze_error_handlers(subclass_handlers)
+          end
+          Ractor.make_shareable(handlers)
+        end
+
+        def freeze_schema
+          # warm some ivars:
+          default_analysis_engine
+          default_execution_strategy
+          GraphQL.default_parser
+          default_logger
+          freeze_error_handlers(error_handlers)
+          # TODO: this freezes errors of parent classes which could cause trouble
+          parent_class = superclass
+          while parent_class.respond_to?(:error_handlers)
+            freeze_error_handlers(parent_class.error_handlers)
+            parent_class = parent_class.superclass
+          end
+
+          own_tracers.freeze
+          @frozen_tracers = tracers.freeze
+          own_trace_modes.each do |m|
+            trace_options_for(m)
+            build_trace_mode(m)
+          end
+          build_trace_mode(:default)
+          Ractor.make_shareable(@trace_options_for_mode)
+          Ractor.make_shareable(own_trace_modes)
+          Ractor.make_shareable(own_multiplex_analyzers)
+          @frozen_multiplex_analyzers = Ractor.make_shareable(multiplex_analyzers)
+          Ractor.make_shareable(own_query_analyzers)
+          @frozen_query_analyzers = Ractor.make_shareable(query_analyzers)
+          Ractor.make_shareable(own_plugins)
+          own_plugins.each do |(plugin, options)|
+            Ractor.make_shareable(plugin)
+            Ractor.make_shareable(options)
+          end
+          @frozen_plugins = Ractor.make_shareable(plugins)
+          Ractor.make_shareable(own_references_to)
+          @frozen_directives = Ractor.make_shareable(directives)
+
+          Ractor.make_shareable(visibility)
+          Ractor.make_shareable(introspection_system)
+          extend(FrozenMethods)
+
+          Ractor.make_shareable(self)
+          superclass.respond_to?(:freeze_schema) && superclass.freeze_schema
+        end
+
+        module FrozenMethods
+          def tracers; @frozen_tracers; end
+          def multiplex_analyzers; @frozen_multiplex_analyzers; end
+          def query_analyzers; @frozen_query_analyzers; end
+          def plugins; @frozen_plugins; end
+          def directives; @frozen_directives; end
+
+          # This actually accumulates info during execution...
+          # How to support it?
+          def lazy?(_obj); false; end
+          def sync_lazy(obj); obj; end
+        end
+      end
+    end
+  end
+end

data/lib/graphql/schema/scalar.rb

@@ -50,12 +50,7 @@ module GraphQL
           end
 
           if coerced_result.nil?
-            str_value = if value == Float::INFINITY
-              ""
-            else
-              " #{GraphQL::Language.serialize(value)}"
-            end
-            Query::InputValidationResult.from_problem("Could not coerce value#{str_value} to #{graphql_name}")
+            Query::InputValidationResult.from_problem("Could not coerce value #{GraphQL::Language.serialize(value)} to #{graphql_name}")
           elsif coerced_result.is_a?(GraphQL::CoercionError)
             Query::InputValidationResult.from_problem(coerced_result.message, message: coerced_result.message, extensions: coerced_result.extensions)
           else

data/lib/graphql/schema/timeout.rb

@@ -71,15 +71,23 @@ module GraphQL
         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)
+          if timeout_state == false
+            super
+          elsif Process.clock_gettime(Process::CLOCK_MONOTONIC, :millisecond) > timeout_state.fetch(:timeout_at)
             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
               @timeout.handle_timeout(error, query)
+              timeout_state = query.context.namespace(@timeout).fetch(:state)
             end
 
-            error
+            # `handle_timeout` may have set this to be `false`
+            if timeout_state != false
+              error
+            else
+              super
+            end
           else
             super
           end
@@ -102,6 +110,15 @@ module GraphQL
         # override to do something interesting
       end
 
+      # Call this method (eg, from {#handle_timeout}) to disable timeout tracking
+      # for the given query.
+      # @param query [GraphQL::Query]
+      # @return [void]
+      def disable_timeout(query)
+        query.context.namespace(self)[:state] = false
+        nil
+      end
+
       # This error is raised when a query exceeds `max_seconds`.
       # Since it's a child of {GraphQL::ExecutionError},
       # its message will be added to the response's `errors` key.

data/lib/graphql/schema/validator/required_validator.rb

@@ -96,26 +96,35 @@ module GraphQL
         end
 
         def build_message(context)
-          argument_definitions = @validated.arguments(context).values
+          argument_definitions = context.types.arguments(@validated)
+
           required_names = @one_of.map do |arg_keyword|
             if arg_keyword.is_a?(Array)
-              names = arg_keyword.map { |arg| arg_keyword_to_grapqhl_name(argument_definitions, arg) }
+              names = arg_keyword.map { |arg| arg_keyword_to_graphql_name(argument_definitions, arg) }
+              names.compact! # hidden arguments are `nil`
               "(" + names.join(" and ") + ")"
             else
-              arg_keyword_to_grapqhl_name(argument_definitions, arg_keyword)
+              arg_keyword_to_graphql_name(argument_definitions, arg_keyword)
             end
           end
+          required_names.compact! # remove entries for hidden arguments
+
 
-          if required_names.size == 1
+          case required_names.size
+          when 0
+            # The required definitions were hidden from the client.
+            # Another option here would be to raise an error in the application....
+            "%{validated} is missing a required argument."
+          when 1
             "%{validated} must include the following argument: #{required_names.first}."
           else
             "%{validated} must include exactly one of the following arguments: #{required_names.join(", ")}."
           end
         end
 
-        def arg_keyword_to_grapqhl_name(argument_definitions, arg_keyword)
+        def arg_keyword_to_graphql_name(argument_definitions, arg_keyword)
           argument_definition = argument_definitions.find { |defn| defn.keyword == arg_keyword }
-          argument_definition.graphql_name
+          argument_definition&.graphql_name
         end
       end
     end

data/lib/graphql/schema/visibility/migration.rb

@@ -76,10 +76,10 @@ module GraphQL
           end
         end
 
-        def initialize(context:, schema:, name: nil)
+        def initialize(context:, schema:, name: nil, visibility:)
           @name = name
           @skip_error = context[:skip_visibility_migration_error] || context.is_a?(Query::NullContext) || context.is_a?(Hash)
-          @profile_types = GraphQL::Schema::Visibility::Profile.new(context: context, schema: schema)
+          @profile_types = GraphQL::Schema::Visibility::Profile.new(context: context, schema: schema, visibility: visibility)
           if !@skip_error
             context[:visibility_migration_running] = true
             warden_ctx_vals = context.to_h.dup