graphql 1.9.3 → 1.9.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
-SHA1:
-  metadata.gz: fe0eb7f5a621028df479067eb72143c397f34ecd
-  data.tar.gz: db4afa75f08ba2a8a409837c962442b824779e05
+SHA256:
+  metadata.gz: c4a10bf3dce4841a53a78308eab58db972aeeb6daade67cf019a45ad48d2c1f6
+  data.tar.gz: ca20d0a586c0076ee47b65c09e12a39d8c52b2db4a4c232cf9d1fee95202280c
 SHA512:
-  metadata.gz: 9bccb51d411ce789817fa821216eae65c0e88faee075f3859c130ffb10a6c6c8fca7fd1a2455c8aff2d9ba7f7a378804528e4d3f5ea9a579167de10f77234e0a
-  data.tar.gz: dba82fb8a24a3b309701278db3f6d95818090f22f128d3a7ed57703fcef9826949a1eec7449afddc5892b24e08cc1172d3b98c88f80f092dbaf0a06a9674323e
+  metadata.gz: c3ebc480c7e4c209b319f382aae6eed1f0d1c61c6886ad620950b51dc457863f9da1af8d451f382a22a467230daa95c5d8a28fd86d1bde22f499aa9a797d6f75
+  data.tar.gz: 86655364098750c3430395b637def8952a1bdb5082643ebe74fb0110d04114411f9077539621cd50c38ff151c64eb54c275ae0b23f248ac27a99f75e356f918d

data/lib/graphql.rb

@@ -106,3 +106,4 @@ require "graphql/deprecated_dsl"
 require "graphql/authorization"
 require "graphql/unauthorized_error"
 require "graphql/unauthorized_field_error"
+require "graphql/load_application_object_failed_error"

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

@@ -9,7 +9,7 @@ module GraphQL
           @used_deprecated_fields = Set.new
         end
 
-        def on_leave_field(parent,  node, visitor)
+        def on_leave_field(node, parent, visitor)
           field_defn = visitor.field_definition
           field = "#{visitor.parent_type_definition.name}.#{field_defn.name}"
           @used_fields << field

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

@@ -9,7 +9,7 @@ module GraphQL
         def result
           return if query.max_complexity.nil?
 
-          total_complexity = super
+          total_complexity = max_possible_complexity
 
           if total_complexity > query.max_complexity
             GraphQL::AnalysisError.new("Query has complexity of #{total_complexity}, which exceeds max complexity of #{query.max_complexity}")

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

@@ -13,7 +13,7 @@ module GraphQL
 
         # Overide this method to use the complexity result
         def result
-          raise NotImplementedError
+          max_possible_complexity
         end
 
         def on_enter_field(node, parent, visitor)
@@ -57,7 +57,8 @@ module GraphQL
           visitor.leave_fragment_spread_inline(node)
         end
 
-        def result
+        # @return [Integer]
+        def max_possible_complexity
           @complexities_on_type.last.max_possible_complexity
         end
 

data/lib/graphql/execution/execute.rb

@@ -50,12 +50,16 @@ module GraphQL
             operation = query.selected_operation
             op_type = operation.operation_type
             root_type = query.root_type_for_operation(op_type)
-            resolve_selection(
-              query.root_value,
-              root_type,
-              query.context,
-              mutation: query.mutation?
-            )
+            if query.context[:__root_unauthorized]
+              # This was set by member/instrumentation.rb so that we wouldn't continue.
+            else
+              resolve_selection(
+                query.root_value,
+                root_type,
+                query.context,
+                mutation: query.mutation?
+              )
+            end
           end
         end
 

data/lib/graphql/execution/interpreter/runtime.rb

@@ -49,9 +49,15 @@ module GraphQL
           root_type = legacy_root_type.metadata[:type_class] || raise("Invariant: type must be class-based: #{legacy_root_type}")
           object_proxy = root_type.authorized_new(query.root_value, context)
           object_proxy = schema.sync_lazy(object_proxy)
-          path = []
-          evaluate_selections(path, object_proxy, root_type, root_operation.selections, root_operation_type: root_op_type)
-          nil
+          if object_proxy.nil?
+            # Root .authorized? returned false.
+            write_in_response([], nil)
+            nil
+          else
+            path = []
+            evaluate_selections(path, object_proxy, root_type, root_operation.selections, root_operation_type: root_op_type)
+            nil
+          end
         end
 
         def gather_selections(owner_object, owner_type, selections, selections_by_name)
@@ -158,8 +164,13 @@ module GraphQL
               object = field_defn.owner.authorized_new(object, context)
             end
 
+            begin
+              kwarg_arguments = arguments(object, field_defn, ast_node)
+            rescue GraphQL::ExecutionError => e
+              continue_value(next_path, e, field_defn, return_type.non_null?, ast_node)
+              next
+            end
 
-            kwarg_arguments = arguments(object, field_defn, ast_node)
             # It might turn out that making arguments for every field is slow.
             # If we have to cache them, we'll need a more subtle approach here.
             field_defn.extras.each do |extra|
@@ -194,10 +205,10 @@ module GraphQL
 
             field_result = resolve_with_directives(object, ast_node) do
               # Actually call the field resolver and capture the result
-              app_result = query.trace("execute_field", {field: field_defn, path: next_path}) do
+              app_result = query.trace("execute_field", {owner: owner_type, field: field_defn, path: next_path}) do
                 field_defn.resolve(object, kwarg_arguments, context)
               end
-              after_lazy(app_result, field: field_defn, path: next_path) do |inner_result|
+              after_lazy(app_result, owner: owner_type, field: field_defn, path: next_path) do |inner_result|
                 continue_value = continue_value(next_path, inner_result, field_defn, return_type.non_null?, ast_node)
                 if HALT != continue_value
                   continue_field(next_path, continue_value, field_defn, return_type, ast_node, next_selections, false)
@@ -271,7 +282,7 @@ module GraphQL
             r
           when "UNION", "INTERFACE"
             resolved_type_or_lazy = query.resolve_type(type, value)
-            after_lazy(resolved_type_or_lazy, path: path, field: field) do |resolved_type|
+            after_lazy(resolved_type_or_lazy, owner: type, path: path, field: field) do |resolved_type|
               possible_types = query.possible_types(type)
 
               if !possible_types.include?(resolved_type)
@@ -291,7 +302,7 @@ module GraphQL
             rescue GraphQL::ExecutionError => err
               err
             end
-            after_lazy(object_proxy, path: path, field: field) do |inner_object|
+            after_lazy(object_proxy, owner: type, path: path, field: field) do |inner_object|
               continue_value = continue_value(path, inner_object, field, is_non_null, ast_node)
               if HALT != continue_value
                 response_hash = {}
@@ -312,7 +323,7 @@ module GraphQL
               idx += 1
               set_type_at_path(next_path, inner_type)
               # This will update `response_list` with the lazy
-              after_lazy(inner_value, path: next_path, field: field) do |inner_inner_value|
+              after_lazy(inner_value, owner: inner_type, path: next_path, field: field) do |inner_inner_value|
                 # reset `is_non_null` here and below, because the inner type will have its own nullability constraint
                 continue_value = continue_value(next_path, inner_inner_value, field, false, ast_node)
                 if HALT != continue_value
@@ -378,7 +389,7 @@ module GraphQL
         # @param field [GraphQL::Schema::Field]
         # @param eager [Boolean] Set to `true` for mutation root fields only
         # @return [GraphQL::Execution::Lazy, Object] If loading `object` will be deferred, it's a wrapper over it.
-        def after_lazy(obj, field:, path:, eager: false)
+        def after_lazy(obj, owner:, field:, path:, eager: false)
           @interpreter_context[:current_path] = path
           @interpreter_context[:current_field] = field
           if schema.lazy?(obj)
@@ -387,14 +398,14 @@ module GraphQL
               @interpreter_context[:current_field] = field
               # Wrap the execution of _this_ method with tracing,
               # but don't wrap the continuation below
-              inner_obj = query.trace("execute_field_lazy", {field: field, path: path}) do
+              inner_obj = query.trace("execute_field_lazy", {owner: owner, field: field, path: path}) do
                 begin
                   schema.sync_lazy(obj)
                 rescue GraphQL::ExecutionError, GraphQL::UnauthorizedError => err
                   yield(err)
                 end
               end
-              after_lazy(inner_obj, field: field, path: path, eager: eager) do |really_inner_obj|
+              after_lazy(inner_obj, owner: owner, field: field, path: path, eager: eager) do |really_inner_obj|
                 yield(really_inner_obj)
               end
             end

data/lib/graphql/execution/lookahead.rb

@@ -9,10 +9,6 @@ module GraphQL
     # A field may get access to its lookahead by adding `extras: [:lookahead]`
     # to its configuration.
     #
-    # __NOTE__: Lookahead for typed fragments (eg `node { ... on Thing { ... } }`)
-    # hasn't been implemented yet. It's possible, I just didn't need it yet.
-    # Feel free to open a PR or an issue if you want to add it.
-    #
     # @example looking ahead in a field
     #   field :articles, [Types::Article], null: false,
     #     extras: [:lookahead]

data/lib/graphql/integer_encoding_error.rb

@@ -1,12 +1,20 @@
 # frozen_string_literal: true
 module GraphQL
+  # This error is raised when `Types::Int` is asked to return a value outside of 32-bit integer range.
+  #
+  # For values outside that range, consider:
+  #
+  # - `ID` for database primary keys or other identifiers
+  # - `GraphQL::Types::BigInt` for really big integer values
+  #
+  # @see GraphQL::Types::Int which raises this error
   class IntegerEncodingError < GraphQL::RuntimeTypeError
     # The value which couldn't be encoded
     attr_reader :integer_value
 
     def initialize(value)
       @integer_value = value
-      super('Integer out of bounds.')
+      super("Integer out of bounds: #{value}. \nConsider using ID or GraphQL::Types::BigInt instead.")
     end
   end
 end

data/lib/graphql/language/visitor.rb

@@ -168,6 +168,8 @@ module GraphQL
       # Run the hooks for `node`, and if the hooks return a copy of `node`,
       # copy `parent` so that it contains the copy of that node as a child,
       # then return the copies
+      # If a non-array value is returned, consuming functions should ignore
+      # said value
       def on_node_with_modifications(node, parent)
         new_node_and_new_parent = visit_node(node, parent)
         if new_node_and_new_parent.is_a?(Array)
@@ -181,6 +183,10 @@ module GraphQL
             # The user-provided hook requested to remove this node
             new_parent = new_parent && new_parent.delete_child(node)
             return nil, new_parent
+          elsif new_node_and_new_parent.none? { |n| n == nil || n.class < Nodes::AbstractNode }
+            # The user-provided hook returned an array of who-knows-what
+            # return nil here to signify that no changes should be made
+            nil
           else
             new_node_and_new_parent
           end

data/lib/graphql/load_application_object_failed_error.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+module GraphQL
+  # Raised when a argument is configured with `loads:` and the client provides an `ID`,
+  # but no object is loaded for that ID.
+  #
+  # @see GraphQL::Schema::Member::HasArguments::ArgumentObjectLoader#load_application_object_failed, A hook which you can override in resolvers, mutations and input objects.
+  class LoadApplicationObjectFailedError < GraphQL::ExecutionError
+    # @return [GraphQL::Schema::Argument] the argument definition for the argument that was looked up
+    attr_reader :argument
+    # @return [String] The ID provided by the client
+    attr_reader :id
+    # @return [Object] The value found with this ID
+    attr_reader :object
+    def initialize(argument:, id:, object:)
+      @id = id
+      @argument = argument
+      @object = object
+      super("No object found for `#{argument.graphql_name}: #{id.inspect}`")
+    end
+  end
+end

data/lib/graphql/query.rb

@@ -40,7 +40,7 @@ module GraphQL
     # @return [Boolean] if false, static validation is skipped (execution behavior for invalid queries is undefined)
     attr_accessor :validate
 
-    attr_accessor :query_string
+    attr_writer :query_string
 
     # @return [GraphQL::Language::Nodes::Document]
     def document
@@ -135,6 +135,11 @@ module GraphQL
       end
     end
 
+    # If a document was provided to `GraphQL::Schema#execute` instead of the raw query string, we will need to get it from the document
+    def query_string
+      @query_string ||= (document ? document.to_query_string : nil)
+    end
+
     def_delegators :@schema, :interpreter?
 
     def subscription_update?

data/lib/graphql/query/arguments.rb

@@ -19,7 +19,7 @@ module GraphQL
             method_names = [expose_as, expose_as_underscored].uniq
             method_names.each do |method_name|
               # Don't define a helper method if it would override something.
-              if instance_methods.include?(method_name)
+              if instance_methods.include?(method_name.to_sym)
                 warn(
                   "Unable to define a helper for argument with name '#{method_name}' "\
                   "as this is a reserved name. If you're using an argument such as "\

data/lib/graphql/query/variables.rb

@@ -32,20 +32,26 @@ module GraphQL
 
             begin
               validation_result = variable_type.validate_input(provided_value, ctx)
-            rescue GraphQL::CoercionError => ex
+              if validation_result.valid?
+                if value_was_provided
+                  # Add the variable if a value was provided
+                  memo[variable_name] = variable_type.coerce_input(provided_value, ctx)
+                elsif default_value != nil
+                  # Add the variable if it wasn't provided but it has a default value (including `null`)
+                  memo[variable_name] = GraphQL::Query::LiteralInput.coerce(variable_type, default_value, self)
+                end
+              end
+            rescue GraphQL::CoercionError, GraphQL::ExecutionError => ex
+              # TODO: This should really include the path to the problematic node in the variable value
+              # like InputValidationResults generated by validate_non_null_input but unfortunately we don't
+              # have this information available in the coerce_input call chain. Note this path is the path
+              # that appears under errors.extensions.problems.path and NOT the result path under errors.path.
               validation_result = GraphQL::Query::InputValidationResult.new
               validation_result.add_problem(ex.message)
             end
 
             if !validation_result.valid?
-              # This finds variables that were required but not provided
               @errors << GraphQL::Query::VariableValidationError.new(ast_variable, variable_type, provided_value, validation_result)
-            elsif value_was_provided
-              # Add the variable if a value was provided
-              memo[variable_name] = variable_type.coerce_input(provided_value, ctx)
-            elsif default_value != nil
-              # Add the variable if it wasn't provided but it has a default value (including `null`)
-              memo[variable_name] = GraphQL::Query::LiteralInput.coerce(variable_type, default_value, self)
             end
           end
         end

data/lib/graphql/rake_task/validate.rb

@@ -37,7 +37,7 @@ module GraphQL
       # Remove final newline from .txt file
       github_digest = Net::HTTP.get(github_uri).chomp
 
-      docs_uri = URI("https://raw.githubusercontent.com/rmosolgo/graphql-ruby/master/guides/pro/checksums/graphql-pro-#{version}.txt")
+      docs_uri = URI("https://graphql-ruby.org/pro/checksums/graphql-pro-#{version}.txt")
       docs_digest = Net::HTTP.get(docs_uri).chomp
 
       if docs_digest == gem_digest && github_digest == gem_digest

data/lib/graphql/schema/field_extension.rb

@@ -18,10 +18,10 @@ module GraphQL
       # Called when the extension is mounted with `extension(name, options)`.
       # The instance is frozen to avoid improper use of state during execution.
       # @param field [GraphQL::Schema::Field] The field where this extension was mounted
-      # @param options [Object] The second argument to `extension`, or `nil` if nothing was passed.
+      # @param options [Object] The second argument to `extension`, or `{}` if nothing was passed.
       def initialize(field:, options:)
         @field = field
-        @options = options
+        @options = options || {}
         apply
         freeze
       end

data/lib/graphql/schema/input_object.rb

@@ -17,7 +17,9 @@ module GraphQL
           @ruby_style_hash = @arguments.to_kwargs
         end
         # Apply prepares, not great to have it duplicated here.
+        @arguments_by_keyword = {}
         self.class.arguments.each do |name, arg_defn|
+          @arguments_by_keyword[arg_defn.keyword] = arg_defn
           ruby_kwargs_key = arg_defn.keyword
           if @ruby_style_hash.key?(ruby_kwargs_key) && arg_defn.prepare
             @ruby_style_hash[ruby_kwargs_key] = arg_defn.prepare_value(self, @ruby_style_hash[ruby_kwargs_key])
@@ -81,13 +83,20 @@ module GraphQL
         # @return [Class<GraphQL::Arguments>]
         attr_accessor :arguments_class
 
-        def argument(*args)
-          argument_defn = super
+        def argument(name, type, *rest, loads: nil, **kwargs, &block)
+          argument_defn = super(*argument_with_loads(name, type, *rest, loads: loads, **kwargs, &block))
           # Add a method access
-          arg_name = argument_defn.graphql_definition.name
-          method_name = Member::BuildType.underscore(arg_name).to_sym
+          method_name = argument_defn.keyword
           define_method(method_name) do
-            @ruby_style_hash[method_name]
+            value = @ruby_style_hash[method_name]
+            argument = @arguments_by_keyword[method_name]
+            if loads && argument_defn.type.list?
+              GraphQL::Execution::Lazy.all(value.map { |val| load_application_object(argument, loads, val) })
+            elsif loads
+              load_application_object(argument, loads, value)
+            else
+              value
+            end
           end
         end
 
@@ -113,4 +122,4 @@ module GraphQL
       end
     end
   end
-end
+end

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

@@ -5,10 +5,33 @@ module GraphQL
       module HasArguments
         def self.included(cls)
           cls.extend(ArgumentClassAccessor)
+          cls.include(ArgumentObjectLoader)
         end
 
         def self.extended(cls)
           cls.extend(ArgumentClassAccessor)
+          cls.include(ArgumentObjectLoader)
+        end
+
+        def argument_with_loads(name, type, *rest, loads: nil, **kwargs)
+          if loads
+            name_as_string = name.to_s
+
+            inferred_arg_name = case name_as_string
+            when /_id$/
+              name_as_string.sub(/_id$/, "").to_sym
+            when /_ids$/
+              name_as_string.sub(/_ids$/, "")
+                .sub(/([^s])$/, "\\1s")
+                .to_sym
+            else
+              name
+            end
+
+            kwargs[:as] ||= inferred_arg_name
+          end
+
+          return [name, type, *rest, **kwargs]
         end
 
         # @see {GraphQL::Schema::Argument#initialize} for parameters
@@ -53,6 +76,63 @@ module GraphQL
           end
         end
 
+        module ArgumentObjectLoader
+          # Look up the corresponding object for a provided ID.
+          # By default, it uses Relay-style {Schema.object_from_id},
+          # override this to find objects another way.
+          #
+          # @param type [Class, Module] A GraphQL type definition
+          # @param id [String] A client-provided to look up
+          # @param context [GraphQL::Query::Context] the current context
+          def object_from_id(type, id, context)
+            context.schema.object_from_id(id, context)
+          end
+
+          def load_application_object(argument, lookup_as_type, id)
+            # See if any object can be found for this ID
+            loaded_application_object = object_from_id(lookup_as_type, id, context)
+            context.schema.after_lazy(loaded_application_object) do |application_object|
+              if application_object.nil?
+                err = GraphQL::LoadApplicationObjectFailedError.new(argument: argument, id: id, object: application_object)
+                load_application_object_failed(err)
+              end
+              # Double-check that the located object is actually of this type
+              # (Don't want to allow arbitrary access to objects this way)
+              resolved_application_object_type = context.schema.resolve_type(lookup_as_type, application_object, context)
+              context.schema.after_lazy(resolved_application_object_type) do |application_object_type|
+                possible_object_types = context.schema.possible_types(lookup_as_type)
+                if !possible_object_types.include?(application_object_type)
+                  err = GraphQL::LoadApplicationObjectFailedError.new(argument: argument, id: id, object: application_object)
+                  load_application_object_failed(err)
+                else
+                  # This object was loaded successfully
+                  # and resolved to the right type,
+                  # now apply the `.authorized?` class method if there is one
+                  if (class_based_type = application_object_type.metadata[:type_class])
+                    context.schema.after_lazy(class_based_type.authorized?(application_object, context)) do |authed|
+                      if authed
+                        application_object
+                      else
+                        raise GraphQL::UnauthorizedError.new(
+                          object: application_object,
+                          type: class_based_type,
+                          context: context,
+                        )
+                      end
+                    end
+                  else
+                    application_object
+                  end
+                end
+              end
+            end
+          end
+
+          def load_application_object_failed(err)
+            raise err
+          end
+        end
+
         def own_arguments
           @own_arguments ||= {}
         end