graphql 1.10.7 → 1.10.12

data/lib/graphql/schema/object.rb

@@ -71,6 +71,13 @@ module GraphQL
       end
 
       class << self
+        # Set up a type-specific invalid null error to use when this object's non-null fields wrongly return `nil`.
+        # It should help with debugging and bug tracker integrations.
+        def inherited(child_class)
+          child_class.const_set(:InvalidNullError, Class.new(GraphQL::InvalidNullError))
+          super
+        end
+
         def implements(*new_interfaces, **options)
           new_memberships = []
           new_interfaces.each do |int|
@@ -79,14 +86,14 @@ module GraphQL
                 raise "#{int} cannot be implemented since it's not a GraphQL Interface. Use `include` for plain Ruby modules."
               end
 
-              new_memberships << int.type_membership_class.new(int, self, options)
+              new_memberships << int.type_membership_class.new(int, self, **options)
 
               # Include the methods here,
               # `.fields` will use the inheritance chain
               # to find inherited fields
               include(int)
             elsif int.is_a?(GraphQL::InterfaceType)
-              new_memberships << int.type_membership_class.new(int, self, options)
+              new_memberships << int.type_membership_class.new(int, self, **options)
             elsif int.is_a?(String) || int.is_a?(GraphQL::Schema::LateBoundType)
               if options.any?
                 raise ArgumentError, "`implements(...)` doesn't support options with late-loaded types yet. Remove #{options} and open an issue to request this feature."

data/lib/graphql/schema/resolver.rb

@@ -220,7 +220,7 @@ module GraphQL
         # or use it as a configuration method to assign a return type
         # instead of generating one.
         # TODO unify with {#null}
-        # @param new_type [Class, nil] If a type definition class is provided, it will be used as the return type of the field
+        # @param new_type [Class, Array<Class>, nil] If a type definition class is provided, it will be used as the return type of the field
         # @param null [true, false] Whether or not the field may return `nil`
         # @return [Class] The type which this field returns.
         def type(new_type = nil, null: nil)

data/lib/graphql/schema/union.rb

@@ -3,8 +3,14 @@ module GraphQL
   class Schema
     class Union < GraphQL::Schema::Member
       extend GraphQL::Schema::Member::AcceptsDefinition
+      extend GraphQL::Schema::Member::HasUnresolvedTypeError
 
       class << self
+        def inherited(child_class)
+          add_unresolved_type_error(child_class)
+          super
+        end
+
         def possible_types(*types, context: GraphQL::Query::NullContext, **options)
           if types.any?
             types.each do |t|

data/lib/graphql/schema/warden.rb

@@ -166,7 +166,13 @@ module GraphQL
       end
 
       def visible_field?(owner_type, field_defn)
-        visible?(field_defn) && visible_type?(field_defn.type.unwrap) && field_on_visible_interface?(field_defn, owner_type)
+        # This field is visible in its own right
+        visible?(field_defn) &&
+          # This field's return type is visible
+          visible_type?(field_defn.type.unwrap) &&
+          # This field is either defined on this object type,
+          # or the interface it's inherited from is also visible
+          ((field_defn.respond_to?(:owner) && field_defn.owner == owner_type) || field_on_visible_interface?(field_defn, owner_type))
       end
 
       # We need this to tell whether a field was inherited by an interface

data/lib/graphql/subscriptions/action_cable_subscriptions.rb

@@ -8,6 +8,7 @@ module GraphQL
     #
     # - No queueing system; ActiveJob should be added
     # - Take care to reload context when re-delivering the subscription. (see {Query#subscription_update?})
+    # - Avoid the async ActionCable adapter and use the redis or PostgreSQL adapters instead. Otherwise calling #trigger won't work from background jobs or the Rails console. 
     #
     # @example Adding ActionCableSubscriptions to your schema
     #   class MySchema < GraphQL::Schema

data/lib/graphql/subscriptions/subscription_root.rb

@@ -40,7 +40,7 @@ module GraphQL
             # for the backend to register:
             event = Subscriptions::Event.new(
               name: field.name,
-              arguments: arguments,
+              arguments: arguments_without_field_extras(arguments: arguments),
               context: context,
               field: field,
             )
@@ -48,7 +48,7 @@ module GraphQL
             value
           elsif context.query.subscription_topic == Subscriptions::Event.serialize(
               field.name,
-              arguments,
+              arguments_without_field_extras(arguments: arguments),
               field,
               scope: (field.subscription_scope ? context[field.subscription_scope] : nil),
             )
@@ -60,6 +60,14 @@ module GraphQL
             context.skip
           end
         end
+
+        private
+
+        def arguments_without_field_extras(arguments:)
+          arguments.dup.tap do |event_args|
+            field.extras.each { |k| event_args.delete(k) }
+          end
+        end
       end
     end
   end

data/lib/graphql/tracing.rb

@@ -63,8 +63,9 @@ module GraphQL
       # @param key [String] The name of the event in GraphQL internals
       # @param metadata [Hash] Event-related metadata (can be anything)
       # @return [Object] Must return the value of the block
-      def trace(key, metadata)
-        call_tracers(0, key, metadata) { yield }
+      def trace(key, metadata, &block)
+        return yield if @tracers.empty?
+        call_tracers(0, key, metadata, &block)
       end
 
       private
@@ -76,11 +77,11 @@ module GraphQL
       # @param key [String] The current event name
       # @param metadata [Object] The current event object
       # @return Whatever the block returns
-      def call_tracers(idx, key, metadata)
+      def call_tracers(idx, key, metadata, &block)
         if idx == @tracers.length
           yield
         else
-          @tracers[idx].trace(key, metadata) { call_tracers(idx + 1, key, metadata) { yield } }
+          @tracers[idx].trace(key, metadata) { call_tracers(idx + 1, key, metadata, &block) }
         end
       end
     end

data/lib/graphql/tracing/new_relic_tracing.rb

@@ -26,18 +26,7 @@ module GraphQL
         if key == "execute_query"
           set_this_txn_name =  data[:query].context[:set_new_relic_transaction_name]
           if set_this_txn_name == true || (set_this_txn_name.nil? && @set_transaction_name)
-            query = data[:query]
-            # Set the transaction name based on the operation type and name
-            selected_op = query.selected_operation
-            if selected_op
-              op_type = selected_op.operation_type
-              op_name = selected_op.name || "anonymous"
-            else
-              op_type = "query"
-              op_name = "anonymous"
-            end
-
-            NewRelic::Agent.set_transaction_name("GraphQL/#{op_type}.#{op_name}")
+            NewRelic::Agent.set_transaction_name(transaction_name(data[:query]))
           end
         end
 

data/lib/graphql/tracing/platform_tracing.rb

@@ -103,6 +103,20 @@ module GraphQL
       end
 
       private
+
+      # Get the transaction name based on the operation type and name
+      def transaction_name(query)
+        selected_op = query.selected_operation
+        if selected_op
+          op_type = selected_op.operation_type
+          op_name = selected_op.name || "anonymous"
+        else
+          op_type = "query"
+          op_name = "anonymous"
+        end
+        "GraphQL/#{op_type}.#{op_name}"
+      end
+
       attr_reader :options
 
       def platform_key_cache(ctx)

data/lib/graphql/tracing/scout_tracing.rb

@@ -16,12 +16,23 @@ module GraphQL
         "execute_query_lazy" => "execute.graphql",
       }
 
+      # @param set_transaction_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_scout_transaction_name]`.
       def initialize(options = {})
         self.class.include ScoutApm::Tracer
+        @set_transaction_name = options.fetch(:set_transaction_name, false)
         super(options)
       end
 
       def platform_trace(platform_key, key, data)
+        if key == "execute_query"
+          set_this_txn_name = data[:query].context[:set_scout_transaction_name]
+          if set_this_txn_name == true || (set_this_txn_name.nil? && @set_transaction_name)
+            ScoutApm::Transaction.rename(transaction_name(data[:query]))
+          end
+        end
+
         self.class.instrument("GraphQL", platform_key, INSTRUMENT_OPTS) do
           yield
         end

data/lib/graphql/types/iso_8601_date.rb

@@ -15,7 +15,7 @@ module GraphQL
     class ISO8601Date < GraphQL::Schema::Scalar
       description "An ISO 8601-encoded date"
 
-      # @param value [Date,DateTime,String]
+      # @param value [Date,Time,DateTime,String]
       # @return [String]
       def self.coerce_result(value, _ctx)
         Date.parse(value.to_s).iso8601
@@ -25,7 +25,7 @@ module GraphQL
       # @return [Date]
       def self.coerce_input(str_value, _ctx)
         Date.iso8601(str_value)
-      rescue ArgumentError
+      rescue ArgumentError, TypeError
         # Invalid input
         nil
       end

data/lib/graphql/types/iso_8601_date_time.rb

@@ -1,7 +1,9 @@
+require 'time'
+
 # frozen_string_literal: true
 module GraphQL
   module Types
-    # This scalar takes `DateTime`s and transmits them as strings,
+    # This scalar takes `Time`s and transmits them as strings,
     # using ISO 8601 format.
     #
     # Use it for fields or arguments as follows:
@@ -29,31 +31,33 @@ module GraphQL
         @time_precision = value
       end
 
-      # @param value [Date,DateTime,String]
+      # @param value [Time,Date,DateTime,String]
       # @return [String]
-      def self.coerce_result(value, _ctx)\
+      def self.coerce_result(value, _ctx)
         case value
-        when DateTime
-          return value.iso8601(time_precision)
         when Date
-          return DateTime.parse(value.to_s).iso8601(time_precision)
+          return value.to_time.iso8601(time_precision)
         when ::String
-          return DateTime.parse(value).iso8601(time_precision)
+          return Time.parse(value).iso8601(time_precision)
         else
-          # In case some other API-compliant thing is given: 
+          # Time, DateTime or compatible is given:
           return value.iso8601(time_precision)
-        end 
+        end
       rescue StandardError => error
-        raise GraphQL::Error, "An incompatible object (#{value.class}) was given to #{self}. Make sure that only Dates, DateTimes, and well-formatted Strings are used with this type. (#{error.message})"
+        raise GraphQL::Error, "An incompatible object (#{value.class}) was given to #{self}. Make sure that only Times, Dates, DateTimes, and well-formatted Strings are used with this type. (#{error.message})"
       end
 
       # @param str_value [String]
-      # @return [DateTime]
+      # @return [Time]
       def self.coerce_input(str_value, _ctx)
-        DateTime.iso8601(str_value)
-      rescue ArgumentError
-        # Invalid input
-        nil
+        Time.iso8601(str_value)
+      rescue ArgumentError, TypeError
+        begin
+          Date.iso8601(str_value).to_time
+        rescue ArgumentError, TypeError
+          # Invalid input
+          nil
+        end
       end
     end
   end

data/lib/graphql/version.rb

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

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: graphql
 version: !ruby/object:Gem::Version
-  version: 1.10.7
+  version: 1.10.12
 platform: ruby
 authors:
 - Robert Mosolgo
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2020-04-16 00:00:00.000000000 Z
+date: 2020-06-13 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: benchmark-ips
@@ -422,6 +422,8 @@ files:
 - lib/graphql/execution/flatten.rb
 - lib/graphql/execution/instrumentation.rb
 - lib/graphql/execution/interpreter.rb
+- lib/graphql/execution/interpreter/argument_value.rb
+- lib/graphql/execution/interpreter/arguments.rb
 - lib/graphql/execution/interpreter/arguments_cache.rb
 - lib/graphql/execution/interpreter/execution_errors.rb
 - lib/graphql/execution/interpreter/handles_raw_value.rb
@@ -580,6 +582,7 @@ files:
 - lib/graphql/schema/member/has_ast_node.rb
 - lib/graphql/schema/member/has_fields.rb
 - lib/graphql/schema/member/has_path.rb
+- lib/graphql/schema/member/has_unresolved_type_error.rb
 - lib/graphql/schema/member/instrumentation.rb
 - lib/graphql/schema/member/relay_shortcuts.rb
 - lib/graphql/schema/member/scoped.rb
@@ -746,7 +749,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.0.3
+rubygems_version: 3.1.2
 signing_key: 
 specification_version: 4
 summary: A GraphQL language and runtime for Ruby