graphql 2.0.14 → 2.0.16

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: a3bc6610f88b6689ee6991a6ad3543580f9bdf1b3cb9f2f7e3f78862d76072f7
-  data.tar.gz: ce52505d6c43e330aa8e5def38719f62bdfe067274a86530c889350c64994bd0
+  metadata.gz: d626d72a5ae0bfb10f8fcdb9cbd781f04b5bb38b3f90b20de062a78679c254a8
+  data.tar.gz: 6793ba627f3f59a43426258e187567f391a44f8973816fb0b1e1eb7784ae19b0
 SHA512:
-  metadata.gz: 8f3aac93aa1013c257c84521b54285719d6edb8c212a83140123902a06f3cffabc1005d2a176b723cff5677614eab7ae1617b71ce7eb403e721fcbafbe07c1e1
-  data.tar.gz: a84bf37728b5c0ff8795070fd682ac7af83e8888d47cadff5103a76ee333788c30bf78f505528fee4f868288b99dfc11d82f7c604710e13b4a7d9690eb2efe36
+  metadata.gz: 5958721b08e45d886036f8afe0a5942e443117d9aa71d94450b727ec20d13b63a945a97c247f8605d4eb1ae8631ba301599e95b938355f18dc7c5bf64e2b1b44
+  data.tar.gz: 9d029e7d0288c87cc9c09e627538b5e93b3d1ec7e785914b135088ec7bafcf8172458fa1d68a95a6385786d472c7260f6bc82b719e86743b5dac1f2a87501f7c

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

@@ -93,7 +93,7 @@ module GraphQL
       class ScopedContext
         def initialize(query_context)
           @query_context = query_context
-          @path_contexts = {}
+          @scoped_contexts = {}
           @no_path = [].freeze
         end
 
@@ -106,12 +106,17 @@ module GraphQL
         end
 
         def merge!(hash)
-          current_ctx = @path_contexts[current_path] ||= {}
-          current_ctx.merge!(hash)
+          ctx = @scoped_contexts
+          current_path.each do |path_part|
+            ctx = ctx[path_part] ||= { parent: ctx }
+          end
+          this_scoped_ctx = ctx[:scoped_context] ||= {}
+          this_scoped_ctx.merge!(hash)
         end
 
         def current_path
-          @query_context.namespace(:interpreter)[:current_path] || @no_path
+          thread_info = Thread.current[:__graphql_runtime_info]
+          (thread_info && thread_info[:current_path]) || @no_path
         end
 
         def key?(key)
@@ -151,16 +156,20 @@ module GraphQL
         # Start at the current location,
         # but look up the tree for previously-assigned scoped values
         def each_present_path_ctx
-          search_path = current_path.dup
-          if (current_path_ctx = @path_contexts[search_path])
-            yield(current_path_ctx)
+          ctx = @scoped_contexts
+          current_path.each do |path_part|
+            if ctx.key?(path_part)
+              ctx = ctx[path_part]
+            else
+              break
+            end
           end
 
-          while search_path.size > 0
-            search_path.pop # look one level higher
-            if (search_path_ctx = @path_contexts[search_path])
-              yield(search_path_ctx)
+          while ctx
+            if (scoped_ctx = ctx[:scoped_context])
+              yield(scoped_ctx)
             end
+            ctx = ctx[:parent]
           end
         end
       end
@@ -189,6 +198,7 @@ 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:`
 
@@ -196,8 +206,14 @@ module GraphQL
       def [](key)
         if @scoped_context.key?(key)
           @scoped_context[key]
-        else
+        elsif @provided_values.key?(key)
           @provided_values[key]
+        elsif RUNTIME_METADATA_KEYS.include?(key)
+          thread_info = Thread.current[:__graphql_runtime_info]
+          thread_info && thread_info[key]
+        else
+          # not found
+          nil
         end
       end
 
@@ -212,7 +228,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 +245,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, *other_keys)
+        elsif @scoped_context.key?(key)
           @scoped_context.dig(key, *other_keys)
         else
           @provided_values.dig(key, *other_keys)
@@ -259,7 +281,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/rake_task.rb

@@ -23,6 +23,10 @@ module GraphQL
   # @example Invoking the task from Ruby
   #   require "rake"
   #   Rake::Task["graphql:schema:dump"].invoke
+  #
+  # @example Providing arguments to build the introspection query
+  #   require "graphql/rake_task"
+  #   GraphQL::RakeTask.new(schema_name: "MySchema", include_is_one_of: true)
   class RakeTask
     include Rake::DSL
 
@@ -37,6 +41,11 @@ module GraphQL
       directory: ".",
       idl_outfile: "schema.graphql",
       json_outfile: "schema.json",
+      include_deprecated_args: true,
+      include_schema_description: false,
+      include_is_repeatable: false,
+      include_specified_by_url: false,
+      include_is_one_of: false
     }
 
     # @return [String] Namespace for generated tasks
@@ -74,6 +83,10 @@ module GraphQL
     # @return [String] directory for IDL & JSON files
     attr_accessor :directory
 
+    # @return [Boolean] Options for additional fields in the introspection query JSON response
+    # @see GraphQL::Schema.as_json
+    attr_accessor :include_deprecated_args, :include_schema_description, :include_is_repeatable, :include_specified_by_url, :include_is_one_of
+
     # Set the parameters of this task by passing keyword arguments
     # or assigning attributes inside the block
     def initialize(options = {})
@@ -96,7 +109,21 @@ module GraphQL
     def write_outfile(method_name, file)
       schema = @load_schema.call(self)
       context = @load_context.call(self)
-      result = schema.public_send(method_name, only: @only, except: @except, context: context)
+      result = case method_name
+      when :to_json
+        schema.to_json(
+          include_is_one_of: include_is_one_of,
+          include_deprecated_args: include_deprecated_args,
+          include_is_repeatable: include_is_repeatable,
+          include_specified_by_url: include_specified_by_url,
+          include_schema_description: include_schema_description,
+          only: @only, except: @except, context: context
+        )
+      when :to_definition
+        schema.to_definition(only: @only, except: @except, context: context)
+      else
+        raise ArgumentError, "Unexpected schema dump method: #{method_name.inspect}"
+      end
       dir = File.dirname(file)
       FileUtils.mkdir_p(dir)
       if !result.end_with?("\n")

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

@@ -70,9 +70,18 @@ module GraphQL
         private
 
         def assert_valid_union_member(type_defn)
-          if type_defn.is_a?(Module) && !type_defn.is_a?(Class)
+          case type_defn
+          when Class
+            if !type_defn.kind.object?
+              raise ArgumentError, "Union possible_types can only be object types (not #{type_defn.kind.name}, #{type_defn.inspect})"
+            end
+          when Module
             # it's an interface type, defined as a module
             raise ArgumentError, "Union possible_types can only be object types (not interface types), remove #{type_defn.graphql_name} (#{type_defn.inspect})"
+          when String, GraphQL::Schema::LateBoundType
+            # Ok - assume it will get checked later
+          else
+            raise ArgumentError, "Union possible_types can only be class-based GraphQL types (not #{type_defn.inspect} (#{type_defn.class.name}))."
           end
         end
       end

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,
@@ -152,9 +154,22 @@ module GraphQL
       # @param context [Hash]
       # @param only [<#call(member, ctx)>]
       # @param except [<#call(member, ctx)>]
+      # @param include_deprecated_args [Boolean] If true, deprecated arguments will be included in the JSON response
+      # @param include_schema_description [Boolean] If true, the schema's description will be queried and included in the response
+      # @param include_is_repeatable [Boolean] If true, `isRepeatable: true|false` will be included with the schema's directives
+      # @param include_specified_by_url [Boolean] If true, scalar types' `specifiedByUrl:` will be included in the response
+      # @param include_is_one_of [Boolean] If true, `isOneOf: true|false` will be included with input objects
       # @return [Hash] GraphQL result
-      def as_json(only: nil, except: nil, context: {})
-        execute(Introspection.query(include_deprecated_args: true), only: only, except: except, context: context).to_h
+      def as_json(only: nil, except: nil, context: {}, include_deprecated_args: true, include_schema_description: false, include_is_repeatable: false, include_specified_by_url: false, include_is_one_of: false)
+        introspection_query = Introspection.query(
+          include_deprecated_args: include_deprecated_args,
+          include_schema_description: include_schema_description,
+          include_is_repeatable: include_is_repeatable,
+          include_is_one_of: include_is_one_of,
+          include_specified_by_url: include_specified_by_url,
+        )
+
+        execute(introspection_query, only: only, except: except, context: context).to_h
       end
 
       # Return the GraphQL IDL for the schema
@@ -738,11 +753,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 +830,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/static_validation/definition_dependencies.rb

@@ -127,8 +127,14 @@ module GraphQL
         # same name as if they were the same name. If _any_ of the fragments
         # with that name has a dependency, we record it.
         independent_fragment_nodes = @defdep_fragment_definitions.values.flatten - @defdep_immediate_dependencies.keys
-
+        visited_fragment_names = Set.new
         while fragment_node = independent_fragment_nodes.pop
+          if visited_fragment_names.add?(fragment_node.name)
+            # this is a new fragment name
+          else
+            # this is a duplicate fragment name
+            next
+          end
           loops += 1
           if loops > max_loops
             raise("Resolution loops exceeded the number of definitions; infinite loop detected. (Max: #{max_loops}, Current: #{loops})")

data/lib/graphql/subscriptions/action_cable_subscriptions.rb

@@ -91,7 +91,13 @@ module GraphQL
         # A per-process map of subscriptions to deliver.
         # This is provided by Rails, so let's use it
         @subscriptions = Concurrent::Map.new
-        @events = Concurrent::Map.new { |h, k| h[k] = Concurrent::Map.new { |h2, k2| h2[k2] = Concurrent::Array.new } }
+        @events = Concurrent::Map.new do |h, k|
+          h.compute_if_absent(k) do
+            Concurrent::Map.new do |h2, k2|
+              h2.compute_if_absent(k2) { Concurrent::Array.new }
+            end
+          end
+        end
         @action_cable = action_cable
         @action_cable_coder = action_cable_coder
         @serializer = serializer

data/lib/graphql/subscriptions.rb

@@ -90,6 +90,7 @@ module GraphQL
         arguments: normalized_args,
         field: field,
         scope: scope,
+        context: context,
       )
       execute_all(event, object)
     end
@@ -124,6 +125,10 @@ module GraphQL
         variables: variables,
         root_value: object,
       }
+      
+       # merge event's and query's context together
+      context.merge!(event.context) unless event.context.nil? || context.nil?
+      
       execute_options[:validate] = validate_update?(**execute_options)
       result = @schema.execute(**execute_options)
       subscriptions_context = result.context.namespace(:subscriptions)

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

@@ -50,6 +50,8 @@ module GraphQL
               null: edges_nullable,
               description: "A list of edges.",
               connection: false,
+              # Assume that the connection was scoped before this step:
+              scope: false,
             }
 
             if field_options
@@ -135,6 +137,8 @@ module GraphQL
               null: nullable,
               description: "A list of nodes.",
               connection: false,
+              # Assume that the connection was scoped before this step:
+              scope: false,
             }
             if field_options
               base_field_options.merge!(field_options)

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

@@ -13,7 +13,13 @@ module GraphQL
         end
 
         def default_relay?
-          !!@default_relay
+          if defined?(@default_relay)
+            @default_relay
+          elsif self.is_a?(Class)
+            superclass.respond_to?(:default_relay?) && superclass.default_relay?
+          else
+            false
+          end
         end
       end
     end

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

@@ -8,6 +8,7 @@ module GraphQL
           child_class.description("An edge in a connection.")
           child_class.field(:cursor, String, null: false, description: "A cursor for use in pagination.")
           child_class.extend(ClassMethods)
+          child_class.extend(GraphQL::Types::Relay::DefaultRelay)
           child_class.node_nullable(true)
         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.16"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: graphql
 version: !ruby/object:Gem::Version
-  version: 2.0.14
+  version: 2.0.16
 platform: ruby
 authors:
 - Robert Mosolgo
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2022-09-08 00:00:00.000000000 Z
+date: 2022-12-19 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: benchmark-ips
@@ -597,7 +597,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.2.33
+rubygems_version: 3.3.3
 signing_key:
 specification_version: 4
 summary: A GraphQL language and runtime for Ruby