graphql 1.13.12 → 2.0.21

data/lib/graphql/execution/multiplex.rb

@@ -23,18 +23,16 @@ 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
+      attr_reader :context, :queries, :schema, :max_complexity, :dataloader, :current_trace
+
       def initialize(schema:, queries:, context:, max_complexity:)
         @schema = schema
         @queries = queries
         @queries.each { |q| q.multiplex = self }
         @context = context
+        @current_trace = @context[:trace] || schema.new_trace(multiplex: self)
         @dataloader = @context[:dataloader] ||= @schema.dataloader_class.new
         @tracers = schema.tracers + (context[:tracers] || [])
         # Support `context: {backtrace: true}`
@@ -43,175 +41,6 @@ module GraphQL
         end
         @max_complexity = max_complexity
       end
-
-      class << self
-        def run_all(schema, query_options, **kwargs)
-          queries = query_options.map { |opts| GraphQL::Query.new(schema, nil, **opts) }
-          run_queries(schema, queries, **kwargs)
-        end
-
-        # @param schema [GraphQL::Schema]
-        # @param queries [Array<GraphQL::Query>]
-        # @param context [Hash]
-        # @param max_complexity [Integer, nil]
-        # @return [Array<Hash>] One result per query
-        def run_queries(schema, queries, context: {}, max_complexity: schema.max_complexity)
-          multiplex = self.new(schema: schema, queries: queries, context: context, max_complexity: max_complexity)
-          multiplex.trace("execute_multiplex", { multiplex: multiplex }) do
-            if supports_multiplexing?(schema)
-              instrument_and_analyze(multiplex) do
-                run_as_multiplex(multiplex)
-              end
-            else
-              if queries.length != 1
-                raise ArgumentError, "Multiplexing doesn't support custom execution strategies, run one query at a time instead"
-              else
-                instrument_and_analyze(multiplex) do
-                  [run_one_legacy(schema, queries.first)]
-                end
-              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
-              # These were checked to be the same in `#supports_multiplexing?`
-              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
-
-        def run_as_multiplex(multiplex)
-
-          multiplex.schema.query_execution_strategy.begin_multiplex(multiplex)
-          queries = multiplex.queries
-          # 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
-
-        # @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
-
-        # use the old `query_execution_strategy` etc to run this query
-        def run_one_legacy(schema, query)
-          GraphQL::Deprecation.warn "Multiplex.run_one_legacy will be removed from GraphQL-Ruby 2.0, upgrade to the Interpreter to avoid this deprecated codepath: https://graphql-ruby.org/queries/interpreter.html"
-
-          query.result_values = if !query.valid?
-            all_errors = query.validation_errors + query.analysis_errors + query.context.errors
-            if all_errors.any?
-              { "errors" => all_errors.map(&:to_h) }
-            else
-              nil
-            end
-          else
-            GraphQL::Query::Executor.new(query).result
-          end
-        end
-
-        DEFAULT_STRATEGIES = [
-          GraphQL::Execution::Execute,
-          GraphQL::Execution::Interpreter
-        ]
-        # @return [Boolean] True if the schema is only using one strategy, and it's one that supports multiplexing.
-        def supports_multiplexing?(schema)
-          schema_strategies = [schema.query_execution_strategy, schema.mutation_execution_strategy, schema.subscription_execution_strategy]
-          schema_strategies.uniq!
-          schema_strategies.size == 1 && DEFAULT_STRATEGIES.include?(schema_strategies.first)
-        end
-
-        # Apply multiplex & query instrumentation to `queries`.
-        #
-        # It yields when the queries should be executed, then runs teardown.
-        def instrument_and_analyze(multiplex)
-          GraphQL::Execution::Instrumentation.apply_instrumenters(multiplex) do
-            schema = multiplex.schema
-            if schema.interpreter? && schema.analysis_engine != GraphQL::Analysis::AST
-              raise <<-ERR
-Can't use `GraphQL::Execution::Interpreter` without `GraphQL::Analysis::AST`, please add this plugin to your schema:
-
-    use GraphQL::Analysis::AST
-
-For information about the new analysis engine: https://graphql-ruby.org/queries/ast_analysis.html
-ERR
-            end
-            multiplex_analyzers = schema.multiplex_analyzers
-            if multiplex.max_complexity
-              multiplex_analyzers += if schema.using_ast_analysis?
-                [GraphQL::Analysis::AST::MaxQueryComplexity]
-              else
-                [GraphQL::Analysis::MaxQueryComplexity.new(multiplex.max_complexity)]
-              end
-            end
-
-            schema.analysis_engine.analyze_multiplex(multiplex, multiplex_analyzers)
-            yield
-          end
-        end
-      end
     end
   end
 end

data/lib/graphql/execution.rb

@@ -1,11 +1,18 @@
 # frozen_string_literal: true
 require "graphql/execution/directive_checks"
-require "graphql/execution/execute"
-require "graphql/execution/flatten"
-require "graphql/execution/instrumentation"
 require "graphql/execution/interpreter"
 require "graphql/execution/lazy"
 require "graphql/execution/lookahead"
 require "graphql/execution/multiplex"
-require "graphql/execution/typecast"
 require "graphql/execution/errors"
+
+module GraphQL
+  module Execution
+    # @api private
+    class Skip < GraphQL::Error; end
+
+    # Just a singleton for implementing {Query::Context#skip}
+    # @api private
+    SKIP = Skip.new
+  end
+end

data/lib/graphql/filter.rb

@@ -1,8 +1,13 @@
 # frozen_string_literal: true
+require "graphql/deprecation"
+
 module GraphQL
   # @api private
   class Filter
-    def initialize(only: nil, except: nil)
+    def initialize(only: nil, except: nil, silence_deprecation_warning: false)
+      if !silence_deprecation_warning
+        GraphQL::Deprecation.warn("GraphQL::Filter is deprecated and will be removed in v2.1.0. Implement `visible?` on your schema members instead (https://graphql-ruby.org/authorization/visibility.html).")
+      end
       @only = only
       @except = except
     end
@@ -17,7 +22,7 @@ module GraphQL
       onlies = [self].concat(Array(only))
       merged_only = MergedOnly.build(onlies)
       merged_except = MergedExcept.build(Array(except))
-      self.class.new(only: merged_only, except: merged_except)
+      self.class.new(only: merged_only, except: merged_except, silence_deprecation_warning: true)
     end
 
     private

data/lib/graphql/introspection/directive_type.rb

@@ -11,8 +11,8 @@ module GraphQL
                     "to the executor."
       field :name, String, null: false, method: :graphql_name
       field :description, String
-      field :locations, [GraphQL::Schema::LateBoundType.new("__DirectiveLocation")], null: false
-      field :args, [GraphQL::Schema::LateBoundType.new("__InputValue")], null: false do
+      field :locations, [GraphQL::Schema::LateBoundType.new("__DirectiveLocation")], null: false, scope: false
+      field :args, [GraphQL::Schema::LateBoundType.new("__InputValue")], null: false, scope: false do
         argument :include_deprecated, Boolean, required: false, default_value: false
       end
       field :on_operation, Boolean, null: false, deprecation_reason: "Use `locations`.", method: :on_operation?

data/lib/graphql/introspection/dynamic_fields.rb

@@ -2,15 +2,10 @@
 module GraphQL
   module Introspection
     class DynamicFields < Introspection::BaseObject
-      field :__typename, String, "The name of this type", null: false, extras: [:irep_node]
+      field :__typename, String, "The name of this type", null: false
 
-      # `irep_node:` will be nil for the interpreter, since there is no such thing
-      def __typename(irep_node: nil)
-        if context.interpreter?
-          object.class.graphql_name
-        else
-          irep_node.owner_type.name
-        end
+      def __typename
+        object.class.graphql_name
       end
     end
   end

data/lib/graphql/introspection/entry_points.rb

@@ -11,24 +11,11 @@ module GraphQL
         # Apply wrapping manually since this field isn't wrapped by instrumentation
         schema = @context.query.schema
         schema_type = schema.introspection_system.types["__Schema"]
-        schema_type.type_class.authorized_new(schema, @context)
+        schema_type.authorized_new(schema, @context)
       end
 
       def __type(name:)
-        return unless context.warden.reachable_type?(name)
-        type = context.warden.get_type(name)
-
-        if type && context.interpreter? && !type.is_a?(Module)
-          type = type.type_class || raise("Invariant: interpreter requires class-based type for #{name}")
-        end
-
-        # The interpreter provides this wrapping, other execution doesnt, so support both.
-        if type && !context.interpreter?
-          # Apply wrapping manually since this field isn't wrapped by instrumentation
-          type_type = context.schema.introspection_system.types["__Type"]
-          type = type_type.type_class.authorized_new(type, context)
-        end
-        type
+        context.warden.reachable_type?(name) ? context.warden.get_type(name) : nil
       end
     end
   end

data/lib/graphql/introspection/field_type.rb

@@ -7,7 +7,7 @@ module GraphQL
                   "a name, potentially a list of arguments, and a return type."
       field :name, String, null: false
       field :description, String
-      field :args, [GraphQL::Schema::LateBoundType.new("__InputValue")], null: false do
+      field :args, [GraphQL::Schema::LateBoundType.new("__InputValue")], null: false, scope: false do
         argument :include_deprecated, Boolean, required: false, default_value: false
       end
       field :type, GraphQL::Schema::LateBoundType.new("__Type"), null: false

data/lib/graphql/introspection/schema_type.rb

@@ -8,11 +8,11 @@ module GraphQL
                   "available types and directives on the server, as well as the entry points for "\
                   "query, mutation, and subscription operations."
 
-      field :types, [GraphQL::Schema::LateBoundType.new("__Type")], "A list of all types supported by this server.", null: false
+      field :types, [GraphQL::Schema::LateBoundType.new("__Type")], "A list of all types supported by this server.", null: false, scope: false
       field :query_type, GraphQL::Schema::LateBoundType.new("__Type"), "The type that query operations will be rooted at.", null: false
       field :mutation_type, GraphQL::Schema::LateBoundType.new("__Type"), "If this server supports mutation, the type that mutation operations will be rooted at."
       field :subscription_type, GraphQL::Schema::LateBoundType.new("__Type"), "If this server support subscription, the type that subscription operations will be rooted at."
-      field :directives, [GraphQL::Schema::LateBoundType.new("__Directive")], "A list of all directives supported by this server.", null: false
+      field :directives, [GraphQL::Schema::LateBoundType.new("__Directive")], "A list of all directives supported by this server.", null: false, scope: false
       field :description, String, resolver_method: :schema_description
 
       def schema_description

data/lib/graphql/introspection/type_type.rb

@@ -14,20 +14,27 @@ module GraphQL
       field :kind, GraphQL::Schema::LateBoundType.new("__TypeKind"), null: false
       field :name, String, method: :graphql_name
       field :description, String
-      field :fields, [GraphQL::Schema::LateBoundType.new("__Field")] do
+      field :fields, [GraphQL::Schema::LateBoundType.new("__Field")], scope: false do
         argument :include_deprecated, Boolean, required: false, default_value: false
       end
-      field :interfaces, [GraphQL::Schema::LateBoundType.new("__Type")]
-      field :possible_types, [GraphQL::Schema::LateBoundType.new("__Type")]
-      field :enum_values, [GraphQL::Schema::LateBoundType.new("__EnumValue")] do
+      field :interfaces, [GraphQL::Schema::LateBoundType.new("__Type")], scope: false
+      field :possible_types, [GraphQL::Schema::LateBoundType.new("__Type")], scope: false
+      field :enum_values, [GraphQL::Schema::LateBoundType.new("__EnumValue")], scope: false do
         argument :include_deprecated, Boolean, required: false, default_value: false
       end
-      field :input_fields, [GraphQL::Schema::LateBoundType.new("__InputValue")]  do
+      field :input_fields, [GraphQL::Schema::LateBoundType.new("__InputValue")], scope: false  do
         argument :include_deprecated, Boolean, required: false, default_value: false
       end
       field :of_type, GraphQL::Schema::LateBoundType.new("__Type")
 
-      field :specified_by_url, String
+      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?

data/lib/graphql/introspection.rb

@@ -1,10 +1,10 @@
 # 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
+      <<-QUERY.gsub(/\n{2,}/, "\n")
 query IntrospectionQuery {
   __schema {
     #{include_schema_description ? "description" : ""}
@@ -29,7 +29,8 @@ fragment FullType on __Type {
   kind
   name
   description
-  #{include_specified_by_url ? "specifiedByUrl" : ""}
+  #{include_specified_by_url ? "specifiedByURL" : ""}
+  #{include_is_one_of ? "isOneOf" : ""}
   fields(includeDeprecated: true) {
     name
     description

data/lib/graphql/language/document_from_schema_definition.rb

@@ -22,8 +22,9 @@ module GraphQL
         @include_introspection_types = include_introspection_types
         @include_built_in_scalars = include_built_in_scalars
         @include_built_in_directives = include_built_in_directives
+        @include_one_of = false
 
-        filter = GraphQL::Filter.new(only: only, except: except)
+        filter = GraphQL::Filter.new(only: only, except: except, silence_deprecation_warning: true)
         if @schema.respond_to?(:visible?)
           filter = filter.merge(only: @schema.method(:visible?))
         end
@@ -44,16 +45,18 @@ module GraphQL
       end
 
       def build_schema_node
-        GraphQL::Language::Nodes::SchemaDefinition.new(
-          query: (q = warden.root_type_for_operation("query")) && q.graphql_name,
-          mutation: (m = warden.root_type_for_operation("mutation")) && m.graphql_name,
-          subscription: (s = warden.root_type_for_operation("subscription")) && s.graphql_name,
-          # This only supports directives from parsing,
-          # use a custom printer to add to this list.
-          #
+        schema_options = {
           # `@schema.directives` is covered by `build_definition_nodes`
-          directives: ast_directives(@schema),
-        )
+          directives: definition_directives(@schema, :schema_directives),
+        }
+        if !schema_respects_root_name_conventions?(@schema)
+          schema_options.merge!({
+            query: (q = warden.root_type_for_operation("query")) && q.graphql_name,
+            mutation: (m = warden.root_type_for_operation("mutation")) && m.graphql_name,
+            subscription: (s = warden.root_type_for_operation("subscription")) && s.graphql_name,
+          })
+        end
+        GraphQL::Language::Nodes::SchemaDefinition.new(schema_options)
       end
 
       def build_object_type_node(object_type)
@@ -243,20 +246,30 @@ module GraphQL
       end
 
       def build_directive_nodes(directives)
-        if !include_built_in_directives
-          directives = directives.reject { |directive| directive.default_directive? }
-        end
-
         directives
           .map { |directive| build_directive_node(directive) }
           .sort_by(&:name)
       end
 
       def build_definition_nodes
-        definitions = []
-        definitions << build_schema_node if include_schema_node?
-        definitions += build_directive_nodes(warden.directives)
-        definitions += build_type_definition_nodes(warden.reachable_types)
+        dirs_to_build = warden.directives
+        if !include_built_in_directives
+          dirs_to_build = dirs_to_build.reject { |directive| directive.default_directive? }
+        end
+        dir_nodes = build_directive_nodes(dirs_to_build)
+
+        type_nodes = build_type_definition_nodes(warden.reachable_types)
+
+        if @include_one_of
+          # This may have been set to true when iterating over all types
+          dir_nodes.concat(build_directive_nodes([GraphQL::Schema::Directive::OneOf]))
+        end
+
+        definitions = [*dir_nodes, *type_nodes]
+        if include_schema_node?
+          definitions.unshift(build_schema_node)
+        end
+
         definitions
       end
 
@@ -283,7 +296,9 @@ module GraphQL
       private
 
       def include_schema_node?
-        always_include_schema || !schema_respects_root_name_conventions?(schema)
+        always_include_schema ||
+          !schema_respects_root_name_conventions?(schema) ||
+          !schema.schema_directives.empty?
       end
 
       def schema_respects_root_name_conventions?(schema)
@@ -293,14 +308,14 @@ module GraphQL
       end
 
       def directives(member)
-        definition_directives(member)
+        definition_directives(member, :directives)
       end
 
-      def definition_directives(member)
-        dirs = if !member.respond_to?(:directives) || member.directives.empty?
+      def definition_directives(member, directives_method)
+        dirs = if !member.respond_to?(directives_method) || member.directives.empty?
           []
         else
-          member.directives.map do |dir|
+          member.public_send(directives_method).map do |dir|
             args = []
             dir.arguments.argument_values.each_value do |arg_value| # rubocop:disable Development/ContextIsPassedCop -- directive instance method
               arg_defn = arg_value.definition
@@ -314,6 +329,11 @@ module GraphQL
                 )
               end
             end
+
+            # If this schema uses this built-in directive definition,
+            # include it in the print-out since it's not part of the spec yet.
+            @include_one_of ||= dir.class == GraphQL::Schema::Directive::OneOf
+
             GraphQL::Language::Nodes::Directive.new(
               name: dir.class.graphql_name,
               arguments: args
@@ -321,30 +341,9 @@ module GraphQL
           end
         end
 
-        # This is just for printing legacy `.define { ... }` schemas, where `deprecation_reason` isn't added to `.directives`.
-        if !member.respond_to?(:directives) && member.respond_to?(:deprecation_reason) && (reason = member.deprecation_reason)
-          arguments = []
-
-          if reason != GraphQL::Schema::Directive::DEFAULT_DEPRECATION_REASON
-            arguments << GraphQL::Language::Nodes::Argument.new(
-              name: "reason",
-              value: reason
-            )
-          end
-
-          dirs << GraphQL::Language::Nodes::Directive.new(
-            name: GraphQL::Directive::DeprecatedDirective.graphql_name,
-            arguments: arguments
-          )
-        end
-
         dirs
       end
 
-      def ast_directives(member)
-        member.ast_node ? member.ast_node.directives : []
-      end
-
       attr_reader :schema, :warden, :always_include_schema,
         :include_introspection_types, :include_built_in_directives, :include_built_in_scalars
     end