graphql 1.11.1 → 1.11.6

data/lib/graphql/language/parser.y

@@ -466,6 +466,10 @@ def self.parse(query_string, filename: nil, tracer: GraphQL::Tracing::NullTracer
   self.new(query_string, filename: filename, tracer: tracer).parse_document
 end
 
+def self.parse_file(filename, tracer: GraphQL::Tracing::NullTracer)
+  self.parse(File.read(filename), filename: filename, tracer: tracer)
+end
+
 private
 
 def next_token

data/lib/graphql/language/sanitized_printer.rb

@@ -19,11 +19,12 @@ module GraphQL
 
       REDACTED = "\"<REDACTED>\""
 
-      def initialize(query)
+      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.
@@ -36,15 +37,14 @@ module GraphQL
       end
 
       def print_node(node, indent: "")
-        if node.is_a?(String)
-          type = @current_input_type.unwrap
-          # Replace any strings that aren't IDs or Enum values with REDACTED
-          if type.kind.enum? || type.graphql_name == "ID"
-            super
+        case node
+        when FalseClass, Float, Integer, String, TrueClass
+          if @current_argument && redact_argument_value?(@current_argument, node)
+            redacted_argument_value(@current_argument)
           else
-            REDACTED
+            super
           end
-        elsif node.is_a?(Array)
+        when Array
           old_input_type = @current_input_type
           if @current_input_type && @current_input_type.list?
             @current_input_type = @current_input_type.of_type
@@ -59,28 +59,57 @@ module GraphQL
         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
-        arg_def = arg_owner.arguments[argument.name]
+        old_current_argument = @current_argument
+        @current_argument = arg_owner.arguments[argument.name]
 
         old_input_type = @current_input_type
-        @current_input_type = arg_def.type.non_null? ? arg_def.type.of_type : arg_def.type
-        res = super
+        @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 print_list_type(list_type)
-        old_input_type = @current_input_type
-        @current_input_type = old_input_type.of_type
-        res = super
-        @current_input_type = old_input_type
-        res
+      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)
-        variable_value = query.variables[variable_id.name]
-        print_node(value_to_ast(variable_value, @current_input_type))
+        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: "")
@@ -132,10 +161,14 @@ module GraphQL
         old_type = @current_type
         @current_type = query.schema.public_send(operation_definition.operation_type)
 
-        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)
+        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
@@ -171,10 +204,10 @@ module GraphQL
             arguments: arguments
           )
         when "LIST"
-          if value.respond_to?(:each)
-            value.each { |v| value_to_ast(v, type.of_type) }
+          if value.is_a?(Array)
+            value.map { |v| value_to_ast(v, type.of_type) }
           else
-            [value].each { |v| value_to_ast(v, type.of_type) }
+            [value].map { |v| value_to_ast(v, type.of_type) }
           end
         when "ENUM"
           GraphQL::Language::Nodes::Enum.new(name: value)

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/name_validator.rb

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

data/lib/graphql/pagination/connection.rb

@@ -15,11 +15,6 @@ 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
 
@@ -58,7 +53,7 @@ module GraphQL
       # @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 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, parent: nil, context: nil, first: nil, after: nil, max_page_size: :not_given, last: nil, before: nil)
+      def initialize(items, parent: nil, context: nil, first: nil, after: nil, max_page_size: :not_given, last: nil, before: nil, edge_class: nil)
         @items = items
         @parent = parent
         @context = context
@@ -66,7 +61,7 @@ module GraphQL
         @after_value = after
         @last_value = last
         @before_value = before
-
+        @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
@@ -117,9 +112,12 @@ 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 [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`"

data/lib/graphql/pagination/connections.rb

@@ -63,9 +63,7 @@ module GraphQL
         all_wrappers
       end
 
-      # Used by the runtime to wrap values in connection wrappers.
-      # @api Private
-      def wrap(field, parent, items, arguments, context, wrappers: all_wrappers)
+      def wrapper_for(items, wrappers: all_wrappers)
         impl = nil
 
         items.class.ancestors.each { |cls|
@@ -73,6 +71,16 @@ module GraphQL
           break if impl
         }
 
+        impl
+      end
+
+      # Used by the runtime to wrap values in connection wrappers.
+      # @api Private
+      def wrap(field, parent, items, arguments, context, wrappers: all_wrappers)
+        return items if GraphQL::Execution::Interpreter::RawValue === items
+
+        impl = wrapper_for(items, wrappers: wrappers)
+
         if impl.nil?
           raise ImplementationMissingError, "Couldn't find a connection wrapper for #{items.class} during #{field.path} (#{items.inspect})"
         end
@@ -86,9 +94,21 @@ module GraphQL
           after: arguments[:after],
           last: arguments[:last],
           before: arguments[:before],
+          edge_class: edge_class_for_field(field),
         )
       end
 
+      # use an override if there is one
+      # @api private
+      def edge_class_for_field(field)
+        conn_type = field.type.unwrap
+        conn_type_edge_type = conn_type.respond_to?(:edge_class) && conn_type.edge_class
+        if conn_type_edge_type && conn_type_edge_type != Relay::Edge
+          conn_type_edge_type
+        else
+          nil
+        end
+      end
       protected
 
       attr_reader :wrappers

data/lib/graphql/query.rb

@@ -259,9 +259,9 @@ module GraphQL
     # - Variables inlined to the query
     # - Strings replaced with `<REDACTED>`
     # @return [String, nil] Returns nil if the query is invalid.
-    def sanitized_query_string
+    def sanitized_query_string(inline_variables: true)
       with_prepared_ast {
-        GraphQL::Language::SanitizedPrinter.new(self).sanitized_query_string
+        GraphQL::Language::SanitizedPrinter.new(self, inline_variables: inline_variables).sanitized_query_string
       }
     end
 

data/lib/graphql/query/context.rb

@@ -34,7 +34,7 @@ module GraphQL
         # Remove this child from the result value
         # (used for null propagation and skip)
         # @api private
-        def delete(child_ctx)
+        def delete_child(child_ctx)
           @value.delete(child_ctx.key)
         end
 
@@ -168,7 +168,6 @@ module GraphQL
       attr_accessor :scoped_context
 
       def_delegators :@provided_values, :[]=
-      def_delegators :to_h, :fetch, :dig
       def_delegators :@query, :trace, :interpreter?
 
       # @!method []=(key, value)
@@ -180,6 +179,34 @@ module GraphQL
         @provided_values[key]
       end
 
+      def delete(key)
+        if @scoped_context.key?(key)
+          @scoped_context.delete(key)
+        else
+          @provided_values.delete(key)
+        end
+      end
+
+      UNSPECIFIED_FETCH_DEFAULT = Object.new
+
+      def fetch(key, default = UNSPECIFIED_FETCH_DEFAULT)
+        if @scoped_context.key?(key)
+          @scoped_context[key]
+        elsif @provided_values.key?(key)
+          @provided_values[key]
+        elsif default != UNSPECIFIED_FETCH_DEFAULT
+          default
+        elsif block_given?
+          yield(self, key)
+        else
+          raise KeyError.new(key: key)
+        end
+      end
+
+      def dig(key, *other_keys)
+        @scoped_context.key?(key) ? @scoped_context.dig(key, *other_keys) : @provided_values.dig(key, *other_keys)
+      end
+
       def to_h
         @provided_values.merge(@scoped_context)
       end
@@ -293,7 +320,7 @@ module GraphQL
             end
           when GraphQL::Execution::Execute::SKIP
             @parent.skipped = true
-            @parent.delete(self)
+            @parent.delete_child(self)
           else
             @value = new_value
           end

data/lib/graphql/query/fingerprint.rb

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 
+require 'digest/sha2'
+
 module GraphQL
   class Query
     # @api private

data/lib/graphql/query/validation_pipeline.rb

@@ -90,6 +90,9 @@ module GraphQL
         end
 
         @valid = @validation_errors.empty?
+      rescue SystemStackError => err
+        @valid = false
+        @schema.query_stack_error(@query, err)
       end
 
       # If there are max_* values, add them,

data/lib/graphql/relay/range_add.rb

@@ -33,12 +33,21 @@ module GraphQL
       # @param item [Object] The newly-added item (will be wrapped in `edge_class`)
       # @param parent [Object] The owner of `collection`, will be passed to the connection if provided
       # @param context [GraphQL::Query::Context] The surrounding `ctx`, will be passed to the connection if provided (this is required for cursor encoders)
-      # @param edge_class [Class] The class to wrap `item` with
-      def initialize(collection:, item:, parent: nil, context: nil, edge_class: Relay::Edge)
-        connection_class = BaseConnection.connection_for_nodes(collection)
+      # @param edge_class [Class] The class to wrap `item` with (defaults to the connection's edge class)
+      def initialize(collection:, item:, parent: nil, context: nil, edge_class: nil)
+        if context && context.schema.new_connections?
+          conn_class = context.schema.connections.wrapper_for(collection)
+          # The rest will be added by ConnectionExtension
+          @connection = conn_class.new(collection, parent: parent, context: context, edge_class: edge_class)
+          @edge = @connection.edge_class.new(item, @connection)
+        else
+          connection_class = BaseConnection.connection_for_nodes(collection)
+          @connection = connection_class.new(collection, {}, parent: parent, context: context)
+          edge_class ||= Relay::Edge
+          @edge = edge_class.new(item, @connection)
+        end
+
         @parent = parent
-        @connection = connection_class.new(collection, {}, parent: parent, context: context)
-        @edge = edge_class.new(item, @connection)
       end
     end
   end

data/lib/graphql/schema.rb

@@ -127,7 +127,7 @@ module GraphQL
         end
       end
 
-      # @return [Symbol, nil] The method name to lazily resolve `obj`, or nil if `obj`'s class wasn't registered wtih {#lazy_resolve}.
+      # @return [Symbol, nil] The method name to lazily resolve `obj`, or nil if `obj`'s class wasn't registered with {#lazy_resolve}.
       def lazy_method_name(obj)
         lazy_methods.get(obj)
       end
@@ -789,20 +789,25 @@ module GraphQL
     # @param using [Hash] Plugins to attach to the created schema with `use(key, value)`
     # @param interpreter [Boolean] If false, the legacy {Execution::Execute} runtime will be used
     # @return [Class] the schema described by `document`
-    def self.from_definition(definition_or_path, default_resolve: nil, interpreter: true, parser: BuildFromDefinition::DefaultParser, using: {})
+    def self.from_definition(definition_or_path, default_resolve: nil, interpreter: true, parser: GraphQL.default_parser, using: {})
       # If the file ends in `.graphql`, treat it like a filepath
-      definition = if definition_or_path.end_with?(".graphql")
-        File.read(definition_or_path)
+      if definition_or_path.end_with?(".graphql")
+        GraphQL::Schema::BuildFromDefinition.from_definition_path(
+          definition_or_path,
+          default_resolve: default_resolve,
+          parser: parser,
+          using: using,
+          interpreter: interpreter,
+        )
       else
-        definition_or_path
-      end
-      GraphQL::Schema::BuildFromDefinition.from_definition(
-        definition,
-        default_resolve: default_resolve,
-        parser: parser,
-        using: using,
-        interpreter: interpreter,
-      )
+        GraphQL::Schema::BuildFromDefinition.from_definition(
+          definition_or_path,
+          default_resolve: default_resolve,
+          parser: parser,
+          using: using,
+          interpreter: interpreter,
+        )
+      end
     end
 
     # Error that is raised when [#Schema#from_definition] is passed an invalid schema definition string.
@@ -832,7 +837,7 @@ module GraphQL
     # @param except [<#call(member, ctx)>]
     # @return [Hash] GraphQL result
     def as_json(only: nil, except: nil, context: {})
-      execute(Introspection::INTROSPECTION_QUERY, only: only, except: except, context: context).to_h
+      execute(Introspection.query(include_deprecated_args: true), only: only, except: except, context: context).to_h
     end
 
     # Returns the JSON response of {Introspection::INTROSPECTION_QUERY}.
@@ -880,7 +885,7 @@ module GraphQL
       # @param except [<#call(member, ctx)>]
       # @return [Hash] GraphQL result
       def as_json(only: nil, except: nil, context: {})
-        execute(Introspection::INTROSPECTION_QUERY, only: only, except: except, context: context).to_h
+        execute(Introspection.query(include_deprecated_args: true), only: only, except: except, context: context).to_h
       end
 
       # Return the GraphQL IDL for the schema
@@ -1112,7 +1117,16 @@ module GraphQL
           if type.kind.union?
             type.possible_types(context: context)
           else
-            own_possible_types[type.graphql_name] ||
+            stored_possible_types = own_possible_types[type.graphql_name]
+            visible_possible_types = stored_possible_types.select do |possible_type|
+              next true unless type.kind.interface?
+              next true unless possible_type.kind.object?
+
+              # Use `.graphql_name` comparison to match legacy vs class-based types.
+              # When we don't need to support legacy `.define` types, use `.include?(type)` instead.
+              possible_type.interfaces(context).any? { |interface| interface.graphql_name == type.graphql_name }
+            end if stored_possible_types
+            visible_possible_types ||
               introspection_system.possible_types[type.graphql_name] ||
               (
                 superclass.respond_to?(:possible_types) ?
@@ -1534,9 +1548,9 @@ module GraphQL
 
       # Add several directives at once
       # @param new_directives [Class]
-      def directives(new_directives = nil)
-        if new_directives
-          new_directives.each { |d| directive(d) }
+      def directives(*new_directives)
+        if new_directives.any?
+          new_directives.flatten.each { |d| directive(d) }
         end
 
         find_inherited_value(:directives, default_directives).merge(own_directives)
@@ -1550,11 +1564,11 @@ module GraphQL
       end
 
       def default_directives
-        {
+        @default_directives ||= {
           "include" => GraphQL::Schema::Directive::Include,
           "skip" => GraphQL::Schema::Directive::Skip,
           "deprecated" => GraphQL::Schema::Directive::Deprecated,
-        }
+        }.freeze
       end
 
       def tracer(new_tracer)
@@ -1663,6 +1677,10 @@ module GraphQL
         end
       end
 
+      def query_stack_error(query, err)
+        query.context.errors.push(GraphQL::ExecutionError.new("This query is too large to execute."))
+      end
+
       private
 
       def lazy_methods
@@ -1783,16 +1801,7 @@ module GraphQL
           if owner.kind.union?
             # It's a union with possible_types
             # Replace the item by class name
-            owner.type_memberships.each { |tm|
-              possible_type = tm.object_type
-              if possible_type.is_a?(String) && (possible_type == type.name)
-                # This is a match of Ruby class names, not graphql names,
-                # since strings are used to refer to constants.
-                tm.object_type = type
-              elsif possible_type.is_a?(LateBoundType) && possible_type.graphql_name == type.graphql_name
-                tm.object_type = type
-              end
-            }
+            owner.assign_type_membership_object_type(type)
             own_possible_types[owner.graphql_name] = owner.possible_types
           elsif type.kind.interface? && owner.kind.object?
             new_interfaces = []