graphql 1.7.6 → 1.8.0

data/lib/graphql/subscriptions/action_cable_subscriptions.rb

@@ -39,7 +39,7 @@ module GraphQL
     #       })
     #
     #       payload = {
-    #         result: result.subscription? ? nil : result.to_h,
+    #         result: result.subscription? ? {data: nil} : result.to_h,
     #         more: result.subscription?,
     #       }
     #
@@ -62,19 +62,21 @@ module GraphQL
     class ActionCableSubscriptions < GraphQL::Subscriptions
       SUBSCRIPTION_PREFIX = "graphql-subscription:"
       EVENT_PREFIX = "graphql-event:"
-      def initialize(**rest)
+
+      # @param serializer [<#dump(obj), #load(string)] Used for serializing messages before handing them to `.broadcast(msg)`
+      def initialize(serializer: Serialize, **rest)
         # A per-process map of subscriptions to deliver.
         # This is provided by Rails, so let's use it
         @subscriptions = Concurrent::Map.new
+        @serializer = serializer
         super
       end
 
       # An event was triggered; Push the data over ActionCable.
       # Subscribers will re-evaluate locally.
-      # TODO: this method name is a smell
       def execute_all(event, object)
         stream = EVENT_PREFIX + event.topic
-        message = Serialize.dump(object)
+        message = @serializer.dump(object)
         ActionCable.server.broadcast(stream, message)
       end
 
@@ -97,7 +99,7 @@ module GraphQL
         @subscriptions[subscription_id] = query
         events.each do |event|
           channel.stream_from(EVENT_PREFIX + event.topic, coder: ActiveSupport::JSON) do |message|
-            execute(subscription_id, event, Serialize.load(message))
+            execute(subscription_id, event, @serializer.load(message))
             nil
           end
         end

data/lib/graphql/subscriptions/instrumentation.rb

@@ -56,7 +56,11 @@ module GraphQL
             ctx.skip
           elsif ctx.irep_node.subscription_topic == ctx.query.subscription_topic
             # The root object is _already_ the subscription update:
-            obj
+            if obj.is_a?(GraphQL::Schema::Object)
+              obj.object
+            else
+              obj
+            end
           else
             # This is a subscription update, but this event wasn't triggered.
             ctx.skip

data/lib/graphql/subscriptions/serialize.rb

@@ -35,6 +35,8 @@ module GraphQL
           obj.map { |i| dump_recursive(i) }.join(':')
         when obj.is_a?(Hash)
           obj.map { |k, v| "#{dump_recursive(k)}:#{dump_recursive(v)}" }.join(":")
+        when obj.is_a?(GraphQL::Schema::InputObject)
+          dump_recursive(obj.to_h)
         when obj.respond_to?(:to_gid_param)
           obj.to_gid_param
         when obj.respond_to?(:to_param)

data/lib/graphql/subscriptions.rb

@@ -9,6 +9,13 @@ end
 
 module GraphQL
   class Subscriptions
+    # Raised when either:
+    # - the triggered `event_name` doesn't match a field in the schema; or
+    # - one or more arguments don't match the field arguments
+    class InvalidTriggerError < GraphQL::Error
+    end
+
+    # @see {Subscriptions#initialize} for options, concrete implementations may add options.
     def self.use(defn, options = {})
       schema = defn.target
       options[:schema] = schema
@@ -19,8 +26,9 @@ module GraphQL
       nil
     end
 
-    def initialize(kwargs)
-      @schema = kwargs[:schema]
+    # @param schema [Class] the GraphQL schema this manager belongs to
+    def initialize(schema:, **rest)
+      @schema = schema
     end
 
     # Fetch subscriptions matching this field + arguments pair
@@ -31,31 +39,35 @@ module GraphQL
     # @param scope [Symbol, String]
     # @return [void]
     def trigger(event_name, args, object, scope: nil)
+      event_name = event_name.to_s
+
+      # Try with the verbatim input first:
       field = @schema.get_field("Subscription", event_name)
-      if !field
-        raise "No subscription matching trigger: #{event_name}"
-      end
 
-      # Normalize symbol-keyed args to strings
-      if args.any?
-        stringified_args = {}
-        args.each { |k, v| stringified_args[k.to_s] = v }
-        args = stringified_args
+      if field.nil?
+        # And if it wasn't found, normalize it:
+        normalized_event_name = normalize_name(event_name)
+        field = @schema.get_field("Subscription", normalized_event_name)
+        if field.nil?
+          raise InvalidTriggerError, "No subscription matching trigger: #{event_name} (looked for #{@schema.subscription.graphql_name}.#{normalized_event_name})"
+        end
+      else
+        # Since we found a field, the original input was already normalized
+        normalized_event_name = event_name
       end
 
+      # Normalize symbol-keyed args to strings, try camelizing them
+      normalized_args = normalize_arguments(normalized_event_name, field, args)
+
       event = Subscriptions::Event.new(
-        name: event_name,
-        arguments: args,
+        name: normalized_event_name,
+        arguments: normalized_args,
         field: field,
         scope: scope,
       )
       execute_all(event, object)
     end
 
-    def initialize(schema:, **rest)
-      @schema = schema
-    end
-
     # `event` was triggered on `object`, and `subscription_id` was subscribed,
     # so it should be updated.
     #
@@ -139,5 +151,67 @@ module GraphQL
     def build_id
       SecureRandom.uuid
     end
+
+    # Convert a user-provided event name or argument
+    # to the equivalent in GraphQL.
+    #
+    # By default, it converts the identifier to camelcase.
+    # Override this in a subclass to change the transformation.
+    #
+    # @param event_or_arg_name [String, Symbol]
+    # @return [String]
+    def normalize_name(event_or_arg_name)
+      Schema::Member::BuildType.camelize(event_or_arg_name.to_s)
+    end
+
+    private
+
+    # Recursively normalize `args` as belonging to `arg_owner`:
+    # - convert symbols to strings,
+    # - if needed, camelize the string (using {#normalize_name})
+    # @param arg_owner [GraphQL::Field, GraphQL::BaseType]
+    # @param args [Hash, Array, Any] some GraphQL input value to coerce as `arg_owner`
+    # @return [Any] normalized arguments value
+    def normalize_arguments(event_name, arg_owner, args)
+      case arg_owner
+      when GraphQL::Field, GraphQL::InputObjectType
+        normalized_args = {}
+        missing_arg_names = []
+        args.each do |k, v|
+          arg_name = k.to_s
+          arg_defn = arg_owner.arguments[arg_name]
+          if arg_defn
+            normalized_arg_name = arg_name
+          else
+            normalized_arg_name = normalize_name(arg_name)
+            arg_defn = arg_owner.arguments[normalized_arg_name]
+          end
+
+          if arg_defn
+            normalized_args[normalized_arg_name] = normalize_arguments(event_name, arg_defn.type, v)
+          else
+            # Couldn't find a matching argument definition
+            missing_arg_names << arg_name
+          end
+        end
+
+        if missing_arg_names.any?
+          arg_owner_name = if arg_owner.is_a?(GraphQL::Field)
+            "Subscription.#{arg_owner.name}"
+          else
+            arg_owner.to_s
+          end
+          raise InvalidTriggerError, "Can't trigger Subscription.#{event_name}, received undefined arguments: #{missing_arg_names.join(", ")}. (Should match arguments of #{arg_owner_name}.)"
+        end
+
+        normalized_args
+      when GraphQL::ListType
+        args.map { |a| normalize_arguments(event_name, arg_owner.of_type, a) }
+      when GraphQL::NonNullType
+        normalize_arguments(event_name, arg_owner.of_type, args)
+      else
+        args
+      end
+    end
   end
 end

data/lib/graphql/tracing/data_dog_tracing.rb

@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+
+module GraphQL
+  module Tracing
+    class DataDogTracing < PlatformTracing
+      self.platform_keys = {
+        'lex' => 'lex.graphql',
+        'parse' => 'parse.graphql',
+        'validate' => 'validate.graphql',
+        'analyze_query' => 'analyze.graphql',
+        'analyze_multiplex' => 'analyze.graphql',
+        'execute_multiplex' => 'execute.graphql',
+        'execute_query' => 'execute.graphql',
+        'execute_query_lazy' => 'execute.graphql',
+      }
+
+      def platform_trace(platform_key, key, data)
+        tracer.trace(platform_key, service: service_name) do |span|
+          span.span_type = 'custom'
+
+          if key == 'execute_multiplex'
+            operations = data[:multiplex].queries.map(&:selected_operation_name).join(', ')
+            span.resource = operations unless operations.empty?
+          end
+
+          if key == 'execute_query'
+            span.set_tag(:selected_operation_name, data[:query].selected_operation_name)
+            span.set_tag(:selected_operation_type, data[:query].selected_operation.operation_type)
+            span.set_tag(:query_string, data[:query].query_string)
+          end
+
+          yield
+        end
+      end
+
+      def service_name
+        options.fetch(:service, 'ruby-graphql')
+      end
+
+      def tracer
+        options.fetch(:tracer, Datadog.tracer)
+      end
+
+      def platform_field_key(type, field)
+        "#{type.name}.#{field.name}"
+      end
+    end
+  end
+end

data/lib/graphql/tracing/new_relic_tracing.rb

@@ -14,7 +14,33 @@ module GraphQL
         "execute_query_lazy" => "GraphQL/execute",
       }
 
+      # @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_new_relic_transaction_name]`.
+      def initialize(set_transaction_name: false)
+        @set_transaction_name = set_transaction_name
+        super
+      end
+
       def platform_trace(platform_key, key, data)
+        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}")
+          end
+        end
+
         NewRelic::Agent::MethodTracerHelpers.trace_execution_scoped(platform_key) do
           yield
         end

data/lib/graphql/tracing/platform_tracing.rb

@@ -12,8 +12,10 @@ module GraphQL
         attr_accessor :platform_keys
       end
 
-      def initialize
+      def initialize(options = {})
+        @options = options
         @platform_keys = self.class.platform_keys
+        @trace_scalars = options.fetch(:trace_scalars, false)
       end
 
       def trace(key, data)
@@ -41,19 +43,30 @@ module GraphQL
         return_type = field.type.unwrap
         case return_type
         when GraphQL::ScalarType, GraphQL::EnumType
-          field
+          if field.trace || (field.trace.nil? && @trace_scalars)
+            trace_field(type, field)
+          else
+            field
+          end
         else
-          new_f = field.redefine
-          new_f.metadata[:platform_key] = platform_field_key(type, field)
-          new_f
+          trace_field(type, field)
         end
       end
 
-      def self.use(schema_defn)
-        tracer = self.new
+      def trace_field(type, field)
+        new_f = field.redefine
+        new_f.metadata[:platform_key] = platform_field_key(type, field)
+        new_f
+      end
+
+      def self.use(schema_defn, options = {})
+        tracer = self.new(options)
         schema_defn.instrument(:field, tracer)
         schema_defn.tracer(tracer)
       end
+
+      private
+      attr_reader :options
     end
   end
 end

data/lib/graphql/tracing/scout_tracing.rb

@@ -16,9 +16,9 @@ module GraphQL
         "execute_query_lazy" => "execute.graphql",
       }
 
-      def initialize
+      def initialize(options = {})
         self.class.include ScoutApm::Tracer
-        super
+        super(options)
       end
 
       def platform_trace(platform_key, key, data)

data/lib/graphql/tracing.rb

@@ -2,6 +2,7 @@
 require "graphql/tracing/active_support_notifications_tracing"
 require "graphql/tracing/platform_tracing"
 require "graphql/tracing/appsignal_tracing"
+require "graphql/tracing/data_dog_tracing"
 require "graphql/tracing/new_relic_tracing"
 require "graphql/tracing/scout_tracing"
 require "graphql/tracing/skylight_tracing"

data/lib/graphql/unresolved_type_error.rb

@@ -26,8 +26,9 @@ module GraphQL
       @possible_types = possible_types
       message = "The value from \"#{field.name}\" on \"#{parent_type}\" could not be resolved to \"#{field.type}\". " \
         "(Received: `#{resolved_type.inspect}`, Expected: [#{possible_types.map(&:inspect).join(", ")}]) " \
-        "Make sure you have defined a `type_from_object` proc on your schema and that value `#{value.inspect}` " \
-        "gets resolved to a valid type."
+        "Make sure you have defined a `resolve_type` proc on your schema and that value `#{value.inspect}` " \
+        "gets resolved to a valid type. You may need to add your type to `orphan_types` if it implements an " \
+        "interface but isn't a return type of any other field."
       super(message)
     end
   end