graphql 1.9.21 → 1.10.0.pre1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 7cc71a5ff7b742541447b08e62f4b0561ae2b7ae3767d9b18000e0cfdcd411a1
-  data.tar.gz: decb826d15ed416571e152b108698a326803cadf45cc78d9a823344bc156b3f4
+  metadata.gz: 6d8cd9472c04900ca59a46d06eedf501e09d1f0561a5df1c902faada7c9536df
+  data.tar.gz: 409d5ef50405fe5f6ca2f1c197e9c98696c3b89bbf35323e325e7a4bc157419c
 SHA512:
-  metadata.gz: ef0ce5989f626b9907fd77c0c54dd42f695e4484236da24f689a160fc521614d7cdc9600f0c9044c2e3b547afc1d862efa23da45b2bc13b0173f3c3af2683059
-  data.tar.gz: e45810e9c2e0f885e42bfe90c4daf9383e0860543ac9a6ecf6215f994b7af43c0d8d46b74da78a43f9159e3c9fe3882c5ac97257f67a5272407eb6f9b80bbe87
+  metadata.gz: '0511959efa6a890699def5ea1d681ed9000435903f078955ecdf0a4f4c1be409ea542cd8e8b9cced7f22e22df49115038bbb544d611b9f66a6fdb5ae75c92566'
+  data.tar.gz: cb29aa9f21e13c65d4b700720cd2079968f6f6b709712e464133f78c383841c219c24bce7a5ffe6b6dd6577c6e7c03f282f259dca73896b669d2cfcaaa072abe

data/lib/generators/graphql/core.rb

@@ -25,7 +25,6 @@ module Graphql
 
       def create_mutation_root_type
         create_dir("#{options[:directory]}/mutations")
-        template("base_mutation.erb", "#{options[:directory]}/mutations/base_mutation.rb", { skip: true })
         template("mutation_type.erb", "#{options[:directory]}/types/mutation_type.rb", { skip: true })
         insert_root_type('mutation', 'MutationType')
       end

data/lib/generators/graphql/install_generator.rb

@@ -24,7 +24,6 @@ module Graphql
     #       - query_type.rb
     #     - loaders/
     #     - mutations/
-    #       - base_mutation.rb
     #     - {app_name}_schema.rb
     # ```
     #

data/lib/generators/graphql/mutation_generator.rb

@@ -45,7 +45,7 @@ module Graphql
       private
 
       def assign_names!(name)
-        @field_name = name.camelize.underscore
+        @field_name = name.camelize(:lower)
         @mutation_name = name.camelize(:upper)
         @file_name = name.camelize.underscore
       end

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

@@ -1,5 +1,9 @@
 module Types
   class BaseField < GraphQL::Schema::Field
     argument_class Types::BaseArgument
+
+    def resolve_field(obj, args, ctx)
+      resolve(obj, args, ctx)
+    end
   end
 end

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

@@ -1,9 +1,4 @@
 class GraphqlController < ApplicationController
-  # If accessing from outside this domain, nullify the session
-  # This allows for outside API access while preventing CSRF attacks,
-  # but you'll have to authenticate your user separately
-  # protect_from_forgery with: :null_session
-
   def execute
     variables = ensure_hash(params[:variables])
     query = params[:query]

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

@@ -1,5 +1,5 @@
 module Mutations
-  class <%= mutation_name %> < BaseMutation
+  class <%= mutation_name %> < GraphQL::Schema::RelayClassicMutation
     # TODO: define return fields
     # field :post, Types::PostType, null: false
 

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

@@ -24,7 +24,7 @@ class <%= schema_name %> < GraphQL::Schema
   def self.resolve_type(type, obj, ctx)
     # TODO: Implement this function
     # to return the correct type for `obj`
-    raise(GraphQL::RequiredImplementationMissingError)
+    raise(NotImplementedError)
   end
 <% end %><% if options[:batch] %>
   # GraphQL::Batch setup:

data/lib/graphql.rb

@@ -7,20 +7,9 @@ require "forwardable"
 require_relative "./graphql/railtie" if defined? Rails::Railtie
 
 module GraphQL
-  # forwards-compat for argument handling
-  module Ruby2Keywords
-    if RUBY_VERSION < "2.7"
-      def ruby2_keywords(*)
-      end
-    end
-  end
-
   class Error < StandardError
   end
 
-  class RequiredImplementationMissingError < Error
-  end
-
   # Turn a query string or schema definition into an AST
   # @param graphql_string [String] a GraphQL query string or schema definition
   # @return [GraphQL::Language::Nodes::Document]
@@ -131,3 +120,4 @@ require "graphql/authorization"
 require "graphql/unauthorized_error"
 require "graphql/unauthorized_field_error"
 require "graphql/load_application_object_failed_error"
+require "graphql/pagination"

data/lib/graphql/analysis/ast.rb

@@ -23,7 +23,7 @@ module GraphQL
       #
       # @param multiplex [GraphQL::Execution::Multiplex]
       # @param analyzers [Array<GraphQL::Analysis::AST::Analyzer>]
-      # @return [Array<Any>] Results from multiplex analyzers
+      # @return [void]
       def analyze_multiplex(multiplex, analyzers)
         multiplex_analyzers = analyzers.map { |analyzer| analyzer.new(multiplex) }
 
@@ -46,8 +46,8 @@ module GraphQL
           multiplex.queries.each_with_index do |query, idx|
             query.analysis_errors = multiplex_errors + analysis_errors(query_results[idx])
           end
-          multiplex_results
         end
+        nil
       end
 
       # @param query [GraphQL::Query]

data/lib/graphql/analysis/ast/analyzer.rb

@@ -5,21 +5,10 @@ module GraphQL
       # Query analyzer for query ASTs. Query analyzers respond to visitor style methods
       # but are prefixed by `enter` and `leave`.
       #
-      # When an analyzer is initialized with a Multiplex, you can always get the current query from
-      # `visitor.query` in the visit methods.
-      #
-      # @param [GraphQL::Query, GraphQL::Execution::Multiplex] The query or multiplex to analyze
+      # @param [GraphQL::Query] The query to analyze
       class Analyzer
-        def initialize(subject)
-          @subject = subject
-
-          if subject.is_a?(GraphQL::Query)
-            @query = subject
-            @multiplex = nil
-          else
-            @multiplex = subject
-            @query = nil
-          end
+        def initialize(query)
+          @query = query
         end
 
         # Analyzer hook to decide at analysis time whether a query should
@@ -33,7 +22,7 @@ module GraphQL
         # in a query error.
         # @return [Any] The analyzer result
         def result
-          raise GraphQL::RequiredImplementationMissingError
+          raise NotImplementedError
         end
 
         class << self
@@ -69,15 +58,7 @@ module GraphQL
 
         protected
 
-        # @return [GraphQL::Query, GraphQL::Execution::Multiplex] Whatever this analyzer is analyzing
-        attr_reader :subject
-
-        # @return [GraphQL::Query, nil] `nil` if this analyzer is visiting a multiplex
-        #  (When this is `nil`, use `visitor.query` inside visit methods to get the current query)
         attr_reader :query
-
-        # @return [GraphQL::Execution::Multiplex, nil] `nil` if this analyzer is visiting a query
-        attr_reader :multiplex
       end
     end
   end

data/lib/graphql/analysis/ast/max_query_complexity.rb

@@ -7,12 +7,12 @@ module GraphQL
       # see {Schema#max_complexity} and {Query#max_complexity}
       class MaxQueryComplexity < QueryComplexity
         def result
-          return if subject.max_complexity.nil?
+          return if query.max_complexity.nil?
 
           total_complexity = max_possible_complexity
 
-          if total_complexity > subject.max_complexity
-            GraphQL::AnalysisError.new("Query has complexity of #{total_complexity}, which exceeds max complexity of #{subject.max_complexity}")
+          if total_complexity > query.max_complexity
+            GraphQL::AnalysisError.new("Query has complexity of #{total_complexity}, which exceeds max complexity of #{query.max_complexity}")
           else
             nil
           end

data/lib/graphql/analysis/ast/max_query_depth.rb

@@ -4,14 +4,10 @@ module GraphQL
     module AST
       class MaxQueryDepth < QueryDepth
         def result
-          configured_max_depth = if query
-            query.max_depth
-          else
-            multiplex.schema.max_depth
-          end
+          return unless query.max_depth
 
-          if configured_max_depth && @max_depth > configured_max_depth
-            GraphQL::AnalysisError.new("Query has depth of #{@max_depth}, which exceeds max depth of #{configured_max_depth}")
+          if @max_depth > query.max_depth
+            GraphQL::AnalysisError.new("Query has depth of #{@max_depth}, which exceeds max depth of #{query.max_depth}")
           else
             nil
           end

data/lib/graphql/analysis/ast/query_complexity.rb

@@ -42,7 +42,7 @@ module GraphQL
           if @complexities_on_type.last.is_a?(AbstractTypeComplexity)
             key = selection_key(visitor.response_path, visitor.query)
             parent_type = visitor.parent_type_definition
-            visitor.query.possible_types(parent_type).each do |type|
+            query.possible_types(parent_type).each do |type|
               @complexities_on_type.last.merge(type, key, own_complexity)
             end
           else
@@ -74,7 +74,7 @@ module GraphQL
 
           case defined_complexity
           when Proc
-            defined_complexity.call(visitor.query.context, arguments, child_complexity)
+            defined_complexity.call(query.context, arguments, child_complexity)
           when Numeric
             defined_complexity + (child_complexity || 0)
           else

data/lib/graphql/argument.rb

@@ -113,6 +113,10 @@ module GraphQL
       @prepare_proc = BackwardsCompatibility.wrap_arity(prepare_proc, from: 1, to: 2, name: "Argument#prepare(value, ctx)")
     end
 
+    def type_class
+      metadata[:type_class]
+    end
+
     NO_DEFAULT_VALUE = Object.new
     # @api private
     def self.from_dsl(name, type_or_argument = nil, description = nil, default_value: NO_DEFAULT_VALUE, as: nil, prepare: DefaultPrepare, **kwargs, &block)
@@ -134,9 +138,9 @@ module GraphQL
       end
 
       if type_or_argument.is_a?(GraphQL::Argument)
-        type_or_argument.redefine(**kwargs, &block)
+        type_or_argument.redefine(kwargs, &block)
       else
-        GraphQL::Argument.define(**kwargs, &block)
+        GraphQL::Argument.define(kwargs, &block)
       end
     end
 

data/lib/graphql/backtrace/table.rb

@@ -84,10 +84,14 @@ module GraphQL
           field_name = "#{ctx.irep_node.owner_type.name}.#{ctx.field.name}"
           position = "#{ctx.ast_node.line}:#{ctx.ast_node.col}"
           field_alias = ctx.ast_node.alias
+          object = ctx.object
+          if object.is_a?(GraphQL::Schema::Object)
+            object = object.object
+          end
           rows << [
             "#{position}",
             "#{field_name}#{field_alias ? " as #{field_alias}" : ""}",
-            "#{ctx.object.inspect}",
+            "#{object.inspect}",
             ctx.irep_node.arguments.to_h.inspect,
             Backtrace::InspectResult.inspect_result(top && @override_value ? @override_value : ctx.value),
           ]
@@ -104,10 +108,14 @@ module GraphQL
             position = "?:?"
           end
           op_name = query.selected_operation_name
+          object = query.root_value
+          if object.is_a?(GraphQL::Schema::Object)
+            object = object.object
+          end
           rows << [
             "#{position}",
             "#{op_type}#{op_name ? " #{op_name}" : ""}",
-            "#{query.root_value.inspect}",
+            "#{object.inspect}",
             query.variables.to_h.inspect,
             Backtrace::InspectResult.inspect_result(query.context.value),
           ]

data/lib/graphql/base_type.rb

@@ -43,6 +43,10 @@ module GraphQL
     # @see {GraphQL::SchemaMember}
     alias :graphql_definition :itself
 
+    def type_class
+      metadata[:type_class]
+    end
+
     def name=(name)
       GraphQL::NameValidator.validate!(name)
       @name = name
@@ -167,7 +171,7 @@ module GraphQL
     end
 
     def coerce_result(value, ctx)
-      raise GraphQL::RequiredImplementationMissingError
+      raise NotImplementedError
     end
 
     # Types with fields may override this

data/lib/graphql/compatibility/query_parser_specification/parse_error_specification.rb

@@ -70,15 +70,11 @@ module GraphQL
           ")
         end
 
-        def assert_empty_document(query_string)
-          doc = parse(query_string)
-          assert_equal 0, doc.definitions.length
-        end
-
-        def test_it_parses_blank_queries
-          assert_empty_document("")
-          assert_empty_document(" ")
-          assert_empty_document("\t \t")
+        def test_it_rejects_blank_queries
+          assert_raises_parse_error("")
+          assert_raises_parse_error(" ")
+          assert_raises_parse_error("\t \t")
+          assert_raises_parse_error(" # comment ")
         end
 
         def test_it_restricts_on

data/lib/graphql/define/assign_object_field.rb

@@ -28,9 +28,9 @@ module GraphQL
         end
 
         obj_field = if base_field
-          base_field.redefine(**kwargs, &block)
+          base_field.redefine(kwargs, &block)
         else
-          GraphQL::Field.define(**kwargs, &block)
+          GraphQL::Field.define(kwargs, &block)
         end
 
 

data/lib/graphql/define/defined_object_proxy.rb

@@ -1,12 +1,10 @@
 # frozen_string_literal: true
-
 module GraphQL
   module Define
     # This object delegates most methods to a dictionary of functions, {@dictionary}.
     # {@target} is passed to the specified function, along with any arguments and block.
     # This allows a method-based DSL without adding methods to the defined class.
     class DefinedObjectProxy
-      extend GraphQL::Ruby2Keywords
       # The object which will be defined by definition functions
       attr_reader :target
 
@@ -34,7 +32,6 @@ module GraphQL
       end
 
       # Lookup a function from the dictionary and call it if it's found.
-      ruby2_keywords
       def method_missing(name, *args, &block)
         definition = @dictionary[name]
         if definition

data/lib/graphql/define/instance_definable.rb

@@ -154,12 +154,7 @@ module GraphQL
             defn_proxy = DefinedObjectProxy.new(self)
             # Apply definition from `define(...)` kwargs
             defn.define_keywords.each do |keyword, value|
-              # Don't splat string hashes, which blows up on Rubies before 2.7
-              if value.is_a?(Hash) && !value.empty? && value.each_key.all? { |k| k.is_a?(Symbol) }
-                defn_proxy.public_send(keyword, **value)
-              else
-                defn_proxy.public_send(keyword, value)
-              end
+              defn_proxy.public_send(keyword, value)
             end
             # and/or apply definition from `define { ... }` block
             if defn.define_proc
@@ -292,18 +287,12 @@ module GraphQL
       end
 
       class AssignAttribute
-        extend GraphQL::Ruby2Keywords
-
         def initialize(attr_name)
           @attr_assign_method = :"#{attr_name}="
         end
 
-        # Even though we're just using the first value here,
-        # We have to add a splat here to use `ruby2_keywords`,
-        # so that it will accept a `[{}]` input from the caller.
-        ruby2_keywords
-        def call(defn, *value)
-          defn.public_send(@attr_assign_method, value.first)
+        def call(defn, value)
+          defn.public_send(@attr_assign_method, value)
         end
       end
     end

data/lib/graphql/enum_type.rb

@@ -151,6 +151,10 @@ module GraphQL
       def graphql_name
         name
       end
+
+      def type_class
+        metadata[:type_class]
+      end
     end
 
     class UnresolvedValueError < GraphQL::Error

data/lib/graphql/execution/directive_checks.rb

@@ -18,12 +18,12 @@ module GraphQL
           case name
           when SKIP
             args = query.arguments_for(directive_ast_node, directive_defn)
-            if args['if'] == true
+            if args[:if] == true
               return false
             end
           when INCLUDE
             args = query.arguments_for(directive_ast_node, directive_defn)
-            if args['if'] == false
+            if args[:if] == false
               return false
             end
           else

data/lib/graphql/execution/errors.rb

@@ -2,7 +2,7 @@
 
 module GraphQL
   module Execution
-    # A plugin that wraps query execution with error handling.
+    # A tracer that wraps query execution with error handling.
     # Supports class-based schemas and the new {Interpreter} runtime only.
     #
     # @example Handling ActiveRecord::NotFound
@@ -19,35 +19,34 @@ module GraphQL
     class Errors
       def self.use(schema)
         schema_class = schema.is_a?(Class) ? schema : schema.target.class
-        schema_class.error_handler = self.new(schema_class)
+        schema.tracer(self.new(schema_class))
       end
 
       def initialize(schema)
         @schema = schema
       end
 
-      class NullErrorHandler
-        def self.with_error_handling(_ctx)
+      def trace(event, data)
+        case event
+        when "execute_field", "execute_field_lazy"
+          with_error_handling(data) { yield }
+        else
           yield
         end
       end
 
-      # Call the given block with the schema's configured error handlers.
-      #
-      # If the block returns a lazy value, it's not wrapped with error handling. That area will have to be wrapped itself.
-      #
-      # @param ctx [GraphQL::Query::Context]
-      # @return [Object] Either the result of the given block, or some object to replace the result, in case of error handling.
-      def with_error_handling(ctx)
+      private
+
+      def with_error_handling(trace_data)
         yield
       rescue StandardError => err
         rescues = @schema.rescues
         _err_class, handler = rescues.find { |err_class, handler| err.is_a?(err_class) }
         if handler
-          runtime_info = ctx.namespace(:interpreter) || {}
-          obj = runtime_info[:current_object]
-          args = runtime_info[:current_arguments]
-          field = runtime_info[:current_field]
+          obj = trace_data[:object]
+          args = trace_data[:arguments]
+          ctx = trace_data[:query].context
+          field = trace_data[:field]
           if obj.is_a?(GraphQL::Schema::Object)
             obj = obj.object
           end