graphql 1.10.4 → 1.10.5

data/lib/graphql/pagination/active_record_relation_connection.rb

@@ -6,12 +6,18 @@ module GraphQL
     # Customizes `RelationConnection` to work with `ActiveRecord::Relation`s.
     class ActiveRecordRelationConnection < Pagination::RelationConnection
       def relation_count(relation)
-        if relation.respond_to?(:unscope)
+        int_or_hash = if relation.respond_to?(:unscope)
           relation.unscope(:order).count(:all)
         else
           # Rails 3
           relation.count
         end
+        if int_or_hash.is_a?(Integer)
+          int_or_hash
+        else
+          # Grouped relations return count-by-group hashes
+          int_or_hash.length
+        end
       end
 
       def relation_limit(relation)

data/lib/graphql/pagination/array_connection.rb

@@ -21,7 +21,7 @@ module GraphQL
 
       def cursor_for(item)
         idx = items.find_index(item) + 1
-        context.schema.cursor_encoder.encode(idx.to_s)
+        encode(idx.to_s)
       end
 
       private
@@ -59,7 +59,7 @@ module GraphQL
             sliced_nodes.count > first
           elsif before
             # The original array is longer than the `before` index
-            index_from_cursor(before) < items.length
+            index_from_cursor(before) < items.length + 1
           else
             false
           end

data/lib/graphql/pagination/connection.rb

@@ -29,14 +29,22 @@ module GraphQL
       # Raw access to client-provided values. (`max_page_size` not applied to first or last.)
       attr_accessor :before_value, :after_value, :first_value, :last_value
 
-      # @return [String, nil] the client-provided cursor
+      # @return [String, nil] the client-provided cursor. `""` is treated as `nil`.
       def before
-        @before_value
+        if defined?(@before)
+          @before
+        else
+          @before = @before_value == "" ? nil : @before_value
+        end
       end
 
-      # @return [String, nil] the client-provided cursor
+      # @return [String, nil] the client-provided cursor. `""` is treated as `nil`.
       def after
-        @after_value
+        if defined?(@after)
+          @after
+        else
+          @after = @after_value == "" ? nil : @after_value
+        end
       end
 
       # @param items [Object] some unpaginated collection item, like an `Array` or `ActiveRecord::Relation`
@@ -147,7 +155,11 @@ module GraphQL
       end
 
       def decode(cursor)
-        context.schema.cursor_encoder.decode(cursor)
+        context.schema.cursor_encoder.decode(cursor, nonce: true)
+      end
+
+      def encode(cursor)
+        context.schema.cursor_encoder.encode(cursor, nonce: true)
       end
 
       # A wrapper around paginated items. It includes a {cursor} for pagination

data/lib/graphql/pagination/relation_connection.rb

@@ -44,7 +44,7 @@ module GraphQL
         load_nodes
         # index in nodes + existing offset + 1 (because it's offset, not index)
         offset = nodes.index(item) + 1 + (@paged_nodes_offset || 0) + (relation_offset(items) || 0)
-        context.schema.cursor_encoder.encode(offset.to_s)
+        encode(offset.to_s)
       end
 
       private
@@ -137,8 +137,9 @@ module GraphQL
       def limited_nodes
         @limited_nodes ||= begin
           paginated_nodes = sliced_nodes
+          previous_limit = relation_limit(paginated_nodes)
 
-          if first && (relation_limit(paginated_nodes).nil? || relation_limit(paginated_nodes) > first) && last.nil?
+          if first && (previous_limit.nil? || previous_limit > first)
             # `first` would create a stricter limit that the one already applied, so add it
             paginated_nodes = set_limit(paginated_nodes, first)
           end

data/lib/graphql/query/input_validation_result.rb

@@ -4,22 +4,39 @@ module GraphQL
     class InputValidationResult
       attr_accessor :problems
 
+      def initialize(valid: true, problems: nil)
+        @valid = valid
+        @problems = problems
+      end
+
       def valid?
-        @problems.nil?
+        @valid
       end
 
-      def add_problem(explanation, path = nil)
+      def add_problem(explanation, path = nil, extensions: nil, message: nil)
         @problems ||= []
-        @problems.push({ "path" => path || [], "explanation" => explanation })
+        @valid = false
+        problem = { "path" => path || [], "explanation" => explanation }
+        if extensions
+          problem["extensions"] = extensions
+        end
+        if message
+          problem["message"] = message
+        end
+        @problems.push(problem)
       end
 
       def merge_result!(path, inner_result)
         return if inner_result.valid?
 
-        inner_result.problems.each do |p|
-          item_path = [path, *p["path"]]
-          add_problem(p["explanation"], item_path)
+        if inner_result.problems
+          inner_result.problems.each do |p|
+            item_path = [path, *p["path"]]
+            add_problem(p["explanation"], item_path, message: p["message"], extensions: p["extensions"])
+          end
         end
+        # It could have been explicitly set on inner_result (if it had no problems)
+        @valid = false
       end
     end
   end

data/lib/graphql/query/variables.rb

@@ -52,7 +52,7 @@ module GraphQL
                   end
                 end
               end
-            rescue GraphQL::CoercionError, GraphQL::ExecutionError => ex
+            rescue 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

data/lib/graphql/relay/array_connection.rb

@@ -34,19 +34,17 @@ module GraphQL
       private
 
       def first
-        return @first if defined? @first
-
-        @first = get_limited_arg(:first)
-        @first = max_page_size if @first && max_page_size && @first > max_page_size
-        @first
+        @first ||= begin
+          capped = limit_pagination_argument(arguments[:first], max_page_size)
+          if capped.nil? && last.nil?
+            capped = max_page_size
+          end
+          capped
+        end
       end
 
       def last
-        return @last if defined? @last
-
-        @last = get_limited_arg(:last)
-        @last = max_page_size if @last && max_page_size && @last > max_page_size
-        @last
+        @last ||= limit_pagination_argument(arguments[:last], max_page_size)
       end
 
       # apply first / last limit results

data/lib/graphql/relay/base_connection.rb

@@ -81,7 +81,13 @@ module GraphQL
       # The value passed as `first:`, if there was one. Negative numbers become `0`.
       # @return [Integer, nil]
       def first
-        @first ||= get_limited_arg(:first)
+        @first ||= begin
+          capped = limit_pagination_argument(arguments[:first], max_page_size)
+          if capped.nil? && last.nil?
+            capped = max_page_size
+          end
+          capped
+        end
       end
 
       # The value passed as `after:`, if there was one
@@ -93,7 +99,7 @@ module GraphQL
       # The value passed as `last:`, if there was one. Negative numbers become `0`.
       # @return [Integer, nil]
       def last
-        @last ||= get_limited_arg(:last)
+        @last ||= limit_pagination_argument(arguments[:last], max_page_size)
       end
 
       # The value passed as `before:`, if there was one
@@ -152,16 +158,18 @@ module GraphQL
 
       private
 
-      # Return a sanitized `arguments[arg_name]` (don't allow negatives)
-      def get_limited_arg(arg_name)
-        arg_value = arguments[arg_name]
-        if arg_value.nil?
-          arg_value
-        elsif arg_value < 0
-          0
-        else
-          arg_value
+      # @param argument [nil, Integer] `first` or `last`, as provided by the client
+      # @param max_page_size [nil, Integer]
+      # @return [nil, Integer] `nil` if the input was `nil`, otherwise a value between `0` and `max_page_size`
+      def limit_pagination_argument(argument, max_page_size)
+        if argument
+          if argument < 0
+            argument = 0
+          elsif max_page_size && argument > max_page_size
+            argument = max_page_size
+          end
         end
+        argument
       end
 
       def paged_nodes

data/lib/graphql/relay/relation_connection.rb

@@ -50,19 +50,17 @@ module GraphQL
       end
 
       def first
-        return @first if defined? @first
-
-        @first = get_limited_arg(:first)
-        @first = max_page_size if @first && max_page_size && @first > max_page_size
-        @first
+        @first ||= begin
+          capped = limit_pagination_argument(arguments[:first], max_page_size)
+          if capped.nil? && last.nil?
+            capped = max_page_size
+          end
+          capped
+        end
       end
 
       def last
-        return @last if defined? @last
-
-        @last = get_limited_arg(:last)
-        @last = max_page_size if @last && max_page_size && @last > max_page_size
-        @last
+        @last ||= limit_pagination_argument(arguments[:last], max_page_size)
       end
 
       private

data/lib/graphql/scalar_type.rb

@@ -67,8 +67,21 @@ module GraphQL
 
     def validate_non_null_input(value, ctx)
       result = Query::InputValidationResult.new
-      if value.is_a?(GraphQL::Language::Nodes::Enum) || coerce_non_null_input(value, ctx).nil?
+
+      coerced_result = begin
+        coerce_non_null_input(value, ctx)
+      rescue GraphQL::CoercionError => err
+        err
+      end
+
+      if value.is_a?(GraphQL::Language::Nodes::Enum) || coerced_result.nil?
         result.add_problem("Could not coerce value #{GraphQL::Language.serialize(value)} to #{name}")
+      elsif coerced_result.is_a?(GraphQL::CoercionError)
+        result.add_problem(
+          coerced_result.message,
+          message: coerced_result.message,
+          extensions: coerced_result.extensions
+        )
       end
       result
     end

data/lib/graphql/schema.rb

@@ -908,6 +908,7 @@ module GraphQL
         schema_defn.cursor_encoder = cursor_encoder
         schema_defn.tracers.concat(tracers)
         schema_defn.query_analyzers.concat(query_analyzers)
+        schema_defn.analysis_engine = analysis_engine
 
         schema_defn.middleware.concat(all_middleware)
         schema_defn.multiplex_analyzers.concat(multiplex_analyzers)
@@ -934,6 +935,11 @@ module GraphQL
         if !schema_defn.interpreter?
           schema_defn.instrumenters[:query] << GraphQL::Schema::Member::Instrumentation
         end
+
+        if new_connections?
+          schema_defn.connections = self.connections
+        end
+
         schema_defn.send(:rebuild_artifacts)
 
         schema_defn

data/lib/graphql/schema/build_from_definition.rb

@@ -140,6 +140,9 @@ module GraphQL
                 use(plugin)
               end
             end
+
+            # Empty `orphan_types` -- this will make unreachable types ... unreachable.
+            own_orphan_types.clear
           end
         end
 

data/lib/graphql/schema/scalar.rb

@@ -43,13 +43,21 @@ module GraphQL
 
         def validate_non_null_input(value, ctx)
           result = Query::InputValidationResult.new
-          if coerce_input(value, ctx).nil?
+          coerced_result = begin
+            coerce_input(value, ctx)
+          rescue GraphQL::CoercionError => err
+            err
+          end
+
+          if coerced_result.nil?
             str_value = if value == Float::INFINITY
               ""
             else
               " #{GraphQL::Language.serialize(value)}"
             end
             result.add_problem("Could not coerce value#{str_value} to #{graphql_name}")
+          elsif coerced_result.is_a?(GraphQL::CoercionError)
+            result.add_problem(coerced_result.message, message: coerced_result.message, extensions: coerced_result.extensions)
           end
           result
         end

data/lib/graphql/static_validation/literal_validator.rb

@@ -6,59 +6,73 @@ module GraphQL
       def initialize(context:)
         @context = context
         @warden = context.warden
+        @invalid_response = GraphQL::Query::InputValidationResult.new(valid: false, problems: [])
+        @valid_response = GraphQL::Query::InputValidationResult.new(valid: true, problems: [])
       end
 
       def validate(ast_value, type)
+        catch(:invalid) do
+          recursively_validate(ast_value, type)
+        end
+      end
+
+      private
+
+      def recursively_validate(ast_value, type)
         if type.nil?
           # this means we're an undefined argument, see #present_input_field_values_are_valid
           maybe_raise_if_invalid(ast_value) do
-            false
+            @invalid_response
           end
         elsif ast_value.is_a?(GraphQL::Language::Nodes::NullValue)
           maybe_raise_if_invalid(ast_value) do
-            !type.kind.non_null?
+            type.kind.non_null? ? @invalid_response : @valid_response
           end
         elsif type.kind.non_null?
           maybe_raise_if_invalid(ast_value) do
-            (!ast_value.nil?)
-          end && validate(ast_value, type.of_type)
+            ast_value.nil? ?
+              @invalid_response :
+              recursively_validate(ast_value, type.of_type)
+          end
         elsif type.kind.list?
           item_type = type.of_type
-          ensure_array(ast_value).all? { |val| validate(val, item_type) }
+          results = ensure_array(ast_value).map { |val| recursively_validate(val, item_type) }
+          merge_results(results)
         elsif ast_value.is_a?(GraphQL::Language::Nodes::VariableIdentifier)
-          true
+          @valid_response
         elsif type.kind.scalar? && constant_scalar?(ast_value)
           maybe_raise_if_invalid(ast_value) do
-            type.valid_input?(ast_value, @context)
+            type.validate_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)
+              type.validate_input(ast_value.name, @context)
             else
               # if our ast_value isn't an Enum it's going to be invalid so return false
-              false
+              @invalid_response
             end
           end
         elsif type.kind.input_object? && ast_value.is_a?(GraphQL::Language::Nodes::InputObject)
           maybe_raise_if_invalid(ast_value) do
-            required_input_fields_are_present(type, ast_value) && present_input_field_values_are_valid(type, ast_value)
+            merge_results([
+              required_input_fields_are_present(type, ast_value),
+              present_input_field_values_are_valid(type, ast_value)
+            ])
           end
         else
           maybe_raise_if_invalid(ast_value) do
-            false
+            @invalid_response
           end
         end
       end
 
-      private
-
+      # When `error_bubbling` is false, we want to bail on the first failure that we find.
+      # Use `throw` to escape the current call stack, returning the invalid response.
       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
+        if !@context.schema.error_bubbling && !ret.valid?
+          throw(:invalid, ret)
         else
           ret
         end
@@ -87,28 +101,39 @@ module GraphQL
         present_field_names = ast_node.arguments.map(&:name)
         missing_required_field_names = required_field_names - present_field_names
         if @context.schema.error_bubbling
-          missing_required_field_names.empty?
+          missing_required_field_names.empty? ? @valid_response : @invalid_response
         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 )
+          results = missing_required_field_names.map do |name|
+            arg_type = @warden.arguments(type).find { |f| f.name == name }.type
+            recursively_validate(GraphQL::Language::Nodes::NullValue.new(name: name), arg_type)
           end
+          merge_results(results)
         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|
+        results = ast_node.arguments.map do |value|
           field = field_map[value.name]
           # 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)
+          recursively_validate(value.value, type)
         end
+        merge_results(results)
       end
 
       def ensure_array(value)
         value.is_a?(Array) ? value : [value]
       end
+
+      def merge_results(results_list)
+        merged_result = Query::InputValidationResult.new
+        results_list.each do |inner_result|
+          merged_result.merge_result!([], inner_result)
+        end
+        merged_result
+      end
     end
   end
 end