graphql 1.9.15 → 1.9.16

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 2f0505024fefcdebc975dad9259c3f3470f883b4251380e759de60ba380b3314
-  data.tar.gz: d92149e0da6aa4e110525a38badaf2163bf887205e2c6dd75c327302e0cfabb4
+  metadata.gz: 75a0bed671ca4979601036351265dfb7a0ce502b4f6937938084f2b9efaa7cd3
+  data.tar.gz: c43fd98af6355bde57ca2e66b1c98831498f3ac71792176063d934f968c1355f
 SHA512:
-  metadata.gz: 47b920de6ba95b4c15ebc4aace97d74931cc24efee8c3fb6a6291ea68a13b3ef46b9c613658306e1ff100d0917433431c129baba12553a94dc96a4184cbc5435
-  data.tar.gz: 0e9c03e45fd3b3cb40a9b6b948ee1f71952f618511254acb3840195ff9c054036308636c7b2a42858096e70d1764e38458b88b0f2f369f699c7f71cdd0afd415
+  metadata.gz: '096f8f6cfa0aa0465f13a54297e10e5564555e5f7937ab1ea2c10d4af49db84b3a4dcf2ca30692aac5b55a6df09e163db62e8e2d712ea3ef7763b20230b642e0'
+  data.tar.gz: aa41d320f6ecf571c81d9243179fc5ffd7b53da4f12b741670caed08fb9405725a30dd56c1db5b6e6a20985e7e506a7ee2c1548097fb8a35e71e0094fbe307ff

data/lib/generators/graphql/core.rb

@@ -25,6 +25,7 @@ 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,6 +24,7 @@ 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(:lower)
+        @field_name = name.camelize.underscore
         @mutation_name = name.camelize(:upper)
         @file_name = name.camelize.underscore
       end

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

@@ -0,0 +1,8 @@
+module Mutations
+  class BaseMutation < GraphQL::Schema::RelayClassicMutation
+    argument_class Types::BaseArgument
+    field_class Types::BaseField
+    input_object_class Types::BaseInputObject
+    object_class Types::BaseObject
+  end
+end

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

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

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 [void]
+      # @return [Array<Any>] Results from multiplex analyzers
       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,10 +5,21 @@ module GraphQL
       # Query analyzer for query ASTs. Query analyzers respond to visitor style methods
       # but are prefixed by `enter` and `leave`.
       #
-      # @param [GraphQL::Query] The query to analyze
+      # 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
       class Analyzer
-        def initialize(query)
-          @query = query
+        def initialize(subject)
+          @subject = subject
+
+          if subject.is_a?(GraphQL::Query)
+            @query = subject
+            @multiplex = nil
+          else
+            @multiplex = subject
+            @query = nil
+          end
         end
 
         # Analyzer hook to decide at analysis time whether a query should
@@ -58,7 +69,15 @@ 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 query.max_complexity.nil?
+          return if subject.max_complexity.nil?
 
           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}")
+          if total_complexity > subject.max_complexity
+            GraphQL::AnalysisError.new("Query has complexity of #{total_complexity}, which exceeds max complexity of #{subject.max_complexity}")
           else
             nil
           end

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

@@ -4,10 +4,14 @@ module GraphQL
     module AST
       class MaxQueryDepth < QueryDepth
         def result
-          return unless query.max_depth
+          configured_max_depth = if query
+            query.max_depth
+          else
+            multiplex.schema.max_depth
+          end
 
-          if @max_depth > query.max_depth
-            GraphQL::AnalysisError.new("Query has depth of #{@max_depth}, which exceeds max depth of #{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}")
           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
-            query.possible_types(parent_type).each do |type|
+            visitor.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(query.context, arguments, child_complexity)
+            defined_complexity.call(visitor.query.context, arguments, child_complexity)
           when Numeric
             defined_complexity + (child_complexity || 0)
           else

data/lib/graphql/language/block_string.rb

@@ -32,10 +32,10 @@ module GraphQL
         end
 
         # Remove leading & trailing blank lines
-        while lines.first.empty?
+        while lines.size > 0 && lines[0].empty?
           lines.shift
         end
-        while lines.last.empty?
+        while lines.size > 0 && lines[-1].empty?
           lines.pop
         end
 

data/lib/graphql/schema/field.rb

@@ -525,7 +525,7 @@ module GraphQL
                 else
                   extended_obj
                 end
-                @resolver_class.new(object: resolver_obj, context: ctx)
+                @resolver_class.new(object: resolver_obj, context: ctx, field: self)
               else
                 extended_obj
               end
@@ -642,7 +642,7 @@ module GraphQL
             if extended_obj.is_a?(GraphQL::Schema::Object)
               extended_obj = extended_obj.object
             end
-            extended_obj = @resolver_class.new(object: extended_obj, context: query_ctx)
+            extended_obj = @resolver_class.new(object: extended_obj, context: query_ctx, field: self)
           end
 
           if extended_obj.respond_to?(@resolver_method)

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

@@ -78,7 +78,7 @@ module GraphQL
 
           def call(obj, args, ctx)
             result = @inner_resolve.call(obj, args, ctx)
-            if ctx.skip == result || ctx.schema.lazy?(result) || result.nil? || result.is_a?(GraphQL::ExecutionError) || ctx.wrapped_object
+            if ctx.skip == result || ctx.schema.lazy?(result) || result.nil? || execution_errors?(result) || ctx.wrapped_object
               result
             else
               ctx.wrapped_object = true
@@ -88,6 +88,11 @@ module GraphQL
 
           private
 
+          def execution_errors?(result)
+            result.is_a?(GraphQL::ExecutionError) ||
+              (result.is_a?(Array) && result.any? && result.all? { |v| v.is_a?(GraphQL::ExecutionError) })
+          end
+
           def proxy_to_depth(inner_obj, depth, ctx)
             if depth > 0
               inner_obj.map { |i| proxy_to_depth(i, depth - 1, ctx) }

data/lib/graphql/schema/relay_classic_mutation.rb

@@ -33,9 +33,13 @@ module GraphQL
         # But when using the interpreter, no instrumenters are applied.
         if context.interpreter?
           input = inputs[:input].to_kwargs
+
+          new_extras = field ? field.extras : []
+          all_extras = self.class.extras + new_extras
+
           # Transfer these from the top-level hash to the
           # shortcutted `input:` object
-          self.class.extras.each do |ext|
+          all_extras.each do |ext|
             # It's possible that the `extra` was not passed along by this point,
             # don't re-add it if it wasn't given here.
             if inputs.key?(ext)

data/lib/graphql/schema/resolver.rb

@@ -29,9 +29,11 @@ module GraphQL
 
       # @param object [Object] the initialize object, pass to {Query.initialize} as `root_value`
       # @param context [GraphQL::Query::Context]
-      def initialize(object:, context:)
+      # @param field [GraphQL::Schema::Field]
+      def initialize(object:, context:, field:)
         @object = object
         @context = context
+        @field = field
         # Since this hash is constantly rebuilt, cache it for this call
         @arguments_by_keyword = {}
         self.class.arguments.each do |name, arg|
@@ -46,6 +48,9 @@ module GraphQL
       # @return [GraphQL::Query::Context]
       attr_reader :context
 
+      # @return [GraphQL::Schema::Field]
+      attr_reader :field
+
       # This method is _actually_ called by the runtime,
       # it does some preparation and then eventually calls
       # the user-defined `#resolve` method.

data/lib/graphql/schema/subscription.rb

@@ -29,7 +29,7 @@ module GraphQL
       # propagate null.
       null false
 
-      def initialize(object:, context:)
+      def initialize(object:, context:, field:)
         super
         # Figure out whether this is an update or an initial subscription
         @mode = context.query.subscription_update? ? :update : :subscribe

data/lib/graphql/schema/timeout_middleware.rb

@@ -35,9 +35,10 @@ module GraphQL
 
       def call(parent_type, parent_object, field_definition, field_args, query_context)
         ns = query_context.namespace(self.class)
-        timeout_at = ns[:timeout_at] ||= Time.now + @max_seconds
+        now = Process.clock_gettime(Process::CLOCK_MONOTONIC)
+        timeout_at = ns[:timeout_at] ||= now + @max_seconds
 
-        if timeout_at < Time.now
+        if timeout_at < now
           on_timeout(parent_type, parent_object, field_definition, field_args, query_context)
         else
           yield

data/lib/graphql/subscriptions/event.rb

@@ -37,7 +37,7 @@ module GraphQL
           arguments
         when Hash
           if field.is_a?(GraphQL::Schema::Field)
-            stringify_args(arguments)
+            stringify_args(field, arguments)
           else
             GraphQL::Query::LiteralInput.from_arguments(
               arguments,
@@ -55,21 +55,35 @@ module GraphQL
 
       class << self
         private
-        def stringify_args(args)
+        def stringify_args(arg_owner, args)
           case args
           when Hash
             next_args = {}
             args.each do |k, v|
-              str_k = GraphQL::Schema::Member::BuildType.camelize(k.to_s)
-              next_args[str_k] = stringify_args(v)
+              arg_name = k.to_s
+              camelized_arg_name = GraphQL::Schema::Member::BuildType.camelize(arg_name)
+              arg_defn = get_arg_definition(arg_owner, camelized_arg_name)
+
+              if arg_defn
+                normalized_arg_name = camelized_arg_name
+              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[1].type, v)
             end
             next_args
           when Array
-            args.map { |a| stringify_args(a) }
+            args.map { |a| stringify_args(arg_owner, a) }
           else
             args
           end
         end
+
+        def get_arg_definition(arg_owner, arg_name)
+          arg_owner.arguments.find { |k, v| k == arg_name || v.keyword.to_s == arg_name }
+        end
       end
     end
   end

data/lib/graphql/tracing/skylight_tracing.rb

@@ -18,6 +18,7 @@ module GraphQL
       #   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_skylight_endpoint_name]`.
       def initialize(options = {})
+        warn("GraphQL::Tracing::SkylightTracing is deprecated, please enable Skylight's GraphQL probe instead: https://www.skylight.io/support/getting-more-from-skylight#graphql.")
         @set_endpoint_name = options.fetch(:set_endpoint_name, false)
         super
       end

data/lib/graphql/version.rb

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

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: graphql
 version: !ruby/object:Gem::Version
-  version: 1.9.15
+  version: 1.9.16
 platform: ruby
 authors:
 - Robert Mosolgo
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2019-10-30 00:00:00.000000000 Z
+date: 2019-12-02 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: benchmark-ips
@@ -340,6 +340,7 @@ files:
 - lib/generators/graphql/templates/base_field.erb
 - lib/generators/graphql/templates/base_input_object.erb
 - lib/generators/graphql/templates/base_interface.erb
+- lib/generators/graphql/templates/base_mutation.erb
 - lib/generators/graphql/templates/base_object.erb
 - lib/generators/graphql/templates/base_scalar.erb
 - lib/generators/graphql/templates/base_union.erb