graphql 1.6.8 → 1.7.0

data/lib/graphql/subscriptions/action_cable_subscriptions.rb

@@ -0,0 +1,122 @@
+# frozen_string_literal: true
+require "securerandom"
+
+module GraphQL
+  class Subscriptions
+    # A subscriptions implementation that sends data
+    # as ActionCable broadcastings.
+    #
+    # Experimental, some things to keep in mind:
+    #
+    # - No queueing system; ActiveJob should be added
+    # - Take care to reload context when re-delivering the subscription. (see {Query#subscription_update?})
+    #
+    # @example Adding ActionCableSubscriptions to your schema
+    #   MySchema = GraphQL::Schema.define do
+    #     # ...
+    #     use GraphQL::Subscriptions::ActionCableSubscriptions
+    #   end
+    #
+    # @example Implementing a channel for GraphQL Subscriptions
+    #   class GraphqlChannel < ApplicationCable::Channel
+    #     def subscribed
+    #       @subscription_ids = []
+    #     end
+    #
+    #     def execute(data)
+    #       query = data["query"]
+    #       variables = ensure_hash(data["variables"])
+    #       operation_name = data["operationName"]
+    #       context = {
+    #         current_user: current_user,
+    #         # Make sure the channel is in the context
+    #         channel: self,
+    #       }
+    #
+    #       result = MySchema.execute({
+    #         query: query,
+    #         context: context,
+    #         variables: variables,
+    #         operation_name: operation_name
+    #       })
+    #
+    #       payload = {
+    #         result: result.to_h,
+    #         more: result.subscription?,
+    #       }
+    #
+    #       # Track the subscription here so we can remove it
+    #       # on unsubscribe.
+    #       if result.context[:subscription_id]
+    #         @subscription_ids << context[:subscription_id]
+    #       end
+    #
+    #       transmit(payload)
+    #     end
+    #
+    #     def unsubscribed
+    #       @subscription_ids.each { |sid|
+    #         CardsSchema.subscriptions.delete_subscription(sid)
+    #       }
+    #     end
+    #   end
+    #
+    class ActionCableSubscriptions < GraphQL::Subscriptions
+      SUBSCRIPTION_PREFIX = "graphql-subscription:"
+      EVENT_PREFIX = "graphql-event:"
+      def initialize(**rest)
+        # A per-process map of subscriptions to deliver.
+        # This is provided by Rails, so let's use it
+        @subscriptions = Concurrent::Map.new
+        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)
+        ActionCable.server.broadcast(EVENT_PREFIX + event.topic, object)
+      end
+
+      # This subscription was re-evaluated.
+      # Send it to the specific stream where this client was waiting.
+      def deliver(subscription_id, result)
+        payload = { result: result.to_h, more: true }
+        ActionCable.server.broadcast(SUBSCRIPTION_PREFIX + subscription_id, payload)
+      end
+
+      # A query was run where these events were subscribed to.
+      # Store them in memory in _this_ ActionCable frontend.
+      # It will receive notifications when events come in
+      # and re-evaluate the query locally.
+      def write_subscription(query, events)
+        channel = query.context[:channel]
+        subscription_id = query.context[:subscription_id] ||= SecureRandom.uuid
+        channel.stream_from(SUBSCRIPTION_PREFIX + subscription_id)
+        @subscriptions[subscription_id] = query
+        events.each do |event|
+          channel.stream_from(EVENT_PREFIX + event.topic, coder: ActiveSupport::JSON) do |message|
+            execute(subscription_id, event, message)
+            nil
+          end
+        end
+      end
+
+      # Return the query from "storage" (in memory)
+      def read_subscription(subscription_id)
+        query = @subscriptions[subscription_id]
+        {
+          query_string: query.query_string,
+          variables: query.provided_variables,
+          context: query.context.to_h,
+          operation_name: query.operation_name,
+        }
+      end
+
+      # The channel was closed, forget about it.
+      def delete_subscription(subscription_id)
+        @subscriptions.delete(subscription_id)
+      end
+    end
+  end
+end

data/lib/graphql/subscriptions/event.rb

@@ -0,0 +1,52 @@
+# frozen_string_literal: true
+module GraphQL
+  class Subscriptions
+    # This thing can be:
+    # - Subscribed to by `subscription { ... }`
+    # - Triggered by `MySchema.subscriber.trigger(name, arguments, obj)`
+    #
+    # An array of `Event`s are passed to `store.register(query, events)`.
+    class Event
+      # @return [String] Corresponds to the Subscription root field name
+      attr_reader :name
+
+      # @return [GraphQL::Query::Arguments]
+      attr_reader :arguments
+
+      # @return [GraphQL::Query::Context]
+      attr_reader :context
+
+      # @return [String] An opaque string which identifies this event, derived from `name` and `arguments`
+      attr_reader :topic
+
+      def initialize(name:, arguments:, field: nil, context: nil, scope: nil)
+        @name = name
+        @arguments = arguments
+        @context = context
+        field ||= context.field
+        scope_val = scope || (context && field.subscription_scope && context[field.subscription_scope])
+
+        @topic = self.class.serialize(name, arguments, field, scope: scope_val)
+      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
+          GraphQL::Query::LiteralInput.from_arguments(
+            arguments,
+            field.arguments,
+            nil,
+          )
+        else
+          raise ArgumentError, "Unexpected arguments: #{arguments}, must be Hash or GraphQL::Arguments"
+        end
+
+        sorted_h = normalized_args.to_h.sort.to_h
+        JSON.dump([scope, name, sorted_h])
+      end
+    end
+  end
+end

data/lib/graphql/subscriptions/instrumentation.rb

@@ -0,0 +1,68 @@
+# frozen_string_literal: true
+# test_via: ../subscriptions.rb
+module GraphQL
+  class Subscriptions
+    # Wrap the root fields of the subscription type with special logic for:
+    # - Registering the subscription during the first execution
+    # - Evaluating the triggered portion(s) of the subscription during later execution
+    class Instrumentation
+      def initialize(schema:)
+        @schema = schema
+      end
+
+      def instrument(type, field)
+        if type == @schema.subscription
+          # This is a root field of `subscription`
+          subscribing_resolve_proc = SubscriptionRegistrationResolve.new(field.resolve_proc)
+          field.redefine(resolve: subscribing_resolve_proc)
+        else
+          field
+        end
+      end
+
+      # If needed, prepare to gather events which this query subscribes to
+      def before_query(query)
+        if query.subscription? && !query.subscription_update?
+          query.context.namespace(:subscriptions)[:events] = []
+        end
+      end
+
+      # After checking the root fields, pass the gathered events to the store
+      def after_query(query)
+        events = query.context.namespace(:subscriptions)[:events]
+        if events && events.any?
+          @schema.subscriptions.write_subscription(query, events)
+        end
+      end
+
+      private
+
+      class SubscriptionRegistrationResolve
+        def initialize(inner_proc)
+          @inner_proc = inner_proc
+        end
+
+        # Wrap the proc with subscription registration logic
+        def call(obj, args, ctx)
+          events = ctx.namespace(:subscriptions)[:events]
+          if events
+            # This is the first execution, so gather an Event
+            # for the backend to register:
+            events << Subscriptions::Event.new(
+              name: ctx.field.name,
+              arguments: args,
+              context: ctx,
+            )
+            ctx.skip
+          elsif ctx.irep_node.subscription_topic == ctx.query.subscription_topic
+            # The root object is _already_ the subscription update:
+            @inner_proc.call(obj, args, ctx)
+          else
+            # This is a subscription update, but this event wasn't triggered.
+            ctx.skip
+          end
+        end
+      end
+    end
+  end
+end

data/lib/graphql/tracing.rb

@@ -0,0 +1,80 @@
+# frozen_string_literal: true
+require "graphql/tracing/active_support_notifications_tracing"
+module GraphQL
+  # Library entry point for performance metric reporting.
+  #
+  # {ActiveSupportNotificationsTracing} is imported by default
+  # when `ActiveSupport::Notifications` is found.
+  #
+  # You can remove it with `GraphQL::Tracing.uninstall(GraphQL::Tracing::ActiveSupportNotificationsTracing)`.
+  #
+  # __Warning:__ Installing/uninstalling tracers is not thread-safe. Do it during application boot only.
+  #
+  # @example Sending custom events
+  #   GraphQL::Tracing.trace("my_custom_event", { ... }) do
+  #     # do stuff ...
+  #   end
+  #
+  # Events:
+  #
+  # Key | Metadata
+  # ----|---------
+  # lex | `{ query_string: String }`
+  # parse | `{ query_string: String }`
+  # validate | `{ query: GraphQL::Query, validate: Boolean }`
+  # analyze_multiplex |  `{ multiplex: GraphQL::Execution::Multiplex }`
+  # analyze_query | `{ query: GraphQL::Query }`
+  # execute_multiplex | `{ query: GraphQL::Execution::Multiplex }`
+  # execute_query | `{ query: GraphQL::Query }`
+  # execute_query_lazy | `{ query: GraphQL::Query?, queries: Array<GraphQL::Query>? }`
+  # execute_field | `{ context: GraphQL::Query::Context::FieldResolutionContext }`
+  # execute_field_lazy | `{ context: GraphQL::Query::Context::FieldResolutionContext }`
+  #
+  module Tracing
+    class << self
+      # Override this method to do stuff
+      # @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 }
+      end
+
+      # Install a tracer to receive events.
+      # @param tracer [<#trace(key, metadata)>]
+      # @return [void]
+      def install(tracer)
+        if !tracers.include?(tracer)
+          @tracers << tracer
+        end
+      end
+
+      def uninstall(tracer)
+        @tracers.delete(tracer)
+      end
+
+      def tracers
+        @tracers ||= []
+      end
+
+      private
+
+      # If there's a tracer at `idx`, call it and then increment `idx`.
+      # Otherwise, yield.
+      #
+      # @param idx [Integer] Which tracer to call
+      # @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)
+        if idx == @tracers.length
+          yield
+        else
+          @tracers[idx].trace(key, metadata) { call_tracers(idx + 1, key, metadata) { yield } }
+        end
+      end
+    end
+    # Initialize the array
+    tracers
+  end
+end

data/lib/graphql/tracing/active_support_notifications_tracing.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+module GraphQL
+  module Tracing
+    # This implementation forwards events to ActiveSupport::Notifications
+    # with a `graphql.` prefix.
+    #
+    # Installed automatically when `ActiveSupport::Notifications` is discovered.
+    module ActiveSupportNotificationsTracing
+      # A cache of frequently-used keys to avoid needless string allocations
+      KEYS = {
+        "lex" => "graphql.lex",
+        "parse" => "graphql.parse",
+        "validate" => "graphql.validate",
+        "analyze_multiplex" => "graphql.analyze_multiplex",
+        "analyze_query" => "graphql.analyze_query",
+        "execute_query" => "graphql.execute_query",
+        "execute_query_lazy" => "graphql.execute_query_lazy",
+        "execute_field" => "graphql.execute_field",
+        "execute_field_lazy" => "graphql.execute_field_lazy",
+      }
+
+      def self.trace(key, metadata)
+        prefixed_key = KEYS[key] || "graphql.#{key}"
+        ActiveSupport::Notifications.instrument(prefixed_key, metadata) do
+          yield
+        end
+      end
+    end
+  end
+end

data/lib/graphql/version.rb

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

data/readme.md

@@ -37,7 +37,7 @@ Or, see ["Getting Started"](https://rmosolgo.github.io/graphql-ruby/).
 
 ## Upgrade
 
-I also sell [GraphQL::Pro](http://graphql.pro) which provides several features on top of the GraphQL runtime, including [authorization](http://rmosolgo.github.io/graphql-ruby/pro/authorization), [monitoring](http://rmosolgo.github.io/graphql-ruby/pro/monitoring) plugins and [static queries](http://rmosolgo.github.io/graphql-ruby/pro/persisted_queries). Besides that, Pro customers get email support and an opportunity to support graphql-ruby's development!
+I also sell [GraphQL::Pro](http://graphql.pro) which provides several features on top of the GraphQL runtime, including [authorization](http://rmosolgo.github.io/graphql-ruby/pro/authorization), [monitoring](http://rmosolgo.github.io/graphql-ruby/pro/monitoring) plugins and [persisted queries](http://rmosolgo.github.io/graphql-ruby/operation_store/overview). Besides that, Pro customers get email support and an opportunity to support graphql-ruby's development!
 
 ## Goals
 

data/spec/graphql/analysis/analyze_query_spec.rb

@@ -49,6 +49,25 @@ describe GraphQL::Analysis do
       assert_equal expected_node_counts, node_counts
     end
 
+    describe "tracing" do
+      let(:query_string) { "{ t: __typename }"}
+
+      it "emits traces" do
+        traces = TestTracing.with_trace do
+          Dummy::Schema.execute(document: GraphQL.parse(query_string))
+        end
+
+        # The query_trace is on the list _first_ because it finished first
+        _lex, _parse, _validate, query_trace, multiplex_trace, *_rest = traces
+
+        assert_equal "analyze_multiplex", multiplex_trace[:key]
+        assert_instance_of GraphQL::Execution::Multiplex, multiplex_trace[:multiplex]
+
+        assert_equal "analyze_query", query_trace[:key]
+        assert_instance_of GraphQL::Query, query_trace[:query]
+      end
+    end
+
     describe "when a variable is missing" do
       let(:query_string) {%|
         query something($cheeseId: Int!){

data/spec/graphql/argument_spec.rb

@@ -19,6 +19,34 @@ describe GraphQL::Argument do
     assert_includes err.message, expected_error
   end
 
+  describe ".from_dsl" do
+    it "accepts an existing argument" do
+      existing = GraphQL::Argument.define do
+        name "bar"
+        type GraphQL::STRING_TYPE
+      end
+
+      arg = GraphQL::Argument.from_dsl(:foo, existing)
+
+      assert_equal "foo", arg.name
+      assert_equal GraphQL::STRING_TYPE, arg.type
+    end
+
+    it "creates an argument from dsl arguments" do
+      arg = GraphQL::Argument.from_dsl(
+        :foo,
+        GraphQL::STRING_TYPE,
+        "A Description",
+        default_value: "Bar"
+      )
+
+      assert_equal "foo", arg.name
+      assert_equal GraphQL::STRING_TYPE, arg.type
+      assert_equal "A Description", arg.description
+      assert_equal "Bar", arg.default_value
+    end
+  end
+
   it "accepts custom keywords" do
     type = GraphQL::ObjectType.define do
       name "Something"

data/spec/graphql/backtrace_spec.rb

@@ -0,0 +1,144 @@
+# frozen_string_literal: true
+require "spec_helper"
+
+describe GraphQL::Backtrace do
+  before {
+    GraphQL::Backtrace.enable
+  }
+
+  after {
+    GraphQL::Backtrace.disable
+  }
+
+  class LazyError
+    def raise_err
+      raise "Lazy Boom"
+    end
+  end
+
+  let(:resolvers) {
+    {
+      "Query" => {
+        "field1" => Proc.new { :something },
+        "field2" => Proc.new { :something },
+      },
+      "Thing" => {
+        "listField" => Proc.new { :not_a_list },
+        "raiseField" => Proc.new { |o, a| raise("This is broken: #{a[:message]}") },
+      },
+      "OtherThing" => {
+        "strField" => Proc.new { LazyError.new },
+      },
+    }
+  }
+  let(:schema) {
+    defn = <<-GRAPHQL
+    type Query {
+      field1: Thing
+      field2: OtherThing
+    }
+
+    type Thing {
+      listField: [OtherThing]
+      raiseField(message: String!): Int
+    }
+
+    type OtherThing {
+      strField: String
+    }
+    GRAPHQL
+    GraphQL::Schema.from_definition(defn, default_resolve: resolvers).redefine {
+      lazy_resolve(LazyError, :raise_err)
+    }
+  }
+
+  describe "GraphQL backtrace helpers" do
+    it "raises a TracedError when enabled" do
+      assert_raises(GraphQL::Backtrace::TracedError) {
+        schema.execute("query BrokenList { field1 { listField { strField } } }")
+      }
+
+      GraphQL::Backtrace.disable
+
+      assert_raises(NoMethodError) {
+        schema.execute("query BrokenList { field1 { listField { strField } } }")
+      }
+    end
+
+    it "annotates crashes from user code" do
+      err = assert_raises(GraphQL::Backtrace::TracedError) {
+        schema.execute <<-GRAPHQL, root_value: "Root"
+        query($msg: String = \"Boom\") {
+          field1 {
+            boomError: raiseField(message: $msg)
+          }
+        }
+        GRAPHQL
+      }
+
+      # The original error info is present
+      assert_instance_of RuntimeError, err.cause
+      b = err.cause.backtrace
+      assert_backtrace_includes(b, file: "backtrace_spec.rb", method: "block")
+      assert_backtrace_includes(b, file: "execute.rb", method: "resolve_field")
+      assert_backtrace_includes(b, file: "execute.rb", method: "resolve_field")
+      assert_backtrace_includes(b, file: "execute.rb", method: "resolve_root_selection")
+
+      # GraphQL backtrace is present
+      expected_graphql_backtrace = [
+        "3:13: Thing.raiseField as boomError",
+        "2:11: Query.field1",
+        "1:9: query",
+      ]
+      assert_equal expected_graphql_backtrace, err.graphql_backtrace
+
+      # The message includes the GraphQL context
+      rendered_table = [
+        'Loc  | Field                         | Object     | Arguments           | Result',
+        '3:13 | Thing.raiseField as boomError | :something | {"message"=>"Boom"} | #<RuntimeError: This is broken: Boom>',
+        '2:11 | Query.field1                  | "Root"     | {}                  | {}',
+        '1:9  | query                         | "Root"     | {"msg"=>"Boom"}     | ',
+      ].join("\n")
+
+      assert_includes err.message, rendered_table
+      # The message includes the original error message
+      assert_includes err.message, "This is broken: Boom"
+      assert_includes err.message, "spec/graphql/backtrace_spec.rb:27", "It includes the original backtrace"
+      assert_includes err.message, "more lines"
+    end
+
+    it "annotates errors inside lazy resolution" do
+      err = assert_raises(GraphQL::Backtrace::TracedError) {
+        schema.execute("query StrField { field2 { strField } __typename }")
+      }
+      assert_instance_of RuntimeError, err.cause
+      b = err.cause.backtrace
+      assert_backtrace_includes(b, file: "backtrace_spec.rb", method: "raise_err")
+      assert_backtrace_includes(b, file: "field.rb", method: "lazy_resolve")
+      assert_backtrace_includes(b, file: "lazy/resolve.rb", method: "block")
+
+      expected_graphql_backtrace = [
+        "1:27: OtherThing.strField",
+        "1:18: Query.field2",
+        "1:1: query StrField",
+      ]
+
+      assert_equal(expected_graphql_backtrace, err.graphql_backtrace)
+
+      rendered_table = [
+        'Loc  | Field               | Object     | Arguments | Result',
+        '1:27 | OtherThing.strField | :something | {}        | #<RuntimeError: Lazy Boom>',
+        '1:18 | Query.field2        | nil        | {}        | {strField: (unresolved)}',
+        '1:1  | query StrField      | nil        | {}        | {field2: {...}, __typename: "Query"}',
+      ].join("\n")
+      assert_includes err.message, rendered_table
+    end
+  end
+
+  # This will get brittle when execution code moves between files
+  # but I'm not sure how to be sure that the backtrace contains the right stuff!
+  def assert_backtrace_includes(backtrace, file:, method:)
+    includes_tag = backtrace.any? { |s| s.include?(file) && s.include?("`" + method) }
+    assert includes_tag, "Backtrace should include #{file} inside method #{method}"
+  end
+end