graphql 2.0.14 → 2.0.15

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: a3bc6610f88b6689ee6991a6ad3543580f9bdf1b3cb9f2f7e3f78862d76072f7
-  data.tar.gz: ce52505d6c43e330aa8e5def38719f62bdfe067274a86530c889350c64994bd0
+  metadata.gz: 46b43157a331eae41dd54897d24dbc3adac190910237c7c1c158fc2bc32b6616
+  data.tar.gz: 118ac97b740ba1340d3e6b9aee5fa2f81ca25dc8769a98ec0d8e25d63e839711
 SHA512:
-  metadata.gz: 8f3aac93aa1013c257c84521b54285719d6edb8c212a83140123902a06f3cffabc1005d2a176b723cff5677614eab7ae1617b71ce7eb403e721fcbafbe07c1e1
-  data.tar.gz: a84bf37728b5c0ff8795070fd682ac7af83e8888d47cadff5103a76ee333788c30bf78f505528fee4f868288b99dfc11d82f7c604710e13b4a7d9690eb2efe36
+  metadata.gz: be38356ecdff7f8a9627bb021e83d13ea92e951b287386e76fd6e42ff05ef0a5a37ce9c98e6e4bf1834459989558f6c8b512c98e7642bef2c624578c1db24932
+  data.tar.gz: b0b75f342dca7a731b1b59e6399d364184152ceb0c5deb9fb4338a3582b3b6e38bf789a53839f6def9eb4b9c079c45e74675fb608a184dff4e6aeaf0ce052dfd

data/lib/graphql/backtrace/table.rb

@@ -83,7 +83,7 @@ module GraphQL
           value = if top && @override_value
             @override_value
           else
-            value_at(@context.query.context.namespace(:interpreter)[:runtime], context_entry.path)
+            value_at(@context.query.context.namespace(:interpreter_runtime)[:runtime], context_entry.path)
           end
           rows << [
             "#{context_entry.ast_node ? context_entry.ast_node.position.join(":") : ""}",
@@ -112,7 +112,7 @@ module GraphQL
           if object.is_a?(GraphQL::Schema::Object)
             object = object.object
           end
-          value = value_at(context_entry.namespace(:interpreter)[:runtime], [])
+          value = value_at(context_entry.namespace(:interpreter_runtime)[:runtime], [])
           rows << [
             "#{position}",
             "#{op_type}#{op_name ? " #{op_name}" : ""}",

data/lib/graphql/dataloader.rb

@@ -289,7 +289,10 @@ module GraphQL
       fiber_locals = {}
 
       Thread.current.keys.each do |fiber_var_key|
-        fiber_locals[fiber_var_key] = Thread.current[fiber_var_key]
+        # This variable should be fresh in each new fiber
+        if fiber_var_key != :__graphql_runtime_info
+          fiber_locals[fiber_var_key] = Thread.current[fiber_var_key]
+        end
       end
 
       if @nonblocking

data/lib/graphql/execution/interpreter/runtime.rb

@@ -148,13 +148,23 @@ module GraphQL
         # @return [GraphQL::Query::Context]
         attr_reader :context
 
+        def thread_info
+          info = Thread.current[:__graphql_runtime_info]
+          if !info
+            new_ti = {}
+            info = Thread.current[:__graphql_runtime_info] = new_ti
+          end
+          info
+        end
+
         def initialize(query:)
           @query = query
           @dataloader = query.multiplex.dataloader
           @schema = query.schema
           @context = query.context
           @multiplex_context = query.multiplex.context
-          @interpreter_context = @context.namespace(:interpreter)
+          # Start this off empty:
+          Thread.current[:__graphql_runtime_info] = nil
           @response = GraphQLResultHash.new(nil, nil)
           # Identify runtime directives by checking which of this schema's directives have overridden `def self.resolve`
           @runtime_directive_names = []
@@ -680,7 +690,11 @@ module GraphQL
 
           case current_type.kind.name
           when "SCALAR", "ENUM"
-            r = current_type.coerce_result(value, context)
+            r = begin
+              current_type.coerce_result(value, context)
+            rescue StandardError => err
+              schema.handle_or_reraise(context, err)
+            end
             set_result(selection_result, result_name, r)
             r
           when "UNION", "INTERFACE"
@@ -870,17 +884,18 @@ module GraphQL
         end
 
         def set_all_interpreter_context(object, field, arguments, path)
+          ti = thread_info
           if object
-            @context[:current_object] = @interpreter_context[:current_object] = object
+            ti[:current_object] = object
           end
           if field
-            @context[:current_field] = @interpreter_context[:current_field] = field
+            ti[:current_field] = field
           end
           if arguments
-            @context[:current_arguments] = @interpreter_context[:current_arguments] = arguments
+            ti[:current_arguments] = arguments
           end
           if path
-            @context[:current_path] = @interpreter_context[:current_path] = path
+            ti[:current_path] = path
           end
         end
 
@@ -940,13 +955,11 @@ module GraphQL
         # Set this pair in the Query context, but also in the interpeter namespace,
         # for compatibility.
         def set_interpreter_context(key, value)
-          @interpreter_context[key] = value
-          @context[key] = value
+          thread_info[key] = value
         end
 
         def delete_interpreter_context(key)
-          @interpreter_context.delete(key)
-          @context.delete(key)
+          (ti = thread_info) && ti.delete(key)
         end
 
         def resolve_type(type, value, path)

data/lib/graphql/execution/interpreter.rb

@@ -68,7 +68,7 @@ module GraphQL
                           # they also have another item of state, which is private to that query
                           # in particular, assign it here:
                           runtime = Runtime.new(query: query)
-                          query.context.namespace(:interpreter)[:runtime] = runtime
+                          query.context.namespace(:interpreter_runtime)[:runtime] = runtime
 
                           query.trace("execute_query", {query: query}) do
                             runtime.run_eager
@@ -90,7 +90,7 @@ module GraphQL
                     query = multiplex.queries.length == 1 ? multiplex.queries[0] : nil
                     queries = multiplex ? multiplex.queries : [query]
                     final_values = queries.map do |query|
-                      runtime = query.context.namespace(:interpreter)[:runtime]
+                      runtime = query.context.namespace(:interpreter_runtime)[:runtime]
                       # it might not be present if the query has an error
                       runtime ? runtime.final_result : nil
                     end
@@ -99,7 +99,7 @@ module GraphQL
                       Interpreter::Resolve.resolve_all(final_values, multiplex.dataloader)
                     end
                     queries.each do |query|
-                      runtime = query.context.namespace(:interpreter)[:runtime]
+                      runtime = query.context.namespace(:interpreter_runtime)[:runtime]
                       if runtime
                         runtime.delete_interpreter_context(:current_path)
                         runtime.delete_interpreter_context(:current_field)
@@ -123,7 +123,7 @@ module GraphQL
                       end
                     else
                       result = {
-                        "data" => query.context.namespace(:interpreter)[:runtime].final_result
+                        "data" => query.context.namespace(:interpreter_runtime)[:runtime].final_result
                       }
 
                       if query.context.errors.any?

data/lib/graphql/execution/lookahead.rb

@@ -76,8 +76,8 @@ module GraphQL
       # @param field_name [String, Symbol]
       # @param arguments [Hash] Arguments which must match in the selection
       # @return [Boolean]
-      def selects?(field_name, arguments: nil)
-        selection(field_name, arguments: arguments).selected?
+      def selects?(field_name, selected_type: @selected_type, arguments: nil)
+        selection(field_name, selected_type: selected_type, arguments: arguments).selected?
       end
 
       # @return [Boolean] True if this lookahead represents a field that was requested
@@ -95,11 +95,22 @@ module GraphQL
           @query.get_field(selected_type, field_name)
         when Symbol
           # Try to avoid the `.to_s` below, if possible
-          all_fields = @query.warden.fields(selected_type)
+          all_fields = if selected_type.kind.fields?
+            @query.warden.fields(selected_type)
+          else
+            # Handle unions by checking possible
+            @query.warden
+              .possible_types(selected_type)
+              .map { |t| @query.warden.fields(t) }
+              .flatten
+          end
+
           if (match_by_orig_name = all_fields.find { |f| f.original_name == field_name })
             match_by_orig_name
           else
-            guessed_name = Schema::Member::BuildType.camelize(field_name.to_s)
+            # Symbol#name is only present on 3.0+
+            sym_s = field_name.respond_to?(:name) ? field_name.name : field_name.to_s
+            guessed_name = Schema::Member::BuildType.camelize(sym_s)
             @query.get_field(selected_type, guessed_name)
           end
         end

data/lib/graphql/introspection.rb

@@ -4,7 +4,7 @@ module GraphQL
     def self.query(include_deprecated_args: false, include_schema_description: false, include_is_repeatable: false, include_specified_by_url: false, include_is_one_of: false)
       # The introspection query to end all introspection queries, copied from
       # https://github.com/graphql/graphql-js/blob/master/src/utilities/introspectionQuery.js
-      <<-QUERY
+      <<-QUERY.gsub(/\n{2,}/, "\n")
 query IntrospectionQuery {
   __schema {
     #{include_schema_description ? "description" : ""}

data/lib/graphql/language/document_from_schema_definition.rb

@@ -44,16 +44,18 @@ module GraphQL
       end
 
       def build_schema_node
-        GraphQL::Language::Nodes::SchemaDefinition.new(
-          query: (q = warden.root_type_for_operation("query")) && q.graphql_name,
-          mutation: (m = warden.root_type_for_operation("mutation")) && m.graphql_name,
-          subscription: (s = warden.root_type_for_operation("subscription")) && s.graphql_name,
-          # This only supports directives from parsing,
-          # use a custom printer to add to this list.
-          #
+        schema_options = {
           # `@schema.directives` is covered by `build_definition_nodes`
-          directives: ast_directives(@schema),
-        )
+          directives: definition_directives(@schema, :schema_directives),
+        }
+        if !schema_respects_root_name_conventions?(@schema)
+          schema_options.merge!({
+            query: (q = warden.root_type_for_operation("query")) && q.graphql_name,
+            mutation: (m = warden.root_type_for_operation("mutation")) && m.graphql_name,
+            subscription: (s = warden.root_type_for_operation("subscription")) && s.graphql_name,
+          })
+        end
+        GraphQL::Language::Nodes::SchemaDefinition.new(schema_options)
       end
 
       def build_object_type_node(object_type)
@@ -283,7 +285,9 @@ module GraphQL
       private
 
       def include_schema_node?
-        always_include_schema || !schema_respects_root_name_conventions?(schema)
+        always_include_schema ||
+          !schema_respects_root_name_conventions?(schema) ||
+          !schema.schema_directives.empty?
       end
 
       def schema_respects_root_name_conventions?(schema)
@@ -293,14 +297,14 @@ module GraphQL
       end
 
       def directives(member)
-        definition_directives(member)
+        definition_directives(member, :directives)
       end
 
-      def definition_directives(member)
-        dirs = if !member.respond_to?(:directives) || member.directives.empty?
+      def definition_directives(member, directives_method)
+        dirs = if !member.respond_to?(directives_method) || member.directives.empty?
           []
         else
-          member.directives.map do |dir|
+          member.public_send(directives_method).map do |dir|
             args = []
             dir.arguments.argument_values.each_value do |arg_value| # rubocop:disable Development/ContextIsPassedCop -- directive instance method
               arg_defn = arg_value.definition
@@ -324,10 +328,6 @@ module GraphQL
         dirs
       end
 
-      def ast_directives(member)
-        member.ast_node ? member.ast_node.directives : []
-      end
-
       attr_reader :schema, :warden, :always_include_schema,
         :include_introspection_types, :include_built_in_directives, :include_built_in_scalars
     end

data/lib/graphql/language/printer.rb

@@ -132,10 +132,11 @@ module GraphQL
       end
 
       def print_schema_definition(schema)
-        if (schema.query.nil? || schema.query == 'Query') &&
-           (schema.mutation.nil? || schema.mutation == 'Mutation') &&
-           (schema.subscription.nil? || schema.subscription == 'Subscription') &&
-           (schema.directives.empty?)
+        has_conventional_names = (schema.query.nil? || schema.query == 'Query') &&
+          (schema.mutation.nil? || schema.mutation == 'Mutation') &&
+          (schema.subscription.nil? || schema.subscription == 'Subscription')
+
+        if has_conventional_names && schema.directives.empty?
           return
         end
 
@@ -145,14 +146,22 @@ module GraphQL
             out << "\n  "
             out << print_node(dir)
           end
-          out << "\n{"
-        else
-          out << " {\n"
+          if !has_conventional_names
+            out << "\n"
+          end
         end
-        out << "  query: #{schema.query}\n" if schema.query
-        out << "  mutation: #{schema.mutation}\n" if schema.mutation
-        out << "  subscription: #{schema.subscription}\n" if schema.subscription
-        out << "}"
+
+        if !has_conventional_names
+          if schema.directives.empty?
+            out << " "
+          end
+          out << "{\n"
+          out << "  query: #{schema.query}\n" if schema.query
+          out << "  mutation: #{schema.mutation}\n" if schema.mutation
+          out << "  subscription: #{schema.subscription}\n" if schema.subscription
+          out << "}"
+        end
+        out
       end
 
       def print_scalar_type_definition(scalar_type)

data/lib/graphql/query/context.rb

@@ -111,7 +111,7 @@ module GraphQL
         end
 
         def current_path
-          @query_context.namespace(:interpreter)[:current_path] || @no_path
+          @query_context[:current_path] || @no_path
         end
 
         def key?(key)
@@ -189,12 +189,16 @@ module GraphQL
 
       def_delegators :@query, :trace, :interpreter?
 
+      RUNTIME_METADATA_KEYS = Set.new([:current_object, :current_arguments, :current_field, :current_path])
       # @!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)
-        if @scoped_context.key?(key)
+        if RUNTIME_METADATA_KEYS.include?(key)
+          thread_info = Thread.current[:__graphql_runtime_info]
+          thread_info && thread_info[key]
+        elsif @scoped_context.key?(key)
           @scoped_context[key]
         else
           @provided_values[key]
@@ -212,7 +216,10 @@ module GraphQL
       UNSPECIFIED_FETCH_DEFAULT = Object.new
 
       def fetch(key, default = UNSPECIFIED_FETCH_DEFAULT)
-        if @scoped_context.key?(key)
+        if RUNTIME_METADATA_KEYS.include?(key)
+          (thread_info = Thread.current[:__graphql_runtime_info]) &&
+            thread_info[key]
+        elsif @scoped_context.key?(key)
           scoped_context[key]
         elsif @provided_values.key?(key)
           @provided_values[key]
@@ -226,7 +233,10 @@ module GraphQL
       end
 
       def dig(key, *other_keys)
-        if @scoped_context.key?(key)
+        if RUNTIME_METADATA_KEYS.include?(key)
+          (thread_info = Thread.current[:__graphql_runtime_info]).key?(key) &&
+            thread_info.dig(key)
+        elsif @scoped_context.key?(key)
           @scoped_context.dig(key, *other_keys)
         else
           @provided_values.dig(key, *other_keys)
@@ -259,7 +269,11 @@ module GraphQL
       # @param ns [Object] a usage-specific namespace identifier
       # @return [Hash] namespaced storage
       def namespace(ns)
-        @storage[ns]
+        if ns == :interpreter
+          self
+        else
+          @storage[ns]
+        end
       end
 
       # @return [Boolean] true if this namespace was accessed before

data/lib/graphql/schema/build_from_definition.rb

@@ -6,16 +6,16 @@ module GraphQL
     module BuildFromDefinition
       class << self
         # @see {Schema.from_definition}
-        def from_definition(definition_string, parser: GraphQL.default_parser, **kwargs)
-          from_document(parser.parse(definition_string), **kwargs)
+        def from_definition(schema_superclass, definition_string, parser: GraphQL.default_parser, **kwargs)
+          from_document(schema_superclass, parser.parse(definition_string), **kwargs)
         end
 
-        def from_definition_path(definition_path, parser: GraphQL.default_parser, **kwargs)
-          from_document(parser.parse_file(definition_path), **kwargs)
+        def from_definition_path(schema_superclass, definition_path, parser: GraphQL.default_parser, **kwargs)
+          from_document(schema_superclass, parser.parse_file(definition_path), **kwargs)
         end
 
-        def from_document(document, default_resolve:, using: {}, relay: false)
-          Builder.build(document, default_resolve: default_resolve || {}, relay: relay, using: using)
+        def from_document(schema_superclass, document, default_resolve:, using: {}, relay: false)
+          Builder.build(schema_superclass, document, default_resolve: default_resolve || {}, relay: relay, using: using)
         end
       end
 
@@ -23,7 +23,7 @@ module GraphQL
       module Builder
         extend self
 
-        def build(document, default_resolve:, using: {}, relay:)
+        def build(schema_superclass, document, default_resolve:, using: {}, relay:)
           raise InvalidDocumentError.new('Must provide a document ast.') if !document || !document.is_a?(GraphQL::Language::Nodes::Document)
 
           if default_resolve.is_a?(Hash)
@@ -36,7 +36,7 @@ module GraphQL
           end
           schema_definition = schema_defns.first
           types = {}
-          directives = {}
+          directives = schema_superclass.directives.dup
           type_resolver = build_resolve_type(types, directives, ->(type_name) { types[type_name] ||= Schema::LateBoundType.new(type_name)})
           # Make a different type resolver because we need to coerce directive arguments
           # _while_ building the schema.
@@ -65,10 +65,14 @@ module GraphQL
           # In case any directives referenced built-in types for their arguments:
           replace_late_bound_types_with_built_in(types)
 
+          schema_extensions = nil
           document.definitions.each do |definition|
             case definition
             when GraphQL::Language::Nodes::SchemaDefinition, GraphQL::Language::Nodes::DirectiveDefinition
               nil # already handled
+            when GraphQL::Language::Nodes::SchemaExtension
+              schema_extensions ||= []
+              schema_extensions << definition
             else
               # It's possible that this was already loaded by the directives
               prev_type = types[definition.name]
@@ -103,7 +107,7 @@ module GraphQL
 
           raise InvalidDocumentError.new('Must provide schema definition with query type or a type named Query.') unless query_root_type
 
-          Class.new(GraphQL::Schema) do
+          schema_class = Class.new(schema_superclass) do
             begin
               # Add these first so that there's some chance of resolving late-bound types
               orphan_types types.values
@@ -157,6 +161,14 @@ module GraphQL
               child_class.definition_default_resolve = self.definition_default_resolve
             end
           end
+
+          if schema_extensions
+            schema_extensions.each do |ext|
+              build_directives(schema_class, ext, type_resolver)
+            end
+          end
+
+          schema_class
         end
 
         NullResolveType = ->(type, obj, ctx) {
@@ -196,13 +208,18 @@ module GraphQL
 
         def build_directives(definition, ast_node, type_resolver)
           dirs = prepare_directives(ast_node, type_resolver)
-          dirs.each do |dir_class, options|
-            definition.directive(dir_class, **options)
+          dirs.each do |(dir_class, options)|
+            if definition.respond_to?(:schema_directive)
+              # it's a schema
+              definition.schema_directive(dir_class, **options)
+            else
+              definition.directive(dir_class, **options)
+            end
           end
         end
 
         def prepare_directives(ast_node, type_resolver)
-          dirs = {}
+          dirs = []
           ast_node.directives.each do |dir_node|
             if dir_node.name == "deprecated"
               # This is handled using `deprecation_reason`
@@ -210,10 +227,10 @@ module GraphQL
             else
               dir_class = type_resolver.call(dir_node.name)
               if dir_class.nil?
-                raise ArgumentError, "No definition for @#{dir_node.name} on #{ast_node.name} at #{ast_node.line}:#{ast_node.col}"
+                raise ArgumentError, "No definition for @#{dir_node.name} #{ast_node.respond_to?(:name) ? "on #{ast_node.name} " : ""}at #{ast_node.line}:#{ast_node.col}"
               end
               options = args_to_kwargs(dir_class, dir_node)
-              dirs[dir_class] = options
+              dirs << [dir_class, options]
             end
           end
           dirs
@@ -389,7 +406,6 @@ module GraphQL
             graphql_name(interface_type_definition.name)
             description(interface_type_definition.description)
             interface_type_definition.interfaces.each do |interface_name|
-              "Implements: #{interface_type_definition} -> #{interface_name}"
               interface_defn = type_resolver.call(interface_name)
               implements(interface_defn)
             end

data/lib/graphql/schema/directive/transform.rb

@@ -39,7 +39,7 @@ module GraphQL
           transform_name = arguments[:by]
           if TRANSFORMS.include?(transform_name) && return_value.respond_to?(transform_name)
             return_value = return_value.public_send(transform_name)
-            response = context.namespace(:interpreter)[:runtime].final_result
+            response = context.namespace(:interpreter_runtime)[:runtime].final_result
             *keys, last = path
             keys.each do |key|
               if response && (response = response[key])

data/lib/graphql/schema/field.rb

@@ -129,10 +129,10 @@ module GraphQL
       def connection?
         if @connection.nil?
           # Provide default based on type name
-          return_type_name = if @resolver_class && @resolver_class.type
-            Member::BuildType.to_type_name(@resolver_class.type)
-          elsif @return_type_expr
+          return_type_name = if @return_type_expr
             Member::BuildType.to_type_name(@return_type_expr)
+          elsif @resolver_class && @resolver_class.type
+            Member::BuildType.to_type_name(@resolver_class.type)
           else
             # As a last ditch, try to force loading the return type:
             type.unwrap.name

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

@@ -120,7 +120,7 @@ module GraphQL
         def camelize(string)
           return string if string == '_'
           return string unless string.include?("_")
-          camelized = string.split('_').map(&:capitalize).join
+          camelized = string.split('_').each(&:capitalize!).join
           camelized[0] = camelized[0].downcase
           if (match_data = string.match(/\A(_+)/))
             camelized = "#{match_data[0]}#{camelized}"

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

@@ -11,8 +11,7 @@ module GraphQL
         # @return [void]
         def directive(dir_class, **options)
           @own_directives ||= []
-          remove_directive(dir_class) unless dir_class.repeatable?
-          @own_directives << dir_class.new(self, **options)
+          HasDirectives.add_directive(self, @own_directives, dir_class, options)
           nil
         end
 
@@ -20,78 +19,94 @@ module GraphQL
         # @param dir_class [Class<GraphQL::Schema::Directive>]
         # @return [viod]
         def remove_directive(dir_class)
-          @own_directives && @own_directives.reject! { |d| d.is_a?(dir_class) }
+          HasDirectives.remove_directive(@own_directives, dir_class)
           nil
         end
 
         NO_DIRECTIVES = [].freeze
 
         def directives
-          case self
-          when Class
-            inherited_directives = if superclass.respond_to?(:directives)
-              superclass.directives
-            else
-              NO_DIRECTIVES
-            end
-            if inherited_directives.any? && @own_directives
-              dirs = []
-              merge_directives(dirs, inherited_directives)
-              merge_directives(dirs, @own_directives)
-              dirs
-            elsif @own_directives
-              @own_directives
-            elsif inherited_directives.any?
-              inherited_directives
-            else
-              NO_DIRECTIVES
-            end
-          when Module
-            dirs = nil
-            self.ancestors.reverse_each do |ancestor|
-              if ancestor.respond_to?(:own_directives) &&
-                  (anc_dirs = ancestor.own_directives).any?
+          HasDirectives.get_directives(self, @own_directives, :directives)
+        end
+
+        class << self
+          def add_directive(schema_member, directives, directive_class, directive_options)
+            remove_directive(directives, directive_class) unless directive_class.repeatable?
+            directives << directive_class.new(schema_member, **directive_options)
+          end
+
+          def remove_directive(directives, directive_class)
+            directives && directives.reject! { |d| d.is_a?(directive_class) }
+          end
+
+          def get_directives(schema_member, directives, directives_method)
+            case schema_member
+            when Class
+              inherited_directives = if schema_member.superclass.respond_to?(directives_method)
+                get_directives(schema_member.superclass, schema_member.superclass.public_send(directives_method), directives_method)
+              else
+                NO_DIRECTIVES
+              end
+              if inherited_directives.any? && directives
+                dirs = []
+                merge_directives(dirs, inherited_directives)
+                merge_directives(dirs, directives)
+                dirs
+              elsif directives
+                directives
+              elsif inherited_directives.any?
+                inherited_directives
+              else
+                NO_DIRECTIVES
+              end
+            when Module
+              dirs = nil
+              schema_member.ancestors.reverse_each do |ancestor|
+                if ancestor.respond_to?(:own_directives) &&
+                    (anc_dirs = ancestor.own_directives).any?
+                  dirs ||= []
+                  merge_directives(dirs, anc_dirs)
+                end
+              end
+              if directives
                 dirs ||= []
-                merge_directives(dirs, anc_dirs)
+                merge_directives(dirs, directives)
               end
+              dirs || NO_DIRECTIVES
+            when HasDirectives
+              directives || NO_DIRECTIVES
+            else
+              raise "Invariant: how could #{schema_member} not be a Class, Module, or instance of HasDirectives?"
             end
-            if own_directives
-              dirs ||= []
-              merge_directives(dirs, own_directives)
+          end
+
+          private
+
+          # Modify `target` by adding items from `dirs` such that:
+          # - Any name conflict is overriden by the incoming member of `dirs`
+          # - Any other member of `dirs` is appended
+          # @param target [Array<GraphQL::Schema::Directive>]
+          # @param dirs [Array<GraphQL::Schema::Directive>]
+          # @return [void]
+          def merge_directives(target, dirs)
+            dirs.each do |dir|
+              if (idx = target.find_index { |d| d.graphql_name == dir.graphql_name })
+                target.slice!(idx)
+                target.insert(idx, dir)
+              else
+                target << dir
+              end
             end
-            dirs || NO_DIRECTIVES
-          when HasDirectives
-            @own_directives || NO_DIRECTIVES
-          else
-            raise "Invariant: how could #{self} not be a Class, Module, or instance of HasDirectives?"
+            nil
           end
         end
 
+
         protected
 
         def own_directives
           @own_directives
         end
-
-        private
-
-        # Modify `target` by adding items from `dirs` such that:
-        # - Any name conflict is overriden by the incoming member of `dirs`
-        # - Any other member of `dirs` is appended
-        # @param target [Array<GraphQL::Schema::Directive>]
-        # @param dirs [Array<GraphQL::Schema::Directive>]
-        # @return [void]
-        def merge_directives(target, dirs)
-          dirs.each do |dir|
-            if (idx = target.find_index { |d| d.graphql_name == dir.graphql_name })
-              target.slice!(idx)
-              target.insert(idx, dir)
-            else
-              target << dir
-            end
-          end
-          nil
-        end
       end
     end
   end

data/lib/graphql/schema/resolver/has_payload_type.rb

@@ -91,7 +91,7 @@ module GraphQL
           resolver_fields = all_field_definitions
           Class.new(object_class) do
             graphql_name("#{resolver_name}Payload")
-            description("Autogenerated return type of #{resolver_name}")
+            description("Autogenerated return type of #{resolver_name}.")
             resolver_fields.each do |f|
               # Reattach the already-defined field here
               # (The field's `.owner` will still point to the mutation, not the object type, I think)

data/lib/graphql/schema/type_membership.rb

@@ -11,6 +11,9 @@ module GraphQL
       # @return [Class<GraphQL::Schema::Union>, Module<GraphQL::Schema::Interface>]
       attr_reader :abstract_type
 
+      # @return [Hash]
+      attr_reader :options
+
       # Called when an object is hooked up to an abstract type, such as {Schema::Union.possible_types}
       # or {Schema::Object.implements} (for interfaces).
       #

data/lib/graphql/schema.rb

@@ -110,9 +110,10 @@ module GraphQL
       # @param using [Hash] Plugins to attach to the created schema with `use(key, value)`
       # @return [Class] the schema described by `document`
       def from_definition(definition_or_path, default_resolve: nil, parser: GraphQL.default_parser, using: {})
-        # If the file ends in `.graphql`, treat it like a filepath
-        if definition_or_path.end_with?(".graphql")
+        # If the file ends in `.graphql` or `.graphqls`, treat it like a filepath
+        if definition_or_path.end_with?(".graphql") || definition_or_path.end_with?(".graphqls")
           GraphQL::Schema::BuildFromDefinition.from_definition_path(
+            self,
             definition_or_path,
             default_resolve: default_resolve,
             parser: parser,
@@ -120,6 +121,7 @@ module GraphQL
           )
         else
           GraphQL::Schema::BuildFromDefinition.from_definition(
+            self,
             definition_or_path,
             default_resolve: default_resolve,
             parser: parser,
@@ -738,11 +740,10 @@ module GraphQL
       def handle_or_reraise(context, err)
         handler = Execution::Errors.find_handler_for(self, err.class)
         if handler
-          runtime_info = context.namespace(:interpreter) || {}
-          obj = runtime_info[:current_object]
-          args = runtime_info[:current_arguments]
+          obj = context[:current_object]
+          args = context[:current_arguments]
           args = args && args.keyword_arguments
-          field = runtime_info[:current_field]
+          field = context[:current_field]
           if obj.is_a?(GraphQL::Schema::Object)
             obj = obj.object
           end
@@ -816,6 +817,15 @@ module GraphQL
         member.accessible?(ctx)
       end
 
+      def schema_directive(dir_class, **options)
+        @own_schema_directives ||= []
+        Member::HasDirectives.add_directive(self, @own_schema_directives, dir_class, options)
+      end
+
+      def schema_directives
+        Member::HasDirectives.get_directives(self, @own_schema_directives, :schema_directives)
+      end
+
       # This hook is called when a client tries to access one or more
       # fields that fail the `accessible?` check.
       #

data/lib/graphql/tracing/instrumentation_tracing.rb

@@ -0,0 +1,83 @@
+module GraphQL
+  module Tracing
+    class InstrumentationTracing
+      def initialize(schema)
+        @schema = schema
+      end
+
+      def trace(event, data)
+        instrumenters = nil
+        query_instrumenters = nil
+        case event
+        when "execute_multiplex"
+          instrumenters = @schema.instrumenters
+          multiplex_instrumenters = instrumenters[:multiplex]
+          query_instrumenters = instrumenters[:query]
+          call_hooks(multiplex_instrumenters, data[:multiplex], :before_multiplex, :after_multiplex) {
+            each_query_call_hooks(query_instrumenters, data[:multiplex].queries) {
+              yield
+            }
+          }
+        else
+          yield
+        end
+      end
+
+      private
+
+      # Call the before_ hooks of each query,
+      # Then yield if no errors.
+      # `call_hooks` takes care of appropriate cleanup.
+      def each_query_call_hooks(instrumenters, queries, i = 0)
+        if i >= queries.length
+          yield
+        else
+          query = queries[i]
+          call_hooks(instrumenters, query, :before_query, :after_query) {
+            each_query_call_hooks(instrumenters, queries, i + 1) {
+              yield
+            }
+          }
+        end
+      end
+
+      # Call each before hook, and if they all succeed, yield.
+      # If they don't all succeed, call after_ for each one that succeeded.
+      def call_hooks(instrumenters, object, before_hook_name, after_hook_name)
+        begin
+          successful = []
+          instrumenters.each do |instrumenter|
+            instrumenter.public_send(before_hook_name, object)
+            successful << instrumenter
+          end
+
+          # if any before hooks raise an exception, quit calling before hooks,
+          # but call the after hooks on anything that succeeded but also
+          # raise the exception that came from the before hook.
+        rescue GraphQL::ExecutionError => err
+          object.context.errors << err
+        rescue => e
+          raise call_after_hooks(successful, object, after_hook_name, e)
+        end
+
+        begin
+          yield # Call the user code
+        ensure
+          ex = call_after_hooks(successful, object, after_hook_name, nil)
+          raise ex if ex
+        end
+      end
+
+      def call_after_hooks(instrumenters, object, after_hook_name, ex)
+        instrumenters.reverse_each do |instrumenter|
+          begin
+            instrumenter.public_send(after_hook_name, object)
+          rescue => e
+            ex = e
+          end
+        end
+        ex
+      end
+    end
+  end
+end

data/lib/graphql/types/relay/node_behaviors.rb

@@ -11,7 +11,7 @@ module GraphQL
         end
 
         def default_global_id
-          context.schema.id_from_object(object, self, context)
+          context.schema.id_from_object(object, self.class, context)
         end
       end
     end

data/lib/graphql/version.rb

@@ -1,4 +1,4 @@
 # frozen_string_literal: true
 module GraphQL
-  VERSION = "2.0.14"
+  VERSION = "2.0.15"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: graphql
 version: !ruby/object:Gem::Version
-  version: 2.0.14
+  version: 2.0.15
 platform: ruby
 authors:
 - Robert Mosolgo
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2022-09-08 00:00:00.000000000 Z
+date: 2022-10-21 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: benchmark-ips
@@ -538,6 +538,7 @@ files:
 - lib/graphql/tracing/appoptics_tracing.rb
 - lib/graphql/tracing/appsignal_tracing.rb
 - lib/graphql/tracing/data_dog_tracing.rb
+- lib/graphql/tracing/instrumentation_tracing.rb
 - lib/graphql/tracing/new_relic_tracing.rb
 - lib/graphql/tracing/notifications_tracing.rb
 - lib/graphql/tracing/platform_tracing.rb