graphql 1.8.0 → 1.12.12

data/lib/graphql/language/sanitized_printer.rb

@@ -0,0 +1,222 @@
+# frozen_string_literal: true
+module GraphQL
+  module Language
+    # A custom printer used to print sanitized queries. It inlines provided variables
+    # within the query for facilitate logging and analysis of queries.
+    #
+    # The printer returns `nil` if the query is invalid.
+    #
+    # Since the GraphQL Ruby AST for a GraphQL query doesnt contain any reference
+    # on the type of fields or arguments, we have to track the current object, field
+    # and input type while printing the query.
+    #
+    # @example Printing a scrubbed string
+    #   printer = QueryPrinter.new(query)
+    #   puts printer.sanitized_query_string
+    #
+    # @see {Query#sanitized_query_string}
+    class SanitizedPrinter < GraphQL::Language::Printer
+
+      REDACTED = "\"<REDACTED>\""
+
+      def initialize(query, inline_variables: true)
+        @query = query
+        @current_type = nil
+        @current_field = nil
+        @current_input_type = nil
+        @inline_variables = inline_variables
+      end
+
+      # @return [String, nil] A scrubbed query string, if the query was valid.
+      def sanitized_query_string
+        if query.valid?
+          print(query.document)
+        else
+          nil
+        end
+      end
+
+      def print_node(node, indent: "")
+        case node
+        when FalseClass, Float, Integer, String, TrueClass
+          if @current_argument && redact_argument_value?(@current_argument, node)
+            redacted_argument_value(@current_argument)
+          else
+            super
+          end
+        when Array
+          old_input_type = @current_input_type
+          if @current_input_type && @current_input_type.list?
+            @current_input_type = @current_input_type.of_type
+            @current_input_type = @current_input_type.of_type if @current_input_type.non_null?
+          end
+
+          res = super
+          @current_input_type = old_input_type
+          res
+        else
+          super
+        end
+      end
+
+      # Indicates whether or not to redact non-null values for the given argument. Defaults to redacting all strings
+      # arguments but this can be customized by subclasses.
+      def redact_argument_value?(argument, value)
+        # Default to redacting any strings or custom scalars encoded as strings
+        type = argument.type.unwrap
+        value.is_a?(String) && type.kind.scalar? && (type.graphql_name == "String" || !type.default_scalar?)
+      end
+
+      # Returns the value to use for redacted versions of the given argument. Defaults to the
+      # string "<REDACTED>".
+      def redacted_argument_value(argument)
+        REDACTED
+      end
+
+      def print_argument(argument)
+        # We won't have type information if we're recursing into a custom scalar
+        return super if @current_input_type && @current_input_type.kind.scalar?
+
+        arg_owner = @current_input_type || @current_directive || @current_field
+        old_current_argument = @current_argument
+        @current_argument = arg_owner.arguments[argument.name]
+
+        old_input_type = @current_input_type
+        @current_input_type = @current_argument.type.non_null? ? @current_argument.type.of_type : @current_argument.type
+
+        argument_value = if coerce_argument_value_to_list?(@current_input_type, argument.value)
+          [argument.value]
+        else
+          argument.value
+        end
+        res = "#{argument.name}: #{print_node(argument_value)}".dup
+
+        @current_input_type = old_input_type
+        @current_argument = old_current_argument
+        res
+      end
+
+      def coerce_argument_value_to_list?(type, value)
+        type.list? &&
+          !value.is_a?(Array) &&
+          !value.nil? &&
+          !value.is_a?(GraphQL::Language::Nodes::VariableIdentifier)
+      end
+
+      def print_variable_identifier(variable_id)
+        if @inline_variables
+          variable_value = query.variables[variable_id.name]
+          print_node(value_to_ast(variable_value, @current_input_type))
+        else
+          super
+        end
+      end
+
+      def print_field(field, indent: "")
+        @current_field = query.schema.get_field(@current_type, field.name)
+        old_type = @current_type
+        @current_type = @current_field.type.unwrap
+        res = super
+        @current_type = old_type
+        res
+      end
+
+      def print_inline_fragment(inline_fragment, indent: "")
+        old_type = @current_type
+
+        if inline_fragment.type
+          @current_type = query.schema.types[inline_fragment.type.name]
+        end
+
+        res = super
+
+        @current_type = old_type
+
+        res
+      end
+
+      def print_fragment_definition(fragment_def, indent: "")
+        old_type = @current_type
+        @current_type = query.schema.types[fragment_def.type.name]
+
+        res = super
+
+        @current_type = old_type
+
+        res
+      end
+
+      def print_directive(directive)
+        @current_directive = query.schema.directives[directive.name]
+
+        res = super
+
+        @current_directive = nil
+        res
+      end
+
+      # Print the operation definition but do not include the variable
+      # definitions since we will inline them within the query
+      def print_operation_definition(operation_definition, indent: "")
+        old_type = @current_type
+        @current_type = query.schema.public_send(operation_definition.operation_type)
+
+        if @inline_variables
+          out = "#{indent}#{operation_definition.operation_type}".dup
+          out << " #{operation_definition.name}" if operation_definition.name
+          out << print_directives(operation_definition.directives)
+          out << print_selections(operation_definition.selections, indent: indent)
+        else
+          out = super
+        end
+
+        @current_type = old_type
+        out
+      end
+
+      private
+
+      def value_to_ast(value, type)
+        type = type.of_type if type.non_null?
+
+        if value.nil?
+          return GraphQL::Language::Nodes::NullValue.new(name: "null")
+        end
+
+        case type.kind.name
+        when "INPUT_OBJECT"
+          value = if value.respond_to?(:to_unsafe_h)
+            # for ActionController::Parameters
+            value.to_unsafe_h
+          else
+            value.to_h
+          end
+
+          arguments = value.map do |key, val|
+            sub_type = type.arguments[key.to_s].type
+
+            GraphQL::Language::Nodes::Argument.new(
+              name: key.to_s,
+              value: value_to_ast(val, sub_type)
+            )
+          end
+          GraphQL::Language::Nodes::InputObject.new(
+            arguments: arguments
+          )
+        when "LIST"
+          if value.is_a?(Array)
+            value.map { |v| value_to_ast(v, type.of_type) }
+          else
+            [value].map { |v| value_to_ast(v, type.of_type) }
+          end
+        when "ENUM"
+          GraphQL::Language::Nodes::Enum.new(name: value)
+        else
+          value
+        end
+      end
+
+      attr_reader :query
+    end
+  end
+end

data/lib/graphql/language/token.rb

@@ -4,15 +4,19 @@ module GraphQL
     # Emitted by the lexer and passed to the parser.
     # Contains type, value and position data.
     class Token
+      if !String.method_defined?(:-@)
+        using GraphQL::StringDedupBackport
+      end
+
       # @return [Symbol] The kind of token this is
       attr_reader :name
       # @return [String] The text of this token
       attr_reader :value
       attr_reader :prev_token, :line, :col
 
-      def initialize(value:, name:, line:, col:, prev_token:)
+      def initialize(name, value, line, col, prev_token)
         @name = name
-        @value = value.freeze
+        @value = -value
         @line = line
         @col = col
         @prev_token = prev_token

data/lib/graphql/language/visitor.rb

@@ -3,32 +3,61 @@ module GraphQL
   module Language
     # Depth-first traversal through the tree, calling hooks at each stop.
     #
-    # @example Create a visitor, add hooks, then search a document
-    #   total_field_count = 0
-    #   visitor = GraphQL::Language::Visitor.new(document)
-    #   # Whenever you find a field, increment the field count:
-    #   visitor[GraphQL::Language::Nodes::Field] << ->(node) { total_field_count += 1 }
-    #   # When we finish, print the field count:
-    #   visitor[GraphQL::Language::Nodes::Document].leave << ->(node) { p total_field_count }
-    #   visitor.visit
-    #   # => 6
+    # @example Create a visitor counting certain field names
+    #   class NameCounter < GraphQL::Language::Visitor
+    #     def initialize(document, field_name)
+    #       super(document)
+    #       @field_name = field_name
+    #       @count = 0
+    #     end
+    #
+    #     attr_reader :count
+    #
+    #     def on_field(node, parent)
+    #       # if this field matches our search, increment the counter
+    #       if node.name == @field_name
+    #         @count += 1
+    #       end
+    #       # Continue visiting subfields:
+    #       super
+    #     end
+    #   end
     #
+    #   # Initialize a visitor
+    #   visitor = NameCounter.new(document, "name")
+    #   # Run it
+    #   visitor.visit
+    #   # Check the result
+    #   visitor.count
+    #   # => 3
     class Visitor
       # If any hook returns this value, the {Visitor} stops visiting this
       # node right away
+      # @deprecated Use `super` to continue the visit; or don't call it to halt.
       SKIP = :_skip
 
+      class DeleteNode; end
+
+      # When this is returned from a visitor method,
+      # Then the `node` passed into the method is removed from `parent`'s children.
+      DELETE_NODE = DeleteNode.new
+
       def initialize(document)
         @document = document
         @visitors = {}
+        @result = nil
       end
 
+      # @return [GraphQL::Language::Nodes::Document] The document with any modifications applied
+      attr_reader :result
+
       # Get a {NodeVisitor} for `node_class`
       # @param node_class [Class] The node class that you want to listen to
       # @return [NodeVisitor]
       #
       # @example Run a hook whenever you enter a new Field
       #   visitor[GraphQL::Language::Nodes::Field] << ->(node, parent) { p "Here's a field" }
+      # @deprecated see `on_` methods, like {#on_field}
       def [](node_class)
         @visitors[node_class] ||= NodeVisitor.new
       end
@@ -36,17 +65,137 @@ module GraphQL
       # Visit `document` and all children, applying hooks as you go
       # @return [void]
       def visit
-        visit_node(@document, nil)
+        result = on_node_with_modifications(@document, nil)
+        @result = if result.is_a?(Array)
+          result.first
+        else
+          # The node wasn't modified
+          @document
+        end
+      end
+
+      # Call the user-defined handler for `node`.
+      def visit_node(node, parent)
+        public_send(node.visit_method, node, parent)
       end
 
+      # The default implementation for visiting an AST node.
+      # It doesn't _do_ anything, but it continues to visiting the node's children.
+      # To customize this hook, override one of its make_visit_methodes (or the base method?)
+      # in your subclasses.
+      #
+      # For compatibility, it calls hook procs, too.
+      # @param node [GraphQL::Language::Nodes::AbstractNode] the node being visited
+      # @param parent [GraphQL::Language::Nodes::AbstractNode, nil] the previously-visited node, or `nil` if this is the root node.
+      # @return [Array, nil] If there were modifications, it returns an array of new nodes, otherwise, it returns `nil`.
+      def on_abstract_node(node, parent)
+        if node.equal?(DELETE_NODE)
+          # This might be passed to `super(DELETE_NODE, ...)`
+          # by a user hook, don't want to keep visiting in that case.
+          nil
+        else
+          # Run hooks if there are any
+          new_node = node
+          no_hooks = !@visitors.key?(node.class)
+          if no_hooks || begin_visit(new_node, parent)
+            node.children.each do |child_node|
+              new_child_and_node = on_node_with_modifications(child_node, new_node)
+              # Reassign `node` in case the child hook makes a modification
+              if new_child_and_node.is_a?(Array)
+                new_node = new_child_and_node[1]
+              end
+            end
+          end
+          end_visit(new_node, parent) unless no_hooks
+
+          if new_node.equal?(node)
+            nil
+          else
+            [new_node, parent]
+          end
+        end
+      end
+
+      # We don't use `alias` here because it breaks `super`
+      def self.make_visit_method(node_method)
+        class_eval(<<-RUBY, __FILE__, __LINE__ + 1)
+          def #{node_method}(node, parent)
+            child_mod = on_abstract_node(node, parent)
+            # If visiting the children returned changes, continue passing those.
+            child_mod || [node, parent]
+          end
+        RUBY
+      end
+
+      make_visit_method :on_argument
+      make_visit_method :on_directive
+      make_visit_method :on_directive_definition
+      make_visit_method :on_directive_location
+      make_visit_method :on_document
+      make_visit_method :on_enum
+      make_visit_method :on_enum_type_definition
+      make_visit_method :on_enum_type_extension
+      make_visit_method :on_enum_value_definition
+      make_visit_method :on_field
+      make_visit_method :on_field_definition
+      make_visit_method :on_fragment_definition
+      make_visit_method :on_fragment_spread
+      make_visit_method :on_inline_fragment
+      make_visit_method :on_input_object
+      make_visit_method :on_input_object_type_definition
+      make_visit_method :on_input_object_type_extension
+      make_visit_method :on_input_value_definition
+      make_visit_method :on_interface_type_definition
+      make_visit_method :on_interface_type_extension
+      make_visit_method :on_list_type
+      make_visit_method :on_non_null_type
+      make_visit_method :on_null_value
+      make_visit_method :on_object_type_definition
+      make_visit_method :on_object_type_extension
+      make_visit_method :on_operation_definition
+      make_visit_method :on_scalar_type_definition
+      make_visit_method :on_scalar_type_extension
+      make_visit_method :on_schema_definition
+      make_visit_method :on_schema_extension
+      make_visit_method :on_type_name
+      make_visit_method :on_union_type_definition
+      make_visit_method :on_union_type_extension
+      make_visit_method :on_variable_definition
+      make_visit_method :on_variable_identifier
+
       private
 
-      def visit_node(node, parent)
-        begin_hooks_ok = begin_visit(node, parent)
-        if begin_hooks_ok
-          node.children.each { |child| visit_node(child, node) }
+      # Run the hooks for `node`, and if the hooks return a copy of `node`,
+      # copy `parent` so that it contains the copy of that node as a child,
+      # then return the copies
+      # If a non-array value is returned, consuming functions should ignore
+      # said value
+      def on_node_with_modifications(node, parent)
+        new_node_and_new_parent = visit_node(node, parent)
+        if new_node_and_new_parent.is_a?(Array)
+          new_node = new_node_and_new_parent[0]
+          new_parent = new_node_and_new_parent[1]
+          if new_node.is_a?(Nodes::AbstractNode) && !node.equal?(new_node)
+            # The user-provided hook returned a new node.
+            new_parent = new_parent && new_parent.replace_child(node, new_node)
+            return new_node, new_parent
+          elsif new_node.equal?(DELETE_NODE)
+            # The user-provided hook requested to remove this node
+            new_parent = new_parent && new_parent.delete_child(node)
+            return nil, new_parent
+          elsif new_node_and_new_parent.none? { |n| n == nil || n.class < Nodes::AbstractNode }
+            # The user-provided hook returned an array of who-knows-what
+            # return nil here to signify that no changes should be made
+            nil
+          else
+            new_node_and_new_parent
+          end
+        else
+          # The user-provided hook didn't make any modifications.
+          # In fact, the hook might have returned who-knows-what, so
+          # ignore the return value and use the original values.
+          new_node_and_new_parent
         end
-        end_visit(node, parent)
       end
 
       def begin_visit(node, parent)
@@ -62,7 +211,10 @@ module GraphQL
 
       # If one of the visitors returns SKIP, stop visiting this node
       def self.apply_hooks(hooks, node, parent)
-        hooks.reduce(true) { |memo, proc| memo && (proc.call(node, parent) != SKIP) }
+        hooks.each do |proc|
+          return false if proc.call(node, parent) == SKIP
+        end
+        true
       end
 
       # Collect `enter` and `leave` hooks for classes in {GraphQL::Language::Nodes}

data/lib/graphql/language.rb

@@ -1,15 +1,16 @@
 # frozen_string_literal: true
 require "graphql/language/block_string"
 require "graphql/language/printer"
-require "graphql/language/definition_slice"
+require "graphql/language/sanitized_printer"
 require "graphql/language/document_from_schema_definition"
 require "graphql/language/generation"
 require "graphql/language/lexer"
 require "graphql/language/nodes"
+require "graphql/language/cache"
 require "graphql/language/parser"
 require "graphql/language/token"
 require "graphql/language/visitor"
-require "graphql/language/comments"
+require "graphql/language/definition_slice"
 
 module GraphQL
   module Language

data/lib/graphql/list_type.rb

@@ -40,6 +40,7 @@ module GraphQL
       "[#{of_type.to_s}]"
     end
     alias_method :inspect, :to_s
+    alias :to_type_signature :to_s
 
     def coerce_result(value, ctx = nil)
       if ctx.nil?

data/lib/graphql/load_application_object_failed_error.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+module GraphQL
+  # Raised when a argument is configured with `loads:` and the client provides an `ID`,
+  # but no object is loaded for that ID.
+  #
+  # @see GraphQL::Schema::Member::HasArguments::ArgumentObjectLoader#load_application_object_failed, A hook which you can override in resolvers, mutations and input objects.
+  class LoadApplicationObjectFailedError < GraphQL::ExecutionError
+    # @return [GraphQL::Schema::Argument] the argument definition for the argument that was looked up
+    attr_reader :argument
+    # @return [String] The ID provided by the client
+    attr_reader :id
+    # @return [Object] The value found with this ID
+    attr_reader :object
+    def initialize(argument:, id:, object:)
+      @id = id
+      @argument = argument
+      @object = object
+      super("No object found for `#{argument.graphql_name}: #{id.inspect}`")
+    end
+  end
+end

data/lib/graphql/name_validator.rb

@@ -1,16 +1,15 @@
 # frozen_string_literal: true
 module GraphQL
   class NameValidator
-    VALID_NAME_REGEX = /^[_a-zA-Z][_a-zA-Z0-9]*$/
-
-    def self.validate!(name)
-      raise GraphQL::InvalidNameError.new(name, VALID_NAME_REGEX) unless valid?(name)
+    if !String.method_defined?(:match?)
+      using GraphQL::StringMatchBackport
     end
 
-    private
+    VALID_NAME_REGEX = /^[_a-zA-Z][_a-zA-Z0-9]*$/
 
-    def self.valid?(name)
-      name =~ VALID_NAME_REGEX
+    def self.validate!(name)
+      name = name.is_a?(String) ? name : name.to_s
+      raise GraphQL::InvalidNameError.new(name, VALID_NAME_REGEX) unless name.match?(VALID_NAME_REGEX)
     end
   end
 end

data/lib/graphql/non_null_type.rb

@@ -1,8 +1,5 @@
 # frozen_string_literal: true
 module GraphQL
-  class DoubleNonNullTypeError < GraphQL::Error
-  end
-
   # A non-null type modifies another type.
   #
   # Non-null types can be created with `!` (`InnerType!`)
@@ -37,13 +34,6 @@ module GraphQL
 
     attr_reader :of_type
     def initialize(of_type:)
-      if of_type.is_a?(GraphQL::NonNullType)
-        raise(
-          DoubleNonNullTypeError,
-          "You tried to add a non-null constraint twice (!! instead of !)"
-        )
-      end
-
       super()
       @of_type = of_type
     end
@@ -72,6 +62,7 @@ module GraphQL
       "#{of_type.to_s}!"
     end
     alias_method :inspect, :to_s
+    alias :to_type_signature :to_s
 
     def non_null?
       true