graphql 1.12.15 → 1.12.19

data/lib/graphql/schema.rb

@@ -161,7 +161,7 @@ module GraphQL
 
     accepts_definitions \
       :query_execution_strategy, :mutation_execution_strategy, :subscription_execution_strategy,
-      :validate_timeout, :max_depth, :max_complexity, :default_max_page_size,
+      :validate_timeout, :validate_max_errors, :max_depth, :max_complexity, :default_max_page_size,
       :orphan_types, :resolve_type, :type_error, :parse_error,
       :error_bubbling,
       :raise_definition_error,
@@ -200,7 +200,7 @@ module GraphQL
     attr_accessor \
       :query, :mutation, :subscription,
       :query_execution_strategy, :mutation_execution_strategy, :subscription_execution_strategy,
-      :validate_timeout, :max_depth, :max_complexity, :default_max_page_size,
+      :validate_timeout, :validate_max_errors, :max_depth, :max_complexity, :default_max_page_size,
       :orphan_types, :directives,
       :query_analyzers, :multiplex_analyzers, :instrumenters, :lazy_methods,
       :cursor_encoder,
@@ -552,7 +552,7 @@ module GraphQL
       end
     end
 
-    # @see [GraphQL::Schema::Warden] Resticted access to root types
+    # @see [GraphQL::Schema::Warden] Restricted access to root types
     # @return [GraphQL::ObjectType, nil]
     def root_type_for_operation(operation)
       case operation
@@ -934,6 +934,7 @@ module GraphQL
         schema_defn.mutation = mutation && mutation.graphql_definition
         schema_defn.subscription = subscription && subscription.graphql_definition
         schema_defn.validate_timeout = validate_timeout
+        schema_defn.validate_max_errors = validate_max_errors
         schema_defn.max_complexity = max_complexity
         schema_defn.error_bubbling = error_bubbling
         schema_defn.max_depth = max_depth
@@ -1073,7 +1074,7 @@ module GraphQL
         end
       end
 
-      # @see [GraphQL::Schema::Warden] Resticted access to root types
+      # @see [GraphQL::Schema::Warden] Restricted access to root types
       # @return [GraphQL::ObjectType, nil]
       def root_type_for_operation(operation)
         case operation
@@ -1290,10 +1291,22 @@ module GraphQL
         validator_opts = { schema: self }
         rules && (validator_opts[:rules] = rules)
         validator = GraphQL::StaticValidation::Validator.new(**validator_opts)
-        res = validator.validate(query, timeout: validate_timeout)
+        res = validator.validate(query, timeout: validate_timeout, max_errors: validate_max_errors)
         res[:errors]
       end
 
+      attr_writer :validate_max_errors
+
+      def validate_max_errors(new_validate_max_errors = nil)
+        if new_validate_max_errors
+          @validate_max_errors = new_validate_max_errors
+        elsif defined?(@validate_max_errors)
+          @validate_max_errors
+        else
+          find_inherited_value(:validate_max_errors)
+        end
+      end
+
       attr_writer :max_complexity
 
       def max_complexity(max_complexity = nil)

data/lib/graphql/static_validation/base_visitor.rb

@@ -205,6 +205,9 @@ module GraphQL
       private
 
       def add_error(error, path: nil)
+        if @context.too_many_errors?
+          throw :too_many_validation_errors
+        end
         error.path ||= (path || @path.dup)
         context.errors << error
       end

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

@@ -193,26 +193,26 @@ module GraphQL
           if node1.name != node2.name
             errored_nodes = [node1.name, node2.name].sort.join(" or ")
             msg = "Field '#{response_key}' has a field conflict: #{errored_nodes}?"
-            context.errors << GraphQL::StaticValidation::FieldsWillMergeError.new(
+            add_error(GraphQL::StaticValidation::FieldsWillMergeError.new(
               msg,
               nodes: [node1, node2],
               path: [],
               field_name: response_key,
               conflicts: errored_nodes
-            )
+            ))
           end
 
           if !same_arguments?(node1, node2)
             args = [serialize_field_args(node1), serialize_field_args(node2)]
             conflicts = args.map { |arg| GraphQL::Language.serialize(arg) }.join(" or ")
             msg = "Field '#{response_key}' has an argument conflict: #{conflicts}?"
-            context.errors << GraphQL::StaticValidation::FieldsWillMergeError.new(
+            add_error(GraphQL::StaticValidation::FieldsWillMergeError.new(
               msg,
               nodes: [node1, node2],
               path: [],
               field_name: response_key,
               conflicts: conflicts
-            )
+            ))
           end
         end
 

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

@@ -7,12 +7,12 @@ module GraphQL
         dependency_map = context.dependencies
         dependency_map.cyclical_definitions.each do |defn|
           if defn.node.is_a?(GraphQL::Language::Nodes::FragmentDefinition)
-            context.errors << GraphQL::StaticValidation::FragmentsAreFiniteError.new(
+            add_error(GraphQL::StaticValidation::FragmentsAreFiniteError.new(
               "Fragment #{defn.name} contains an infinite loop",
               nodes: defn.node,
               path: defn.path,
               name: defn.name
-            )
+            ))
           end
         end
       end

data/lib/graphql/static_validation/validation_context.rb

@@ -19,10 +19,11 @@ module GraphQL
 
       def_delegators :@query, :schema, :document, :fragments, :operations, :warden
 
-      def initialize(query, visitor_class)
+      def initialize(query, visitor_class, max_errors)
         @query = query
         @literal_validator = LiteralValidator.new(context: query.context)
         @errors = []
+        @max_errors = max_errors || Float::INFINITY
         @on_dependency_resolve_handlers = []
         @visitor = visitor_class.new(document, self)
       end
@@ -38,6 +39,10 @@ module GraphQL
       def validate_literal(ast_value, type)
         @literal_validator.validate(ast_value, type)
       end
+
+      def too_many_errors?
+        @errors.length >= @max_errors
+      end
     end
   end
 end

data/lib/graphql/static_validation/validator.rb

@@ -24,8 +24,9 @@ module GraphQL
       # @param query [GraphQL::Query]
       # @param validate [Boolean]
       # @param timeout [Float] Number of seconds to wait before aborting validation. Any positive number may be used, including Floats to specify fractional seconds.
+      # @param max_errors [Integer] Maximum number of errors before aborting validation. Any positive number will limit the number of errors. Defaults to nil for no limit.
       # @return [Array<Hash>]
-      def validate(query, validate: true, timeout: nil)
+      def validate(query, validate: true, timeout: nil, max_errors: nil)
         query.trace("validate", { validate: validate, query: query }) do
           can_skip_rewrite = query.context.interpreter? && query.schema.using_ast_analysis? && query.schema.is_a?(Class)
           errors = if validate == false && can_skip_rewrite
@@ -34,25 +35,27 @@ module GraphQL
             rules_to_use = validate ? @rules : []
             visitor_class = BaseVisitor.including_rules(rules_to_use, rewrite: !can_skip_rewrite)
 
-            context = GraphQL::StaticValidation::ValidationContext.new(query, visitor_class)
+            context = GraphQL::StaticValidation::ValidationContext.new(query, visitor_class, max_errors)
 
             begin
               # CAUTION: Usage of the timeout module makes the assumption that validation rules are stateless Ruby code that requires no cleanup if process was interrupted. This means no blocking IO calls, native gems, locks, or `rescue` clauses that must be reached.
               # A timeout value of 0 or nil will execute the block without any timeout.
               Timeout::timeout(timeout) do
-                # Attach legacy-style rules.
-                # Only loop through rules if it has legacy-style rules
-                unless (legacy_rules = rules_to_use - GraphQL::StaticValidation::ALL_RULES).empty?
-                  legacy_rules.each do |rule_class_or_module|
-                    if rule_class_or_module.method_defined?(:validate)
-                      GraphQL::Deprecation.warn "Legacy validator rules will be removed from GraphQL-Ruby 2.0, use a module instead (see the built-in rules: https://github.com/rmosolgo/graphql-ruby/tree/master/lib/graphql/static_validation/rules)"
-                      GraphQL::Deprecation.warn "  -> Legacy validator: #{rule_class_or_module}"
-                      rule_class_or_module.new.validate(context)
+                catch(:too_many_validation_errors) do
+                  # Attach legacy-style rules.
+                  # Only loop through rules if it has legacy-style rules
+                  unless (legacy_rules = rules_to_use - GraphQL::StaticValidation::ALL_RULES).empty?
+                    legacy_rules.each do |rule_class_or_module|
+                      if rule_class_or_module.method_defined?(:validate)
+                        GraphQL::Deprecation.warn "Legacy validator rules will be removed from GraphQL-Ruby 2.0, use a module instead (see the built-in rules: https://github.com/rmosolgo/graphql-ruby/tree/master/lib/graphql/static_validation/rules)"
+                        GraphQL::Deprecation.warn "  -> Legacy validator: #{rule_class_or_module}"
+                        rule_class_or_module.new.validate(context)
+                      end
                     end
                   end
-                end
 
-                context.visitor.visit
+                  context.visitor.visit
+                end
               end
             rescue Timeout::Error
               handle_timeout(query, context)

data/lib/graphql/string_encoding_error.rb

@@ -1,10 +1,20 @@
 # frozen_string_literal: true
 module GraphQL
   class StringEncodingError < GraphQL::RuntimeTypeError
-    attr_reader :string
-    def initialize(str)
+    attr_reader :string, :field, :path
+    def initialize(str, context:)
       @string = str
-      super("String \"#{str}\" was encoded as #{str.encoding}! GraphQL requires an encoding compatible with UTF-8.")
+      @field = context[:current_field]
+      @path = context[:current_path]
+      message = "String #{str.inspect} was encoded as #{str.encoding}".dup
+      if @path
+        message << " @ #{@path.join(".")}"
+      end
+      if @field
+        message << " (#{@field.path})"
+      end
+      message << ". GraphQL requires an encoding compatible with UTF-8."
+      super(message)
     end
   end
 end

data/lib/graphql/subscriptions/action_cable_subscriptions.rb

@@ -127,7 +127,13 @@ module GraphQL
       # It will receive notifications when events come in
       # and re-evaluate the query locally.
       def write_subscription(query, events)
-        channel = query.context.fetch(:channel)
+        unless (channel = query.context[:channel])
+          raise GraphQL::Error, "This GraphQL Subscription client does not support the transport protocol expected"\
+            "by the backend Subscription Server implementation (graphql-ruby ActionCableSubscriptions in this case)."\
+            "Some official client implementation including Apollo (https://graphql-ruby.org/javascript_client/apollo_subscriptions.html), "\
+            "Relay Modern (https://graphql-ruby.org/javascript_client/relay_subscriptions.html#actioncable)."\
+            "GraphiQL via `graphiql-rails` may not work out of box (#1051)."
+        end
         subscription_id = query.context[:subscription_id] ||= build_id
         stream = stream_subscription_name(subscription_id)
         channel.stream_from(stream)

data/lib/graphql/subscriptions/event.rb

@@ -29,26 +29,10 @@ module GraphQL
       end
 
       # @return [String] an identifier for this unit of subscription
-      def self.serialize(name, arguments, field, scope:)
-        normalized_args = case arguments
-        when GraphQL::Query::Arguments
-          arguments
-        when Hash
-          if field.is_a?(GraphQL::Schema::Field)
-            stringify_args(field, arguments)
-          else
-            GraphQL::Query::LiteralInput.from_arguments(
-              arguments,
-              field,
-              nil,
-            )
-          end
-        else
-          raise ArgumentError, "Unexpected arguments: #{arguments}, must be Hash or GraphQL::Arguments"
-        end
-
-        sorted_h = stringify_args(field, normalized_args.to_h)
-        Serialize.dump_recursive([scope, name, sorted_h])
+      def self.serialize(_name, arguments, field, scope:)
+        subscription = field.resolver || GraphQL::Schema::Subscription
+        normalized_args = stringify_args(field, arguments.to_h)
+        subscription.topic_for(arguments: normalized_args, field: field, scope: scope)
       end
 
       # @return [String] a logical identifier for this event. (Stable when the query is broadcastable.)
@@ -70,6 +54,7 @@ module GraphQL
       class << self
         private
         def stringify_args(arg_owner, args)
+          arg_owner = arg_owner.respond_to?(:unwrap) ? arg_owner.unwrap : arg_owner # remove list and non-null wrappers
           case args
           when Hash
             next_args = {}
@@ -80,11 +65,11 @@ module GraphQL
 
               if arg_defn
                 normalized_arg_name = camelized_arg_name
+                next_args[normalized_arg_name] = stringify_args(arg_defn.type, v)
               else
                 normalized_arg_name = arg_name
                 arg_defn = get_arg_definition(arg_owner, normalized_arg_name)
               end
-
               next_args[normalized_arg_name] = stringify_args(arg_defn.type, v)
             end
             # Make sure they're deeply sorted

data/lib/graphql/subscriptions/serialize.rb

@@ -9,7 +9,7 @@ module GraphQL
       SYMBOL_KEY = "__sym__"
       SYMBOL_KEYS_KEY = "__sym_keys__"
       TIMESTAMP_KEY = "__timestamp__"
-      TIMESTAMP_FORMAT = "%Y-%m-%d %H:%M:%S.%N%Z" # eg '2020-01-01 23:59:59.123456789+05:00'
+      TIMESTAMP_FORMAT = "%Y-%m-%d %H:%M:%S.%N%z" # eg '2020-01-01 23:59:59.123456789+05:00'
       OPEN_STRUCT_KEY = "__ostruct__"
 
       module_function

data/lib/graphql/tracing/appsignal_tracing.rb

@@ -14,7 +14,22 @@ module GraphQL
         "execute_query_lazy" => "execute.graphql",
       }
 
+      # @param set_action_name [Boolean] If true, the GraphQL operation name will be used as the transaction name.
+      #   This is not advised if you run more than one query per HTTP request, for example, with `graphql-client` or multiplexing.
+      #   It can also be specified per-query with `context[:set_appsignal_action_name]`.
+      def initialize(options = {})
+        @set_action_name = options.fetch(:set_action_name, false)
+        super
+      end
+
       def platform_trace(platform_key, key, data)
+        if key == "execute_query"
+          set_this_txn_name =  data[:query].context[:set_appsignal_action_name]
+          if set_this_txn_name == true || (set_this_txn_name.nil? && @set_action_name)
+            Appsignal::Transaction.current.set_action(transaction_name(data[:query]))
+          end
+        end
+
         Appsignal.instrument(platform_key) do
           yield
         end

data/lib/graphql/types/big_int.rb

@@ -6,7 +6,7 @@ module GraphQL
       description "Represents non-fractional signed whole numeric values. Since the value may exceed the size of a 32-bit integer, it's encoded as a string."
 
       def self.coerce_input(value, _ctx)
-        value && Integer(value)
+        value && parse_int(value)
       rescue ArgumentError
         nil
       end
@@ -14,6 +14,10 @@ module GraphQL
       def self.coerce_result(value, _ctx)
         value.to_i.to_s
       end
+
+      def self.parse_int(value)
+        value.is_a?(Numeric) ? value : Integer(value, 10)
+      end
     end
   end
 end

data/lib/graphql/types/int.rb

@@ -25,7 +25,7 @@ module GraphQL
         if value >= MIN && value <= MAX
           value
         else
-          err = GraphQL::IntegerEncodingError.new(value)
+          err = GraphQL::IntegerEncodingError.new(value, context: ctx)
           ctx.schema.type_error(err, ctx)
         end
       end

data/lib/graphql/types/string.rb

@@ -15,7 +15,7 @@ module GraphQL
           str.encode!(Encoding::UTF_8)
         end
       rescue EncodingError
-        err = GraphQL::StringEncodingError.new(str)
+        err = GraphQL::StringEncodingError.new(str, context: ctx)
         ctx.schema.type_error(err, ctx)
       end
 

data/lib/graphql/unauthorized_error.rb

@@ -12,7 +12,7 @@ module GraphQL
     attr_reader :type
 
     # @return [GraphQL::Query::Context] the context for the current query
-    attr_reader :context
+    attr_accessor :context
 
     def initialize(message = nil, object: nil, type: nil, context: nil)
       if message.nil? && object.nil? && type.nil?

data/lib/graphql/version.rb

@@ -1,4 +1,4 @@
 # frozen_string_literal: true
 module GraphQL
-  VERSION = "1.12.15"
+  VERSION = "1.12.19"
 end

data/lib/graphql.rb

@@ -57,22 +57,26 @@ module GraphQL
   end
 
   # Support Ruby 2.2 by implementing `-"str"`. If we drop 2.2 support, we can remove this backport.
-  module StringDedupBackport
-    refine String do
-      def -@
-        if frozen?
-          self
-        else
-          self.dup.freeze
+  if !String.method_defined?(:-@)
+    module StringDedupBackport
+      refine String do
+        def -@
+          if frozen?
+            self
+          else
+            self.dup.freeze
+          end
         end
       end
     end
   end
 
-  module StringMatchBackport
-    refine String do
-      def match?(pattern)
-        self =~ pattern
+  if !String.method_defined?(:match?)
+    module StringMatchBackport
+      refine String do
+        def match?(pattern)
+          self =~ pattern
+        end
       end
     end
   end

data/readme.md

@@ -44,6 +44,6 @@ I also sell [GraphQL::Pro](https://graphql.pro) which provides several features
 
 ## Getting Involved
 
-- __Say hi & ask questions__ in the [#ruby channel on Slack](https://graphql-slack.herokuapp.com/) or [on Twitter](https://twitter.com/rmosolgo)!
+- __Say hi & ask questions__ in the #graphql-ruby channel on [Discord](https://discord.com/invite/xud7bH9) or [on Twitter](https://twitter.com/rmosolgo)!
 - __Report bugs__ by posting a description, full stack trace, and all relevant code in a  [GitHub issue](https://github.com/rmosolgo/graphql-ruby/issues).
 - __Start hacking__ with the [Development guide](https://graphql-ruby.org/development).

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: graphql
 version: !ruby/object:Gem::Version
-  version: 1.12.15
+  version: 1.12.19
 platform: ruby
 authors:
 - Robert Mosolgo
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2021-08-23 00:00:00.000000000 Z
+date: 2021-11-05 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: benchmark-ips
@@ -544,6 +544,8 @@ files:
 - lib/graphql/schema/unique_within_type.rb
 - lib/graphql/schema/validation.rb
 - lib/graphql/schema/validator.rb
+- lib/graphql/schema/validator/allow_blank_validator.rb
+- lib/graphql/schema/validator/allow_null_validator.rb
 - lib/graphql/schema/validator/exclusion_validator.rb
 - lib/graphql/schema/validator/format_validator.rb
 - lib/graphql/schema/validator/inclusion_validator.rb
@@ -700,7 +702,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.2.15
+rubygems_version: 3.2.22
 signing_key:
 specification_version: 4
 summary: A GraphQL language and runtime for Ruby