graphql 1.13.17 → 2.0.20

data/lib/graphql/query/validation_pipeline.rb

@@ -18,7 +18,6 @@ module GraphQL
 
       def initialize(query:, parse_error:, operation_name_error:, max_depth:, max_complexity:)
         @validation_errors = []
-        @internal_representation = nil
         @parse_error = parse_error
         @operation_name_error = operation_name_error
         @query = query
@@ -41,17 +40,15 @@ module GraphQL
         @validation_errors
       end
 
-      # @return [Hash<String, nil => GraphQL::InternalRepresentation::Node] Operation name -> Irep node pairs
-      def internal_representation
-        ensure_has_validated
-        @internal_representation
-      end
-
       def analyzers
         ensure_has_validated
         @query_analyzers
       end
 
+      def has_validated?
+        @has_validated == true
+      end
+
       private
 
       # If the pipeline wasn't run yet, run it.
@@ -62,7 +59,7 @@ module GraphQL
 
         if @parse_error
           # This is kind of crazy: we push the parse error into `ctx`
-          # in {DefaultParseError} so that users can _opt out_ by redefining that hook.
+          # in `def self.parse_error` by default so that users can _opt out_ by redefining that hook.
           # That means we can't _re-add_ the error here (otherwise we'd either
           # add it twice _or_ override the user's choice to not add it).
           # So we just have to know that it was invalid and go from there.
@@ -73,7 +70,6 @@ module GraphQL
         else
           validation_result = @schema.static_validator.validate(@query, validate: @query.validate, timeout: @schema.validate_timeout, max_errors: @schema.validate_max_errors)
           @validation_errors.concat(validation_result[:errors])
-          @internal_representation = validation_result[:irep]
 
           if @validation_errors.empty?
             @validation_errors.concat(@query.variables.errors)
@@ -99,35 +95,15 @@ module GraphQL
       def build_analyzers(schema, max_depth, max_complexity)
         qa = schema.query_analyzers.dup
 
-        # Filter out the built in authorization analyzer.
-        # It is deprecated and does not have an AST analyzer alternative.
-        qa = qa.select do |analyzer|
-          if analyzer == GraphQL::Authorization::Analyzer && schema.using_ast_analysis?
-            raise "The Authorization analyzer is not supported with AST Analyzers"
-          else
-            true
-          end
-        end
-
         if max_depth || max_complexity
           # Depending on the analysis engine, we must use different analyzers
           # remove this once everything has switched over to AST analyzers
-          if schema.using_ast_analysis?
-            if max_depth
-              qa << GraphQL::Analysis::AST::MaxQueryDepth
-            end
-            if max_complexity
-              qa << GraphQL::Analysis::AST::MaxQueryComplexity
-            end
-          else
-            if max_depth
-              qa << GraphQL::Analysis::MaxQueryDepth.new(max_depth)
-            end
-            if max_complexity
-              qa << GraphQL::Analysis::MaxQueryComplexity.new(max_complexity)
-            end
+          if max_depth
+            qa << GraphQL::Analysis::AST::MaxQueryDepth
+          end
+          if max_complexity
+            qa << GraphQL::Analysis::AST::MaxQueryComplexity
           end
-
           qa
         else
           qa

data/lib/graphql/query/variables.rb

@@ -14,7 +14,7 @@ module GraphQL
         schema = ctx.schema
         @context = ctx
 
-        @provided_variables = GraphQL::Argument.deep_stringify(provided_variables)
+        @provided_variables = deep_stringify(provided_variables)
         @errors = []
         @storage = ast_variables.each_with_object({}) do |ast_variable, memo|
           if schema.validate_max_errors && schema.validate_max_errors <= @errors.count
@@ -39,25 +39,12 @@ module GraphQL
               if validation_result.valid?
                 if value_was_provided
                   # Add the variable if a value was provided
-                  memo[variable_name] = if ctx.interpreter?
-                    provided_value
-                  elsif provided_value.nil?
-                    nil
-                  else
-                    schema.error_handler.with_error_handling(context) do
-                      variable_type.coerce_input(provided_value, ctx)
-                    end
-                  end
+                  memo[variable_name] = provided_value
                 elsif default_value != nil
-                  memo[variable_name] = if ctx.interpreter?
-                    if default_value.is_a?(Language::Nodes::NullValue)
-                      nil
-                    else
-                      default_value
-                    end
+                  memo[variable_name] = if default_value.is_a?(Language::Nodes::NullValue)
+                    nil
                   else
-                    # Add the variable if it wasn't provided but it has a default value (including `null`)
-                    GraphQL::Query::LiteralInput.coerce(variable_type, default_value, self)
+                    default_value
                   end
                 end
               end
@@ -93,12 +80,12 @@ module GraphQL
         else
           val
         end
-      end
+      end    
 
       def add_max_errors_reached_message
         message = "Too many errors processing variables, max validation error limit reached. Execution aborted"
         validation_result = GraphQL::Query::InputValidationResult.from_problem(message)
-        errors << GraphQL::Query::VariableValidationError.new(nil, nil, nil, validation_result, msg: message)
+        errors << GraphQL::Query::VariableValidationError.new(nil, nil, nil, validation_result, msg: message) 
       end
     end
   end

data/lib/graphql/query.rb

@@ -1,13 +1,8 @@
 # frozen_string_literal: true
-require "graphql/query/arguments"
-require "graphql/query/arguments_cache"
 require "graphql/query/context"
-require "graphql/query/executor"
 require "graphql/query/fingerprint"
-require "graphql/query/literal_input"
 require "graphql/query/null_context"
 require "graphql/query/result"
-require "graphql/query/serial_execution"
 require "graphql/query/variables"
 require "graphql/query/input_validation_result"
 require "graphql/query/variable_validation_error"
@@ -39,7 +34,16 @@ module GraphQL
     attr_accessor :operation_name
 
     # @return [Boolean] if false, static validation is skipped (execution behavior for invalid queries is undefined)
-    attr_accessor :validate
+    attr_reader :validate
+
+    # @param new_validate [Boolean] if false, static validation is skipped. This can't be reasssigned after validation.
+    def validate=(new_validate)
+      if defined?(@validation_pipeline) && @validation_pipeline && @validation_pipeline.has_validated?
+        raise ArgumentError, "Can't reassign Query#validate= after validation has run, remove this assignment."
+      else
+        @validate = new_validate
+      end
+    end
 
     attr_writer :query_string
 
@@ -82,13 +86,7 @@ module GraphQL
     def initialize(schema, query_string = nil, query: nil, document: nil, context: nil, variables: nil, validate: true, subscription_topic: nil, operation_name: nil, root_value: nil, max_depth: schema.max_depth, max_complexity: schema.max_complexity, except: nil, only: nil, warden: nil)
       # Even if `variables: nil` is passed, use an empty hash for simpler logic
       variables ||= {}
-
-      # Use the `.graphql_definition` here which will return legacy types instead of classes
-      if schema.is_a?(Class) && !schema.interpreter?
-        schema = schema.graphql_definition
-      end
       @schema = schema
-      @interpreter = @schema.interpreter?
       @filter = schema.default_filter.merge(except: except, only: only)
       @context = schema.context_class.new(query: self, object: root_value, values: context)
       @warden = warden
@@ -97,12 +95,20 @@ module GraphQL
       @fragments = nil
       @operations = nil
       @validate = validate
-      @tracers = schema.tracers + (context ? context.fetch(:tracers, []) : [])
+      context_tracers = (context ? context.fetch(:tracers, []) : [])
+      @tracers = schema.tracers + context_tracers
+
       # Support `ctx[:backtrace] = true` for wrapping backtraces
       if context && context[:backtrace] && !@tracers.include?(GraphQL::Backtrace::Tracer)
+        context_tracers += [GraphQL::Backtrace::Tracer]
         @tracers << GraphQL::Backtrace::Tracer
       end
 
+      if context_tracers.any? && !(schema.trace_class <= GraphQL::Tracing::LegacyTrace)
+        raise ArgumentError, "context[:tracers] and context[:backtrace] are not supported without `tracer_class(GraphQL::Tracing::LegacyTrace)` in the schema configuration, please add it."
+      end
+
+
       @analysis_errors = []
       if variables.is_a?(String)
         raise ArgumentError, "Query variables should be a Hash, not a String. Try JSON.parse to prepare variables."
@@ -154,11 +160,16 @@ module GraphQL
     end
 
     def interpreter?
-      @interpreter
+      true
     end
 
     attr_accessor :multiplex
 
+    # @return [GraphQL::Tracing::Trace]
+    def current_trace
+      @current_trace ||= multiplex ? multiplex.current_trace : schema.new_trace(multiplex: multiplex, query: self)
+    end
+
     def subscription_update?
       @subscription_topic && subscription?
     end
@@ -169,7 +180,6 @@ module GraphQL
       @lookahead ||= begin
         ast_node = selected_operation
         root_type = warden.root_type_for_operation(ast_node.operation_type || "query")
-        root_type = root_type.type_class || raise("Invariant: `lookahead` only works with class-based types")
         GraphQL::Execution::Lookahead.new(query: self, root_type: root_type, ast_nodes: [ast_node])
       end
     end
@@ -199,7 +209,7 @@ module GraphQL
     # @return [Hash] A GraphQL response, with `"data"` and/or `"errors"` keys
     def result
       if !@executed
-        Execution::Multiplex.run_queries(@schema, [self], context: @context)
+        Execution::Interpreter.run_all(@schema, [self], context: @context)
       end
       @result ||= Query::Result.new(query: self, values: @result_values)
     end
@@ -237,35 +247,17 @@ module GraphQL
       end
     end
 
-    def irep_selection
-      @selection ||= begin
-        if selected_operation && internal_representation
-          internal_representation.operation_definitions[selected_operation.name]
-        else
-          nil
-        end
-      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)
-      if interpreter?
-        arguments_cache.fetch(ast_node, definition, parent_object)
-      else
-        arguments_cache[ast_node][definition]
-      end
+      arguments_cache.fetch(ast_node, definition, parent_object)
     end
 
     def arguments_cache
-      if interpreter?
-        @arguments_cache ||= Execution::Interpreter::ArgumentsCache.new(self)
-      else
-        @arguments_cache ||= ArgumentsCache.build(self)
-      end
+      @arguments_cache ||= Execution::Interpreter::ArgumentsCache.new(self)
     end
 
     # A version of the given query string, with:
@@ -308,7 +300,7 @@ module GraphQL
       with_prepared_ast { @validation_pipeline }
     end
 
-    def_delegators :validation_pipeline, :validation_errors, :internal_representation,
+    def_delegators :validation_pipeline, :validation_errors,
                    :analyzers, :ast_analyzers, :max_depth, :max_complexity
 
     attr_accessor :analysis_errors
@@ -361,10 +353,8 @@ module GraphQL
     end
 
     # @api private
-    def with_error_handling
-      schema.error_handler.with_error_handling(context) do
-        yield
-      end
+    def handle_or_reraise(err)
+      schema.handle_or_reraise(context, err)
     end
 
     private
@@ -385,7 +375,7 @@ module GraphQL
       parse_error = nil
       @document ||= begin
         if query_string
-          GraphQL.parse(query_string, tracer: self)
+          GraphQL.parse(query_string, trace: self.current_trace)
         end
       rescue GraphQL::ParseError => err
         parse_error = err

data/lib/graphql/railtie.rb

@@ -1,5 +1,4 @@
 # frozen_string_literal: true
-
 module GraphQL
   class Railtie < Rails::Railtie
     config.before_configuration do
@@ -10,108 +9,5 @@ module GraphQL
         Language::Parser.cache ||= Language::Cache.new(Pathname.new(Bootsnap::CompileCache::ISeq.cache_dir).join('graphql'))
       end
     end
-
-    rake_tasks do
-      # Defer this so that you only need the `parser` gem when you _run_ the upgrader
-      def load_upgraders
-        require_relative './upgrader/member'
-        require_relative './upgrader/schema'
-      end
-
-      namespace :graphql do
-        task :upgrade, [:dir] do |t, args|
-          unless (dir = args[:dir])
-            fail 'You have to give me a directory where your GraphQL schema and types live. ' \
-             'For example: `bin/rake graphql:upgrade[app/graphql/**/*]`'
-          end
-
-          Dir[dir].each do |file|
-            # Members (types, interfaces, etc.)
-            if file =~ /.*_(type|interface|enum|union|)\.rb$/
-              Rake::Task["graphql:upgrade:member"].execute(Struct.new(:member_file).new(file))
-            end
-          end
-
-          puts "Upgrade complete! Note that this is a best-effort approach, and may very well contain some bugs."
-          puts "Don't forget to create the base objects. For example, you could run:"
-          puts "\tbin/rake graphql:upgrade:create_base_objects[app/graphql]"
-        end
-
-        namespace :upgrade do
-          task :create_base_objects, [:base_dir] do |t, args|
-            unless (base_dir = args[:base_dir])
-              fail 'You have to give me a directory where your GraphQL types live. ' \
-                   'For example: `bin/rake graphql:upgrade:create_base_objects[app/graphql]`'
-            end
-
-            destination_file = File.join(base_dir, "types", "base_scalar.rb")
-            unless File.exists?(destination_file)
-              FileUtils.mkdir_p(File.dirname(destination_file))
-              File.open(destination_file, 'w') do |f|
-                f.puts "class Types::BaseScalar < GraphQL::Schema::Scalar\nend"
-              end
-            end
-
-            destination_file = File.join(base_dir, "types", "base_input_object.rb")
-            unless File.exists?(destination_file)
-              FileUtils.mkdir_p(File.dirname(destination_file))
-              File.open(destination_file, 'w') do |f|
-                f.puts "class Types::BaseInputObject < GraphQL::Schema::InputObject\nend"
-              end
-            end
-
-            destination_file = File.join(base_dir, "types", "base_enum.rb")
-            unless File.exists?(destination_file)
-              FileUtils.mkdir_p(File.dirname(destination_file))
-              File.open(destination_file, 'w') do |f|
-                f.puts "class Types::BaseEnum < GraphQL::Schema::Enum\nend"
-              end
-            end
-
-            destination_file = File.join(base_dir, "types", "base_union.rb")
-            unless File.exists?(destination_file)
-              FileUtils.mkdir_p(File.dirname(destination_file))
-              File.open(destination_file, 'w') do |f|
-                f.puts "class Types::BaseUnion < GraphQL::Schema::Union\nend"
-              end
-            end
-
-            destination_file = File.join(base_dir, "types", "base_interface.rb")
-            unless File.exists?(destination_file)
-              FileUtils.mkdir_p(File.dirname(destination_file))
-              File.open(destination_file, 'w') do |f|
-                f.puts "module Types::BaseInterface\n  include GraphQL::Schema::Interface\nend"
-              end
-            end
-
-            destination_file = File.join(base_dir, "types", "base_object.rb")
-            unless File.exists?(destination_file)
-              File.open(destination_file, 'w') do |f|
-                f.puts "class Types::BaseObject < GraphQL::Schema::Object\nend"
-              end
-            end
-          end
-
-          task :schema, [:schema_file] do |t, args|
-            schema_file = args.schema_file
-            load_upgraders
-            upgrader = GraphQL::Upgrader::Schema.new File.read(schema_file)
-
-            puts "- Transforming schema #{schema_file}"
-            File.open(schema_file, 'w') { |f| f.write upgrader.upgrade }
-          end
-
-          task :member, [:member_file] do |t, args|
-            member_file = args.member_file
-            load_upgraders
-            upgrader = GraphQL::Upgrader::Member.new File.read(member_file)
-            next unless upgrader.upgradeable?
-
-            puts "- Transforming member #{member_file}"
-            File.open(member_file, 'w') { |f| f.write upgrader.upgrade }
-          end
-        end
-      end
-    end
   end
 end

data/lib/graphql/rake_task/validate.rb

@@ -15,7 +15,7 @@ module GraphQL
       puts "Validating graphql-pro v#{version}"
       puts "  - Checking for graphql-pro credentials..."
 
-      creds = `bundle config gems.graphql.pro`[/[a-z0-9]{11}:[a-z0-9]{11}/]
+      creds = `bundle config gems.graphql.pro --parseable`[/[a-z0-9]{11}:[a-z0-9]{11}/]
       if creds.nil?
         puts "    #{ex} failed, please set with `bundle config gems.graphql.pro $MY_CREDENTIALS`"
         exit(1)

data/lib/graphql/rake_task.rb

@@ -1,5 +1,6 @@
 # frozen_string_literal: true
 require "fileutils"
+require "rake"
 require "graphql/rake_task/validate"
 
 module GraphQL
@@ -22,6 +23,10 @@ module GraphQL
   # @example Invoking the task from Ruby
   #   require "rake"
   #   Rake::Task["graphql:schema:dump"].invoke
+  #
+  # @example Providing arguments to build the introspection query
+  #   require "graphql/rake_task"
+  #   GraphQL::RakeTask.new(schema_name: "MySchema", include_is_one_of: true)
   class RakeTask
     include Rake::DSL
 
@@ -36,6 +41,11 @@ module GraphQL
       directory: ".",
       idl_outfile: "schema.graphql",
       json_outfile: "schema.json",
+      include_deprecated_args: true,
+      include_schema_description: false,
+      include_is_repeatable: false,
+      include_specified_by_url: false,
+      include_is_one_of: false
     }
 
     # @return [String] Namespace for generated tasks
@@ -73,6 +83,10 @@ module GraphQL
     # @return [String] directory for IDL & JSON files
     attr_accessor :directory
 
+    # @return [Boolean] Options for additional fields in the introspection query JSON response
+    # @see GraphQL::Schema.as_json
+    attr_accessor :include_deprecated_args, :include_schema_description, :include_is_repeatable, :include_specified_by_url, :include_is_one_of
+
     # Set the parameters of this task by passing keyword arguments
     # or assigning attributes inside the block
     def initialize(options = {})
@@ -95,7 +109,21 @@ module GraphQL
     def write_outfile(method_name, file)
       schema = @load_schema.call(self)
       context = @load_context.call(self)
-      result = schema.public_send(method_name, only: @only, except: @except, context: context)
+      result = case method_name
+      when :to_json
+        schema.to_json(
+          include_is_one_of: include_is_one_of,
+          include_deprecated_args: include_deprecated_args,
+          include_is_repeatable: include_is_repeatable,
+          include_specified_by_url: include_specified_by_url,
+          include_schema_description: include_schema_description,
+          only: @only, except: @except, context: context
+        )
+      when :to_definition
+        schema.to_definition(only: @only, except: @except, context: context)
+      else
+        raise ArgumentError, "Unexpected schema dump method: #{method_name.inspect}"
+      end
       dir = File.dirname(file)
       FileUtils.mkdir_p(dir)
       if !result.end_with?("\n")

data/lib/graphql/relay/range_add.rb

@@ -31,29 +31,18 @@ module GraphQL
 
       # @param collection [Object] The list of items to wrap in a connection
       # @param item [Object] The newly-added item (will be wrapped in `edge_class`)
+      # @param context [GraphQL::Query::Context] The surrounding `ctx`, will be passed to the connection
       # @param parent [Object] The owner of `collection`, will be passed to the connection if provided
-      # @param context [GraphQL::Query::Context] The surrounding `ctx`, will be passed to the connection if provided (this is required for cursor encoders)
       # @param edge_class [Class] The class to wrap `item` with (defaults to the connection's edge class)
-      def initialize(collection:, item:, parent: nil, context: nil, edge_class: nil)
-        if context.nil?
-          caller_loc = caller(2, 1).first
-          GraphQL::Deprecation.warn("`context: ...` will be required by `RangeAdd.new` in GraphQL-Ruby 2.0. Add `context: context` to the call at #{caller_loc}.")
-        end
-        if context && context.schema.new_connections?
-          conn_class = context.schema.connections.wrapper_for(collection)
-          # The rest will be added by ConnectionExtension
-          @connection = conn_class.new(collection, parent: parent, context: context, edge_class: edge_class)
-          # Check if this connection supports it, to support old versions of GraphQL-Pro
-          @edge = if @connection.respond_to?(:range_add_edge)
-            @connection.range_add_edge(item)
-          else
-            @connection.edge_class.new(item, @connection)
-          end
+      def initialize(collection:, item:, context:, parent: nil, edge_class: nil)
+        conn_class = context.schema.connections.wrapper_for(collection)
+        # The rest will be added by ConnectionExtension
+        @connection = conn_class.new(collection, parent: parent, context: context, edge_class: edge_class)
+        # Check if this connection supports it, to support old versions of GraphQL-Pro
+        @edge = if @connection.respond_to?(:range_add_edge)
+          @connection.range_add_edge(item)
         else
-          connection_class = BaseConnection.connection_for_nodes(collection)
-          @connection = connection_class.new(collection, {}, parent: parent, context: context)
-          edge_class ||= Relay::Edge
-          @edge = edge_class.new(item, @connection)
+          @connection.edge_class.new(item, @connection)
         end
 
         @parent = parent

data/lib/graphql/relay.rb

@@ -1,18 +1,3 @@
 # frozen_string_literal: true
 
-require 'graphql/relay/page_info'
-require 'graphql/relay/edge'
-require 'graphql/relay/edge_type'
-require 'graphql/relay/edges_instrumentation'
-require 'graphql/relay/base_connection'
-require 'graphql/relay/array_connection'
 require 'graphql/relay/range_add'
-require 'graphql/relay/relation_connection'
-require 'graphql/relay/mongo_relation_connection'
-require 'graphql/relay/global_id_resolve'
-require 'graphql/relay/mutation'
-require 'graphql/relay/node'
-require 'graphql/relay/connection_instrumentation'
-require 'graphql/relay/connection_resolve'
-require 'graphql/relay/connection_type'
-require 'graphql/relay/type_extensions'

data/lib/graphql/schema/addition.rb

@@ -107,6 +107,11 @@ module GraphQL
               if !pt.include?(owner) && owner.is_a?(Class)
                 pt << owner
               end
+              int.interfaces.each do |indirect_int|
+                if indirect_int.is_a?(LateBoundType) && (indirect_int_type = get_type(indirect_int.graphql_name))
+                  update_type_owner(owner, indirect_int_type)
+                end
+              end
             end
           end
         when nil
@@ -136,14 +141,7 @@ module GraphQL
       end
 
       def add_type(type, owner:, late_types:, path:)
-        if type.respond_to?(:metadata) && type.metadata.is_a?(Hash)
-          type_class = type.metadata[:type_class]
-          if type_class.nil?
-            raise ArgumentError, "Can't add legacy type: #{type} (#{type.class})"
-          else
-            type = type_class
-          end
-        elsif type.is_a?(String) || type.is_a?(GraphQL::Schema::LateBoundType)
+        if type.is_a?(String) || type.is_a?(GraphQL::Schema::LateBoundType)
           late_types << [owner, type]
           return
         end
@@ -153,7 +151,7 @@ module GraphQL
           um << owner
         end
 
-        if (prev_type = get_local_type(type.graphql_name)) && prev_type == type
+        if (prev_type = get_local_type(type.graphql_name)) && (prev_type == type || (prev_type.is_a?(Array) && prev_type.include?(type)))
           # No need to re-visit
         elsif type.is_a?(Class) && type < GraphQL::Schema::Directive
           @directives << type