graphql 1.9.17 → 2.0.20

data/lib/graphql/language/printer.rb

@@ -93,7 +93,7 @@ module GraphQL
       end
 
       def print_input_object(input_object)
-        "{#{input_object.arguments.map { |a| "#{a.name}: #{print(a.value)}" }.join(", ")}}"
+        "{#{input_object.arguments.map { |a| print_argument(a) }.join(", ")}}"
       end
 
       def print_list_type(list_type)
@@ -132,10 +132,11 @@ module GraphQL
       end
 
       def print_schema_definition(schema)
-        if (schema.query.nil? || schema.query == 'Query') &&
-           (schema.mutation.nil? || schema.mutation == 'Mutation') &&
-           (schema.subscription.nil? || schema.subscription == 'Subscription') &&
-           (schema.directives.empty?)
+        has_conventional_names = (schema.query.nil? || schema.query == 'Query') &&
+          (schema.mutation.nil? || schema.mutation == 'Mutation') &&
+          (schema.subscription.nil? || schema.subscription == 'Subscription')
+
+        if has_conventional_names && schema.directives.empty?
           return
         end
 
@@ -145,14 +146,22 @@ module GraphQL
             out << "\n  "
             out << print_node(dir)
           end
-          out << "\n{"
-        else
-          out << " {\n"
+          if !has_conventional_names
+            out << "\n"
+          end
         end
-        out << "  query: #{schema.query}\n" if schema.query
-        out << "  mutation: #{schema.mutation}\n" if schema.mutation
-        out << "  subscription: #{schema.subscription}\n" if schema.subscription
-        out << "}"
+
+        if !has_conventional_names
+          if schema.directives.empty?
+            out << " "
+          end
+          out << "{\n"
+          out << "  query: #{schema.query}\n" if schema.query
+          out << "  mutation: #{schema.mutation}\n" if schema.mutation
+          out << "  subscription: #{schema.subscription}\n" if schema.subscription
+          out << "}"
+        end
+        out
       end
 
       def print_scalar_type_definition(scalar_type)
@@ -164,11 +173,15 @@ module GraphQL
       def print_object_type_definition(object_type)
         out = print_description(object_type)
         out << "type #{object_type.name}"
-        out << " implements " << object_type.interfaces.map(&:name).join(" & ") unless object_type.interfaces.empty?
+        out << print_implements(object_type) unless object_type.interfaces.empty?
         out << print_directives(object_type.directives)
         out << print_field_definitions(object_type.fields)
       end
 
+      def print_implements(type)
+        " implements #{type.interfaces.map(&:name).join(" & ")}"
+      end
+
       def print_input_value_definition(input_value)
         out = "#{input_value.name}: #{print_node(input_value.type)}".dup
         out << " = #{print_node(input_value.default_value)}" unless input_value.default_value.nil?
@@ -200,6 +213,7 @@ module GraphQL
       def print_interface_type_definition(interface_type)
         out = print_description(interface_type)
         out << "interface #{interface_type.name}"
+        out << print_implements(interface_type) if interface_type.interfaces.any?
         out << print_directives(interface_type.directives)
         out << print_field_definitions(interface_type.fields)
       end
@@ -231,12 +245,15 @@ module GraphQL
         out = print_description(input_object_type)
         out << "input #{input_object_type.name}"
         out << print_directives(input_object_type.directives)
-        out << " {\n"
-        input_object_type.fields.each.with_index do |field, i|
-          out << print_description(field, indent: '  ', first_in_block: i == 0)
-          out << "  #{print_input_value_definition(field)}\n"
+        if !input_object_type.fields.empty?
+          out << " {\n"
+          input_object_type.fields.each.with_index do |field, i|
+            out << print_description(field, indent: '  ', first_in_block: i == 0)
+            out << "  #{print_input_value_definition(field)}\n"
+          end
+          out << "}"
         end
-        out << "}"
+        out
       end
 
       def print_directive_definition(directive)
@@ -247,6 +264,10 @@ module GraphQL
           out << print_arguments(directive.arguments)
         end
 
+        if directive.repeatable
+          out << " repeatable"
+        end
+
         out << " on #{directive.locations.map(&:name).join(' | ')}"
       end
 
@@ -258,12 +279,16 @@ module GraphQL
       end
 
       def print_field_definitions(fields)
-        out = " {\n".dup
-        fields.each.with_index do |field, i|
-          out << print_description(field, indent: '  ', first_in_block: i == 0)
-          out << "  #{print_field_definition(field)}\n"
+        if fields.empty?
+          ""
+        else
+          out = " {\n".dup
+          fields.each.with_index do |field, i|
+            out << print_description(field, indent: '  ', first_in_block: i == 0)
+            out << "  #{print_field_definition(field)}\n"
+          end
+          out << "}"
         end
-        out << "}"
       end
 
       def print_directives(directives)

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.get_argument(argument.name, @query.context)
+
+        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.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.get_type(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.get_type(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.get_argument(key.to_s, @query.context).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,10 +4,6 @@ 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

data/lib/graphql/language/visitor.rb

@@ -65,7 +65,9 @@ module GraphQL
       # Visit `document` and all children, applying hooks as you go
       # @return [void]
       def visit
-        result = on_node_with_modifications(@document, nil)
+        # `@document` may be any kind of node:
+        visit_method = :"#{@document.visit_method}_with_modifications"
+        result = public_send(visit_method, @document, nil)
         @result = if result.is_a?(Array)
           result.first
         else
@@ -74,104 +76,210 @@ module GraphQL
         end
       end
 
-      # Call the user-defined handler for `node`.
-      def visit_node(node, parent)
-        public_send(node.visit_method, node, parent)
-      end
+      # We don't use `alias` here because it breaks `super`
+      def self.make_visit_methods(ast_node_class)
+        node_method = ast_node_class.visit_method
+        children_of_type = ast_node_class.children_of_type
+        child_visit_method = :"#{node_method}_children"
 
-      # 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 == 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]
+        class_eval(<<-RUBY, __FILE__, __LINE__ + 1)
+          # 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_methods (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 #{node_method}(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.
+              [node, parent]
+            else
+              # Run hooks if there are any
+              new_node = node
+              no_hooks = !@visitors.key?(node.class)
+              if no_hooks || begin_visit(new_node, parent)
+                #{
+                  if method_defined?(child_visit_method)
+                    "new_node = #{child_visit_method}(new_node)"
+                  elsif children_of_type
+                    children_of_type.map do |child_accessor, child_class|
+                      "node.#{child_accessor}.each do |child_node|
+                        new_child_and_node = #{child_class.visit_method}_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.join("\n")
+                  else
+                    ""
+                  end
+                }
+              end
+              end_visit(new_node, parent) unless no_hooks
+
+              if new_node.equal?(node)
+                [node, parent]
+              else
+                [new_node, parent]
               end
             end
           end
-          end_visit(new_node, parent) unless no_hooks
 
-          if new_node.equal?(node)
-            nil
+          def #{node_method}_with_modifications(node, parent)
+            new_node_and_new_parent = #{node_method}(node, parent)
+            apply_modifications(node, parent, new_node_and_new_parent)
+          end
+        RUBY
+      end
+
+      def on_document_children(document_node)
+        new_node = document_node
+        document_node.children.each do |child_node|
+          visit_method = :"#{child_node.visit_method}_with_modifications"
+          new_child_and_node = public_send(visit_method, 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
+        new_node
+      end
+
+      def on_field_children(new_node)
+        new_node.arguments.each do |arg_node| # rubocop:disable Development/ContextIsPassedCop
+          new_child_and_node = on_argument_with_modifications(arg_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
+        new_node = visit_directives(new_node)
+        new_node = visit_selections(new_node)
+        new_node
+      end
+
+      def visit_directives(new_node)
+        new_node.directives.each do |dir_node|
+          new_child_and_node = on_directive_with_modifications(dir_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
+        new_node
+      end
+
+      def visit_selections(new_node)
+        new_node.selections.each do |selection|
+          new_child_and_node = case selection
+          when GraphQL::Language::Nodes::Field
+            on_field_with_modifications(selection, new_node)
+          when GraphQL::Language::Nodes::InlineFragment
+            on_inline_fragment_with_modifications(selection, new_node)
+          when GraphQL::Language::Nodes::FragmentSpread
+            on_fragment_spread_with_modifications(selection, new_node)
           else
-            [new_node, parent]
+            raise ArgumentError, "Invariant: unexpected field selection #{selection.class} (#{selection.inspect})"
+          end
+          # 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
+        new_node
       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]
+      def on_fragment_definition_children(new_node)
+        new_node = visit_directives(new_node)
+        new_node = visit_selections(new_node)
+        new_node
+      end
+
+      alias :on_inline_fragment_children :on_fragment_definition_children
+
+      def on_operation_definition_children(new_node)
+        new_node.variables.each do |arg_node|
+          new_child_and_node = on_variable_definition_with_modifications(arg_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
-        RUBY
+        end
+        new_node = visit_directives(new_node)
+        new_node = visit_selections(new_node)
+        new_node
+      end
+
+      def on_argument_children(new_node)
+        new_node.children.each do |value_node|
+          new_child_and_node = case value_node
+          when Language::Nodes::VariableIdentifier
+            on_variable_identifier_with_modifications(value_node, new_node)
+          when Language::Nodes::InputObject
+            on_input_object_with_modifications(value_node, new_node)
+          when Language::Nodes::Enum
+            on_enum_with_modifications(value_node, new_node)
+          when Language::Nodes::NullValue
+            on_null_value_with_modifications(value_node, new_node)
+          else
+            raise ArgumentError, "Invariant: unexpected argument value node #{value_node.class} (#{value_node.inspect})"
+          end
+          # 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
+        new_node
       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
+      [
+        Language::Nodes::Argument,
+        Language::Nodes::Directive,
+        Language::Nodes::DirectiveDefinition,
+        Language::Nodes::DirectiveLocation,
+        Language::Nodes::Document,
+        Language::Nodes::Enum,
+        Language::Nodes::EnumTypeDefinition,
+        Language::Nodes::EnumTypeExtension,
+        Language::Nodes::EnumValueDefinition,
+        Language::Nodes::Field,
+        Language::Nodes::FieldDefinition,
+        Language::Nodes::FragmentDefinition,
+        Language::Nodes::FragmentSpread,
+        Language::Nodes::InlineFragment,
+        Language::Nodes::InputObject,
+        Language::Nodes::InputObjectTypeDefinition,
+        Language::Nodes::InputObjectTypeExtension,
+        Language::Nodes::InputValueDefinition,
+        Language::Nodes::InterfaceTypeDefinition,
+        Language::Nodes::InterfaceTypeExtension,
+        Language::Nodes::ListType,
+        Language::Nodes::NonNullType,
+        Language::Nodes::NullValue,
+        Language::Nodes::ObjectTypeDefinition,
+        Language::Nodes::ObjectTypeExtension,
+        Language::Nodes::OperationDefinition,
+        Language::Nodes::ScalarTypeDefinition,
+        Language::Nodes::ScalarTypeExtension,
+        Language::Nodes::SchemaDefinition,
+        Language::Nodes::SchemaExtension,
+        Language::Nodes::TypeName,
+        Language::Nodes::UnionTypeDefinition,
+        Language::Nodes::UnionTypeExtension,
+        Language::Nodes::VariableDefinition,
+        Language::Nodes::VariableIdentifier,
+      ].each do |ast_node_class|
+        make_visit_methods(ast_node_class)
+      end
 
       private
 
-      # 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)
+      def apply_modifications(node, parent, new_node_and_new_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]
@@ -179,7 +287,7 @@ module GraphQL
             # 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 == DELETE_NODE
+          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