graphql 1.9.16 → 1.9.21

data/lib/graphql/query/context.rb

@@ -143,9 +143,9 @@ module GraphQL
       # Make a new context which delegates key lookup to `values`
       # @param query [GraphQL::Query] the query who owns this context
       # @param values [Hash] A hash of arbitrary values which will be accessible at query-time
-      def initialize(query:, values: , object:)
+      def initialize(query:, schema: query.schema, values:, object:)
         @query = query
-        @schema = query.schema
+        @schema = schema
         @provided_values = values || {}
         @object = object
         # Namespaced storage, where user-provided values are in `nil` namespace:
@@ -155,6 +155,7 @@ module GraphQL
         @path = []
         @value = nil
         @context = self # for SharedMethods
+        @scoped_context = {}
       end
 
       # @api private
@@ -163,15 +164,30 @@ module GraphQL
       # @api private
       attr_writer :value
 
-      def_delegators :@provided_values, :[], :[]=, :to_h, :to_hash, :key?, :fetch, :dig
-      def_delegators :@query, :trace, :interpreter?
+      # @api private
+      attr_accessor :scoped_context
 
-      # @!method [](key)
-      #   Lookup `key` from the hash passed to {Schema#execute} as `context:`
+      def_delegators :@provided_values, :[]=
+      def_delegators :to_h, :fetch, :dig
+      def_delegators :@query, :trace, :interpreter?
 
       # @!method []=(key, value)
       #   Reassign `key` to the hash passed to {Schema#execute} as `context:`
 
+      # Lookup `key` from the hash passed to {Schema#execute} as `context:`
+      def [](key)
+        return @scoped_context[key] if @scoped_context.key?(key)
+        @provided_values[key]
+      end
+
+      def to_h
+        @provided_values.merge(@scoped_context)
+      end
+      alias :to_hash :to_h
+
+      def key?(key)
+        @scoped_context.key?(key) || @provided_values.key?(key)
+      end
 
       # @return [GraphQL::Schema::Warden]
       def warden
@@ -195,6 +211,15 @@ module GraphQL
         @value = nil
       end
 
+      def scoped_merge!(hash)
+        @scoped_context = @scoped_context.merge(hash)
+      end
+
+      def scoped_set!(key, value)
+        scoped_merge!(key => value)
+        nil
+      end
+
       class FieldResolutionContext
         include SharedMethods
         include Tracing::Traceable
@@ -309,6 +334,3 @@ module GraphQL
     end
   end
 end
-
-
-GraphQL::Schema::Context = GraphQL::Query::Context

data/lib/graphql/query/null_context.rb

@@ -21,9 +21,13 @@ module GraphQL
         )
       end
 
+      def [](key); end
+
       class << self
         extend Forwardable
 
+        def [](key); end
+
         def instance
           @instance = self.new
         end

data/lib/graphql/query/variables.rb

@@ -35,7 +35,9 @@ module GraphQL
               if validation_result.valid?
                 if value_was_provided
                   # Add the variable if a value was provided
-                  memo[variable_name] = variable_type.coerce_input(provided_value, ctx)
+                  memo[variable_name] = schema.error_handler.with_error_handling(context) do
+                    variable_type.coerce_input(provided_value, ctx)
+                  end
                 elsif default_value != nil
                   # Add the variable if it wasn't provided but it has a default value (including `null`)
                   memo[variable_name] = GraphQL::Query::LiteralInput.coerce(variable_type, default_value, self)

data/lib/graphql/relay/node.rb

@@ -11,7 +11,7 @@ module GraphQL
         field = GraphQL::Types::Relay::NodeField.graphql_definition
 
         if kwargs.any? || block
-          field = field.redefine(kwargs, &block)
+          field = field.redefine(**kwargs, &block)
         end
 
         field
@@ -21,7 +21,7 @@ module GraphQL
         field = GraphQL::Types::Relay::NodesField.graphql_definition
 
         if kwargs.any? || block
-          field = field.redefine(kwargs, &block)
+          field = field.redefine(**kwargs, &block)
         end
 
         field

data/lib/graphql/schema.rb

@@ -40,6 +40,7 @@ require "graphql/schema/directive/include"
 require "graphql/schema/directive/skip"
 require "graphql/schema/directive/feature"
 require "graphql/schema/directive/transform"
+require "graphql/schema/type_membership"
 
 require "graphql/schema/resolver"
 require "graphql/schema/mutation"
@@ -98,6 +99,8 @@ module GraphQL
       mutation: ->(schema, t) { schema.mutation = t.respond_to?(:graphql_definition) ? t.graphql_definition : t },
       subscription: ->(schema, t) { schema.subscription = t.respond_to?(:graphql_definition) ? t.graphql_definition : t },
       disable_introspection_entry_points: ->(schema) { schema.disable_introspection_entry_points = true },
+      disable_schema_introspection_entry_point: ->(schema) { schema.disable_schema_introspection_entry_point = true },
+      disable_type_introspection_entry_point: ->(schema) { schema.disable_type_introspection_entry_point = true },
       directives: ->(schema, directives) { schema.directives = directives.reduce({}) { |m, d| m[d.name] = d; m } },
       directive: ->(schema, directive) { schema.directives[directive.graphql_name] = directive },
       instrument: ->(schema, type, instrumenter, after_built_ins: false) {
@@ -153,6 +156,12 @@ module GraphQL
     # [Boolean] True if this object disables the introspection entry point fields
     attr_accessor :disable_introspection_entry_points
 
+    # [Boolean] True if this object disables the __schema introspection entry point field
+    attr_accessor :disable_schema_introspection_entry_point
+
+    # [Boolean] True if this object disables the __type introspection entry point field
+    attr_accessor :disable_type_introspection_entry_point
+
     class << self
       attr_writer :default_execution_strategy
     end
@@ -202,6 +211,8 @@ module GraphQL
       @interpreter = false
       @error_bubbling = false
       @disable_introspection_entry_points = false
+      @disable_schema_introspection_entry_point = false
+      @disable_type_introspection_entry_point = false
     end
 
     # @return [Boolean] True if using the new {GraphQL::Execution::Interpreter}
@@ -271,7 +282,7 @@ module GraphQL
       query = GraphQL::Query.new(self, document: doc, context: context)
       validator_opts = { schema: self }
       rules && (validator_opts[:rules] = rules)
-      validator = GraphQL::StaticValidation::Validator.new(validator_opts)
+      validator = GraphQL::StaticValidation::Validator.new(**validator_opts)
       res = validator.validate(query)
       res[:errors]
     end
@@ -448,10 +459,11 @@ module GraphQL
 
     # @see [GraphQL::Schema::Warden] Restricted access to members of a schema
     # @param type_defn [GraphQL::InterfaceType, GraphQL::UnionType] the type whose members you want to retrieve
+    # @param context [GraphQL::Query::Context] The context for the current query
     # @return [Array<GraphQL::ObjectType>] types which belong to `type_defn` in this schema
-    def possible_types(type_defn)
+    def possible_types(type_defn, context = GraphQL::Query::NullContext)
       @possible_types ||= GraphQL::Schema::PossibleTypes.new(self)
-      @possible_types.possible_types(type_defn)
+      @possible_types.possible_types(type_defn, context)
     end
 
     # @see [GraphQL::Schema::Warden] Resticted access to root types
@@ -597,6 +609,7 @@ module GraphQL
     alias :_schema_class :class
     def_delegators :_schema_class, :visible?, :accessible?, :authorized?, :unauthorized_object, :unauthorized_field, :inaccessible_fields
     def_delegators :_schema_class, :directive
+    def_delegators :_schema_class, :error_handler
 
     # A function to call when {#execute} receives an invalid query string
     #
@@ -676,9 +689,12 @@ module GraphQL
     end
 
     # Return the GraphQL::Language::Document IDL AST for the schema
+    # @param context [Hash]
+    # @param only [<#call(member, ctx)>]
+    # @param except [<#call(member, ctx)>]
     # @return [GraphQL::Language::Document]
-    def to_document
-      GraphQL::Language::DocumentFromSchemaDefinition.new(self).document
+    def to_document(only: nil, except: nil, context: {})
+      GraphQL::Language::DocumentFromSchemaDefinition.new(self, only: only, except: except, context: context).document
     end
 
     # Return the Hash response of {Introspection::INTROSPECTION_QUERY}.
@@ -729,13 +745,15 @@ module GraphQL
         :union_memberships,
         :get_field, :root_types, :references_to, :type_from_ast,
         :possible_types,
-        :disable_introspection_entry_points=
+        :disable_introspection_entry_points=,
+        :disable_schema_introspection_entry_point=,
+        :disable_type_introspection_entry_point=
 
       def graphql_definition
         @graphql_definition ||= to_graphql
       end
 
-      def use(plugin, options = {})
+      def use(plugin, **options)
         own_plugins << [plugin, options]
       end
 
@@ -755,6 +773,8 @@ module GraphQL
         schema_defn.default_max_page_size = default_max_page_size
         schema_defn.orphan_types = orphan_types
         schema_defn.disable_introspection_entry_points = disable_introspection_entry_points?
+        schema_defn.disable_schema_introspection_entry_point = disable_schema_introspection_entry_point?
+        schema_defn.disable_type_introspection_entry_point = disable_type_introspection_entry_point?
 
         prepped_dirs = {}
         directives.each { |k, v| prepped_dirs[k] = v.graphql_definition}
@@ -910,6 +930,14 @@ module GraphQL
         @disable_introspection_entry_points = true
       end
 
+      def disable_schema_introspection_entry_point
+        @disable_schema_introspection_entry_point = true
+      end
+
+      def disable_type_introspection_entry_point
+        @disable_type_introspection_entry_point = true
+      end
+
       def disable_introspection_entry_points?
         if instance_variable_defined?(:@disable_introspection_entry_points)
           @disable_introspection_entry_points
@@ -918,6 +946,22 @@ module GraphQL
         end
       end
 
+      def disable_schema_introspection_entry_point?
+        if instance_variable_defined?(:@disable_schema_introspection_entry_point)
+          @disable_schema_introspection_entry_point
+        else
+          find_inherited_value(:disable_schema_introspection_entry_point?, false)
+        end
+      end
+
+      def disable_type_introspection_entry_point?
+        if instance_variable_defined?(:@disable_type_introspection_entry_point)
+          @disable_type_introspection_entry_point
+        else
+          find_inherited_value(:disable_type_introspection_entry_point?, false)
+        end
+      end
+
       def orphan_types(*new_orphan_types)
         if new_orphan_types.any?
           own_orphan_types.concat(new_orphan_types.flatten)
@@ -1027,6 +1071,13 @@ module GraphQL
         DefaultTypeError.call(type_err, ctx)
       end
 
+      attr_writer :error_handler
+
+      # @return [GraphQL::Execution::Errors, Class<GraphQL::Execution::Errors::NullErrorHandler>]
+      def error_handler
+        @error_handler ||= GraphQL::Execution::Errors::NullErrorHandler
+      end
+
       def lazy_resolve(lazy_class, value_method)
         lazy_classes[lazy_class] = value_method
       end

data/lib/graphql/schema/argument.rb

@@ -121,6 +121,10 @@ module GraphQL
       # Used by the runtime.
       # @api private
       def prepare_value(obj, value)
+        if value.is_a?(GraphQL::Schema::InputObject)
+          value = value.prepare
+        end
+
         if @prepare.nil?
           value
         elsif @prepare.is_a?(String) || @prepare.is_a?(Symbol)

data/lib/graphql/schema/base_64_bp.rb

@@ -10,8 +10,9 @@ module Base64Bp
   module_function
 
   def urlsafe_encode64(bin, padding:)
-    str = strict_encode64(bin).tr("+/", "-_")
-    str = str.delete("=") unless padding
+    str = strict_encode64(bin)
+    str.tr!("+/", "-_")
+    str.delete!("=") unless padding
     str
   end
 

data/lib/graphql/schema/build_from_definition.rb

@@ -183,12 +183,16 @@ module GraphQL
         def build_object_type(object_type_definition, type_resolver, default_resolve:)
           type_def = nil
           typed_resolve_fn = ->(field, obj, args, ctx) { default_resolve.call(type_def, field, obj, args, ctx) }
-          type_def = GraphQL::ObjectType.define(
+          defns = {
             name: object_type_definition.name,
             description: object_type_definition.description,
-            fields: Hash[build_fields(object_type_definition.fields, type_resolver, default_resolve: typed_resolve_fn)],
             interfaces: object_type_definition.interfaces.map{ |interface_name| type_resolver.call(interface_name) },
-          )
+          }
+          obj_fields = Hash[build_fields(object_type_definition.fields, type_resolver, default_resolve: typed_resolve_fn)]
+          if obj_fields.any?
+            defns[:fields] = obj_fields
+          end
+          type_def = GraphQL::ObjectType.define(**defns)
           type_def.ast_node = object_type_definition
           type_def
         end
@@ -246,13 +250,19 @@ module GraphQL
         end
 
         def build_directive(directive_definition, type_resolver)
-          directive = GraphQL::Directive.define(
+          directive_args = Hash[build_directive_arguments(directive_definition, type_resolver)]
+
+          defn = {
             name: directive_definition.name,
             description: directive_definition.description,
-            arguments: Hash[build_directive_arguments(directive_definition, type_resolver)],
             locations: directive_definition.locations.map { |location| location.name.to_sym },
-          )
+          }
+
+          if directive_args.any?
+            defn[:arguments] = directive_args
+          end
 
+          directive = GraphQL::Directive.define(**defn)
           directive.ast_node = directive_definition
 
           directive
@@ -317,14 +327,21 @@ module GraphQL
               [argument.name, arg]
             end]
 
-            field = GraphQL::Field.define(
+            field = nil
+
+            defns = {
               name: field_definition.name,
               description: field_definition.description,
               type: type_resolver.call(field_definition.type),
-              arguments: field_arguments,
               resolve: ->(obj, args, ctx) { default_resolve.call(field, obj, args, ctx) },
               deprecation_reason: build_deprecation_reason(field_definition.directives),
-            )
+            }
+
+            if field_arguments.any?
+              defns[:arguments] = field_arguments
+            end
+
+            field = GraphQL::Field.define(**defns)
 
             field.ast_node = field_definition
 

data/lib/graphql/schema/directive.rb

@@ -9,8 +9,14 @@ module GraphQL
     class Directive < GraphQL::Schema::Member
       extend GraphQL::Schema::Member::HasArguments
       class << self
+        # Return a name based on the class name,
+        # but downcase the first letter.
         def default_graphql_name
-          super.downcase
+          @default_graphql_name ||= begin
+            camelized_name = super
+            camelized_name[0] = camelized_name[0].downcase
+            camelized_name
+          end
         end
 
         def locations(*new_locations)

data/lib/graphql/schema/introspection_system.rb

@@ -22,7 +22,10 @@ module GraphQL
           if schema.disable_introspection_entry_points
             {}
           else
-            get_fields_from_class(class_sym: :EntryPoints)
+            entry_point_fields = get_fields_from_class(class_sym: :EntryPoints)
+            entry_point_fields.delete('__schema') if schema.disable_schema_introspection_entry_point
+            entry_point_fields.delete('__type') if schema.disable_type_introspection_entry_point
+            entry_point_fields
           end
         @dynamic_fields = get_fields_from_class(class_sym: :DynamicFields)
       end

data/lib/graphql/schema/loader.rb

@@ -118,14 +118,20 @@ module GraphQL
               }]
             )
           when "FIELD"
-            GraphQL::Field.define(
+            defns = {
               name: type["name"],
               type: type_resolver.call(type["type"]),
               description: type["description"],
-              arguments: Hash[type["args"].map { |arg|
+            }
+
+            # Avoid passing an empty hash, which warns on Ruby 2.7
+            if type["args"].any?
+              defns[:arguments] = Hash[type["args"].map { |arg|
                 [arg["name"], define_type(arg.merge("kind" => "ARGUMENT"), type_resolver)]
               }]
-            )
+            end
+
+            GraphQL::Field.define(**defns)
           when "ARGUMENT"
             kwargs = {}
             if type["defaultValue"]

data/lib/graphql/schema/member/has_fields.rb

@@ -1,5 +1,4 @@
 # frozen_string_literal: true
-require 'irb/ruby-token'
 
 module GraphQL
   class Schema
@@ -43,9 +42,7 @@ module GraphQL
         # A list of Ruby keywords.
         #
         # @api private
-        RUBY_KEYWORDS = RubyToken::TokenDefinitions.select { |definition| definition[1] == RubyToken::TkId }
-                                                   .map { |definition| definition[2] }
-                                                   .compact
+        RUBY_KEYWORDS = [:class, :module, :def, :undef, :begin, :rescue, :ensure, :end, :if, :unless, :then, :elsif, :else, :case, :when, :while, :until, :for, :break, :next, :redo, :retry, :in, :do, :return, :yield, :super, :self, :nil, :true, :false, :and, :or, :not, :alias, :defined?, :BEGIN, :END, :__LINE__, :__FILE__]
 
         # A list of GraphQL-Ruby keywords.
         #

data/lib/graphql/schema/mutation.rb

@@ -64,7 +64,7 @@ module GraphQL
 
       class << self
         # Override this method to handle legacy-style usages of `MyMutation.field`
-        def field(*args, &block)
+        def field(*args, **kwargs, &block)
           if args.empty?
             raise ArgumentError, "#{name}.field is used for adding fields to this mutation. Use `mutation: #{name}` to attach this mutation instead."
           else