graphql 1.8.11 → 1.8.12

data/lib/graphql/language/lexer.rl

@@ -37,9 +37,9 @@
   QUOTE =         '"';
   BLOCK_QUOTE =   '"""';
   ESCAPED_BLOCK_QUOTE = '\\"""';
-  BLOCK_STRING_CHAR = (ESCAPED_BLOCK_QUOTE | ^'"""');
+  BLOCK_STRING_CHAR = (ESCAPED_BLOCK_QUOTE | ^QUOTE | ^QUOTE QUOTE{1,2} ^QUOTE);
   ESCAPED_QUOTE = '\\"';
-  STRING_CHAR =   (ESCAPED_QUOTE | ^'"');
+  STRING_CHAR =   (ESCAPED_QUOTE | ^QUOTE);
   VAR_SIGN =      '$';
   DIR_SIGN =      '@';
   ELLIPSIS =      '...';
@@ -49,7 +49,7 @@
   AMP =           '&';
 
   QUOTED_STRING = QUOTE STRING_CHAR* QUOTE;
-  BLOCK_STRING = BLOCK_QUOTE BLOCK_STRING_CHAR* BLOCK_QUOTE;
+  BLOCK_STRING = BLOCK_QUOTE (QUOTE{1,2} ^QUOTE){0,1} BLOCK_STRING_CHAR* QUOTE{0,2} BLOCK_QUOTE;
   # catch-all for anything else. must be at the bottom for precedence.
   UNKNOWN_CHAR =         /./;
 

data/lib/graphql/language/printer.rb

@@ -254,7 +254,7 @@ module GraphQL
         return ''.dup unless node.description
 
         description = indent != '' && !first_in_block ? "\n".dup : "".dup
-        description << GraphQL::Language::Comments.commentize(node.description, indent: indent)
+        description << GraphQL::Language::BlockString.print(node.description, indent: indent)
       end
 
       def print_field_definitions(fields)

data/lib/graphql/literal_validation_error.rb

@@ -0,0 +1,6 @@
+# frozen_string_literal: true
+module GraphQL
+  class LiteralValidationError < GraphQL::Error
+    attr_accessor :ast_value
+  end
+end

data/lib/graphql/query/arguments.rb

@@ -6,6 +6,7 @@ module GraphQL
     # {Arguments} recursively wraps the input in {Arguments} instances.
     class Arguments
       extend Forwardable
+      include GraphQL::Dig
 
       def self.construct_arguments_class(argument_owner)
         argument_definitions = argument_owner.arguments

data/lib/graphql/query/context.rb

@@ -160,7 +160,7 @@ module GraphQL
       # @api private
       attr_writer :value
 
-      def_delegators :@provided_values, :[], :[]=, :to_h, :key?, :fetch, :dig
+      def_delegators :@provided_values, :[], :[]=, :to_h, :to_hash, :key?, :fetch, :dig
       def_delegators :@query, :trace
 
       # @!method [](key)

data/lib/graphql/relay/relation_connection.rb

@@ -124,7 +124,7 @@ module GraphQL
       # If a relation contains a `.group` clause, a `.count` will return a Hash.
       def relation_count(relation)
         count_or_hash = if(defined?(ActiveRecord::Relation) && relation.is_a?(ActiveRecord::Relation))
-          relation.count(:all)
+          relation.respond_to?(:unscope)? relation.unscope(:order).count(:all) : relation.count(:all)
         else # eg, Sequel::Dataset, don't mess up others
           relation.count
         end

data/lib/graphql/schema.rb

@@ -78,6 +78,7 @@ module GraphQL
       :query_execution_strategy, :mutation_execution_strategy, :subscription_execution_strategy,
       :max_depth, :max_complexity, :default_max_page_size,
       :orphan_types, :resolve_type, :type_error, :parse_error,
+      :error_bubbling,
       :raise_definition_error,
       :object_from_id, :id_from_object,
       :default_mask,
@@ -107,6 +108,9 @@ module GraphQL
       :raise_definition_error,
       :introspection_namespace
 
+    # [Boolean] True if this object bubbles validation errors up from a field into its parent InputObject, if there is one.
+    attr_accessor :error_bubbling
+
     # Single, long-lived instance of the provided subscriptions class, if there is one.
     # @return [GraphQL::Subscriptions]
     attr_accessor :subscriptions
@@ -168,6 +172,7 @@ module GraphQL
       @context_class = GraphQL::Query::Context
       @introspection_namespace = nil
       @introspection_system = nil
+      @error_bubbling = true
     end
 
     def initialize_copy(other)
@@ -656,10 +661,10 @@ module GraphQL
         :execute, :multiplex,
         :static_validator, :introspection_system,
         :query_analyzers, :tracers, :instrumenters,
-        :query_execution_strategy, :mutation_execution_strategy, :subscription_execution_strategy,
         :validate, :multiplex_analyzers, :lazy?, :lazy_method_name, :after_lazy, :sync_lazy,
         # Configuration
         :max_complexity=, :max_depth=,
+        :error_bubbling=,
         :metadata,
         :default_mask,
         :default_filter, :redefine,
@@ -693,6 +698,7 @@ module GraphQL
         schema_defn.mutation = mutation
         schema_defn.subscription = subscription
         schema_defn.max_complexity = max_complexity
+        schema_defn.error_bubbling = error_bubbling
         schema_defn.max_depth = max_depth
         schema_defn.default_max_page_size = default_max_page_size
         schema_defn.orphan_types = orphan_types
@@ -709,6 +715,9 @@ module GraphQL
         schema_defn.query_analyzers << GraphQL::Authorization::Analyzer
         schema_defn.middleware.concat(defined_middleware)
         schema_defn.multiplex_analyzers.concat(defined_multiplex_analyzers)
+        schema_defn.query_execution_strategy = query_execution_strategy
+        schema_defn.mutation_execution_strategy = mutation_execution_strategy
+        schema_defn.subscription_execution_strategy = subscription_execution_strategy
         defined_instrumenters.each do |step, insts|
           insts.each do |inst|
             schema_defn.instrumenters[step] << inst
@@ -789,6 +798,30 @@ module GraphQL
         end
       end
 
+      def query_execution_strategy(new_query_execution_strategy = nil)
+        if new_query_execution_strategy
+          @query_execution_strategy = new_query_execution_strategy
+        else
+          @query_execution_strategy || self.default_execution_strategy
+        end
+      end
+
+      def mutation_execution_strategy(new_mutation_execution_strategy = nil)
+        if new_mutation_execution_strategy
+          @mutation_execution_strategy = new_mutation_execution_strategy
+        else
+          @mutation_execution_strategy || self.default_execution_strategy
+        end
+      end
+
+      def subscription_execution_strategy(new_subscription_execution_strategy = nil)
+        if new_subscription_execution_strategy
+          @subscription_execution_strategy = new_subscription_execution_strategy
+        else
+          @subscription_execution_strategy || self.default_execution_strategy
+        end
+      end
+
       def max_complexity(max_complexity = nil)
         if max_complexity
           @max_complexity = max_complexity
@@ -797,6 +830,14 @@ module GraphQL
         end
       end
 
+      def error_bubbling(new_error_bubbling = nil)
+        if !new_error_bubbling.nil?
+          @error_bubbling = new_error_bubbling
+        else
+          @error_bubbling
+        end
+      end
+
       def max_depth(new_max_depth = nil)
         if new_max_depth
           @max_depth = new_max_depth
@@ -829,9 +870,11 @@ module GraphQL
         end
       end
 
-      def rescue_from(err_class, &handler_block)
+      def rescue_from(*err_classes, &handler_block)
         @rescues ||= {}
-        @rescues[err_class] = handler_block
+        err_classes.each do |err_class|
+          @rescues[err_class] = handler_block
+        end
       end
 
       def resolve_type(type, obj, ctx)

data/lib/graphql/schema/build_from_definition.rb

@@ -113,7 +113,7 @@ module GraphQL
         end
 
         NullResolveType = ->(type, obj, ctx) {
-          raise(NotImplementedError, "Generated Schema cannot use Interface or Union types for execution.")
+          raise(NotImplementedError, "Generated Schema cannot use Interface or Union types for execution. Implement resolve_type on your resolver.")
         }
 
         NullScalarCoerce = ->(val, _ctx) { val }

data/lib/graphql/schema/field.rb

@@ -26,6 +26,9 @@ module GraphQL
       # @return [Class] The type that this field belongs to
       attr_reader :owner
 
+      # @return [Symobol] the orignal name of the field, passed in by the user
+      attr_reader :original_name
+
 
       # @return [Class, nil] The {Schema::Resolver} this field was derived from, if there is one
       def resolver
@@ -142,6 +145,7 @@ module GraphQL
         if (field || function || resolve) && extras.any?
           raise ArgumentError, "keyword `extras:` may only be used with method-based resolve and class-based field such as mutation class, please remove `field:`, `function:` or `resolve:`"
         end
+        @original_name = name
         @name = camelize ? Member::BuildType.camelize(name.to_s) : name.to_s
         @description = description
         if field.is_a?(GraphQL::Schema::Field)
@@ -338,7 +342,9 @@ module GraphQL
         ctx.schema.after_lazy(obj) do |after_obj|
           # First, apply auth ...
           query_ctx = ctx.query.context
-          inner_obj = after_obj.object
+          # Some legacy fields can have `nil` here, not exactly sure why.
+          # @see https://github.com/rmosolgo/graphql-ruby/issues/1990 before removing
+          inner_obj = after_obj && after_obj.object
           if authorized?(inner_obj, query_ctx) && arguments.each_value.all? { |a| a.authorized?(inner_obj, query_ctx) }
             # Then if it passed, resolve the field
             v = if @resolve_proc

data/lib/graphql/schema/input_object.rb

@@ -5,6 +5,7 @@ module GraphQL
       extend GraphQL::Schema::Member::AcceptsDefinition
       extend Forwardable
       extend GraphQL::Schema::Member::HasArguments
+      include GraphQL::Dig
 
       def initialize(values, context:, defaults_used:)
         @context = context

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

@@ -33,7 +33,7 @@ module GraphQL
               null = false
               parse_type(type_expr[0..-2], null: true)
             else
-              maybe_type = Object.const_get(type_expr)
+              maybe_type = constantize(type_expr)
               case maybe_type
               when GraphQL::BaseType
                 maybe_type
@@ -125,6 +125,38 @@ module GraphQL
           camelized
         end
 
+        # Resolves constant from string (based on Rails `ActiveSupport::Inflector.constantize`)
+        def constantize(string)
+          names = string.split('::')
+
+          # Trigger a built-in NameError exception including the ill-formed constant in the message.
+          Object.const_get(string) if names.empty?
+
+          # Remove the first blank element in case of '::ClassName' notation.
+          names.shift if names.size > 1 && names.first.empty?
+
+          names.inject(Object) do |constant, name|
+            if constant == Object
+              constant.const_get(name)
+            else
+              candidate = constant.const_get(name)
+              next candidate if constant.const_defined?(name, false)
+              next candidate unless Object.const_defined?(name)
+
+              # Go down the ancestors to check if it is owned directly. The check
+              # stops when we reach Object or the end of ancestors tree.
+              constant = constant.ancestors.inject do |const, ancestor|
+                break const    if ancestor == Object
+                break ancestor if ancestor.const_defined?(name, false)
+                const
+              end
+
+              # Owner is in Object, so raise.
+              constant.const_get(name, false)
+            end
+          end
+        end
+
         def underscore(string)
           string
             .gsub(/([A-Z]+)([A-Z][a-z])/,'\1_\2') # URLDecoder -> URL_Decoder

data/lib/graphql/static_validation/all_rules.rb

@@ -24,6 +24,7 @@ module GraphQL
       GraphQL::StaticValidation::ArgumentsAreDefined,
       GraphQL::StaticValidation::ArgumentLiteralsAreCompatible,
       GraphQL::StaticValidation::RequiredArgumentsArePresent,
+      GraphQL::StaticValidation::RequiredInputObjectAttributesArePresent,
       GraphQL::StaticValidation::ArgumentNamesAreUnique,
       GraphQL::StaticValidation::VariableNamesAreUnique,
       GraphQL::StaticValidation::VariablesAreInputTypes,

data/lib/graphql/static_validation/arguments_validator.rb

@@ -3,6 +3,25 @@ module GraphQL
   module StaticValidation
     # Implement validate_node
     class ArgumentsValidator
+      module ArgumentsValidatorHelpers
+        private
+
+        def parent_name(parent, type_defn)
+          if parent.is_a?(GraphQL::Language::Nodes::Field)
+            parent.alias || parent.name
+          elsif parent.is_a?(GraphQL::Language::Nodes::InputObject)
+            type_defn.name
+          else
+            parent.name
+          end
+        end
+
+        def node_type(parent)
+          parent.class.name.split("::").last
+        end
+      end
+
+      include ArgumentsValidatorHelpers
       include GraphQL::StaticValidation::Message::MessageHelper
 
       def validate(context)
@@ -29,22 +48,7 @@ module GraphQL
           validate_node(parent, node, parent_defn, context)
         }
       end
-
-      private
-
-      def parent_name(parent, type_defn)
-        if parent.is_a?(GraphQL::Language::Nodes::Field)
-          parent.alias || parent.name
-        elsif parent.is_a?(GraphQL::Language::Nodes::InputObject)
-          type_defn.name
-        else
-          parent.name
-        end
-      end
-
-      def node_type(parent)
-        parent.class.name.split("::").last
-      end
     end
+
   end
 end

data/lib/graphql/static_validation/literal_validator.rb

@@ -9,29 +9,61 @@ module GraphQL
       end
 
       def validate(ast_value, type)
-        if ast_value.is_a?(GraphQL::Language::Nodes::NullValue)
-          !type.kind.non_null?
+        if type.nil?
+          # this means we're an undefined argument, see #present_input_field_values_are_valid
+          return maybe_raise_if_invalid(ast_value) do
+            false
+          end
+        elsif ast_value.is_a?(GraphQL::Language::Nodes::NullValue)
+          maybe_raise_if_invalid(ast_value) do
+            !type.kind.non_null?
+          end
         elsif type.kind.non_null?
-          (!ast_value.nil?) && validate(ast_value, type.of_type)
+          maybe_raise_if_invalid(ast_value) do
+            (!ast_value.nil?)
+          end && validate(ast_value, type.of_type)
         elsif type.kind.list?
           item_type = type.of_type
           ensure_array(ast_value).all? { |val| validate(val, item_type) }
         elsif ast_value.is_a?(GraphQL::Language::Nodes::VariableIdentifier)
           true
         elsif type.kind.scalar? && constant_scalar?(ast_value)
-          type.valid_input?(ast_value, @context)
-        elsif type.kind.enum? && ast_value.is_a?(GraphQL::Language::Nodes::Enum)
-          type.valid_input?(ast_value.name, @context)
+          maybe_raise_if_invalid(ast_value) do
+            type.valid_input?(ast_value, @context)
+          end
+        elsif type.kind.enum?
+          maybe_raise_if_invalid(ast_value) do
+            if ast_value.is_a?(GraphQL::Language::Nodes::Enum)
+              type.valid_input?(ast_value.name, @context)
+            else
+              # if our ast_value isn't an Enum it's going to be invalid so return false
+              false
+            end
+          end
         elsif type.kind.input_object? && ast_value.is_a?(GraphQL::Language::Nodes::InputObject)
-          required_input_fields_are_present(type, ast_value) &&
-            present_input_field_values_are_valid(type, ast_value)
+          maybe_raise_if_invalid(ast_value) do
+            required_input_fields_are_present(type, ast_value) && present_input_field_values_are_valid(type, ast_value)
+          end
         else
-          false
+          maybe_raise_if_invalid(ast_value) do
+            false
+          end
         end
       end
 
       private
 
+      def maybe_raise_if_invalid(ast_value)
+        ret = yield
+        if !@context.schema.error_bubbling && !ret
+          e = LiteralValidationError.new
+          e.ast_value = ast_value
+          raise e
+        else
+          ret
+        end
+      end
+
       # The GraphQL grammar supports variables embedded within scalars but graphql.js
       # doesn't support it so we won't either for simplicity
       def constant_scalar?(ast_value)
@@ -47,19 +79,30 @@ module GraphQL
       end
 
       def required_input_fields_are_present(type, ast_node)
+        # TODO - would be nice to use these to create an error message so the caller knows
+        # that required fields are missing
         required_field_names = @warden.arguments(type)
           .select { |f| f.type.kind.non_null? }
           .map(&:name)
         present_field_names = ast_node.arguments.map(&:name)
         missing_required_field_names = required_field_names - present_field_names
-        missing_required_field_names.none?
+        if @context.schema.error_bubbling
+          missing_required_field_names.none?
+        else
+          missing_required_field_names.all? do |name|
+            validate(GraphQL::Language::Nodes::NullValue.new(name: name), @warden.arguments(type).find { |f| f.name == name }.type )
+          end
+        end
       end
 
       def present_input_field_values_are_valid(type, ast_node)
         field_map = @warden.arguments(type).reduce({}) { |m, f| m[f.name] = f; m}
         ast_node.arguments.all? do |value|
           field = field_map[value.name]
-          field && validate(value.value, field.type)
+          # we want to call validate on an argument even if it's an invalid one
+          # so that our raise exception is on it instead of the entire InputObject
+          type = field && field.type
+          validate(value.value, type)
         end
       end
 

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

@@ -11,8 +11,27 @@ module GraphQL
           valid = context.valid_literal?(node.value, arg_defn.type)
         rescue GraphQL::CoercionError => err
           error_message = err.message
+          context.schema.error_bubbling
+          if !context.schema.error_bubbling && !arg_defn.type.unwrap.kind.scalar?
+            # if error bubbling is disabled and the arg that caused this error isn't a scalar then
+            # short-circuit here so we avoid bubbling this up to whatever input_object / array contains us
+            return false
+          end
+        rescue GraphQL::LiteralValidationError => err
+          # check to see if the ast node that caused the error to be raised is
+          # the same as the node we were checking here.
+          matched = if arg_defn.type.kind.list?
+            # for a list we claim an error if the node is contained in our list
+            node.value.include?(err.ast_value)
+          elsif arg_defn.type.kind.input_object? && node.value.is_a?(GraphQL::Language::Nodes::InputObject)
+            # for an input object we check the arguments
+            node.value.arguments.include?(err.ast_value)
+          else
+            # otherwise we just check equality
+            node.value == (err.ast_value)
+          end
+          return false unless matched
         end
-
         return if valid
 
         error_message ||= begin