graphql 1.11.4 → 1.11.5

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

@@ -66,6 +66,8 @@ module GraphQL
       # 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 = nil
 
         items.class.ancestors.each { |cls|

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
 
@@ -179,6 +179,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 +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/schema.rb

@@ -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) ?
@@ -1664,7 +1678,7 @@ module GraphQL
       end
 
       def query_stack_error(query, err)
-        query.analysis_errors.push(GraphQL::AnalysisError.new("This query is too large to execute."))
+        query.context.errors.push(GraphQL::ExecutionError.new("This query is too large to execute."))
       end
 
       private

data/lib/graphql/schema/argument.rb

@@ -45,7 +45,8 @@ module GraphQL
       # @param camelize [Boolean] if true, the name will be camelized when building the schema
       # @param from_resolver [Boolean] if true, a Resolver class defined this argument
       # @param method_access [Boolean] If false, don't build method access on legacy {Query::Arguments} instances.
-      def initialize(arg_name = nil, type_expr = nil, desc = nil, required:, type: nil, name: nil, loads: nil, description: nil, ast_node: nil, default_value: NO_DEFAULT, as: nil, from_resolver: false, camelize: true, prepare: nil, method_access: true, owner:, &definition_block)
+      # @param deprecation_reason [String]
+      def initialize(arg_name = nil, type_expr = nil, desc = nil, required:, type: nil, name: nil, loads: nil, description: nil, ast_node: nil, default_value: NO_DEFAULT, as: nil, from_resolver: false, camelize: true, prepare: nil, method_access: true, owner:, deprecation_reason: nil, &definition_block)
         arg_name ||= name
         @name = -(camelize ? Member::BuildType.camelize(arg_name.to_s) : arg_name.to_s)
         @type_expr = type_expr || type
@@ -60,6 +61,7 @@ module GraphQL
         @ast_node = ast_node
         @from_resolver = from_resolver
         @method_access = method_access
+        self.deprecation_reason = deprecation_reason
 
         if definition_block
           if definition_block.arity == 1
@@ -89,6 +91,18 @@ module GraphQL
         end
       end
 
+      # @return [String] Deprecation reason for this argument
+      def deprecation_reason(text = nil)
+        if text
+          validate_deprecated_or_optional(null: @null, deprecation_reason: text)
+          @deprecation_reason = text
+        else
+          @deprecation_reason
+        end
+      end
+
+      alias_method :deprecation_reason=, :deprecation_reason
+
       def visible?(context)
         true
       end
@@ -143,15 +157,32 @@ module GraphQL
         if NO_DEFAULT != @default_value
           argument.default_value = @default_value
         end
+        if @deprecation_reason
+          argument.deprecation_reason = @deprecation_reason
+        end
         argument
       end
 
-      attr_writer :type
+      def type=(new_type)
+        validate_input_type(new_type)
+        # This isn't true for LateBoundTypes, but we can assume those will
+        # be updated via this codepath later in schema setup.
+        if new_type.respond_to?(:non_null?)
+          validate_deprecated_or_optional(null: !new_type.non_null?, deprecation_reason: deprecation_reason)
+        end
+        @type = new_type
+      end
 
       def type
-        @type ||= Member::BuildType.parse_type(@type_expr, null: @null)
-      rescue StandardError => err
-        raise ArgumentError, "Couldn't build type for Argument #{@owner.name}.#{name}: #{err.class.name}: #{err.message}", err.backtrace
+        @type ||= begin
+          parsed_type = begin
+            Member::BuildType.parse_type(@type_expr, null: @null)
+          rescue StandardError => err
+            raise ArgumentError, "Couldn't build type for Argument #{@owner.name}.#{name}: #{err.class.name}: #{err.message}", err.backtrace
+          end
+          # Use the setter method to get validations
+          self.type = parsed_type
+        end
       end
 
       def statically_coercible?
@@ -186,6 +217,26 @@ module GraphQL
           raise "Invalid prepare for #{@owner.name}.name: #{@prepare.inspect}"
         end
       end
+
+      private
+
+      def validate_input_type(input_type)
+        if input_type.is_a?(String) || input_type.is_a?(GraphQL::Schema::LateBoundType)
+          # Do nothing; assume this will be validated later
+        elsif input_type.kind.non_null? || input_type.kind.list?
+          validate_input_type(input_type.unwrap)
+        elsif !input_type.kind.input?
+          raise ArgumentError, "Invalid input type for #{path}: #{input_type.graphql_name}. Must be scalar, enum, or input object, not #{input_type.kind.name}."
+        else
+          # It's an input type, we're OK
+        end
+      end
+
+      def validate_deprecated_or_optional(null:, deprecation_reason:)
+        if deprecation_reason && !null
+          raise ArgumentError, "Required arguments cannot be deprecated: #{path}."
+        end
+      end
     end
   end
 end

data/lib/graphql/schema/build_from_definition.rb

@@ -4,17 +4,24 @@ require "graphql/schema/build_from_definition/resolve_map"
 module GraphQL
   class Schema
     module BuildFromDefinition
+      if !String.method_defined?(:-@)
+        using GraphQL::StringDedupBackport
+      end
+
       class << self
         # @see {Schema.from_definition}
-        def from_definition(definition_string, default_resolve:, using: {}, relay: false, interpreter: true, parser: DefaultParser)
-          document = parser.parse(definition_string)
-          default_resolve ||= {}
-          Builder.build(document, default_resolve: default_resolve, relay: relay, using: using, interpreter: interpreter)
+        def from_definition(definition_string, parser: GraphQL.default_parser, **kwargs)
+          from_document(parser.parse(definition_string), **kwargs)
         end
-      end
 
-      # @api private
-      DefaultParser = GraphQL::Language::Parser
+        def from_definition_path(definition_path, parser: GraphQL.default_parser, **kwargs)
+          from_document(parser.parse_file(definition_path), **kwargs)
+        end
+
+        def from_document(document, default_resolve:, using: {}, relay: false, interpreter: true)
+          Builder.build(document, default_resolve: default_resolve || {}, relay: relay, using: using, interpreter: interpreter)
+        end
+      end
 
       # @api private
       module Builder
@@ -43,7 +50,7 @@ module GraphQL
             when GraphQL::Language::Nodes::EnumTypeDefinition
               types[definition.name] = build_enum_type(definition, type_resolver)
             when GraphQL::Language::Nodes::ObjectTypeDefinition
-              types[definition.name] = build_object_type(definition, type_resolver, default_resolve: default_resolve)
+              types[definition.name] = build_object_type(definition, type_resolver)
             when GraphQL::Language::Nodes::InterfaceTypeDefinition
               types[definition.name] = build_interface_type(definition, type_resolver)
             when GraphQL::Language::Nodes::UnionTypeDefinition
@@ -111,11 +118,11 @@ module GraphQL
             end
 
             if default_resolve.respond_to?(:resolve_type)
-              define_singleton_method(:resolve_type) do |*args|
-                default_resolve.resolve_type(*args)
+              def self.resolve_type(*args)
+                self.definition_default_resolve.resolve_type(*args)
               end
             else
-              define_singleton_method(:resolve_type) do |*args|
+              def self.resolve_type(*args)
                 NullResolveType.call(*args)
               end
             end
@@ -141,6 +148,20 @@ module GraphQL
 
             # Empty `orphan_types` -- this will make unreachable types ... unreachable.
             own_orphan_types.clear
+
+            class << self
+              attr_accessor :definition_default_resolve
+            end
+
+            self.definition_default_resolve = default_resolve
+
+            def definition_default_resolve
+              self.class.definition_default_resolve
+            end
+
+            def self.inherited(child_class)
+              child_class.definition_default_resolve = self.definition_default_resolve
+            end
           end
         end
 
@@ -182,12 +203,12 @@ module GraphQL
             ast_node(scalar_type_definition)
 
             if default_resolve.respond_to?(:coerce_input)
-              define_singleton_method(:coerce_input) do |val, ctx|
-                default_resolve.coerce_input(self, val, ctx)
+              def self.coerce_input(val, ctx)
+                ctx.schema.definition_default_resolve.coerce_input(self, val, ctx)
               end
 
-              define_singleton_method(:coerce_result) do |val, ctx|
-                default_resolve.coerce_result(self, val, ctx)
+              def self.coerce_result(val, ctx)
+                ctx.schema.definition_default_resolve.coerce_result(self, val, ctx)
               end
             end
           end
@@ -202,13 +223,10 @@ module GraphQL
           end
         end
 
-        def build_object_type(object_type_definition, type_resolver, default_resolve:)
+        def build_object_type(object_type_definition, type_resolver)
           builder = self
-          type_def = nil
-          typed_resolve_fn = ->(field, obj, args, ctx) { default_resolve.call(type_def, field, obj, args, ctx) }
 
           Class.new(GraphQL::Schema::Object) do
-            type_def = self
             graphql_name(object_type_definition.name)
             description(object_type_definition.description)
             ast_node(object_type_definition)
@@ -218,7 +236,7 @@ module GraphQL
               implements(interface_defn)
             end
 
-            builder.build_fields(self, object_type_definition.fields, type_resolver, default_resolve: typed_resolve_fn)
+            builder.build_fields(self, object_type_definition.fields, type_resolver, default_resolve: true)
           end
         end
 
@@ -247,13 +265,16 @@ module GraphQL
           end
         end
 
+        NO_DEFAULT_VALUE = {}.freeze
+
         def build_arguments(type_class, arguments, type_resolver)
           builder = self
 
           arguments.each do |argument_defn|
-            default_value_kwargs = {}
-            if !argument_defn.default_value.nil?
-              default_value_kwargs[:default_value] = builder.build_default_value(argument_defn.default_value)
+            default_value_kwargs = if !argument_defn.default_value.nil?
+              { default_value: builder.build_default_value(argument_defn.default_value) }
+            else
+              NO_DEFAULT_VALUE
             end
 
             type_class.argument(
@@ -261,6 +282,7 @@ module GraphQL
               type: type_resolver.call(argument_defn.type),
               required: false,
               description: argument_defn.description,
+              deprecation_reason: builder.build_deprecation_reason(argument_defn.directives),
               ast_node: argument_defn,
               camelize: false,
               method_access: false,
@@ -295,10 +317,10 @@ module GraphQL
         def build_fields(owner, field_definitions, type_resolver, default_resolve:)
           builder = self
 
-          field_definitions.map do |field_definition|
+          field_definitions.each do |field_definition|
             type_name = resolve_type_name(field_definition.type)
-            resolve_method_name = "resolve_field_#{field_definition.name}"
-            owner.field(
+            resolve_method_name = -"resolve_field_#{field_definition.name}"
+            schema_field_defn = owner.field(
               field_definition.name,
               description: field_definition.description,
               type: type_resolver.call(field_definition.type),
@@ -310,16 +332,19 @@ module GraphQL
               method_conflict_warning: false,
               camelize: false,
               resolver_method: resolve_method_name,
-            ) do
-              builder.build_arguments(self, field_definition.arguments, type_resolver)
-
-              # Don't do this for interfaces
-              if default_resolve
-                owner.send(:define_method, resolve_method_name) do |**args|
-                  field_instance = self.class.get_field(field_definition.name)
-                  default_resolve.call(field_instance, object, args, context)
+            )
+
+            builder.build_arguments(schema_field_defn, field_definition.arguments, type_resolver)
+
+            # Don't do this for interfaces
+            if default_resolve
+              owner.class_eval <<-RUBY, __FILE__, __LINE__
+                # frozen_string_literal: true
+                def #{resolve_method_name}(**args)
+                  field_instance = self.class.get_field("#{field_definition.name}")
+                  context.schema.definition_default_resolve.call(self.class, field_instance, object, args, context)
                 end
-              end
+              RUBY
             end
           end
         end