graphql 1.10.1 → 1.13.0

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

@@ -89,7 +89,7 @@ module GraphQL
       # @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
+        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
@@ -179,7 +179,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

data/lib/graphql/language.rb

@@ -1,10 +1,12 @@
 # frozen_string_literal: true
 require "graphql/language/block_string"
 require "graphql/language/printer"
+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"

data/lib/graphql/name_validator.rb

@@ -4,13 +4,8 @@ module GraphQL
     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)
-    end
-
-    private
-
-    def self.valid?(name)
-      name =~ VALID_NAME_REGEX
+      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/object_type.rb

@@ -2,6 +2,8 @@
 module GraphQL
   # @api deprecated
   class ObjectType < GraphQL::BaseType
+    extend Define::InstanceDefinable::DeprecatedDefine
+
     accepts_definitions :interfaces, :fields, :mutation, :relay_node_type, field: GraphQL::Define::AssignObjectField
     accepts_definitions implements: ->(type, *interfaces, inherit: false) { type.implements(interfaces, inherit: inherit) }
 
@@ -17,17 +19,15 @@ module GraphQL
     def initialize
       super
       @fields = {}
-      @interface_fields = {}
-      @dirty_interfaces = []
-      @dirty_inherited_interfaces = []
+      @clean_inherited_fields = nil
+      @structural_interface_type_memberships = []
+      @inherited_interface_type_memberships = []
     end
 
     def initialize_copy(other)
       super
-      @clean_interfaces = nil
-      @clean_inherited_interfaces = nil
-      @dirty_interfaces = other.dirty_interfaces.dup
-      @dirty_inherited_interfaces = other.dirty_inherited_interfaces.dup
+      @structural_interface_type_memberships = other.structural_interface_type_memberships.dup
+      @inherited_interface_type_memberships = other.inherited_interface_type_memberships.dup
       @fields = other.fields.dup
     end
 
@@ -35,18 +35,27 @@ module GraphQL
     # @param new_interfaces [Array<GraphQL::Interface>] interfaces that this type implements
     # @deprecated Use `implements` instead of `interfaces`.
     def interfaces=(new_interfaces)
-      @clean_interfaces = nil
-      @clean_inherited_interfaces = nil
+      @structural_interface_type_memberships = []
+      @inherited_interface_type_memberships = []
       @clean_inherited_fields = nil
-
-      @dirty_inherited_interfaces = []
-      @dirty_inherited_fields = {}
       implements(new_interfaces, inherit: true)
     end
 
-    def interfaces
-      load_interfaces
-      @clean_interfaces
+    def interfaces(ctx = GraphQL::Query::NullContext)
+      ensure_defined
+      visible_ifaces = []
+      unfiltered = ctx == GraphQL::Query::NullContext
+      [@structural_interface_type_memberships, @inherited_interface_type_memberships].each do |tms|
+        tms.each do |type_membership|
+          if unfiltered || type_membership.visible?(ctx)
+            # if this is derived from a class-based object, we have to
+            # get the `.graphql_definition` of the attached interface.
+            visible_ifaces << GraphQL::BaseType.resolve_related_type(type_membership.abstract_type)
+          end
+        end
+      end
+
+      visible_ifaces
     end
 
     def kind
@@ -71,24 +80,30 @@ module GraphQL
     # This declaration will be validated when the schema is defined.
     # @param interfaces [Array<GraphQL::Interface>] add a new interface that this type implements
     # @param inherits [Boolean] If true, copy the interfaces' field definitions to this type
-    def implements(interfaces, inherit: false)
+    def implements(interfaces, inherit: false, **options)
       if !interfaces.is_a?(Array)
         raise ArgumentError, "`implements(interfaces)` must be an array, not #{interfaces.class} (#{interfaces})"
       end
-
-      @clean_interfaces = nil
       @clean_inherited_fields = nil
-      dirty_ifaces = inherit ? @dirty_inherited_interfaces : @dirty_interfaces
-      dirty_ifaces.concat(interfaces)
+
+      type_memberships = inherit ? @inherited_interface_type_memberships : @structural_interface_type_memberships
+      interfaces.each do |iface|
+        iface = BaseType.resolve_related_type(iface)
+        if iface.is_a?(GraphQL::InterfaceType)
+          type_memberships << iface.type_membership_class.new(iface, self, **options)
+        end
+      end
     end
 
     def resolve_type_proc
       nil
     end
 
+    attr_writer :structural_interface_type_memberships
+
     protected
 
-    attr_reader :dirty_interfaces, :dirty_inherited_interfaces
+    attr_reader :structural_interface_type_memberships, :inherited_interface_type_memberships
 
     private
 
@@ -97,24 +112,18 @@ module GraphQL
     end
 
     def interface_fields
-      load_interfaces
-      @clean_inherited_fields
-    end
-
-    def load_interfaces
-      @clean_interfaces ||= begin
+      if @clean_inherited_fields
+        @clean_inherited_fields
+      else
         ensure_defined
-        clean_ifaces = normalize_interfaces(@dirty_interfaces)
-        clean_inherited_ifaces = normalize_interfaces(@dirty_inherited_interfaces)
-        inherited_fields = {}
-        clean_inherited_ifaces.each do |iface|
-          # This will be found later in schema validation:
+        @clean_inherited_fields = {}
+        @inherited_interface_type_memberships.each do |type_membership|
+          iface = GraphQL::BaseType.resolve_related_type(type_membership.abstract_type)
           if iface.is_a?(GraphQL::InterfaceType)
-            inherited_fields.merge!(iface.fields)
+            @clean_inherited_fields.merge!(iface.fields)
           end
         end
-        @clean_inherited_fields = inherited_fields
-        clean_inherited_ifaces + clean_ifaces
+        @clean_inherited_fields
       end
     end
   end

data/lib/graphql/pagination/active_record_relation_connection.rb

@@ -5,13 +5,26 @@ module GraphQL
   module Pagination
     # Customizes `RelationConnection` to work with `ActiveRecord::Relation`s.
     class ActiveRecordRelationConnection < Pagination::RelationConnection
+      private
+
+      def relation_larger_than(relation, size)
+        initial_offset = relation.offset_value || 0
+        relation.offset(initial_offset + size).exists?
+      end
+
       def relation_count(relation)
-        if relation.respond_to?(:unscope)
+        int_or_hash = if relation.respond_to?(:unscope)
           relation.unscope(:order).count(:all)
         else
           # Rails 3
           relation.count
         end
+        if int_or_hash.is_a?(Integer)
+          int_or_hash
+        else
+          # Grouped relations return count-by-group hashes
+          int_or_hash.length
+        end
       end
 
       def relation_limit(relation)

data/lib/graphql/pagination/array_connection.rb

@@ -21,7 +21,7 @@ module GraphQL
 
       def cursor_for(item)
         idx = items.find_index(item) + 1
-        context.schema.cursor_encoder.encode(idx.to_s)
+        encode(idx.to_s)
       end
 
       private
@@ -59,7 +59,7 @@ module GraphQL
             sliced_nodes.count > first
           elsif before
             # The original array is longer than the `before` index
-            index_from_cursor(before) < items.length
+            index_from_cursor(before) < items.length + 1
           else
             false
           end

data/lib/graphql/pagination/connection.rb

@@ -15,50 +15,84 @@ module GraphQL
       class PaginationImplementationMissingError < GraphQL::Error
       end
 
-      # @return [Class] The class to use for wrapping items as `edges { ... }`. Defaults to `Connection::Edge`
-      def self.edge_class
-        self::Edge
-      end
-
       # @return [Object] A list object, from the application. This is the unpaginated value passed into the connection.
       attr_reader :items
 
       # @return [GraphQL::Query::Context]
       attr_accessor :context
 
+      # @return [Object] the object this collection belongs to
+      attr_accessor :parent
+
       # Raw access to client-provided values. (`max_page_size` not applied to first or last.)
       attr_accessor :before_value, :after_value, :first_value, :last_value
 
-      # @return [String, nil] the client-provided cursor
+      # @return [String, nil] the client-provided cursor. `""` is treated as `nil`.
       def before
-        @before_value
+        if defined?(@before)
+          @before
+        else
+          @before = @before_value == "" ? nil : @before_value
+        end
       end
 
-      # @return [String, nil] the client-provided cursor
+      # @return [String, nil] the client-provided cursor. `""` is treated as `nil`.
       def after
-        @after_value
+        if defined?(@after)
+          @after
+        else
+          @after = @after_value == "" ? nil : @after_value
+        end
       end
 
+      # @return [Hash<Symbol => Object>] The field arguments from the field that returned this connection
+      attr_accessor :arguments
+
       # @param items [Object] some unpaginated collection item, like an `Array` or `ActiveRecord::Relation`
       # @param context [Query::Context]
+      # @param parent [Object] The object this collection belongs to
       # @param first [Integer, nil] The limit parameter from the client, if it provided one
       # @param after [String, nil] A cursor for pagination, if the client provided one
       # @param last [Integer, nil] Limit parameter from the client, if provided
       # @param before [String, nil] A cursor for pagination, if the client provided one.
+      # @param arguments [Hash] The arguments to the field that returned the collection wrapped by this connection
       # @param max_page_size [Integer, nil] A configured value to cap the result size. Applied as `first` if neither first or last are given.
-      def initialize(items, context: nil, first: nil, after: nil, max_page_size: nil, last: nil, before: nil)
+      def initialize(items, parent: nil, field: nil, context: nil, first: nil, after: nil, max_page_size: :not_given, last: nil, before: nil, edge_class: nil, arguments: nil)
         @items = items
+        @parent = parent
         @context = context
+        @field = field
         @first_value = first
         @after_value = after
         @last_value = last
         @before_value = before
-        @max_page_size = max_page_size
+        @arguments = arguments
+        @edge_class = edge_class || self.class::Edge
+        # This is only true if the object was _initialized_ with an override
+        # or if one is assigned later.
+        @has_max_page_size_override = max_page_size != :not_given
+        @max_page_size = if max_page_size == :not_given
+          nil
+        else
+          max_page_size
+        end
+      end
+
+      def max_page_size=(new_value)
+        @has_max_page_size_override = true
+        @max_page_size = new_value
       end
 
-      attr_writer :max_page_size
       def max_page_size
-        @max_page_size ||= context.schema.default_max_page_size
+        if @has_max_page_size_override
+          @max_page_size
+        else
+          context.schema.default_max_page_size
+        end
+      end
+
+      def has_max_page_size_override?
+        @has_max_page_size_override
       end
 
       attr_writer :first
@@ -76,6 +110,15 @@ module GraphQL
         end
       end
 
+      # This is called by `Relay::RangeAdd` -- it can be overridden
+      # when `item` needs some modifications based on this connection's state.
+      #
+      # @param item [Object] An item newly added to `items`
+      # @return [Edge]
+      def range_add_edge(item)
+        edge_class.new(item, self)
+      end
+
       attr_writer :last
       # @return [Integer, nil] A clamped `last` value. (The underlying instance variable doesn't have limits on it)
       def last
@@ -84,9 +127,15 @@ module GraphQL
 
       # @return [Array<Edge>] {nodes}, but wrapped with Edge instances
       def edges
-        @edges ||= nodes.map { |n| self.class.edge_class.new(n, self) }
+        @edges ||= nodes.map { |n| @edge_class.new(n, self) }
       end
 
+      # @return [Class] A wrapper class for edges of this connection
+      attr_accessor :edge_class
+
+      # @return [GraphQL::Schema::Field] The field this connection was returned by
+      attr_accessor :field
+
       # @return [Array<Object>] A slice of {items}, constrained by {@first_value}/{@after_value}/{@last_value}/{@before_value}
       def nodes
         raise PaginationImplementationMissingError, "Implement #{self.class}#nodes to paginate `@items`"
@@ -147,23 +196,29 @@ module GraphQL
       end
 
       def decode(cursor)
-        context.schema.cursor_encoder.decode(cursor)
+        context.schema.cursor_encoder.decode(cursor, nonce: true)
+      end
+
+      def encode(cursor)
+        context.schema.cursor_encoder.encode(cursor, nonce: true)
       end
 
       # A wrapper around paginated items. It includes a {cursor} for pagination
       # and could be extended with custom relationship-level data.
       class Edge
-        def initialize(item, connection)
+        attr_reader :node
+
+        def initialize(node, connection)
           @connection = connection
-          @item = item
+          @node = node
         end
 
-        def node
-          @item
+        def parent
+          @connection.parent
         end
 
         def cursor
-          @connection.cursor_for(@item)
+          @cursor ||= @connection.cursor_for(@node)
         end
       end
     end