graphql 2.0.15 → 2.0.16

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 46b43157a331eae41dd54897d24dbc3adac190910237c7c1c158fc2bc32b6616
-  data.tar.gz: 118ac97b740ba1340d3e6b9aee5fa2f81ca25dc8769a98ec0d8e25d63e839711
+  metadata.gz: d626d72a5ae0bfb10f8fcdb9cbd781f04b5bb38b3f90b20de062a78679c254a8
+  data.tar.gz: 6793ba627f3f59a43426258e187567f391a44f8973816fb0b1e1eb7784ae19b0
 SHA512:
-  metadata.gz: be38356ecdff7f8a9627bb021e83d13ea92e951b287386e76fd6e42ff05ef0a5a37ce9c98e6e4bf1834459989558f6c8b512c98e7642bef2c624578c1db24932
-  data.tar.gz: b0b75f342dca7a731b1b59e6399d364184152ceb0c5deb9fb4338a3582b3b6e38bf789a53839f6def9eb4b9c079c45e74675fb608a184dff4e6aeaf0ce052dfd
+  metadata.gz: 5958721b08e45d886036f8afe0a5942e443117d9aa71d94450b727ec20d13b63a945a97c247f8605d4eb1ae8631ba301599e95b938355f18dc7c5bf64e2b1b44
+  data.tar.gz: 9d029e7d0288c87cc9c09e627538b5e93b3d1ec7e785914b135088ec7bafcf8172458fa1d68a95a6385786d472c7260f6bc82b719e86743b5dac1f2a87501f7c

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[: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
@@ -195,13 +204,16 @@ module GraphQL
 
       # Lookup `key` from the hash passed to {Schema#execute} as `context:`
       def [](key)
-        if RUNTIME_METADATA_KEYS.include?(key)
+        if @scoped_context.key?(key)
+          @scoped_context[key]
+        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]
-        elsif @scoped_context.key?(key)
-          @scoped_context[key]
         else
-          @provided_values[key]
+          # not found
+          nil
         end
       end
 
@@ -235,7 +247,7 @@ module GraphQL
       def dig(key, *other_keys)
         if RUNTIME_METADATA_KEYS.include?(key)
           (thread_info = Thread.current[:__graphql_runtime_info]).key?(key) &&
-            thread_info.dig(key)
+            thread_info.dig(key, *other_keys)
         elsif @scoped_context.key?(key)
           @scoped_context.dig(key, *other_keys)
         else

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

@@ -154,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

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

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

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: graphql
 version: !ruby/object:Gem::Version
-  version: 2.0.15
+  version: 2.0.16
 platform: ruby
 authors:
 - Robert Mosolgo
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2022-10-21 00:00:00.000000000 Z
+date: 2022-12-19 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: benchmark-ips
@@ -538,7 +538,6 @@ 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
@@ -598,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

data/lib/graphql/tracing/instrumentation_tracing.rb

@@ -1,83 +0,0 @@
-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