graphql 1.8.7 → 1.9.0

data/lib/graphql/static_validation/rules/variables_are_input_types_error.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+module GraphQL
+  module StaticValidation
+    class VariablesAreInputTypesError < StaticValidation::Error
+      attr_reader :type_name
+      attr_reader :variable_name
+
+      def initialize(message, path: nil, nodes: [], type:, name:)
+        super(message, path: path, nodes: nodes)
+        @type_name = type
+        @variable_name = name
+      end
+
+      # A hash representation of this Message
+      def to_h
+        extensions = {
+          "code" => code,
+          "typeName" => type_name,
+          "variableName" => variable_name
+        }
+
+        super.merge({
+          "extensions" => extensions
+        })
+      end
+
+      def code
+        "variableRequiresValidType"
+      end
+    end
+  end
+end

data/lib/graphql/static_validation/rules/variables_are_used_and_defined.rb

@@ -11,9 +11,7 @@ module GraphQL
     #   - re-visiting the AST for each validator
     #   - allowing validators to say `followSpreads: true`
     #
-    class VariablesAreUsedAndDefined
-      include GraphQL::StaticValidation::Message::MessageHelper
-
+    module VariablesAreUsedAndDefined
       class VariableUsage
         attr_accessor :ast_node, :used_by, :declared_by, :path
         def used?
@@ -25,73 +23,67 @@ module GraphQL
         end
       end
 
-      def variable_hash
-        Hash.new {|h, k| h[k] = VariableUsage.new }
+      def initialize(*)
+        super
+        @variable_usages_for_context = Hash.new {|hash, key| hash[key] = Hash.new {|h, k| h[k] = VariableUsage.new } }
+        @spreads_for_context = Hash.new {|hash, key| hash[key] = [] }
+        @variable_context_stack = []
       end
 
-      def validate(context)
-        variable_usages_for_context = Hash.new {|hash, key| hash[key] = variable_hash }
-        spreads_for_context = Hash.new {|hash, key| hash[key] = [] }
-        variable_context_stack = []
-
-        # OperationDefinitions and FragmentDefinitions
-        # both push themselves onto the context stack (and pop themselves off)
-        push_variable_context_stack = ->(node, parent) {
-          # initialize the hash of vars for this context:
-          variable_usages_for_context[node]
-          variable_context_stack.push(node)
-        }
-
-        pop_variable_context_stack = ->(node, parent) {
-          variable_context_stack.pop
-        }
-
-
-        context.visitor[GraphQL::Language::Nodes::OperationDefinition] << push_variable_context_stack
-        context.visitor[GraphQL::Language::Nodes::OperationDefinition] << ->(node, parent) {
-          # mark variables as defined:
-          var_hash = variable_usages_for_context[node]
-          node.variables.each { |var|
-            var_usage = var_hash[var.name]
-            var_usage.declared_by = node
-            var_usage.path = context.path
-          }
+      def on_operation_definition(node, parent)
+        # initialize the hash of vars for this context:
+        @variable_usages_for_context[node]
+        @variable_context_stack.push(node)
+        # mark variables as defined:
+        var_hash = @variable_usages_for_context[node]
+        node.variables.each { |var|
+          var_usage = var_hash[var.name]
+          var_usage.declared_by = node
+          var_usage.path = context.path
         }
-        context.visitor[GraphQL::Language::Nodes::OperationDefinition].leave << pop_variable_context_stack
-
-        context.visitor[GraphQL::Language::Nodes::FragmentDefinition] << push_variable_context_stack
-        context.visitor[GraphQL::Language::Nodes::FragmentDefinition].leave << pop_variable_context_stack
+        super
+        @variable_context_stack.pop
+      end
 
-        # For FragmentSpreads:
-        #  - find the context on the stack
-        #  - mark the context as containing this spread
-        context.visitor[GraphQL::Language::Nodes::FragmentSpread] << ->(node, parent) {
-          variable_context = variable_context_stack.last
-          spreads_for_context[variable_context] << node.name
-        }
+      def on_fragment_definition(node, parent)
+        # initialize the hash of vars for this context:
+        @variable_usages_for_context[node]
+        @variable_context_stack.push(node)
+        super
+        @variable_context_stack.pop
+      end
 
-        # For VariableIdentifiers:
-        #  - mark the variable as used
-        #  - assign its AST node
-        context.visitor[GraphQL::Language::Nodes::VariableIdentifier] << ->(node, parent) {
-          usage_context = variable_context_stack.last
-          declared_variables = variable_usages_for_context[usage_context]
-          usage = declared_variables[node.name]
-          usage.used_by = usage_context
-          usage.ast_node = node
-          usage.path = context.path
-        }
+      # For FragmentSpreads:
+      #  - find the context on the stack
+      #  - mark the context as containing this spread
+      def on_fragment_spread(node, parent)
+        variable_context = @variable_context_stack.last
+        @spreads_for_context[variable_context] << node.name
+        super
+      end
 
+      # For VariableIdentifiers:
+      #  - mark the variable as used
+      #  - assign its AST node
+      def on_variable_identifier(node, parent)
+        usage_context = @variable_context_stack.last
+        declared_variables = @variable_usages_for_context[usage_context]
+        usage = declared_variables[node.name]
+        usage.used_by = usage_context
+        usage.ast_node = node
+        usage.path = context.path
+        super
+      end
 
-        context.visitor[GraphQL::Language::Nodes::Document].leave << ->(node, parent) {
-          fragment_definitions = variable_usages_for_context.select { |key, value| key.is_a?(GraphQL::Language::Nodes::FragmentDefinition) }
-          operation_definitions = variable_usages_for_context.select { |key, value| key.is_a?(GraphQL::Language::Nodes::OperationDefinition) }
+      def on_document(node, parent)
+        super
+        fragment_definitions = @variable_usages_for_context.select { |key, value| key.is_a?(GraphQL::Language::Nodes::FragmentDefinition) }
+        operation_definitions = @variable_usages_for_context.select { |key, value| key.is_a?(GraphQL::Language::Nodes::OperationDefinition) }
 
-          operation_definitions.each do |node, node_variables|
-            follow_spreads(node, node_variables, spreads_for_context, fragment_definitions, [])
-            create_errors(node_variables, context)
-          end
-        }
+        operation_definitions.each do |node, node_variables|
+          follow_spreads(node, node_variables, @spreads_for_context, fragment_definitions, [])
+          create_errors(node_variables)
+        end
       end
 
       private
@@ -129,16 +121,32 @@ module GraphQL
 
       # Determine all the error messages,
       # Then push messages into the validation context
-      def create_errors(node_variables, context)
+      def create_errors(node_variables)
         # Declared but not used:
         node_variables
           .select { |name, usage| usage.declared? && !usage.used? }
-          .each { |var_name, usage| context.errors << message("Variable $#{var_name} is declared by #{usage.declared_by.name} but not used", usage.declared_by, path: usage.path) }
+          .each { |var_name, usage|
+            add_error(GraphQL::StaticValidation::VariablesAreUsedAndDefinedError.new(
+              "Variable $#{var_name} is declared by #{usage.declared_by.name} but not used",
+              nodes: usage.declared_by,
+              path: usage.path,
+              name: var_name,
+              error_type: VariablesAreUsedAndDefinedError::VIOLATIONS[:VARIABLE_NOT_USED]
+            ))
+          }
 
         # Used but not declared:
         node_variables
           .select { |name, usage| usage.used? && !usage.declared? }
-          .each { |var_name, usage| context.errors << message("Variable $#{var_name} is used by #{usage.used_by.name} but not declared", usage.ast_node, path: usage.path) }
+          .each { |var_name, usage|
+            add_error(GraphQL::StaticValidation::VariablesAreUsedAndDefinedError.new(
+              "Variable $#{var_name} is used by #{usage.used_by.name} but not declared",
+              nodes: usage.ast_node,
+              path: usage.path,
+              name: var_name,
+              error_type: VariablesAreUsedAndDefinedError::VIOLATIONS[:VARIABLE_NOT_DEFINED]
+            ))
+          }
       end
     end
   end

data/lib/graphql/static_validation/rules/variables_are_used_and_defined_error.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+module GraphQL
+  module StaticValidation
+    class VariablesAreUsedAndDefinedError < StaticValidation::Error
+      attr_reader :variable_name
+      attr_reader :violation
+
+      VIOLATIONS = {
+        :VARIABLE_NOT_USED     => "variableNotUsed",
+        :VARIABLE_NOT_DEFINED  => "variableNotDefined",
+      }
+
+      def initialize(message, path: nil, nodes: [], name:, error_type:)
+        super(message, path: path, nodes: nodes)
+        @variable_name = name
+        raise("Unexpected error type: #{error_type}") if !VIOLATIONS.values.include?(error_type)
+        @violation = error_type
+      end
+
+      # A hash representation of this Message
+      def to_h
+        extensions = {
+          "code" => code,
+          "variableName" => variable_name
+        }
+
+        super.merge({
+          "extensions" => extensions
+        })
+      end
+
+      def code
+        @violation
+      end
+    end
+  end
+end

data/lib/graphql/static_validation/validation_context.rb

@@ -14,70 +14,27 @@ module GraphQL
     class ValidationContext
       extend Forwardable
 
-      attr_reader :query, :errors, :visitor, :dependencies, :each_irep_node_handlers
+      attr_reader :query, :errors, :visitor,
+        :on_dependency_resolve_handlers
 
       def_delegators :@query, :schema, :document, :fragments, :operations, :warden
 
-      def initialize(query)
+      def initialize(query, visitor_class)
         @query = query
         @literal_validator = LiteralValidator.new(context: query.context)
         @errors = []
-        @visitor = GraphQL::Language::Visitor.new(document)
-        @type_stack = GraphQL::StaticValidation::TypeStack.new(schema, visitor)
-        definition_dependencies = DefinitionDependencies.mount(self)
         @on_dependency_resolve_handlers = []
-        @each_irep_node_handlers = []
-        visitor[GraphQL::Language::Nodes::Document].leave << ->(_n, _p) {
-          @dependencies = definition_dependencies.dependency_map { |defn, spreads, frag|
-            @on_dependency_resolve_handlers.each { |h| h.call(defn, spreads, frag) }
-          }
-        }
+        @visitor = visitor_class.new(document, self)
       end
 
+      def_delegators :@visitor,
+        :path, :type_definition, :field_definition, :argument_definition,
+        :parent_type_definition, :directive_definition, :object_types, :dependencies
+
       def on_dependency_resolve(&handler)
         @on_dependency_resolve_handlers << handler
       end
 
-      def object_types
-        @type_stack.object_types
-      end
-
-      def each_irep_node(&handler)
-        @each_irep_node_handlers << handler
-      end
-
-      # @return [GraphQL::BaseType] The current object type
-      def type_definition
-        object_types.last
-      end
-
-      # @return [GraphQL::BaseType] The type which the current type came from
-      def parent_type_definition
-        object_types[-2]
-      end
-
-      # @return [GraphQL::Field, nil] The most-recently-entered GraphQL::Field, if currently inside one
-      def field_definition
-        @type_stack.field_definitions.last
-      end
-
-      # @return [Array<String>] Field names to get to the current field
-      def path
-        @type_stack.path.dup
-      end
-
-      # @return [GraphQL::Directive, nil] The most-recently-entered GraphQL::Directive, if currently inside one
-      def directive_definition
-        @type_stack.directive_definitions.last
-      end
-
-      # @return [GraphQL::Argument, nil] The most-recently-entered GraphQL::Argument, if currently inside one
-      def argument_definition
-        # Don't get the _last_ one because that's the current one.
-        # Get the second-to-last one, which is the parent of the current one.
-        @type_stack.argument_definitions[-2]
-      end
-
       def valid_literal?(ast_value, type)
         @literal_validator.validate(ast_value, type)
       end

data/lib/graphql/static_validation/validator.rb

@@ -23,29 +23,37 @@ module GraphQL
       # @return [Array<Hash>]
       def validate(query, validate: true)
         query.trace("validate", { validate: validate, query: query }) do
-          context = GraphQL::StaticValidation::ValidationContext.new(query)
-          rewrite = GraphQL::InternalRepresentation::Rewrite.new
+          can_skip_rewrite = query.context.interpreter? && query.schema.using_ast_analysis?
+          errors = if validate == false && can_skip_rewrite
+            []
+          else
+            rules_to_use = validate ? @rules : []
+            visitor_class = BaseVisitor.including_rules(rules_to_use, rewrite: !can_skip_rewrite)
 
-          # Put this first so its enters and exits are always called
-          rewrite.validate(context)
+            context = GraphQL::StaticValidation::ValidationContext.new(query, visitor_class)
 
-          # If the caller opted out of validation, don't attach these
-          if validate
-            @rules.each do |rules|
-              rules.new.validate(context)
+            # Attach legacy-style rules
+            rules_to_use.each do |rule_class_or_module|
+              if rule_class_or_module.method_defined?(:validate)
+                rule_class_or_module.new.validate(context)
+              end
             end
+
+            context.visitor.visit
+            context.errors
           end
 
-          context.visitor.visit
-          rewrite_result = rewrite.document
 
-          # Post-validation: allow validators to register handlers on rewritten query nodes
-          GraphQL::InternalRepresentation::Visit.visit_each_node(rewrite_result.operation_definitions, context.each_irep_node_handlers)
+          irep = if errors.empty? && context
+            # Only return this if there are no errors and validation was actually run
+            context.visitor.rewrite_document
+          else
+            nil
+          end
 
           {
-            errors: context.errors,
-            # If there were errors, the irep is garbage
-            irep: context.errors.any? ? nil : rewrite_result,
+            errors: errors,
+            irep: irep,
           }
         end
       end

data/lib/graphql/static_validation.rb

@@ -1,12 +1,12 @@
 # frozen_string_literal: true
-require "graphql/static_validation/message"
-require "graphql/static_validation/arguments_validator"
+require "graphql/static_validation/error"
 require "graphql/static_validation/definition_dependencies"
 require "graphql/static_validation/type_stack"
 require "graphql/static_validation/validator"
 require "graphql/static_validation/validation_context"
 require "graphql/static_validation/literal_validator"
-
+require "graphql/static_validation/base_visitor"
+require "graphql/static_validation/no_validate_visitor"
 
 rules_glob = File.expand_path("../static_validation/rules/*.rb", __FILE__)
 Dir.glob(rules_glob).each do |file|
@@ -14,3 +14,5 @@ Dir.glob(rules_glob).each do |file|
 end
 
 require "graphql/static_validation/all_rules"
+require "graphql/static_validation/default_visitor"
+require "graphql/static_validation/interpreter_visitor"

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?,
     #       }
     #
@@ -54,9 +54,28 @@ module GraphQL
     #
     #     def unsubscribed
     #       @subscription_ids.each { |sid|
-    #         CardsSchema.subscriptions.delete_subscription(sid)
+    #         MySchema.subscriptions.delete_subscription(sid)
     #       }
     #     end
+    #
+    #     private
+    #
+    #       def ensure_hash(ambiguous_param)
+    #         case ambiguous_param
+    #         when String
+    #           if ambiguous_param.present?
+    #             ensure_hash(JSON.parse(ambiguous_param))
+    #           else
+    #             {}
+    #           end
+    #         when Hash, ActionController::Parameters
+    #           ambiguous_param
+    #         when nil
+    #           {}
+    #         else
+    #           raise ArgumentError, "Unexpected parameter: #{ambiguous_param}"
+    #         end
+    #       end
     #   end
     #
     class ActionCableSubscriptions < GraphQL::Subscriptions

data/lib/graphql/subscriptions/event.rb

@@ -36,11 +36,15 @@ module GraphQL
         when GraphQL::Query::Arguments
           arguments
         when Hash
-          GraphQL::Query::LiteralInput.from_arguments(
-            arguments,
-            field,
-            nil,
-          )
+          if field.is_a?(GraphQL::Schema::Field)
+            stringify_args(arguments)
+          else
+            GraphQL::Query::LiteralInput.from_arguments(
+              arguments,
+              field,
+              nil,
+            )
+          end
         else
           raise ArgumentError, "Unexpected arguments: #{arguments}, must be Hash or GraphQL::Arguments"
         end
@@ -48,6 +52,25 @@ module GraphQL
         sorted_h = normalized_args.to_h.sort.to_h
         Serialize.dump_recursive([scope, name, sorted_h])
       end
+
+      class << self
+        private
+        def stringify_args(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)
+            end
+            next_args
+          when Array
+            args.map { |a| stringify_args(a) }
+          else
+            args
+          end
+        end
+      end
     end
   end
 end

data/lib/graphql/subscriptions/subscription_root.rb

@@ -0,0 +1,66 @@
+# frozen_string_literal: true
+
+module GraphQL
+  class Subscriptions
+    # Extend this module in your subscription root when using {GraphQL::Execution::Interpreter}.
+    module SubscriptionRoot
+      def self.extended(child_cls)
+        child_cls.include(InstanceMethods)
+      end
+
+      # This is for maintaining backwards compatibility:
+      # if a subscription field is created without a `subscription:` resolver class,
+      # then implement the method with the previous default behavior.
+      module InstanceMethods
+        def skip_subscription_root(*)
+          if context.query.subscription_update?
+            object
+          else
+            context.skip
+          end
+        end
+      end
+
+      def field(*args, extensions: [], **rest, &block)
+        extensions += [Extension]
+        # Backwards-compat for schemas
+        if !rest[:subscription]
+          name = args.first
+          alias_method(name, :skip_subscription_root)
+        end
+        super(*args, extensions: extensions, **rest, &block)
+      end
+
+      class Extension < GraphQL::Schema::FieldExtension
+        def after_resolve(value:, context:, object:, arguments:, **rest)
+          if value.is_a?(GraphQL::ExecutionError)
+            value
+          elsif (events = context.namespace(:subscriptions)[:events])
+            # This is the first execution, so gather an Event
+            # for the backend to register:
+            events << Subscriptions::Event.new(
+              name: field.name,
+              arguments: arguments,
+              context: context,
+              field: field,
+            )
+            # TODO compat with non-class-based subscriptions?
+            value
+          elsif context.query.subscription_topic == Subscriptions::Event.serialize(
+              field.name,
+              arguments,
+              field,
+              scope: (field.subscription_scope ? context[field.subscription_scope] : nil),
+            )
+            # This is a subscription update. The resolver returned `skip` if it should be skipped,
+            # or else it returned an object to resolve the update.
+            value
+          else
+            # This is a subscription update, but this event wasn't triggered.
+            context.skip
+          end
+        end
+      end
+    end
+  end
+end

data/lib/graphql/subscriptions.rb

@@ -6,6 +6,7 @@ require "graphql/subscriptions/serialize"
 if defined?(ActionCable)
   require "graphql/subscriptions/action_cable_subscriptions"
 end
+require "graphql/subscriptions/subscription_root"
 
 module GraphQL
   class Subscriptions
@@ -99,6 +100,12 @@ module GraphQL
         }
       )
       deliver(subscription_id, result)
+    rescue GraphQL::Schema::Subscription::NoUpdateError
+      # This update was skipped in user code; do nothing.
+    rescue GraphQL::Schema::Subscription::UnsubscribedError
+      # `unsubscribe` was called, clean up on our side
+      # TODO also send `{more: false}` to client?
+      delete_subscription(subscription_id)
     end
 
     # Event `event` occurred on `object`,
@@ -132,9 +139,8 @@ module GraphQL
     # The result should be send to `subscription_id`.
     # @param subscription_id [String]
     # @param result [Hash]
-    # @param context [GraphQL::Query::Context]
     # @return [void]
-    def deliver(subscription_id, result, context)
+    def deliver(subscription_id, result)
       raise NotImplementedError
     end
 
@@ -147,6 +153,14 @@ module GraphQL
       raise NotImplementedError
     end
 
+    # A subscription was terminated server-side.
+    # Clean up the database.
+    # @param subscription_id [String]
+    # @return void.
+    def delete_subscription(subscription_id)
+      raise NotImplementedError
+    end
+
     # @return [String] A new unique identifier for a subscription
     def build_id
       SecureRandom.uuid

data/lib/graphql/tracing/active_support_notifications_tracing.rb

@@ -5,7 +5,6 @@ module GraphQL
     # 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 = {

data/lib/graphql/tracing/appsignal_tracing.rb

@@ -21,7 +21,7 @@ module GraphQL
       end
 
       def platform_field_key(type, field)
-        "#{type.name}.#{field.name}.graphql"
+        "#{type.graphql_name}.#{field.graphql_name}.graphql"
       end
     end
   end

data/lib/graphql/tracing/data_dog_tracing.rb

@@ -42,7 +42,7 @@ module GraphQL
       end
 
       def platform_field_key(type, field)
-        "#{type.name}.#{field.name}"
+        "#{type.graphql_name}.#{field.graphql_name}"
       end
     end
   end

data/lib/graphql/tracing/new_relic_tracing.rb

@@ -17,8 +17,8 @@ module 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_new_relic_transaction_name]`.
-      def initialize(set_transaction_name: false)
-        @set_transaction_name = set_transaction_name
+      def initialize(options = {})
+        @set_transaction_name = options.fetch(:set_transaction_name, false)
         super
       end
 
@@ -47,7 +47,7 @@ module GraphQL
       end
 
       def platform_field_key(type, field)
-        "GraphQL/#{type.name}/#{field.name}"
+        "GraphQL/#{type.graphql_name}/#{field.graphql_name}"
       end
     end
   end

data/lib/graphql/tracing/platform_tracing.rb

@@ -26,7 +26,23 @@ module GraphQL
             yield
           end
         when "execute_field", "execute_field_lazy"
-          if (platform_key = data[:context].field.metadata[:platform_key])
+          if data[:context]
+            field = data[:context].field
+            platform_key = field.metadata[:platform_key]
+            trace_field = true # implemented with instrumenter
+          else
+            field = data[:field]
+            # Lots of duplicated work here, can this be done ahead of time?
+            platform_key = platform_field_key(field.owner, field)
+            return_type = field.type.unwrap
+            trace_field = if return_type.kind.scalar? || return_type.kind.enum?
+              (field.trace.nil? && @trace_scalars) || field.trace
+            else
+              true
+            end
+          end
+
+          if platform_key && trace_field
             platform_trace(platform_key, key, data) do
               yield
             end