graphql 1.13.12 → 2.0.21

data/lib/graphql/static_validation/all_rules.rb

@@ -36,6 +36,7 @@ module GraphQL
       GraphQL::StaticValidation::QueryRootExists,
       GraphQL::StaticValidation::SubscriptionRootExists,
       GraphQL::StaticValidation::InputObjectNamesAreUnique,
+      GraphQL::StaticValidation::OneOfInputObjectsAreValid,
     ]
   end
 end

data/lib/graphql/static_validation/base_visitor.rb

@@ -14,11 +14,6 @@ module GraphQL
         super(document)
       end
 
-      # This will be overwritten by {InternalRepresentation::Rewrite} if it's included
-      def rewrite_document
-        nil
-      end
-
       attr_reader :context
 
       # @return [Array<GraphQL::ObjectType>] Types whose scope we've entered
@@ -32,22 +27,13 @@ module GraphQL
       # Build a class to visit the AST and perform validation,
       # or use a pre-built class if rules is `ALL_RULES` or empty.
       # @param rules [Array<Module, Class>]
-      # @param rewrite [Boolean] if `false`, don't include rewrite
       # @return [Class] A class for validating `rules` during visitation
-      def self.including_rules(rules, rewrite: true)
+      def self.including_rules(rules)
         if rules.empty?
-          if rewrite
-            NoValidateVisitor
-          else
-            # It's not doing _anything?!?_
-            BaseVisitor
-          end
+          # It's not doing _anything?!?_
+          BaseVisitor
         elsif rules == ALL_RULES
-          if rewrite
-            DefaultVisitor
-          else
-            InterpreterVisitor
-          end
+          InterpreterVisitor
         else
           visitor_class = Class.new(self) do
             include(GraphQL::StaticValidation::DefinitionDependencies)
@@ -60,9 +46,6 @@ module GraphQL
             end
           end
 
-          if rewrite
-            visitor_class.include(GraphQL::InternalRepresentation::Rewrite)
-          end
           visitor_class.include(ContextMethods)
           visitor_class
         end

data/lib/graphql/static_validation/definition_dependencies.rb

@@ -127,8 +127,14 @@ module GraphQL
         # same name as if they were the same name. If _any_ of the fragments
         # with that name has a dependency, we record it.
         independent_fragment_nodes = @defdep_fragment_definitions.values.flatten - @defdep_immediate_dependencies.keys
-
+        visited_fragment_names = Set.new
         while fragment_node = independent_fragment_nodes.pop
+          if visited_fragment_names.add?(fragment_node.name)
+            # this is a new fragment name
+          else
+            # this is a duplicate fragment name
+            next
+          end
           loops += 1
           if loops > max_loops
             raise("Resolution loops exceeded the number of definitions; infinite loop detected. (Max: #{max_loops}, Current: #{loops})")

data/lib/graphql/static_validation/error.rb

@@ -30,10 +30,10 @@ module GraphQL
         }.tap { |h| h["path"] = path unless path.nil? }
       end
 
-      private
-
       attr_reader :nodes
 
+      private
+
       def locations
         nodes.map do |node|
           h = {"line" => node.line, "column" => node.col}

data/lib/graphql/static_validation/literal_validator.rb

@@ -18,6 +18,19 @@ module GraphQL
 
       private
 
+      def replace_nulls_in(ast_value)
+        case ast_value
+        when Array
+          ast_value.map { |v| replace_nulls_in(v) }
+        when GraphQL::Language::Nodes::InputObject
+          ast_value.to_h
+        when GraphQL::Language::Nodes::NullValue
+          nil
+        else
+          ast_value
+        end
+      end
+
       def recursively_validate(ast_value, type)
         if type.nil?
           # this means we're an undefined argument, see #present_input_field_values_are_valid
@@ -42,7 +55,8 @@ module GraphQL
           @valid_response
         elsif type.kind.scalar? && constant_scalar?(ast_value)
           maybe_raise_if_invalid(ast_value) do
-            type.validate_input(ast_value, @context)
+            ruby_value = replace_nulls_in(ast_value)
+            type.validate_input(ruby_value, @context)
           end
         elsif type.kind.enum?
           maybe_raise_if_invalid(ast_value) do
@@ -108,6 +122,10 @@ module GraphQL
             arg_type = @warden.get_argument(type, name).type
             recursively_validate(GraphQL::Language::Nodes::NullValue.new(name: name), arg_type)
           end
+
+          if type.one_of? && ast_node.arguments.size != 1
+            results << Query::InputValidationResult.from_problem("`#{type.graphql_name}` is a OneOf type, so only one argument may be given (instead of #{ast_node.arguments.size})")
+          end
           merge_results(results)
         end
       end

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

@@ -9,11 +9,17 @@ module GraphQL
 
       def on_directive(node, parent)
         if !@directive_names.include?(node.name)
-          add_error(GraphQL::StaticValidation::DirectivesAreDefinedError.new(
-            "Directive @#{node.name} is not defined",
-            nodes: node,
-            directive: node.name
-          ))
+          @directives_are_defined_errors_by_name ||= {}
+          error = @directives_are_defined_errors_by_name[node.name] ||= begin
+            err = GraphQL::StaticValidation::DirectivesAreDefinedError.new(
+              "Directive @#{node.name} is not defined",
+              nodes: [],
+              directive: node.name
+            )
+            add_error(err)
+            err
+          end
+          error.nodes << node
         else
           super
         end

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

@@ -12,20 +12,20 @@ module GraphQL
       private
 
       LOCATION_MESSAGE_NAMES = {
-        GraphQL::Directive::QUERY =>               "queries",
-        GraphQL::Directive::MUTATION =>            "mutations",
-        GraphQL::Directive::SUBSCRIPTION =>        "subscriptions",
-        GraphQL::Directive::FIELD =>               "fields",
-        GraphQL::Directive::FRAGMENT_DEFINITION => "fragment definitions",
-        GraphQL::Directive::FRAGMENT_SPREAD =>     "fragment spreads",
-        GraphQL::Directive::INLINE_FRAGMENT =>     "inline fragments",
+        GraphQL::Schema::Directive::QUERY =>               "queries",
+        GraphQL::Schema::Directive::MUTATION =>            "mutations",
+        GraphQL::Schema::Directive::SUBSCRIPTION =>        "subscriptions",
+        GraphQL::Schema::Directive::FIELD =>               "fields",
+        GraphQL::Schema::Directive::FRAGMENT_DEFINITION => "fragment definitions",
+        GraphQL::Schema::Directive::FRAGMENT_SPREAD =>     "fragment spreads",
+        GraphQL::Schema::Directive::INLINE_FRAGMENT =>     "inline fragments",
       }
 
       SIMPLE_LOCATIONS = {
-        Nodes::Field =>               GraphQL::Directive::FIELD,
-        Nodes::InlineFragment =>      GraphQL::Directive::INLINE_FRAGMENT,
-        Nodes::FragmentSpread =>      GraphQL::Directive::FRAGMENT_SPREAD,
-        Nodes::FragmentDefinition =>  GraphQL::Directive::FRAGMENT_DEFINITION,
+        Nodes::Field =>               GraphQL::Schema::Directive::FIELD,
+        Nodes::InlineFragment =>      GraphQL::Schema::Directive::INLINE_FRAGMENT,
+        Nodes::FragmentSpread =>      GraphQL::Schema::Directive::FRAGMENT_SPREAD,
+        Nodes::FragmentDefinition =>  GraphQL::Schema::Directive::FRAGMENT_DEFINITION,
       }
 
       SIMPLE_LOCATION_NODES = SIMPLE_LOCATIONS.keys
@@ -34,7 +34,7 @@ module GraphQL
         directive_defn = directives[ast_directive.name]
         case ast_parent
         when Nodes::OperationDefinition
-          required_location = GraphQL::Directive.const_get(ast_parent.operation_type.upcase)
+          required_location = GraphQL::Schema::Directive.const_get(ast_parent.operation_type.upcase)
           assert_includes_location(directive_defn, ast_directive, required_location)
         when *SIMPLE_LOCATION_NODES
           required_location = SIMPLE_LOCATIONS[ast_parent.class]

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

@@ -26,11 +26,19 @@ module GraphQL
         msg = if resolved_type.nil?
           nil
         elsif resolved_type.kind.scalar? && ast_node.selections.any?
-          if ast_node.selections.first.is_a?(GraphQL::Language::Nodes::InlineFragment)
-            "Selections can't be made on scalars (%{node_name} returns #{resolved_type.graphql_name} but has inline fragments [#{ast_node.selections.map(&:type).map(&:name).join(", ")}])"
-          else
-            "Selections can't be made on scalars (%{node_name} returns #{resolved_type.graphql_name} but has selections [#{ast_node.selections.map(&:name).join(", ")}])"
+          selection_strs = ast_node.selections.map do |n|
+            case n
+            when GraphQL::Language::Nodes::InlineFragment
+              "\"... on #{n.type.name} { ... }\""
+            when GraphQL::Language::Nodes::Field
+              "\"#{n.name}\""
+            when GraphQL::Language::Nodes::FragmentSpread
+              "\"#{n.name}\""
+            else
+              raise "Invariant: unexpected selection node: #{n}"
+            end
           end
+          "Selections can't be made on scalars (%{node_name} returns #{resolved_type.graphql_name} but has selections [#{selection_strs.join(", ")}])"
         elsif resolved_type.kind.fields? && ast_node.selections.empty?
           "Field must have selections (%{node_name} returns #{resolved_type.graphql_name} but has no selections. Did you mean '#{ast_node.name} { ... }'?)"
         else

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

@@ -9,7 +9,7 @@ module GraphQL
       # without ambiguity.
       #
       # Original Algorithm: https://github.com/graphql/graphql-js/blob/master/src/validation/rules/OverlappingFieldsCanBeMerged.js
-      NO_ARGS = {}.freeze
+      NO_ARGS = GraphQL::EmptyObjects::EMPTY_HASH
 
       Field = Struct.new(:node, :definition, :owner_type, :parents)
       FragmentSpread = Struct.new(:name, :parents)
@@ -323,7 +323,7 @@ module GraphQL
         end
       end
 
-      NO_SELECTIONS = [{}.freeze, [].freeze].freeze
+      NO_SELECTIONS = [GraphQL::EmptyObjects::EMPTY_HASH, GraphQL::EmptyObjects::EMPTY_ARRAY].freeze
 
       def fields_and_fragments_from_selection(node, owner_type:, parents:)
         if node.selections.empty?

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

@@ -0,0 +1,66 @@
+# frozen_string_literal: true
+module GraphQL
+  module StaticValidation
+    module OneOfInputObjectsAreValid
+      def on_input_object(node, parent)
+        return super unless parent.is_a?(GraphQL::Language::Nodes::Argument)
+
+        parent_type = get_parent_type(context, parent)
+        return super unless parent_type && parent_type.kind.input_object? && parent_type.one_of?
+
+        validate_one_of_input_object(node, context, parent_type)
+        super
+      end
+
+      private
+
+      def validate_one_of_input_object(ast_node, context, parent_type)
+        present_fields = ast_node.arguments.map(&:name)
+        input_object_type = parent_type.to_type_signature
+
+        if present_fields.count != 1
+          add_error(
+            OneOfInputObjectsAreValidError.new(
+              "OneOf Input Object '#{input_object_type}' must specify exactly one key.",
+              path: context.path,
+              nodes: ast_node,
+              input_object_type: input_object_type
+            )
+          )
+          return
+        end
+
+        field = present_fields.first
+        value = ast_node.arguments.first.value
+
+        if value.is_a?(GraphQL::Language::Nodes::NullValue)
+          add_error(
+            OneOfInputObjectsAreValidError.new(
+              "Argument '#{input_object_type}.#{field}' must be non-null.",
+              path: [*context.path, field],
+              nodes: ast_node.arguments.first,
+              input_object_type: input_object_type
+            )
+          )
+          return
+        end
+
+        if value.is_a?(GraphQL::Language::Nodes::VariableIdentifier)
+          variable_name = value.name
+          variable_type = @declared_variables[variable_name].type
+
+          unless variable_type.is_a?(GraphQL::Language::Nodes::NonNullType)
+            add_error(
+              OneOfInputObjectsAreValidError.new(
+                "Variable '#{variable_name}' must be non-nullable to be used for OneOf Input Object '#{input_object_type}'.",
+                path: [*context.path, field],
+                nodes: ast_node,
+                input_object_type: input_object_type
+              )
+            )
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+module GraphQL
+  module StaticValidation
+    class OneOfInputObjectsAreValidError < StaticValidation::Error
+      attr_reader :input_object_type
+
+      def initialize(message, path:, nodes:, input_object_type:)
+        super(message, path: path, nodes: nodes)
+        @input_object_type = input_object_type
+      end
+
+      # A hash representation of this Message
+      def to_h
+        extensions = {
+          "code" => code,
+          "inputObjectType" => input_object_type
+        }
+
+        super.merge({
+          "extensions" => extensions
+        })
+      end
+
+      def code
+        "invalidOneOfInputObject"
+      end
+    end
+  end
+end

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

@@ -34,12 +34,18 @@ module GraphQL
         used_directives = {}
         node.directives.each do |ast_directive|
           directive_name = ast_directive.name
-          if used_directives[directive_name]
-            add_error(GraphQL::StaticValidation::UniqueDirectivesPerLocationError.new(
-              "The directive \"#{directive_name}\" can only be used once at this location.",
-              nodes: [used_directives[directive_name], ast_directive],
-              directive: directive_name,
-            ))
+          if (first_node = used_directives[directive_name])
+            @directives_are_unique_errors_by_first_node ||= {}
+            err = @directives_are_unique_errors_by_first_node[first_node] ||= begin
+              error = GraphQL::StaticValidation::UniqueDirectivesPerLocationError.new(
+                "The directive \"#{directive_name}\" can only be used once at this location.",
+                nodes: [used_directives[directive_name]],
+                directive: directive_name,
+              )
+              add_error(error)
+              error
+            end
+            err.nodes << ast_directive
           elsif !((dir_defn = context.schema_directives[directive_name]) && dir_defn.repeatable?)
             used_directives[directive_name] = ast_directive
           end

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

@@ -23,7 +23,7 @@ module GraphQL
                 problems = validation_result.problems
                 first_problem = problems && problems.first
                 if first_problem
-                  error_message = first_problem["message"]
+                  error_message = first_problem["explanation"]
                 end
 
                 error_message ||= "Default value for $#{node.name} doesn't match type #{type.to_type_signature}"

data/lib/graphql/static_validation/validator.rb

@@ -27,13 +27,12 @@ module GraphQL
       # @param max_errors [Integer] Maximum number of errors before aborting validation. Any positive number will limit the number of errors. Defaults to nil for no limit.
       # @return [Array<Hash>]
       def validate(query, validate: true, timeout: nil, max_errors: nil)
-        query.trace("validate", { validate: validate, query: query }) do
-          can_skip_rewrite = query.context.interpreter? && query.schema.using_ast_analysis? && query.schema.is_a?(Class)
-          errors = if validate == false && can_skip_rewrite
+        query.current_trace.validate(validate: validate, query: query) do
+          errors = if validate == false
             []
           else
             rules_to_use = validate ? @rules : []
-            visitor_class = BaseVisitor.including_rules(rules_to_use, rewrite: !can_skip_rewrite)
+            visitor_class = BaseVisitor.including_rules(rules_to_use)
 
             context = GraphQL::StaticValidation::ValidationContext.new(query, visitor_class, max_errors)
 
@@ -42,18 +41,6 @@ module GraphQL
               # A timeout value of 0 or nil will execute the block without any timeout.
               Timeout::timeout(timeout) do
                 catch(:too_many_validation_errors) do
-                  # Attach legacy-style rules.
-                  # Only loop through rules if it has legacy-style rules
-                  unless (legacy_rules = rules_to_use - GraphQL::StaticValidation::ALL_RULES).empty?
-                    legacy_rules.each do |rule_class_or_module|
-                      if rule_class_or_module.method_defined?(:validate)
-                        GraphQL::Deprecation.warn "Legacy validator rules will be removed from GraphQL-Ruby 2.0, use a module instead (see the built-in rules: https://github.com/rmosolgo/graphql-ruby/tree/master/lib/graphql/static_validation/rules)"
-                        GraphQL::Deprecation.warn "  -> Legacy validator: #{rule_class_or_module}"
-                        rule_class_or_module.new.validate(context)
-                      end
-                    end
-                  end
-
                   context.visitor.visit
                 end
               end
@@ -64,22 +51,13 @@ module GraphQL
             context.errors
           end
 
-          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: errors,
-            irep: irep,
           }
         end
       rescue GraphQL::ExecutionError => e
         {
           errors: [e],
-          irep: nil,
         }
       end
 

data/lib/graphql/static_validation.rb

@@ -7,7 +7,6 @@ require "graphql/static_validation/validation_context"
 require "graphql/static_validation/validation_timeout_error"
 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|
@@ -15,5 +14,4 @@ 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

@@ -91,7 +91,13 @@ module GraphQL
         # A per-process map of subscriptions to deliver.
         # This is provided by Rails, so let's use it
         @subscriptions = Concurrent::Map.new
-        @events = Concurrent::Map.new { |h, k| h[k] = Concurrent::Map.new { |h2, k2| h2[k2] = Concurrent::Array.new } }
+        @events = Concurrent::Map.new do |h, k|
+          h.compute_if_absent(k) do
+            Concurrent::Map.new do |h2, k2|
+              h2.compute_if_absent(k2) { Concurrent::Array.new }
+            end
+          end
+        end
         @action_cable = action_cable
         @action_cable_coder = action_cable_coder
         @serializer = serializer

data/lib/graphql/subscriptions/default_subscription_resolve_extension.rb

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 module GraphQL
   class Subscriptions
-    class DefaultSubscriptionResolveExtension < GraphQL::Subscriptions::SubscriptionRoot::Extension
+    class DefaultSubscriptionResolveExtension < GraphQL::Schema::FieldExtension
       def resolve(context:, object:, arguments:)
         has_override_implementation = @field.resolver ||
           object.respond_to?(@field.resolver_method)
@@ -16,6 +16,43 @@ module GraphQL
           yield(object, arguments)
         end
       end
+
+      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:
+          event = Subscriptions::Event.new(
+            name: field.name,
+            arguments: arguments_without_field_extras(arguments: arguments),
+            context: context,
+            field: field,
+          )
+          events << event
+          value
+        elsif context.query.subscription_topic == Subscriptions::Event.serialize(
+            field.name,
+            arguments_without_field_extras(arguments: 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
+
+      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/subscriptions/event.rb

@@ -9,7 +9,7 @@ module GraphQL
       # @return [String] Corresponds to the Subscription root field name
       attr_reader :name
 
-      # @return [GraphQL::Query::Arguments]
+      # @return [GraphQL::Execution::Interpreter::Arguments]
       attr_reader :arguments
 
       # @return [GraphQL::Query::Context]
@@ -100,13 +100,8 @@ module GraphQL
               arg_name = k.to_s
               camelized_arg_name = GraphQL::Schema::Member::BuildType.camelize(arg_name)
               arg_defn = get_arg_definition(arg_owner, camelized_arg_name, context)
-
-              if arg_defn
-                normalized_arg_name = camelized_arg_name
-              else
-                normalized_arg_name = arg_name
-                arg_defn = get_arg_definition(arg_owner, normalized_arg_name, context)
-              end
+              arg_defn ||= get_arg_definition(arg_owner, arg_name, context)
+              normalized_arg_name = arg_defn.graphql_name
               arg_base_type = arg_defn.type.unwrap
               # In the case where the value being emitted is seen as a "JSON"
               # type, treat the value as one atomic unit of serialization

data/lib/graphql/subscriptions/instrumentation.rb

@@ -9,16 +9,6 @@ module GraphQL
         @schema = schema
       end
 
-      def instrument(type, field)
-        if type == @schema.subscription.graphql_definition
-          # 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?
@@ -33,47 +23,6 @@ module GraphQL
           @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)
-          result = nil
-          if @inner_proc && !@inner_proc.is_a?(GraphQL::Field::Resolve::BuiltInResolve)
-            result = @inner_proc.call(obj, args, ctx)
-          end
-
-          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,
-            )
-            result
-          elsif ctx.irep_node.subscription_topic == ctx.query.subscription_topic
-            if !result.nil?
-              result
-            elsif obj.is_a?(GraphQL::Schema::Object)
-              # The root object is _already_ the subscription update:
-              obj.object
-            else
-              obj
-            end
-          else
-            # This is a subscription update, but this event wasn't triggered.
-            ctx.skip
-          end
-        end
-      end
     end
   end
 end