graphql 1.9.21 → 2.0.16

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,14 +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/definition_slice"
 
 module GraphQL
   module Language

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/pagination/active_record_relation_connection.rb

@@ -0,0 +1,85 @@
+# frozen_string_literal: true
+require "graphql/pagination/relation_connection"
+
+module GraphQL
+  module Pagination
+    # Customizes `RelationConnection` to work with `ActiveRecord::Relation`s.
+    class ActiveRecordRelationConnection < Pagination::RelationConnection
+      private
+
+      def relation_larger_than(relation, initial_offset, size)
+        if already_loaded?(relation)
+          (relation.size + initial_offset) > size
+        else
+          set_offset(sliced_nodes, initial_offset + size).exists?
+        end
+      end
+
+      def relation_count(relation)
+        int_or_hash = if already_loaded?(relation)
+          relation.size
+        elsif 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)
+        if relation.is_a?(Array)
+          nil
+        else
+          relation.limit_value
+        end
+      end
+
+      def relation_offset(relation)
+        if relation.is_a?(Array)
+          nil
+        else
+          relation.offset_value
+        end
+      end
+
+      def null_relation(relation)
+        if relation.respond_to?(:none)
+          relation.none
+        else
+          # Rails 3
+          relation.where("1=2")
+        end
+      end
+
+      def set_limit(nodes, limit)
+        if already_loaded?(nodes)
+          nodes.take(limit)
+        else
+          super
+        end
+      end
+
+      def set_offset(nodes, offset)
+        if already_loaded?(nodes)
+          # If the client sent a bogus cursor beyond the size of the relation,
+          # it might get `nil` from `#[...]`, so return an empty array in that case
+          nodes[offset..-1] || []
+        else
+          super
+        end
+      end
+
+      private
+
+      def already_loaded?(relation)
+        relation.is_a?(Array) || relation.loaded?
+      end
+    end
+  end
+end

data/lib/graphql/pagination/array_connection.rb

@@ -0,0 +1,79 @@
+# frozen_string_literal: true
+require "graphql/pagination/connection"
+
+module GraphQL
+  module Pagination
+    class ArrayConnection < Pagination::Connection
+      def nodes
+        load_nodes
+        @nodes
+      end
+
+      def has_previous_page
+        load_nodes
+        @has_previous_page
+      end
+
+      def has_next_page
+        load_nodes
+        @has_next_page
+      end
+
+      def cursor_for(item)
+        idx = items.find_index(item) + 1
+        encode(idx.to_s)
+      end
+
+      private
+
+      def index_from_cursor(cursor)
+        decode(cursor).to_i
+      end
+
+      # Populate all the pagination info _once_,
+      # It doesn't do anything on subsequent calls.
+      def load_nodes
+        @nodes ||= begin
+          sliced_nodes = if before && after
+            end_idx = index_from_cursor(before)-1
+            end_idx < 0 ? [] : items[index_from_cursor(after)..end_idx] || []
+          elsif before
+            end_idx = index_from_cursor(before)-2
+            end_idx < 0 ? [] : items[0..end_idx] || []
+          elsif after
+            items[index_from_cursor(after)..-1] || []
+          else
+            items
+          end
+
+          @has_previous_page = if last
+            # There are items preceding the ones in this result
+            sliced_nodes.count > last
+          elsif after
+            # We've paginated into the Array a bit, there are some behind us
+            index_from_cursor(after) > 0
+          else
+            false
+          end
+
+          @has_next_page = if first
+            # There are more items after these items
+            sliced_nodes.count > first
+          elsif before
+            # The original array is longer than the `before` index
+            index_from_cursor(before) < items.length + 1
+          else
+            false
+          end
+
+          limited_nodes = sliced_nodes
+
+          limited_nodes = limited_nodes.first(first) if first
+          limited_nodes = limited_nodes.last(last) if last
+
+          limited_nodes
+        end
+      end
+    end
+  end
+end

data/lib/graphql/pagination/connection.rb

@@ -0,0 +1,253 @@
+# frozen_string_literal: true
+
+module GraphQL
+  module Pagination
+    # A Connection wraps a list of items and provides cursor-based pagination over it.
+    #
+    # Connections were introduced by Facebook's `Relay` front-end framework, but
+    # proved to be generally useful for GraphQL APIs. When in doubt, use connections
+    # to serve lists (like Arrays, ActiveRecord::Relations) via GraphQL.
+    #
+    # Unlike the previous connection implementation, these default to bidirectional pagination.
+    #
+    # Pagination arguments and context may be provided at initialization or assigned later (see {Schema::Field::ConnectionExtension}).
+    class Connection
+      class PaginationImplementationMissingError < GraphQL::Error
+      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. `""` is treated as `nil`.
+      def before
+        if defined?(@before)
+          @before
+        else
+          @before = @before_value == "" ? nil : @before_value
+        end
+      end
+
+      # @return [String, nil] the client-provided cursor. `""` is treated as `nil`.
+      def after
+        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 and no `default_page_size` is set.
+      # @param default_page_size [Integer, nil] A configured value to determine the result size when neither first or last are given.
+      def initialize(items, parent: nil, field: nil, context: nil, first: nil, after: nil, max_page_size: :not_given, default_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
+        @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
+        @has_default_page_size_override = default_page_size != :not_given
+        @default_page_size = if default_page_size == :not_given
+          nil
+        else
+          default_page_size
+        end
+      end
+
+      def max_page_size=(new_value)
+        @has_max_page_size_override = true
+        @max_page_size = new_value
+      end
+
+      def 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
+
+      def default_page_size=(new_value)
+        @has_default_page_size_override = true
+        @default_page_size = new_value
+      end
+
+      def default_page_size
+        if @has_default_page_size_override
+          @default_page_size
+        else
+          context.schema.default_page_size
+        end
+      end
+
+      def has_default_page_size_override?
+        @has_default_page_size_override
+      end
+
+      attr_writer :first
+      # @return [Integer, nil]
+      #   A clamped `first` value.
+      #   (The underlying instance variable doesn't have limits on it.)
+      #   If neither `first` nor `last` is given, but `default_page_size` is
+      #   present, default_page_size is used for first. If `default_page_size`
+      #   is greater than `max_page_size``, it'll be clamped down to
+      #   `max_page_size`. If `default_page_size` is nil, use `max_page_size`.
+      def first
+        @first ||= begin
+          capped = limit_pagination_argument(@first_value, max_page_size)
+          if capped.nil? && last.nil?
+            capped = limit_pagination_argument(default_page_size, max_page_size) || max_page_size
+          end
+          capped
+        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
+        @last ||= limit_pagination_argument(@last_value, max_page_size)
+      end
+
+      # @return [Array<Edge>] {nodes}, but wrapped with Edge instances
+      def edges
+        @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`"
+      end
+
+      # A dynamic alias for compatibility with {Relay::BaseConnection}.
+      # @deprecated use {#nodes} instead
+      def edge_nodes
+        nodes
+      end
+
+      # The connection object itself implements `PageInfo` fields
+      def page_info
+        self
+      end
+
+      # @return [Boolean] True if there are more items after this page
+      def has_next_page
+        raise PaginationImplementationMissingError, "Implement #{self.class}#has_next_page to return the next-page check"
+      end
+
+      # @return [Boolean] True if there were items before these items
+      def has_previous_page
+        raise PaginationImplementationMissingError, "Implement #{self.class}#has_previous_page to return the previous-page check"
+      end
+
+      # @return [String] The cursor of the first item in {nodes}
+      def start_cursor
+        nodes.first && cursor_for(nodes.first)
+      end
+
+      # @return [String] The cursor of the last item in {nodes}
+      def end_cursor
+        nodes.last && cursor_for(nodes.last)
+      end
+
+      # Return a cursor for this item.
+      # @param item [Object] one of the passed in {items}, taken from {nodes}
+      # @return [String]
+      def cursor_for(item)
+        raise PaginationImplementationMissingError, "Implement #{self.class}#cursor_for(item) to return the cursor for #{item.inspect}"
+      end
+
+      private
+
+      # @param argument [nil, Integer] `first` or `last`, as provided by the client
+      # @param max_page_size [nil, Integer]
+      # @return [nil, Integer] `nil` if the input was `nil`, otherwise a value between `0` and `max_page_size`
+      def limit_pagination_argument(argument, max_page_size)
+        if argument
+          if argument < 0
+            argument = 0
+          elsif max_page_size && argument > max_page_size
+            argument = max_page_size
+          end
+        end
+        argument
+      end
+
+      def 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
+        attr_reader :node
+
+        def initialize(node, connection)
+          @connection = connection
+          @node = node
+        end
+
+        def parent
+          @connection.parent
+        end
+
+        def cursor
+          @cursor ||= @connection.cursor_for(@node)
+        end
+      end
+    end
+  end
+end