graphql 1.9.18 → 1.13.24

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/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

data/lib/graphql/object_type.rb

@@ -1,29 +1,11 @@
 # frozen_string_literal: true
 module GraphQL
-  # This type exposes fields on an object.
-  #
-  # @example defining a type for your IMDB clone
-  #   MovieType = GraphQL::ObjectType.define do
-  #     name "Movie"
-  #     description "A full-length film or a short film"
-  #     interfaces [ProductionInterface, DurationInterface]
-  #
-  #     field :runtimeMinutes, !types.Int, property: :runtime_minutes
-  #     field :director, PersonType
-  #     field :cast, CastType
-  #     field :starring, types[PersonType] do
-  #       argument :limit, types.Int
-  #       resolve ->(object, args, ctx) {
-  #         stars = object.cast.stars
-  #         args[:limit] && stars = stars.limit(args[:limit])
-  #         stars
-  #       }
-  #      end
-  #   end
-  #
+  # @api deprecated
   class ObjectType < GraphQL::BaseType
-    accepts_definitions :interfaces, :fields, :mutation, :relay_node_type, field: GraphQL::Define::AssignObjectField
-    accepts_definitions implements: ->(type, *interfaces, inherit: false) { type.implements(interfaces, inherit: inherit) }
+    extend Define::InstanceDefinable::DeprecatedDefine
+
+    deprecated_accepts_definitions :interfaces, :fields, :mutation, :relay_node_type, field: GraphQL::Define::AssignObjectField
+    deprecated_accepts_definitions implements: ->(type, *interfaces, inherit: false) { type.implements(interfaces, inherit: inherit) }
 
     attr_accessor :fields, :mutation, :relay_node_type
     ensure_defined(:fields, :mutation, :interfaces, :relay_node_type)
@@ -37,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
 
@@ -55,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
@@ -91,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
 
@@ -117,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

@@ -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,77 @@
+# 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
+            items[index_from_cursor(after)..index_from_cursor(before)-1] || []
+          elsif before
+            items[0..index_from_cursor(before)-2] || []
+          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