graphql 1.11.4 → 1.12.1

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

data/lib/graphql/pagination/connection.rb

@@ -53,10 +53,11 @@ 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, edge_class: 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)
         @items = items
         @parent = parent
         @context = context
+        @field = field
         @first_value = first
         @after_value = after
         @last_value = last
@@ -118,6 +119,9 @@ module GraphQL
       # @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`"

data/lib/graphql/pagination/connections.rb

@@ -6,20 +6,13 @@ module GraphQL
     #
     # Attach as a plugin.
     #
-    # @example Using new default connections
-    #   class MySchema < GraphQL::Schema
-    #     use GraphQL::Pagination::Connections
-    #   end
-    #
     # @example Adding a custom wrapper
     #   class MySchema < GraphQL::Schema
-    #     use GraphQL::Pagination::Connections
     #     connections.add(MyApp::SearchResults, MyApp::SearchResultsConnection)
     #   end
     #
     # @example Removing default connection support for arrays (they can still be manually wrapped)
     #   class MySchema < GraphQL::Schema
-    #     use GraphQL::Pagination::Connections
     #     connections.delete(Array)
     #   end
     #
@@ -29,14 +22,10 @@ module GraphQL
       end
 
       def self.use(schema_defn)
-        if schema_defn.is_a?(Class)
-          schema_defn.connections = self.new(schema: schema_defn)
-        else
-          # Unwrap a `.define` object
-          schema_defn = schema_defn.target
-          schema_defn.connections = self.new(schema: schema_defn)
-          schema_defn.class.connections = schema_defn.connections
+        if schema_defn.plugins.any? { |(plugin, args)| plugin == self }
+          warn("#{self} is now the default, remove `use #{self}` from #{caller(2,1).first}")
         end
+        schema_defn.connections = self.new(schema: schema_defn)
       end
 
       def initialize(schema:)
@@ -63,9 +52,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 +60,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)
+        return items if GraphQL::Execution::Interpreter::RawValue === items
+        wrappers = context ? context.namespace(:connections)[:all_wrappers] : all_wrappers
+        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
@@ -81,6 +78,7 @@ module GraphQL
           items,
           context: context,
           parent: parent,
+          field: field,
           max_page_size: field.max_page_size || context.schema.default_max_page_size,
           first: arguments[:first],
           after: arguments[:after],

data/lib/graphql/query.rb

@@ -88,6 +88,7 @@ module GraphQL
         schema = schema.graphql_definition
       end
       @schema = schema
+      @interpreter = @schema.interpreter?
       @filter = schema.default_filter.merge(except: except, only: only)
       @context = schema.context_class.new(query: self, object: root_value, values: context)
       @warden = warden
@@ -148,7 +149,11 @@ module GraphQL
       @query_string ||= (document ? document.to_query_string : nil)
     end
 
-    def_delegators :@schema, :interpreter?
+    def interpreter?
+      @interpreter
+    end
+
+    attr_accessor :multiplex
 
     def subscription_update?
       @subscription_topic && subscription?
@@ -259,9 +264,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
 
@@ -158,6 +158,10 @@ module GraphQL
         @scoped_context = {}
       end
 
+      def dataloader
+        @dataloader ||= query.multiplex.dataloader
+      end
+
       # @api private
       attr_writer :interpreter
 
@@ -167,7 +171,10 @@ module GraphQL
       # @api private
       attr_accessor :scoped_context
 
-      def_delegators :@provided_values, :[]=
+      def []=(key, value)
+        @provided_values[key] = value
+      end
+
       def_delegators :@query, :trace, :interpreter?
 
       # @!method []=(key, value)
@@ -179,6 +186,14 @@ 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)
@@ -312,7 +327,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/serial_execution.rb

@@ -16,6 +16,7 @@ module GraphQL
       # @param query_object [GraphQL::Query] the query object for this execution
       # @return [Hash] a spec-compliant GraphQL result, as a hash
       def execute(ast_operation, root_type, query_object)
+        warn "#{self.class} will be removed in GraphQL-Ruby 2.0, please upgrade to the Interpreter: https://graphql-ruby.org/queries/interpreter.html"
         operation_resolution.resolve(
           query_object.irep_selection,
           root_type,

data/lib/graphql/query/validation_pipeline.rb

@@ -72,7 +72,7 @@ module GraphQL
         elsif @operation_name_error
           @validation_errors << @operation_name_error
         else
-          validation_result = @schema.static_validator.validate(@query, validate: @validate)
+          validation_result = @schema.static_validator.validate(@query, validate: @validate, timeout: @schema.validate_timeout)
           @validation_errors.concat(validation_result[:errors])
           @internal_representation = validation_result[:irep]
 

data/lib/graphql/relay/array_connection.rb

@@ -31,8 +31,6 @@ module GraphQL
         end
       end
 
-      private
-
       def first
         @first ||= begin
           capped = limit_pagination_argument(arguments[:first], max_page_size)
@@ -47,6 +45,8 @@ module GraphQL
         @last ||= limit_pagination_argument(arguments[:last], max_page_size)
       end
 
+      private
+
       # apply first / last limit results
       def paged_nodes
         @paged_nodes ||= begin

data/lib/graphql/relay/base_connection.rb

@@ -59,6 +59,13 @@ module GraphQL
       # @param parent [Object] The object which this collection belongs to
       # @param context [GraphQL::Query::Context] The context from the field being resolved
       def initialize(nodes, arguments, field: nil, max_page_size: nil, parent: nil, context: nil)
+        warn "GraphQL::Relay::BaseConnection (used for #{self.class}) will be removed from GraphQL-Ruby 2.0, use GraphQL::Pagination::Connections instead: https://graphql-ruby.org/pagination/overview.html"
+
+        deprecated_caller = caller(0, 10).find { |c| !c.include?("lib/graphql") }
+        if deprecated_caller
+          warn "  -> called from #{deprecated_caller}"
+        end
+
         @context = context
         @nodes = nodes
         @arguments = arguments

data/lib/graphql/relay/connection_instrumentation.rb

@@ -10,10 +10,10 @@ module GraphQL
       def self.default_arguments
         @default_arguments ||= begin
           argument_definitions = [
-              ["first", GraphQL::INT_TYPE, "Returns the first _n_ elements from the list."],
-              ["after", GraphQL::STRING_TYPE, "Returns the elements in the list that come after the specified cursor."],
-              ["last", GraphQL::INT_TYPE, "Returns the last _n_ elements from the list."],
-              ["before", GraphQL::STRING_TYPE, "Returns the elements in the list that come before the specified cursor."],
+              ["first", GraphQL::DEPRECATED_INT_TYPE, "Returns the first _n_ elements from the list."],
+              ["after", GraphQL::DEPRECATED_STRING_TYPE, "Returns the elements in the list that come after the specified cursor."],
+              ["last", GraphQL::DEPRECATED_INT_TYPE, "Returns the last _n_ elements from the list."],
+              ["before", GraphQL::DEPRECATED_STRING_TYPE, "Returns the elements in the list that come before the specified cursor."],
             ]
 
           argument_definitions.reduce({}) do |memo, arg_defn|

data/lib/graphql/relay/connection_type.rb

@@ -20,7 +20,7 @@ module GraphQL
         # Any call that would trigger `wrapped_type.ensure_defined`
         # must be inside this lazy block, otherwise we get weird
         # cyclical dependency errors :S
-        ObjectType.define do
+        ObjectType.deprecated_define do
           type_name = wrapped_type.is_a?(GraphQL::BaseType) ? wrapped_type.name : wrapped_type.graphql_name
           edge_type ||= wrapped_type.edge_type
           name("#{type_name}Connection")

data/lib/graphql/relay/mutation.rb

@@ -30,6 +30,7 @@ module GraphQL
       alias :input_fields :arguments
 
       def initialize
+        warn "GraphQL::Relay::Mutation will be removed from GraphQL-Ruby 2.0, use GraphQL::Schema::RelayClassicMutation instead: https://graphql-ruby.org/mutations/mutation_classes"
         @fields = {}
         @arguments = {}
         @has_generated_return_type = false