graphql 2.3.10 → 2.3.11

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: df4f4d50869f6ef14685ae04e9020a6b1c151d9fd287af7d86d139aadfc2f105
-  data.tar.gz: 0415f6e0012b4a9517e84d5de66ebccbff41ce01b384b49c480cda7b5353d16d
+  metadata.gz: 7fd32c95924aac8818df81050ba408953617ee69edf0b1e20a16b4927e198230
+  data.tar.gz: a938a1fbde00c6ba934e63f40248b890bc7cbb6d0374d51dd138a88acbc05465
 SHA512:
-  metadata.gz: 7921e2420473405956845345b75ba8c4768e9d90cf6d96b0249844524e7c53ff00ec11ed940635a3f12c264cb52095310be4e6a642c4806362ce2e9f5fe7d15f
-  data.tar.gz: 3e33cd66559ec943b8b5e74124343918037176d1727d4ed425ccee384c3505708c848b5dac0dc04d2c68858ae9bc8717b204fe66dfee48adc981bf4a41fa284c
+  metadata.gz: 595f05e3c28c15e05e65543d48493e101d92ac1238deb0ec9682b2b853293041438652ccdab3dbb9c4242d9b93b29e10da82851f7985ac286916a77697850e0d
+  data.tar.gz: 90c3315b9d03b6c8eb4cee5e44578ec6b968cfe6de5feeaf160ecdbce2428a6a774edff7e06d7e2afaae4a5e33faeb809b629fae486ae1737bcf8bd9d298a0b1

data/lib/generators/graphql/install_generator.rb

@@ -45,6 +45,13 @@ module Graphql
     # post "/graphql", to: "graphql#execute"
     # ```
     #
+    # Add ActiveRecord::QueryLogs metadata:
+    # ```ruby
+    #   current_graphql_operation: -> { GraphQL::Current.operation_name },
+    #   current_graphql_field: -> { GraphQL::Current.field&.path },
+    #   current_dataloader_source: -> { GraphQL::Current.dataloader_source_class },
+    # ```
+    #
     # Accept a `--batch` option which adds `GraphQL::Batch` setup.
     #
     # Use `--skip-graphiql` to skip `graphiql-rails` installation.
@@ -92,6 +99,11 @@ module Graphql
         default: false,
         desc: "Use GraphQL Playground over Graphiql as IDE"
 
+      class_option :skip_query_logs,
+        type: :boolean,
+        default: false,
+        desc: "Skip ActiveRecord::QueryLogs hooks in config/application.rb"
+
       # These two options are taken from Rails' own generators'
       class_option :api,
         type: :boolean,
@@ -180,6 +192,40 @@ RUBY
           install_relay
         end
 
+        if !options[:skip_query_logs]
+          config_file = "config/application.rb"
+          current_app_rb = File.read(Rails.root.join(config_file))
+          existing_log_tags_pattern = /config.active_record.query_log_tags = \[\n?(\s*:[a-z_]+,?\s*\n?|\s*#[^\]]*\n)*/m
+          existing_log_tags = existing_log_tags_pattern.match(current_app_rb)
+          if existing_log_tags && behavior == :invoke
+            code = <<-RUBY
+      # GraphQL-Ruby query log tags:
+      current_graphql_operation: -> { GraphQL::Current.operation_name },
+      current_graphql_field: -> { GraphQL::Current.field&.path },
+      current_dataloader_source: -> { GraphQL::Current.dataloader_source_class },
+RUBY
+            if !existing_log_tags.to_s.end_with?(",")
+              code = ",\n#{code}    "
+            end
+            # Try to insert this code _after_ any plain symbol entries in the array of query log tags:
+            after_code = existing_log_tags_pattern
+          else
+            code = <<-RUBY
+    config.active_record.query_log_tags_enabled = true
+    config.active_record.query_log_tags = [
+      # Rails query log tags:
+      :application, :controller, :action, :job,
+      # GraphQL-Ruby query log tags:
+      current_graphql_operation: -> { GraphQL::Current.operation_name },
+      current_graphql_field: -> { GraphQL::Current.field&.path },
+      current_dataloader_source: -> { GraphQL::Current.dataloader_source_class },
+    ]
+RUBY
+            after_code = "class Application < Rails::Application\n"
+          end
+          insert_into_file(config_file, code, after: after_code)
+        end
+
         if gemfile_modified?
           say "Gemfile has been modified, make sure you `bundle install`"
         end

data/lib/graphql/current.rb

@@ -0,0 +1,52 @@
+# frozen_string_literal: true
+
+module GraphQL
+  # This module exposes Fiber-level runtime information.
+  #
+  # It won't work across unrelated fibers, although it will work in child Fibers.
+  #
+  # @example Setting Up ActiveRecord::QueryLogs
+  #
+  #   config.active_record.query_log_tags = [
+  #     :namespaced_controller,
+  #     :action,
+  #     :job,
+  #     # ...
+  #     {
+  #       # GraphQL runtime info:
+  #       current_graphql_operation: -> { GraphQL::Current.operation_name },
+  #       current_graphql_field: -> { GraphQL::Current.field&.path },
+  #       current_dataloader_source: -> { GraphQL::Current.dataloader_source_class },
+  #       # ...
+  #     },
+  #   ]
+  #
+  module Current
+    # @return [String, nil] Comma-joined operation names for the currently-running {Multiplex}. `nil` if all operations are anonymous.
+    def self.operation_name
+      if (m = Fiber[:__graphql_current_multiplex])
+        m.context[:__graphql_current_operation_name] ||= begin
+          names = m.queries.map { |q| q.selected_operation_name }
+          if names.all?(&:nil?)
+            nil
+          else
+            names.join(",")
+          end
+        end
+      else
+        nil
+      end
+    end
+
+    # @see GraphQL::Field#path for a string identifying this field
+    # @return [GraphQL::Field, nil] The currently-running field, if there is one.
+    def self.field
+      Thread.current[:__graphql_runtime_info]&.values&.first&.current_field
+    end
+
+    # @return [Class, nil] The currently-running {Dataloader::Source} class, if there is one.
+    def self.dataloader_source_class
+      Fiber[:__graphql_current_dataloader_source]&.class
+    end
+  end
+end

data/lib/graphql/dataloader.rb

@@ -271,7 +271,10 @@ module GraphQL
 
       if pending_sources
         spawn_fiber do
-          pending_sources.each(&:run_pending_keys)
+          pending_sources.each do |source|
+            Fiber[:__graphql_current_dataloader_source] = source
+            source.run_pending_keys
+          end
         end
       end
     end

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

@@ -8,22 +8,17 @@ module GraphQL
           @query = query
           @dataloader = query.context.dataloader
           @storage = Hash.new do |h, argument_owner|
-            args_by_parent = if argument_owner.arguments_statically_coercible?
+            h[argument_owner] = if argument_owner.arguments_statically_coercible?
               shared_values_cache = {}
               Hash.new do |h2, ignored_parent_object|
                 h2[ignored_parent_object] = shared_values_cache
-              end
+              end.compare_by_identity
             else
               Hash.new do |h2, parent_object|
-                args_by_node = {}
-                args_by_node.compare_by_identity
-                h2[parent_object] = args_by_node
-              end
+                h2[parent_object] = {}.compare_by_identity
+              end.compare_by_identity
             end
-            args_by_parent.compare_by_identity
-            h[argument_owner] = args_by_parent
-          end
-          @storage.compare_by_identity
+          end.compare_by_identity
         end
 
         def fetch(ast_node, argument_owner, parent_object)

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

@@ -53,8 +53,7 @@ module GraphQL
             end
           end
           # { Class => Boolean }
-          @lazy_cache = {}
-          @lazy_cache.compare_by_identity
+          @lazy_cache = {}.compare_by_identity
         end
 
         def final_result
@@ -727,12 +726,7 @@ module GraphQL
         end
 
         def get_current_runtime_state
-          current_state = Thread.current[:__graphql_runtime_info] ||= begin
-            per_query_state = {}
-            per_query_state.compare_by_identity
-            per_query_state
-          end
-
+          current_state = Thread.current[:__graphql_runtime_info] ||= {}.compare_by_identity
           current_state[@query] ||= CurrentState.new
         end
 

data/lib/graphql/execution/interpreter.rb

@@ -34,6 +34,7 @@ module GraphQL
           end
 
           multiplex = Execution::Multiplex.new(schema: schema, queries: queries, context: context, max_complexity: max_complexity)
+          Fiber[:__graphql_current_multiplex] = multiplex
           multiplex.current_trace.execute_multiplex(multiplex: multiplex) do
             schema = multiplex.schema
             queries = multiplex.queries
@@ -136,6 +137,7 @@ module GraphQL
               queries.map { |q| q.result_values ||= {} }
               raise
             ensure
+              Fiber[:__graphql_current_multiplex] = nil
               queries.map { |query|
                 runtime = query.context.namespace(:interpreter_runtime)[:runtime]
                 if runtime

data/lib/graphql/introspection/entry_points.rb

@@ -15,8 +15,8 @@ module GraphQL
       end
 
       def __type(name:)
-        if context.types.reachable_type?(name)
-          context.types.type(name)
+        if context.types.reachable_type?(name) && (type = context.types.type(name))
+          type
         elsif (type = context.schema.extra_types.find { |t| t.graphql_name == name })
           type
         else

data/lib/graphql/introspection/schema_type.rb

@@ -39,7 +39,7 @@ module GraphQL
       end
 
       def directives
-        @context.types.directives
+        @context.types.directives.sort_by(&:graphql_name)
       end
     end
   end

data/lib/graphql/language/nodes.rb

@@ -34,11 +34,11 @@ module GraphQL
         attr_reader :filename
 
         def line
-          @line ||= @source.line_at(@pos)
+          @line ||= @source&.line_at(@pos)
         end
 
         def col
-          @col ||= @source.column_at(@pos)
+          @col ||= @source&.column_at(@pos)
         end
 
         def definition_line

data/lib/graphql/query/context.rb

@@ -82,12 +82,14 @@ module GraphQL
         @provided_values[key] = value
       end
 
-      def_delegators :@query, :trace, :interpreter?
+      def_delegators :@query, :trace
 
       def types
-        @query.types
+        @types ||= @query.types
       end
 
+      attr_writer :types
+
       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:`

data/lib/graphql/query/null_context.rb

@@ -27,10 +27,6 @@ module GraphQL
         @warden = Schema::Warden::NullWarden.new(context: self, schema: @schema)
       end
 
-      def interpreter?
-        true
-      end
-
       def types
         @types ||= GraphQL::Schema::Warden::SchemaSubset.new(@warden)
       end

data/lib/graphql/query.rb

@@ -106,8 +106,8 @@ module GraphQL
       end
 
       if use_schema_subset
-        @schema_subset = @schema.subset_class.new(self)
-        @warden = Schema::Warden::NullWarden.new(context: self, schema: @schema)
+        @schema_subset = @schema.subset_class.new(context: @context, schema: @schema)
+        @warden = Schema::Warden::NullWarden.new(context: @context, schema: @schema)
       else
         @schema_subset = nil
         @warden = warden
@@ -187,10 +187,6 @@ module GraphQL
       @query_string ||= (document ? document.to_query_string : nil)
     end
 
-    def interpreter?
-      true
-    end
-
     attr_accessor :multiplex
 
     # @return [GraphQL::Tracing::Trace]

data/lib/graphql/schema/build_from_definition.rb

@@ -127,11 +127,12 @@ module GraphQL
           builder = self
 
           found_types = types.values
+          object_types = found_types.select { |t| t.respond_to?(:kind) && t.kind.object? }
           schema_class = Class.new(schema_superclass) do
             begin
               # Add these first so that there's some chance of resolving late-bound types
               add_type_and_traverse(found_types, root: false)
-              orphan_types(found_types.select { |t| t.respond_to?(:kind) && t.kind.object? })
+              orphan_types(object_types)
               query query_root_type
               mutation mutation_root_type
               subscription subscription_root_type
@@ -141,6 +142,12 @@ module GraphQL
               raise InvalidDocumentError, "Type \"#{type_name}\" not found in document.", err_backtrace
             end
 
+            object_types.each do |t|
+              t.interfaces.each do |int_t|
+                int_t.orphan_types(t)
+              end
+            end
+
             if default_resolve.respond_to?(:resolve_type)
               def self.resolve_type(*args)
                 self.definition_default_resolve.resolve_type(*args)

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

@@ -7,7 +7,7 @@ module GraphQL
       # In this case, the server hides types and fields _entirely_, unless the current context has certain `:flags` present.
       class Flagged < GraphQL::Schema::Directive
         def initialize(target, **options)
-          if target.is_a?(Module) && !target.ancestors.include?(VisibleByFlag)
+          if target.is_a?(Module)
             # This is type class of some kind, `include` will put this module
             # in between the type class itself and its super class, so `super` will work fine
             target.include(VisibleByFlag)

data/lib/graphql/schema/field/connection_extension.rb

@@ -50,7 +50,7 @@ module GraphQL
               if field.has_default_page_size? && !value.has_default_page_size_override?
                 value.default_page_size = field.default_page_size
               end
-              if context.schema.new_connections? && (custom_t = context.schema.connections.edge_class_for_field(@field))
+              if (custom_t = context.schema.connections.edge_class_for_field(@field))
                 value.edge_class = custom_t
               end
               value

data/lib/graphql/schema/interface.rb

@@ -82,13 +82,29 @@ module GraphQL
           super
         end
 
+        # Register other Interface or Object types as implementers of this Interface.
+        #
+        # When those Interfaces or Objects aren't used as the return values of fields,
+        # they may have to be registered using this method so that GraphQL-Ruby can find them.
+        # @param types [Class, Module]
+        # @return [Array<Module, Class>] Implementers of this interface, if they're registered
         def orphan_types(*types)
           if types.any?
-            @orphan_types = types
+            @orphan_types ||= []
+            @orphan_types.concat(types)
           else
-            all_orphan_types = @orphan_types || []
-            all_orphan_types += super if defined?(super)
-            all_orphan_types.uniq
+            if defined?(@orphan_types)
+              all_orphan_types = @orphan_types.dup
+              if defined?(super)
+                all_orphan_types += super
+                all_orphan_types.uniq!
+              end
+              all_orphan_types
+            elsif defined?(super)
+              super
+            else
+              EmptyObjects::EMPTY_ARRAY
+            end
           end
         end
 

data/lib/graphql/schema/introspection_system.rb

@@ -25,7 +25,7 @@ module GraphQL
           load_constant(:DirectiveLocationEnum)
         ]
         @types = {}
-        @possible_types = {}.tap(&:compare_by_identity)
+        @possible_types = {}.compare_by_identity
         type_defns.each do |t|
           @types[t.graphql_name] = t
           @possible_types[t] = [t]
@@ -90,7 +90,8 @@ module GraphQL
       def resolve_late_binding(late_bound_type)
         case late_bound_type
         when GraphQL::Schema::LateBoundType
-          @schema.get_type(late_bound_type.name)
+          type_name = late_bound_type.name
+          @types[type_name] || @schema.get_type(type_name)
         when GraphQL::Schema::List
           resolve_late_binding(late_bound_type.of_type).to_list_type
         when GraphQL::Schema::NonNull

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

@@ -198,9 +198,13 @@ module GraphQL
         end
 
         def all_argument_definitions
-          all_defns = own_arguments.values
-          all_defns.flatten!
-          all_defns
+          if own_arguments.any?
+            all_defns = own_arguments.values
+            all_defns.flatten!
+            all_defns
+          else
+            EmptyObjects::EMPTY_ARRAY
+          end
         end
 
         # @return [GraphQL::Schema::Argument, nil] Argument defined on this thing, fetched by name.