graphql 1.12.12 → 2.4.8

data/lib/graphql/subscriptions.rb

@@ -2,10 +2,8 @@
 require "securerandom"
 require "graphql/subscriptions/broadcast_analyzer"
 require "graphql/subscriptions/event"
-require "graphql/subscriptions/instrumentation"
 require "graphql/subscriptions/serialize"
 require "graphql/subscriptions/action_cable_subscriptions"
-require "graphql/subscriptions/subscription_root"
 require "graphql/subscriptions/default_subscription_resolve_extension"
 
 module GraphQL
@@ -16,19 +14,21 @@ module GraphQL
     class InvalidTriggerError < GraphQL::Error
     end
 
+    # Raised when either:
+    # - An initial subscription didn't have a value for `context[subscription_scope]`
+    # - Or, an update didn't pass `.trigger(..., scope:)`
+    # When raised, the initial subscription or update fails completely.
+    class SubscriptionScopeMissingError < GraphQL::Error
+    end
+
     # @see {Subscriptions#initialize} for options, concrete implementations may add options.
     def self.use(defn, options = {})
       schema = defn.is_a?(Class) ? defn : defn.target
 
-      if schema.subscriptions
+      if schema.subscriptions(inherited: false)
         raise ArgumentError, "Can't reinstall subscriptions. #{schema} is using #{schema.subscriptions}, can't also add #{self}"
       end
 
-      instrumentation = Subscriptions::Instrumentation.new(schema: schema)
-      defn.instrument(:query, instrumentation)
-      if !schema.is_a?(Class)
-        defn.instrument(:field, instrumentation)
-      end
       options[:schema] = schema
       schema.subscriptions = self.new(**options)
       schema.add_subscription_extension_if_necessary
@@ -36,15 +36,14 @@ module GraphQL
     end
 
     # @param schema [Class] the GraphQL schema this manager belongs to
-    def initialize(schema:, broadcast: false, default_broadcastable: false, **rest)
+    # @param validate_update [Boolean] If false, then validation is skipped when executing updates
+    def initialize(schema:, validate_update: true, broadcast: false, default_broadcastable: false, **rest)
       if broadcast
-        if !schema.using_ast_analysis?
-          raise ArgumentError, "`broadcast: true` requires AST analysis, add `using GraphQL::Analysis::AST` to your schema or see https://graphql-ruby.org/queries/ast_analysis.html."
-        end
         schema.query_analyzer(Subscriptions::BroadcastAnalyzer)
       end
       @default_broadcastable = default_broadcastable
       @schema = schema
+      @validate_update = validate_update
     end
 
     # @return [Boolean] Used when fields don't have `broadcastable:` explicitly set
@@ -56,17 +55,21 @@ module GraphQL
     # @param args [Hash<String, Symbol => Object]
     # @param object [Object]
     # @param scope [Symbol, String]
+    # @param context [Hash]
     # @return [void]
-    def trigger(event_name, args, object, scope: nil)
+    def trigger(event_name, args, object, scope: nil, context: {})
+      # Make something as context-like as possible, even though there isn't a current query:
+      dummy_query = @schema.query_class.new(@schema, "{ __typename }", validate: false, context: context)
+      context = dummy_query.context
       event_name = event_name.to_s
 
       # Try with the verbatim input first:
-      field = @schema.get_field(@schema.subscription, event_name)
+      field = dummy_query.types.field(@schema.subscription, event_name) # rubocop:disable Development/ContextIsPassedCop
 
       if field.nil?
         # And if it wasn't found, normalize it:
         normalized_event_name = normalize_name(event_name)
-        field = @schema.get_field(@schema.subscription, normalized_event_name)
+        field = dummy_query.types.field(@schema.subscription, normalized_event_name) # rubocop:disable Development/ContextIsPassedCop
         if field.nil?
           raise InvalidTriggerError, "No subscription matching trigger: #{event_name} (looked for #{@schema.subscription.graphql_name}.#{normalized_event_name})"
         end
@@ -76,13 +79,15 @@ module GraphQL
       end
 
       # Normalize symbol-keyed args to strings, try camelizing them
-      normalized_args = normalize_arguments(normalized_event_name, field, args)
+      # Should this accept a real context somehow?
+      normalized_args = normalize_arguments(normalized_event_name, field, args, GraphQL::Query::NullContext.instance)
 
       event = Subscriptions::Event.new(
         name: normalized_event_name,
         arguments: normalized_args,
         field: field,
         scope: scope,
+        context: context,
       )
       execute_all(event, object)
     end
@@ -109,24 +114,28 @@ module GraphQL
       variables = query_data.fetch(:variables)
       context = query_data.fetch(:context)
       operation_name = query_data.fetch(:operation_name)
-      result = @schema.execute(
+      execute_options = {
         query: query_string,
         context: context,
         subscription_topic: event.topic,
         operation_name: operation_name,
         variables: variables,
         root_value: object,
-      )
+      }
+
+       # merge event's and query's context together
+      context.merge!(event.context) unless event.context.nil? || context.nil?
+
+      execute_options[:validate] = validate_update?(**execute_options)
+      result = @schema.execute(**execute_options)
       subscriptions_context = result.context.namespace(:subscriptions)
       if subscriptions_context[:no_update]
         result = nil
       end
 
-      unsubscribed = subscriptions_context[:unsubscribed]
-
-      if unsubscribed
+      if subscriptions_context[:unsubscribed] && !subscriptions_context[:final_update]
         # `unsubscribe` was called, clean up on our side
-        # TODO also send `{more: false}` to client?
+        # The transport should also send `{more: false}` to client
         delete_subscription(subscription_id)
         result = nil
       end
@@ -134,6 +143,14 @@ module GraphQL
       result
     end
 
+    # Define this method to customize whether to validate
+    # this subscription when executing an update.
+    #
+    # @return [Boolean] defaults to `true`, or false if `validate: false` is provided.
+    def validate_update?(query:, context:, root_value:, subscription_topic:, operation_name:, variables:)
+      @validate_update
+    end
+
     # Run the update query for this subscription and deliver it
     # @see {#execute_update}
     # @see {#deliver}
@@ -142,7 +159,14 @@ module GraphQL
       res = execute_update(subscription_id, event, object)
       if !res.nil?
         deliver(subscription_id, res)
+
+        if res.context.namespace(:subscriptions)[:unsubscribed]
+          # `unsubscribe` was called, clean up on our side
+          # The transport should also send `{more: false}` to client
+          delete_subscription(subscription_id)
+        end
       end
+
     end
 
     # Event `event` occurred on `object`,
@@ -151,16 +175,6 @@ module GraphQL
     # @param object [Object]
     # @return [void]
     def execute_all(event, object)
-      each_subscription_id(event) do |subscription_id|
-        execute(subscription_id, event, object)
-      end
-    end
-
-    # Get each `subscription_id` subscribed to `event.topic` and yield them
-    # @param event [GraphQL::Subscriptions::Event]
-    # @yieldparam subscription_id [String]
-    # @return [void]
-    def each_subscription_id(event)
       raise GraphQL::RequiredImplementationMissingError
     end
 
@@ -217,11 +231,11 @@ module GraphQL
 
     # @return [Boolean] if true, then a query like this one would be broadcasted
     def broadcastable?(query_str, **query_options)
-      query = GraphQL::Query.new(@schema, query_str, **query_options)
+      query = @schema.query_class.new(@schema, query_str, **query_options)
       if !query.valid?
         raise "Invalid query: #{query.validation_errors.map(&:to_h).inspect}"
       end
-      GraphQL::Analysis::AST.analyze_query(query, @schema.query_analyzers)
+      GraphQL::Analysis.analyze_query(query, @schema.query_analyzers)
       query.context.namespace(:subscriptions)[:subscription_broadcastable]
     end
 
@@ -233,9 +247,11 @@ module GraphQL
     # @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)
+    def normalize_arguments(event_name, arg_owner, args, context)
       case arg_owner
-      when GraphQL::Field, GraphQL::InputObjectType, GraphQL::Schema::Field, Class
+      when GraphQL::Schema::Field, Class
+        return args if args.nil?
+
         if arg_owner.is_a?(Class) && !arg_owner.kind.input_object?
           # it's a type, but not an input object
           return args
@@ -244,19 +260,19 @@ module GraphQL
         missing_arg_names = []
         args.each do |k, v|
           arg_name = k.to_s
-          arg_defn = arg_owner.arguments[arg_name]
+          arg_defn = arg_owner.get_argument(arg_name, context)
           if arg_defn
             normalized_arg_name = arg_name
           else
             normalized_arg_name = normalize_name(arg_name)
-            arg_defn = arg_owner.arguments[normalized_arg_name]
+            arg_defn = arg_owner.get_argument(normalized_arg_name, context)
           end
 
           if arg_defn
             if arg_defn.loads
               normalized_arg_name = arg_defn.keyword.to_s
             end
-            normalized = normalize_arguments(event_name, arg_defn.type, v)
+            normalized = normalize_arguments(event_name, arg_defn.type, v, context)
             normalized_args[normalized_arg_name] = normalized
           else
             # Couldn't find a matching argument definition
@@ -266,19 +282,17 @@ module GraphQL
 
         # Backfill default values so that trigger arguments
         # match query arguments.
-        arg_owner.arguments.each do |name, arg_defn|
+        arg_owner.arguments(context).each do |_name, arg_defn|
           if arg_defn.default_value? && !normalized_args.key?(arg_defn.name)
             default_value = arg_defn.default_value
             # We don't have an underlying "object" here, so it can't call methods.
             # This is broken.
-            normalized_args[arg_defn.name] = arg_defn.prepare_value(nil, default_value, context: GraphQL::Query::NullContext)
+            normalized_args[arg_defn.name] = arg_defn.prepare_value(nil, default_value, context: context)
           end
         end
 
-        if missing_arg_names.any?
-          arg_owner_name = if arg_owner.is_a?(GraphQL::Field)
-            "Subscription.#{arg_owner.name}"
-          elsif arg_owner.is_a?(GraphQL::Schema::Field)
+        if !missing_arg_names.empty?
+          arg_owner_name = if arg_owner.is_a?(GraphQL::Schema::Field)
             arg_owner.path
           elsif arg_owner.is_a?(Class)
             arg_owner.graphql_name
@@ -289,10 +303,10 @@ module GraphQL
         end
 
         normalized_args
-      when GraphQL::ListType, GraphQL::Schema::List
-        args.map { |a| normalize_arguments(event_name, arg_owner.of_type, a) }
-      when GraphQL::NonNullType, GraphQL::Schema::NonNull
-        normalize_arguments(event_name, arg_owner.of_type, args)
+      when GraphQL::Schema::List
+        args&.map { |a| normalize_arguments(event_name, arg_owner.of_type, a, context) }
+      when GraphQL::Schema::NonNull
+        normalize_arguments(event_name, arg_owner.of_type, args, context)
       else
         args
       end

data/lib/graphql/testing/helpers.rb

@@ -0,0 +1,155 @@
+# frozen_string_literal: true
+module GraphQL
+  module Testing
+    module Helpers
+      # @param schema_class [Class<GraphQL::Schema>]
+      # @return [Module] A helpers module which always uses the given schema
+      def self.for(schema_class)
+        SchemaHelpers.for(schema_class)
+      end
+
+      class Error < GraphQL::Error
+      end
+
+      class TypeNotVisibleError < Error
+        def initialize(type_name:)
+          message = "`#{type_name}` should be `visible?` this field resolution and `context`, but it was not"
+          super(message)
+        end
+      end
+
+      class FieldNotVisibleError < Error
+        def initialize(type_name:, field_name:)
+          message = "`#{type_name}.#{field_name}` should be `visible?` for this resolution, but it was not"
+          super(message)
+        end
+      end
+
+      class TypeNotDefinedError < Error
+        def initialize(type_name:)
+          message = "No type named `#{type_name}` is defined; choose another type name or define this type."
+          super(message)
+        end
+      end
+
+      class FieldNotDefinedError < Error
+        def initialize(type_name:, field_name:)
+          message = "`#{type_name}` has no field named `#{field_name}`; pick another name or define this field."
+          super(message)
+        end
+      end
+
+      def run_graphql_field(schema, field_path, object, arguments: {}, context: {}, ast_node: nil, lookahead: nil)
+        type_name, *field_names = field_path.split(".")
+        dummy_query = GraphQL::Query.new(schema, "{ __typename }", context: context)
+        query_context = dummy_query.context
+        object_type = dummy_query.types.type(type_name) # rubocop:disable Development/ContextIsPassedCop
+        if object_type
+          graphql_result = object
+          field_names.each do |field_name|
+            inner_object = graphql_result
+            graphql_result = object_type.wrap(inner_object, query_context)
+            if graphql_result.nil?
+              return nil
+            end
+            visible_field = dummy_query.types.field(object_type, field_name) # rubocop:disable Development/ContextIsPassedCop
+            if visible_field
+              dummy_query.context.dataloader.run_isolated {
+                query_context[:current_field] = visible_field
+                field_args = visible_field.coerce_arguments(graphql_result, arguments, query_context)
+                field_args = schema.sync_lazy(field_args)
+                if !visible_field.extras.empty?
+                  extra_args = {}
+                  visible_field.extras.each do |extra|
+                    extra_args[extra] = case extra
+                    when :ast_node
+                      ast_node ||= GraphQL::Language::Nodes::Field.new(name: visible_field.graphql_name)
+                    when :lookahead
+                      lookahead ||= begin
+                        ast_node ||= GraphQL::Language::Nodes::Field.new(name: visible_field.graphql_name)
+                        Execution::Lookahead.new(
+                          query: dummy_query,
+                          ast_nodes: [ast_node],
+                          field: visible_field,
+                        )
+                      end
+                    else
+                      raise ArgumentError, "This extra isn't supported in `run_graphql_field` yet: `#{extra.inspect}`. Open an issue on GitHub to request it: https://github.com/rmosolgo/graphql-ruby/issues/new"
+                    end
+                  end
+
+                  field_args = field_args.merge_extras(extra_args)
+                end
+                graphql_result = visible_field.resolve(graphql_result, field_args.keyword_arguments, query_context)
+                graphql_result = schema.sync_lazy(graphql_result)
+              }
+              object_type = visible_field.type.unwrap
+            elsif object_type.all_field_definitions.any? { |f| f.graphql_name == field_name }
+              raise FieldNotVisibleError.new(field_name: field_name, type_name: type_name)
+            else
+              raise FieldNotDefinedError.new(type_name: type_name, field_name: field_name)
+            end
+          end
+          graphql_result
+        else
+          unfiltered_type = schema.use_visibility_profile? ? schema.visibility.get_type(type_name) : schema.get_type(type_name) # rubocop:disable Development/ContextIsPassedCop
+          if unfiltered_type
+            raise TypeNotVisibleError.new(type_name: type_name)
+          else
+            raise TypeNotDefinedError.new(type_name: type_name)
+          end
+        end
+      end
+
+      def with_resolution_context(schema, type:, object:, context:{})
+        resolution_context = ResolutionAssertionContext.new(
+          self,
+          schema: schema,
+          type_name: type,
+          object: object,
+          context: context
+        )
+        yield(resolution_context)
+      end
+
+      class ResolutionAssertionContext
+        def initialize(test, type_name:, object:, schema:, context:)
+          @test = test
+          @type_name = type_name
+          @object = object
+          @schema = schema
+          @context = context
+        end
+
+
+        def run_graphql_field(field_name, arguments: {})
+          if @schema
+            @test.run_graphql_field(@schema, "#{@type_name}.#{field_name}", @object, arguments: arguments, context: @context)
+          else
+            @test.run_graphql_field("#{@type_name}.#{field_name}", @object, arguments: arguments, context: @context)
+          end
+        end
+      end
+
+      module SchemaHelpers
+        include Helpers
+
+        def run_graphql_field(field_path, object, arguments: {}, context: {})
+          super(@@schema_class_for_helpers, field_path, object, arguments: arguments, context: context)
+        end
+
+        def with_resolution_context(*args, **kwargs, &block)
+          # schema will be added later
+          super(nil, *args, **kwargs, &block)
+        end
+
+        def self.for(schema_class)
+          Module.new do
+            include SchemaHelpers
+            @@schema_class_for_helpers = schema_class
+          end
+        end
+      end
+    end
+  end
+end

data/lib/graphql/testing.rb

@@ -0,0 +1,2 @@
+# frozen_string_literal: true
+require "graphql/testing/helpers"

data/lib/graphql/tracing/active_support_notifications_trace.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+require "graphql/tracing/notifications_trace"
+
+module GraphQL
+  module Tracing
+    # This implementation forwards events to ActiveSupport::Notifications
+    # with a `graphql` suffix.
+    module ActiveSupportNotificationsTrace
+      include NotificationsTrace
+      def initialize(engine: ActiveSupport::Notifications, **rest)
+        super
+      end
+    end
+  end
+end

data/lib/graphql/tracing/active_support_notifications_tracing.rb

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 
+require "graphql/tracing/notifications_tracing"
+
 module GraphQL
   module Tracing
     # This implementation forwards events to ActiveSupport::Notifications
@@ -8,27 +10,11 @@ module GraphQL
     # @see KEYS for event names
     module ActiveSupportNotificationsTracing
       # A cache of frequently-used keys to avoid needless string allocations
-      KEYS = {
-        "lex" => "lex.graphql",
-        "parse" => "parse.graphql",
-        "validate" => "validate.graphql",
-        "analyze_multiplex" => "analyze_multiplex.graphql",
-        "analyze_query" => "analyze_query.graphql",
-        "execute_query" => "execute_query.graphql",
-        "execute_query_lazy" => "execute_query_lazy.graphql",
-        "execute_field" => "execute_field.graphql",
-        "execute_field_lazy" => "execute_field_lazy.graphql",
-        "authorized" => "authorized.graphql",
-        "authorized_lazy" => "authorized_lazy.graphql",
-        "resolve_type" => "resolve_type.graphql",
-        "resolve_type_lazy" => "resolve_type.graphql",
-      }
+      KEYS = NotificationsTracing::KEYS
+      NOTIFICATIONS_ENGINE = NotificationsTracing.new(ActiveSupport::Notifications) if defined?(ActiveSupport::Notifications)
 
-      def self.trace(key, metadata)
-        prefixed_key = KEYS[key] || "#{key}.graphql"
-        ActiveSupport::Notifications.instrument(prefixed_key, metadata) do
-          yield
-        end
+      def self.trace(key, metadata, &blk)
+        NOTIFICATIONS_ENGINE.trace(key, metadata, &blk)
       end
     end
   end