graphql 2.0.13 → 2.0.14

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: b8f389d3b7c8052a74ccd4bd9e8412a1fa9d93415e6caeec883b8f179a167395
-  data.tar.gz: f2e6ab7ba5c1e76b0c44557855ab3af55fb2b718b8de1ff6483917de603734b3
+  metadata.gz: a3bc6610f88b6689ee6991a6ad3543580f9bdf1b3cb9f2f7e3f78862d76072f7
+  data.tar.gz: ce52505d6c43e330aa8e5def38719f62bdfe067274a86530c889350c64994bd0
 SHA512:
-  metadata.gz: 10a24271a65c65a402d3243d2e43b3b257f74eb7bbc0ec13c254304bdce3122c444a41fbccf943bd3d626d301aec4b973485f742b831e8658ea252a0c95cfcfa
-  data.tar.gz: 9762008c699f2a53b14913e057dc31ec6c97b4203b1dd28a7a2a4fc18153d5bc200d0a95e3d2a04da80d0486131f5b1ce8d597e1ad6a7085b0766e35e0982959
+  metadata.gz: 8f3aac93aa1013c257c84521b54285719d6edb8c212a83140123902a06f3cffabc1005d2a176b723cff5677614eab7ae1617b71ce7eb403e721fcbafbe07c1e1
+  data.tar.gz: a84bf37728b5c0ff8795070fd682ac7af83e8888d47cadff5103a76ee333788c30bf78f505528fee4f868288b99dfc11d82f7c604710e13b4a7d9690eb2efe36

data/lib/generators/graphql/templates/schema.erb

@@ -23,5 +23,8 @@ class <%= schema_name %> < GraphQL::Schema
     # to return the correct GraphQL object type for `obj`
     raise(GraphQL::RequiredImplementationMissingError)
   end
+
+  # Stop validating when it encounters this many errors:
+  validate_max_errors(100)
 end
 <% end -%>

data/lib/graphql/dataloader/source.rb

@@ -86,6 +86,15 @@ module GraphQL
         !@pending_keys.empty?
       end
 
+      # Add these key-value pairs to this source's cache
+      # (future loads will use these merged values).
+      # @param results [Hash<Object => Object>] key-value pairs to cache in this source
+      # @return [void]
+      def merge(results)
+        @results.merge!(results)
+        nil
+      end
+
       # Called by {GraphQL::Dataloader} to resolve and pending requests to this source.
       # @api private
       # @return [void]

data/lib/graphql/execution/interpreter.rb

@@ -11,76 +11,202 @@ require "graphql/execution/interpreter/handles_raw_value"
 module GraphQL
   module Execution
     class Interpreter
-      def self.begin_multiplex(multiplex)
-        # Since this is basically the batching context,
-        # share it for a whole multiplex
-        multiplex.context[:interpreter_instance] ||= self.new
-      end
+      class << self
+        # Used internally to signal that the query shouldn't be executed
+        # @api private
+        NO_OPERATION = {}.freeze
 
-      def self.begin_query(query, multiplex)
-        # The batching context is shared by the multiplex,
-        # so fetch it out and use that instance.
-        interpreter =
-          query.context.namespace(:interpreter)[:interpreter_instance] =
-          multiplex.context[:interpreter_instance]
-        interpreter.evaluate(query)
-        query
-      end
+        # @param schema [GraphQL::Schema]
+        # @param queries [Array<GraphQL::Query, Hash>]
+        # @param context [Hash]
+        # @param max_complexity [Integer, nil]
+        # @return [Array<Hash>] One result per query
+        def run_all(schema, query_options, context: {}, max_complexity: schema.max_complexity)
+          queries = query_options.map do |opts|
+            case opts
+            when Hash
+              GraphQL::Query.new(schema, nil, **opts)
+            when GraphQL::Query
+              opts
+            else
+              raise "Expected Hash or GraphQL::Query, not #{opts.class} (#{opts.inspect})"
+            end
+          end
 
-      def self.finish_multiplex(_results, multiplex)
-        interpreter = multiplex.context[:interpreter_instance]
-        interpreter.sync_lazies(multiplex: multiplex)
-      end
+          multiplex = Execution::Multiplex.new(schema: schema, queries: queries, context: context, max_complexity: max_complexity)
+          multiplex.trace("execute_multiplex", { multiplex: multiplex }) do
+            schema = multiplex.schema
+            queries = multiplex.queries
+            query_instrumenters = schema.instrumenters[:query]
+            multiplex_instrumenters = schema.instrumenters[:multiplex]
 
-      def self.finish_query(query, _multiplex)
-        {
-          "data" => query.context.namespace(:interpreter)[:runtime].final_result
-        }
-      end
+            # First, run multiplex instrumentation, then query instrumentation for each query
+            call_hooks(multiplex_instrumenters, multiplex, :before_multiplex, :after_multiplex) do
+              each_query_call_hooks(query_instrumenters, queries) do
+                schema = multiplex.schema
+                multiplex_analyzers = schema.multiplex_analyzers
+                queries = multiplex.queries
+                if multiplex.max_complexity
+                  multiplex_analyzers += [GraphQL::Analysis::AST::MaxQueryComplexity]
+                end
 
-      # Run the eager part of `query`
-      # @return {Interpreter::Runtime}
-      def evaluate(query)
-        # Although queries in a multiplex _share_ an Interpreter instance,
-        # they also have another item of state, which is private to that query
-        # in particular, assign it here:
-        runtime = Runtime.new(query: query)
-        query.context.namespace(:interpreter)[:runtime] = runtime
-
-        query.trace("execute_query", {query: query}) do
-          runtime.run_eager
-        end
+                schema.analysis_engine.analyze_multiplex(multiplex, multiplex_analyzers)
+                begin
+                  # Since this is basically the batching context,
+                  # share it for a whole multiplex
+                  multiplex.context[:interpreter_instance] ||= multiplex.schema.query_execution_strategy.new
+                  # Do as much eager evaluation of the query as possible
+                  results = []
+                  queries.each_with_index do |query, idx|
+                    multiplex.dataloader.append_job {
+                      operation = query.selected_operation
+                      result = if operation.nil? || !query.valid? || query.context.errors.any?
+                        NO_OPERATION
+                      else
+                        begin
+                          # Although queries in a multiplex _share_ an Interpreter instance,
+                          # they also have another item of state, which is private to that query
+                          # in particular, assign it here:
+                          runtime = Runtime.new(query: query)
+                          query.context.namespace(:interpreter)[:runtime] = runtime
 
-        runtime
-      end
+                          query.trace("execute_query", {query: query}) do
+                            runtime.run_eager
+                          end
+                        rescue GraphQL::ExecutionError => err
+                          query.context.errors << err
+                          NO_OPERATION
+                        end
+                      end
+                      results[idx] = result
+                    }
+                  end
+
+                  multiplex.dataloader.run
+
+                  # Then, work through lazy results in a breadth-first way
+                  multiplex.dataloader.append_job {
+                    tracer = multiplex
+                    query = multiplex.queries.length == 1 ? multiplex.queries[0] : nil
+                    queries = multiplex ? multiplex.queries : [query]
+                    final_values = queries.map do |query|
+                      runtime = query.context.namespace(:interpreter)[:runtime]
+                      # it might not be present if the query has an error
+                      runtime ? runtime.final_result : nil
+                    end
+                    final_values.compact!
+                    tracer.trace("execute_query_lazy", {multiplex: multiplex, query: query}) do
+                      Interpreter::Resolve.resolve_all(final_values, multiplex.dataloader)
+                    end
+                    queries.each do |query|
+                      runtime = query.context.namespace(:interpreter)[:runtime]
+                      if runtime
+                        runtime.delete_interpreter_context(:current_path)
+                        runtime.delete_interpreter_context(:current_field)
+                        runtime.delete_interpreter_context(:current_object)
+                        runtime.delete_interpreter_context(:current_arguments)
+                      end
+                    end
+                  }
+                  multiplex.dataloader.run
+
+                  # Then, find all errors and assign the result to the query object
+                  results.each_with_index do |data_result, idx|
+                    query = queries[idx]
+                    # Assign the result so that it can be accessed in instrumentation
+                    query.result_values = if data_result.equal?(NO_OPERATION)
+                      if !query.valid? || query.context.errors.any?
+                        # A bit weird, but `Query#static_errors` _includes_ `query.context.errors`
+                        { "errors" => query.static_errors.map(&:to_h) }
+                      else
+                        data_result
+                      end
+                    else
+                      result = {
+                        "data" => query.context.namespace(:interpreter)[:runtime].final_result
+                      }
+
+                      if query.context.errors.any?
+                        error_result = query.context.errors.map(&:to_h)
+                        result["errors"] = error_result
+                      end
 
-      # Run the lazy part of `query` or `multiplex`.
-      # @return [void]
-      def sync_lazies(query: nil, multiplex: nil)
-        tracer = query || multiplex
-        if query.nil? && multiplex.queries.length == 1
-          query = multiplex.queries[0]
+                      result
+                    end
+                    if query.context.namespace?(:__query_result_extensions__)
+                      query.result_values["extensions"] = query.context.namespace(:__query_result_extensions__)
+                    end
+                    # Get the Query::Result, not the Hash
+                    results[idx] = query.result
+                  end
+
+                  results
+                rescue Exception
+                  # TODO rescue at a higher level so it will catch errors in analysis, too
+                  # Assign values here so that the query's `@executed` becomes true
+                  queries.map { |q| q.result_values ||= {} }
+                  raise
+                end
+              end
+            end
+          end
         end
-        queries = multiplex ? multiplex.queries : [query]
-        final_values = queries.map do |query|
-          runtime = query.context.namespace(:interpreter)[:runtime]
-          # it might not be present if the query has an error
-          runtime ? runtime.final_result : nil
+
+        private
+
+        # Call the before_ hooks of each query,
+        # Then yield if no errors.
+        # `call_hooks` takes care of appropriate cleanup.
+        def each_query_call_hooks(instrumenters, queries, i = 0)
+          if i >= queries.length
+            yield
+          else
+            query = queries[i]
+            call_hooks(instrumenters, query, :before_query, :after_query) {
+              each_query_call_hooks(instrumenters, queries, i + 1) {
+                yield
+              }
+            }
+          end
         end
-        final_values.compact!
-        tracer.trace("execute_query_lazy", {multiplex: multiplex, query: query}) do
-          Interpreter::Resolve.resolve_all(final_values, multiplex.dataloader)
+
+        # Call each before hook, and if they all succeed, yield.
+        # If they don't all succeed, call after_ for each one that succeeded.
+        def call_hooks(instrumenters, object, before_hook_name, after_hook_name)
+          begin
+            successful = []
+            instrumenters.each do |instrumenter|
+              instrumenter.public_send(before_hook_name, object)
+              successful << instrumenter
+            end
+
+            # if any before hooks raise an exception, quit calling before hooks,
+            # but call the after hooks on anything that succeeded but also
+            # raise the exception that came from the before hook.
+          rescue GraphQL::ExecutionError => err
+            object.context.errors << err
+          rescue => e
+            raise call_after_hooks(successful, object, after_hook_name, e)
+          end
+
+          begin
+            yield # Call the user code
+          ensure
+            ex = call_after_hooks(successful, object, after_hook_name, nil)
+            raise ex if ex
+          end
         end
-        queries.each do |query|
-          runtime = query.context.namespace(:interpreter)[:runtime]
-          if runtime
-            runtime.delete_interpreter_context(:current_path)
-            runtime.delete_interpreter_context(:current_field)
-            runtime.delete_interpreter_context(:current_object)
-            runtime.delete_interpreter_context(:current_arguments)
+
+        def call_after_hooks(instrumenters, object, after_hook_name, ex)
+          instrumenters.reverse_each do |instrumenter|
+            begin
+              instrumenter.public_send(after_hook_name, object)
+            rescue => e
+              ex = e
+            end
           end
+          ex
         end
-        nil
       end
 
       class ListResultFailedError < GraphQL::Error

data/lib/graphql/execution/lookahead.rb

@@ -87,16 +87,28 @@ module GraphQL
 
       # Like {#selects?}, but can be used for chaining.
       # It returns a null object (check with {#selected?})
+      # @param field_name [String, Symbol]
       # @return [GraphQL::Execution::Lookahead]
       def selection(field_name, selected_type: @selected_type, arguments: nil)
-        next_field_name = normalize_name(field_name)
+        next_field_defn = case field_name
+        when String
+          @query.get_field(selected_type, field_name)
+        when Symbol
+          # Try to avoid the `.to_s` below, if possible
+          all_fields = @query.warden.fields(selected_type)
+          if (match_by_orig_name = all_fields.find { |f| f.original_name == field_name })
+            match_by_orig_name
+          else
+            guessed_name = Schema::Member::BuildType.camelize(field_name.to_s)
+            @query.get_field(selected_type, guessed_name)
+          end
+        end
 
-        next_field_defn = @query.get_field(selected_type, next_field_name)
         if next_field_defn
           next_nodes = []
           @ast_nodes.each do |ast_node|
             ast_node.selections.each do |selection|
-              find_selected_nodes(selection, next_field_name, next_field_defn, arguments: arguments, matches: next_nodes)
+              find_selected_nodes(selection, next_field_defn, arguments: arguments, matches: next_nodes)
             end
           end
 
@@ -196,23 +208,6 @@ module GraphQL
 
       private
 
-      # If it's a symbol, stringify and camelize it
-      def normalize_name(name)
-        if name.is_a?(Symbol)
-          Schema::Member::BuildType.camelize(name.to_s)
-        else
-          name
-        end
-      end
-
-      def normalize_keyword(keyword)
-        if keyword.is_a?(String)
-          Schema::Member::BuildType.underscore(keyword).to_sym
-        else
-          keyword
-        end
-      end
-
       def skipped_by_directive?(ast_selection)
         ast_selection.directives.each do |directive|
           dir_defn = @query.schema.directives.fetch(directive.name)
@@ -265,11 +260,11 @@ module GraphQL
 
       # If a selection on `node` matches `field_name` (which is backed by `field_defn`)
       # and matches the `arguments:` constraints, then add that node to `matches`
-      def find_selected_nodes(node, field_name, field_defn, arguments:, matches:)
+      def find_selected_nodes(node, field_defn, arguments:, matches:)
         return if skipped_by_directive?(node)
         case node
         when GraphQL::Language::Nodes::Field
-          if node.name == field_name
+          if node.name == field_defn.graphql_name
             if arguments.nil? || arguments.empty?
               # No constraint applied
               matches << node
@@ -278,10 +273,10 @@ module GraphQL
             end
           end
         when GraphQL::Language::Nodes::InlineFragment
-          node.selections.each { |s| find_selected_nodes(s, field_name, field_defn, arguments: arguments, matches: matches) }
+          node.selections.each { |s| find_selected_nodes(s, field_defn, arguments: arguments, matches: matches) }
         when GraphQL::Language::Nodes::FragmentSpread
           frag_defn = @query.fragments[node.name] || raise("Invariant: Can't look ahead to nonexistent fragment #{node.name} (found: #{@query.fragments.keys})")
-          frag_defn.selections.each { |s| find_selected_nodes(s, field_name, field_defn, arguments: arguments, matches: matches) }
+          frag_defn.selections.each { |s| find_selected_nodes(s, field_defn, arguments: arguments, matches: matches) }
         else
           raise "Unexpected selection comparison on #{node.class.name} (#{node})"
         end
@@ -290,9 +285,14 @@ module GraphQL
       def arguments_match?(arguments, field_defn, field_node)
         query_kwargs = @query.arguments_for(field_node, field_defn)
         arguments.all? do |arg_name, arg_value|
-          arg_name = normalize_keyword(arg_name)
+          arg_name_sym = if arg_name.is_a?(String)
+            Schema::Member::BuildType.underscore(arg_name).to_sym
+          else
+            arg_name
+          end
+
           # Make sure the constraint is present with a matching value
-          query_kwargs.key?(arg_name) && query_kwargs[arg_name] == arg_value
+          query_kwargs.key?(arg_name_sym) && query_kwargs[arg_name_sym] == arg_value
         end
       end
     end

data/lib/graphql/execution/multiplex.rb

@@ -23,13 +23,10 @@ module GraphQL
     # @see {Schema#multiplex} for public API
     # @api private
     class Multiplex
-      # Used internally to signal that the query shouldn't be executed
-      # @api private
-      NO_OPERATION = {}.freeze
-
       include Tracing::Traceable
 
       attr_reader :context, :queries, :schema, :max_complexity, :dataloader
+
       def initialize(schema:, queries:, context:, max_complexity:)
         @schema = schema
         @queries = queries
@@ -43,118 +40,6 @@ module GraphQL
         end
         @max_complexity = max_complexity
       end
-
-      class << self
-        # @param schema [GraphQL::Schema]
-        # @param queries [Array<GraphQL::Query, Hash>]
-        # @param context [Hash]
-        # @param max_complexity [Integer, nil]
-        # @return [Array<Hash>] One result per query
-        def run_all(schema, query_options, context: {}, max_complexity: schema.max_complexity)
-          queries = query_options.map do |opts|
-            case opts
-            when Hash
-              GraphQL::Query.new(schema, nil, **opts)
-            when GraphQL::Query
-              opts
-            else
-              raise "Expected Hash or GraphQL::Query, not #{opts.class} (#{opts.inspect})"
-            end
-          end
-
-          multiplex = self.new(schema: schema, queries: queries, context: context, max_complexity: max_complexity)
-          multiplex.trace("execute_multiplex", { multiplex: multiplex }) do
-            GraphQL::Execution::Instrumentation.apply_instrumenters(multiplex) do
-              schema = multiplex.schema
-              multiplex_analyzers = schema.multiplex_analyzers
-              if multiplex.max_complexity
-                multiplex_analyzers += [GraphQL::Analysis::AST::MaxQueryComplexity]
-              end
-
-              schema.analysis_engine.analyze_multiplex(multiplex, multiplex_analyzers)
-
-              begin
-                multiplex.schema.query_execution_strategy.begin_multiplex(multiplex)
-                # Do as much eager evaluation of the query as possible
-                results = []
-                queries.each_with_index do |query, idx|
-                  multiplex.dataloader.append_job { begin_query(results, idx, query, multiplex) }
-                end
-
-                multiplex.dataloader.run
-
-                # Then, work through lazy results in a breadth-first way
-                multiplex.dataloader.append_job {
-                  multiplex.schema.query_execution_strategy.finish_multiplex(results, multiplex)
-                }
-                multiplex.dataloader.run
-
-                # Then, find all errors and assign the result to the query object
-                results.each_with_index do |data_result, idx|
-                  query = queries[idx]
-                  finish_query(data_result, query, multiplex)
-                  # Get the Query::Result, not the Hash
-                  results[idx] = query.result
-                end
-
-                results
-              rescue Exception
-                # TODO rescue at a higher level so it will catch errors in analysis, too
-                # Assign values here so that the query's `@executed` becomes true
-                queries.map { |q| q.result_values ||= {} }
-                raise
-              end
-            end
-          end
-        end
-
-        # @param query [GraphQL::Query]
-        def begin_query(results, idx, query, multiplex)
-          operation = query.selected_operation
-          result = if operation.nil? || !query.valid? || query.context.errors.any?
-            NO_OPERATION
-          else
-            begin
-              query.schema.query_execution_strategy.begin_query(query, multiplex)
-            rescue GraphQL::ExecutionError => err
-              query.context.errors << err
-              NO_OPERATION
-            end
-          end
-          results[idx] = result
-          nil
-        end
-
-        private
-
-        # @param data_result [Hash] The result for the "data" key, if any
-        # @param query [GraphQL::Query] The query which was run
-        # @return [Hash] final result of this query, including all values and errors
-        def finish_query(data_result, query, multiplex)
-          # Assign the result so that it can be accessed in instrumentation
-          query.result_values = if data_result.equal?(NO_OPERATION)
-            if !query.valid? || query.context.errors.any?
-              # A bit weird, but `Query#static_errors` _includes_ `query.context.errors`
-              { "errors" => query.static_errors.map(&:to_h) }
-            else
-              data_result
-            end
-          else
-            # Use `context.value` which was assigned during execution
-            result = query.schema.query_execution_strategy.finish_query(query, multiplex)
-
-            if query.context.errors.any?
-              error_result = query.context.errors.map(&:to_h)
-              result["errors"] = error_result
-            end
-
-            result
-          end
-          if query.context.namespace?(:__query_result_extensions__)
-            query.result_values["extensions"] = query.context.namespace(:__query_result_extensions__)
-          end
-        end
-      end
     end
   end
 end

data/lib/graphql/execution.rb

@@ -1,6 +1,5 @@
 # frozen_string_literal: true
 require "graphql/execution/directive_checks"
-require "graphql/execution/instrumentation"
 require "graphql/execution/interpreter"
 require "graphql/execution/lazy"
 require "graphql/execution/lookahead"

data/lib/graphql/introspection/type_type.rb

@@ -29,6 +29,13 @@ module GraphQL
 
       field :specifiedByURL, String, resolver_method: :specified_by_url
 
+      field :is_one_of, Boolean, null: false
+
+      def is_one_of
+        object.kind.input_object? &&
+          object.directives.any? { |d| d.graphql_name == "oneOf" }
+      end
+
       def specified_by_url
         if object.kind.scalar?
           object.specified_by_url

data/lib/graphql/introspection.rb

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 module GraphQL
   module Introspection
-    def self.query(include_deprecated_args: false, include_schema_description: false, include_is_repeatable: false, include_specified_by_url: false)
+    def self.query(include_deprecated_args: false, include_schema_description: false, include_is_repeatable: false, include_specified_by_url: false, include_is_one_of: false)
       # The introspection query to end all introspection queries, copied from
       # https://github.com/graphql/graphql-js/blob/master/src/utilities/introspectionQuery.js
       <<-QUERY
@@ -30,6 +30,7 @@ fragment FullType on __Type {
   name
   description
   #{include_specified_by_url ? "specifiedByURL" : ""}
+  #{include_is_one_of ? "isOneOf" : ""}
   fields(includeDeprecated: true) {
     name
     description

data/lib/graphql/query.rb

@@ -196,7 +196,7 @@ module GraphQL
     # @return [Hash] A GraphQL response, with `"data"` and/or `"errors"` keys
     def result
       if !@executed
-        Execution::Multiplex.run_all(@schema, [self], context: @context)
+        Execution::Interpreter.run_all(@schema, [self], context: @context)
       end
       @result ||= Query::Result.new(query: self, values: @result_values)
     end

data/lib/graphql/schema/build_from_definition.rb

@@ -55,14 +55,13 @@ module GraphQL
             end
           })
 
+          directives.merge!(GraphQL::Schema.default_directives)
           document.definitions.each do |definition|
             if definition.is_a?(GraphQL::Language::Nodes::DirectiveDefinition)
               directives[definition.name] = build_directive(definition, directive_type_resolver)
             end
           end
 
-          directives = GraphQL::Schema.default_directives.merge(directives)
-
           # In case any directives referenced built-in types for their arguments:
           replace_late_bound_types_with_built_in(types)
 

data/lib/graphql/schema/directive/one_of.rb

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+module GraphQL
+  class Schema
+    class Directive < GraphQL::Schema::Member
+      class OneOf < GraphQL::Schema::Directive
+        description "Requires that exactly one field must be supplied and that field must not be `null`."
+        locations(GraphQL::Schema::Directive::INPUT_OBJECT)
+        default_directive true
+      end
+    end
+  end
+end

data/lib/graphql/schema/input_object.rb

@@ -69,6 +69,19 @@ module GraphQL
         true
       end
 
+      def self.one_of
+        if !one_of?
+          if all_argument_definitions.any? { |arg| arg.type.non_null? }
+            raise ArgumentError, "`one_of` may not be used with required arguments -- add `required: false` to argument definitions to use `one_of`"
+          end
+          directive(GraphQL::Schema::Directive::OneOf)
+        end
+      end
+
+      def self.one_of?
+        directives.any? { |d| d.is_a?(GraphQL::Schema::Directive::OneOf) }
+      end
+
       def unwrap_value(value)
         case value
         when Array
@@ -109,6 +122,14 @@ module GraphQL
       class << self
         def argument(*args, **kwargs, &block)
           argument_defn = super(*args, **kwargs, &block)
+          if one_of?
+            if argument_defn.type.non_null?
+              raise ArgumentError, "Argument '#{argument_defn.path}' must be nullable because it is part of a OneOf type, add `required: false`."
+            end
+            if argument_defn.default_value?
+              raise ArgumentError, "Argument '#{argument_defn.path}' cannot have a default value because it is part of a OneOf type, remove `default_value: ...`."
+            end
+          end
           # Add a method access
           method_name = argument_defn.keyword
           class_eval <<-RUBY, __FILE__, __LINE__
@@ -166,6 +187,20 @@ module GraphQL
             end
           end
 
+          if one_of?
+            if input.size == 1
+              input.each do |name, value|
+                if value.nil?
+                  result ||= Query::InputValidationResult.new
+                  result.add_problem("'#{graphql_name}' requires exactly one argument, but '#{name}' was `null`.")
+                end
+              end
+            else
+              result ||= Query::InputValidationResult.new
+              result.add_problem("'#{graphql_name}' requires exactly one argument, but #{input.size} were provided.")
+            end
+          end
+
           result
         end
 

data/lib/graphql/schema/late_bound_type.rb

@@ -27,6 +27,10 @@ module GraphQL
         "#<LateBoundType @name=#{name}>"
       end
 
+      def non_null?
+        false
+      end
+
       alias :to_s :inspect
     end
   end

data/lib/graphql/schema.rb

@@ -31,6 +31,7 @@ require "graphql/schema/union"
 require "graphql/schema/directive"
 require "graphql/schema/directive/deprecated"
 require "graphql/schema/directive/include"
+require "graphql/schema/directive/one_of"
 require "graphql/schema/directive/skip"
 require "graphql/schema/directive/feature"
 require "graphql/schema/directive/flagged"
@@ -913,6 +914,7 @@ module GraphQL
           "include" => GraphQL::Schema::Directive::Include,
           "skip" => GraphQL::Schema::Directive::Skip,
           "deprecated" => GraphQL::Schema::Directive::Deprecated,
+          "oneOf" => GraphQL::Schema::Directive::OneOf,
         }.freeze
       end
 
@@ -990,7 +992,7 @@ module GraphQL
       # @param context [Hash] Multiplex-level context
       # @return [Array<Hash>] One result for each query in the input
       def multiplex(queries, **kwargs)
-        GraphQL::Execution::Multiplex.run_all(self, queries, **kwargs)
+        GraphQL::Execution::Interpreter.run_all(self, queries, **kwargs)
       end
 
       def instrumenters

data/lib/graphql/static_validation/all_rules.rb

@@ -36,6 +36,7 @@ module GraphQL
       GraphQL::StaticValidation::QueryRootExists,
       GraphQL::StaticValidation::SubscriptionRootExists,
       GraphQL::StaticValidation::InputObjectNamesAreUnique,
+      GraphQL::StaticValidation::OneOfInputObjectsAreValid,
     ]
   end
 end

data/lib/graphql/static_validation/literal_validator.rb

@@ -108,6 +108,10 @@ module GraphQL
             arg_type = @warden.get_argument(type, name).type
             recursively_validate(GraphQL::Language::Nodes::NullValue.new(name: name), arg_type)
           end
+
+          if type.one_of? && ast_node.arguments.size != 1
+            results << Query::InputValidationResult.from_problem("`#{type.graphql_name}` is a OneOf type, so only one argument may be given (instead of #{ast_node.arguments.size})")
+          end
           merge_results(results)
         end
       end

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

@@ -0,0 +1,66 @@
+# frozen_string_literal: true
+module GraphQL
+  module StaticValidation
+    module OneOfInputObjectsAreValid
+      def on_input_object(node, parent)
+        return super unless parent.is_a?(GraphQL::Language::Nodes::Argument)
+
+        parent_type = get_parent_type(context, parent)
+        return super unless parent_type && parent_type.kind.input_object? && parent_type.one_of?
+
+        validate_one_of_input_object(node, context, parent_type)
+        super
+      end
+
+      private
+
+      def validate_one_of_input_object(ast_node, context, parent_type)
+        present_fields = ast_node.arguments.map(&:name)
+        input_object_type = parent_type.to_type_signature
+
+        if present_fields.count != 1
+          add_error(
+            OneOfInputObjectsAreValidError.new(
+              "OneOf Input Object '#{input_object_type}' must specify exactly one key.",
+              path: context.path,
+              nodes: ast_node,
+              input_object_type: input_object_type
+            )
+          )
+          return
+        end
+
+        field = present_fields.first
+        value = ast_node.arguments.first.value
+
+        if value.is_a?(GraphQL::Language::Nodes::NullValue)
+          add_error(
+            OneOfInputObjectsAreValidError.new(
+              "Argument '#{input_object_type}.#{field}' must be non-null.",
+              path: [*context.path, field],
+              nodes: ast_node.arguments.first,
+              input_object_type: input_object_type
+            )
+          )
+          return
+        end
+
+        if value.is_a?(GraphQL::Language::Nodes::VariableIdentifier)
+          variable_name = value.name
+          variable_type = @declared_variables[variable_name].type
+
+          unless variable_type.is_a?(GraphQL::Language::Nodes::NonNullType)
+            add_error(
+              OneOfInputObjectsAreValidError.new(
+                "Variable '#{variable_name}' must be non-nullable to be used for OneOf Input Object '#{input_object_type}'.",
+                path: [*context.path, field],
+                nodes: ast_node,
+                input_object_type: input_object_type
+              )
+            )
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+module GraphQL
+  module StaticValidation
+    class OneOfInputObjectsAreValidError < StaticValidation::Error
+      attr_reader :input_object_type
+
+      def initialize(message, path:, nodes:, input_object_type:)
+        super(message, path: path, nodes: nodes)
+        @input_object_type = input_object_type
+      end
+
+      # A hash representation of this Message
+      def to_h
+        extensions = {
+          "code" => code,
+          "inputObjectType" => input_object_type
+        }
+
+        super.merge({
+          "extensions" => extensions
+        })
+      end
+
+      def code
+        "invalidOneOfInputObject"
+      end
+    end
+  end
+end

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

@@ -23,7 +23,7 @@ module GraphQL
                 problems = validation_result.problems
                 first_problem = problems && problems.first
                 if first_problem
-                  error_message = first_problem["message"]
+                  error_message = first_problem["explanation"]
                 end
 
                 error_message ||= "Default value for $#{node.name} doesn't match type #{type.to_type_signature}"

data/lib/graphql/tracing/data_dog_tracing.rb

@@ -75,10 +75,12 @@ module GraphQL
       end
 
       def analytics_enabled?
+        # [Deprecated] options[:analytics_enabled] will be removed in the future
         analytics_available? && Datadog::Contrib::Analytics.enabled?(options.fetch(:analytics_enabled, false))
       end
 
       def analytics_sample_rate
+        # [Deprecated] options[:analytics_sample_rate] will be removed in the future
         options.fetch(:analytics_sample_rate, 1.0)
       end
 

data/lib/graphql/version.rb

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

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: graphql
 version: !ruby/object:Gem::Version
-  version: 2.0.13
+  version: 2.0.14
 platform: ruby
 authors:
 - Robert Mosolgo
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2022-08-12 00:00:00.000000000 Z
+date: 2022-09-08 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: benchmark-ips
@@ -303,7 +303,6 @@ files:
 - lib/graphql/execution.rb
 - lib/graphql/execution/directive_checks.rb
 - lib/graphql/execution/errors.rb
-- lib/graphql/execution/instrumentation.rb
 - lib/graphql/execution/interpreter.rb
 - lib/graphql/execution/interpreter/argument_value.rb
 - lib/graphql/execution/interpreter/arguments.rb
@@ -394,6 +393,7 @@ files:
 - lib/graphql/schema/directive/feature.rb
 - lib/graphql/schema/directive/flagged.rb
 - lib/graphql/schema/directive/include.rb
+- lib/graphql/schema/directive/one_of.rb
 - lib/graphql/schema/directive/skip.rb
 - lib/graphql/schema/directive/transform.rb
 - lib/graphql/schema/enum.rb
@@ -497,6 +497,8 @@ files:
 - lib/graphql/static_validation/rules/mutation_root_exists_error.rb
 - lib/graphql/static_validation/rules/no_definitions_are_present.rb
 - lib/graphql/static_validation/rules/no_definitions_are_present_error.rb
+- lib/graphql/static_validation/rules/one_of_input_objects_are_valid.rb
+- lib/graphql/static_validation/rules/one_of_input_objects_are_valid_error.rb
 - lib/graphql/static_validation/rules/operation_names_are_valid.rb
 - lib/graphql/static_validation/rules/operation_names_are_valid_error.rb
 - lib/graphql/static_validation/rules/query_root_exists.rb
@@ -595,7 +597,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.2.22
+rubygems_version: 3.2.33
 signing_key:
 specification_version: 4
 summary: A GraphQL language and runtime for Ruby

data/lib/graphql/execution/instrumentation.rb

@@ -1,92 +0,0 @@
-# frozen_string_literal: true
-module GraphQL
-  module Execution
-    module Instrumentation
-      # This function implements the instrumentation policy:
-      #
-      # - Instrumenters are a stack; the first `before_query` will have the last `after_query`
-      # - If a `before_` hook returned without an error, its corresponding `after_` hook will run.
-      # - If the `before_` hook did _not_ run, the `after_` hook will not be called.
-      #
-      # When errors are raised from `after_` hooks:
-      #   - Subsequent `after_` hooks _are_ called
-      #   - The first raised error is captured; later errors are ignored
-      #   - If an error was capture, it's re-raised after all hooks are finished
-      #
-      # Partial runs of instrumentation are possible:
-      # - If a `before_multiplex` hook raises an error, no `before_query` hooks will run
-      # - If a `before_query` hook raises an error, subsequent `before_query` hooks will not run (on any query)
-      def self.apply_instrumenters(multiplex)
-        schema = multiplex.schema
-        queries = multiplex.queries
-        query_instrumenters = schema.instrumenters[:query]
-        multiplex_instrumenters = schema.instrumenters[:multiplex]
-
-        # First, run multiplex instrumentation, then query instrumentation for each query
-        call_hooks(multiplex_instrumenters, multiplex, :before_multiplex, :after_multiplex) do
-          each_query_call_hooks(query_instrumenters, queries) do
-            # Let them be executed
-            yield
-          end
-        end
-      end
-
-      class << self
-        private
-        # Call the before_ hooks of each query,
-        # Then yield if no errors.
-        # `call_hooks` takes care of appropriate cleanup.
-        def each_query_call_hooks(instrumenters, queries, i = 0)
-          if i >= queries.length
-            yield
-          else
-            query = queries[i]
-            call_hooks(instrumenters, query, :before_query, :after_query) {
-              each_query_call_hooks(instrumenters, queries, i + 1) {
-                yield
-              }
-            }
-          end
-        end
-
-        # Call each before hook, and if they all succeed, yield.
-        # If they don't all succeed, call after_ for each one that succeeded.
-        def call_hooks(instrumenters, object, before_hook_name, after_hook_name)
-          begin
-            successful = []
-            instrumenters.each do |instrumenter|
-              instrumenter.public_send(before_hook_name, object)
-              successful << instrumenter
-            end
-
-            # if any before hooks raise an exception, quit calling before hooks,
-            # but call the after hooks on anything that succeeded but also
-            # raise the exception that came from the before hook.
-          rescue GraphQL::ExecutionError => err
-            object.context.errors << err
-          rescue => e
-            raise call_after_hooks(successful, object, after_hook_name, e)
-          end
-
-          begin
-            yield # Call the user code
-          ensure
-            ex = call_after_hooks(successful, object, after_hook_name, nil)
-            raise ex if ex
-          end
-        end
-
-        def call_after_hooks(instrumenters, object, after_hook_name, ex)
-          instrumenters.reverse_each do |instrumenter|
-            begin
-              instrumenter.public_send(after_hook_name, object)
-            rescue => e
-              ex = e
-            end
-          end
-          ex
-        end
-      end
-    end
-  end
-end