graphql 2.5.18 → 2.5.20

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 3512540a3ee54e940cc015c0bd3931895b376d8c01550e8c1aedc2244937dd54
-  data.tar.gz: d988a0eeca9a38d914a0def3409e8dc89025420de492a632bc5a63a8203d89d2
+  metadata.gz: fab0bc8a5ed6bcbe53f688f9d0209a7c05808f9dd35fe487407825ee7b5b4000
+  data.tar.gz: 460c780b3ccc6c3b173aef304448c13c84e7f3e28f6b1eb2785e483ee615c848
 SHA512:
-  metadata.gz: 4ab540f193797624203186b0008a05fbfcea52975b6cf9cd078a4a1f275c076526b2ac76fedcd281164fe199a1dee82800636f23ce2f998a8d1a61d623c1c6c0
-  data.tar.gz: fd5a869314ee4a8cf3d6b0019bc1f91908a03425f5c8a6d1618e8a6f95570782a59d014a048a4f526a7e15539d5179db2c5e78c1fd0a79aef7f2104d5532db23
+  metadata.gz: 8919741b4446074f12cba8aba4ce72b97bb40e400f969d056629c57f3b94d57bc00cdb187784dec5eda4ce4e6c937e1ea856b7505ad40ce0692b2c2c596df43e
+  data.tar.gz: a559f8b81eb3148a85cc6e7aeb86023efb4f93ee9230fb72dc9e631e9cda7ae88dd05ab10af250bde8d4620eeb34804b4c81f78c30c58e9c670c58bd26090d01

data/lib/generators/graphql/detailed_trace_generator.rb

@@ -0,0 +1,77 @@
+# frozen_string_literal: true
+require 'rails/generators/active_record'
+
+module Graphql
+  module Generators
+    class DetailedTraceGenerator < ::Rails::Generators::Base
+      include ::Rails::Generators::Migration
+      desc "Install GraphQL::Tracing::DetailedTrace for your schema"
+      source_root File.expand_path('../templates', __FILE__)
+
+      class_option :redis,
+        type: :boolean,
+        default: false,
+        desc: "Use Redis for persistence instead of ActiveRecord"
+
+      def self.next_migration_number(dirname)
+        ::ActiveRecord::Generators::Base.next_migration_number(dirname)
+      end
+
+      def install_detailed_traces
+
+        schema_glob = File.expand_path("app/graphql/*_schema.rb", destination_root)
+        schema_file = Dir.glob(schema_glob).first
+        if !schema_file
+          raise ArgumentError, "Failed to find schema definition file (checked: #{schema_glob.inspect})"
+        end
+        schema_file_match = /( *)class ([A-Za-z:]+) < GraphQL::Schema/.match(File.read(schema_file))
+        schema_name = schema_file_match[2]
+        indent = schema_file_match[1] + "  "
+
+        if !options.redis?
+          migration_template 'create_graphql_detailed_traces.erb', 'db/migrate/create_graphql_detailed_traces.rb'
+        end
+
+        log :add_detailed_traces_plugin
+        sentinel = /< GraphQL::Schema\s*\n/m
+        code = <<-RUBY
+#{indent}use GraphQL::Tracing::DetailedTrace#{options.redis? ? ", redis: raise(\"TODO: pass a connection to a persistent redis database\")" : ""}, limit: 50
+
+#{indent}# When this returns true, DetailedTrace will trace the query
+#{indent}# Could use `query.context`, `query.selected_operation_name`, `query.query_string` here
+#{indent}# Could call out to Flipper, etc
+#{indent}def self.detailed_trace?(query)
+#{indent}  rand <= 0.000_1 # one in ten thousand
+#{indent}end
+
+        RUBY
+
+        in_root do
+          inject_into_file schema_file, code, after: sentinel, force: false
+        end
+
+        routes_source = File.read(File.expand_path("config/routes.rb", destination_root))
+        already_has_dashboard = routes_source.include?("GraphQL::Dashboard") ||
+          routes_source.include?("Schema.dashboard") ||
+          routes_source.include?("GraphQL::Pro::Routes::Lazy")
+
+        if (!already_has_dashboard || behavior == :revoke)
+          log :route, "GraphQL::Dashboard"
+          shell.mute do
+            route <<~RUBY
+            # TODO: add authorization to this route and expose it in production
+            # See https://graphql-ruby.org/pro/dashboard.html#authorizing-the-dashboard
+            if Rails.env.development?
+              mount GraphQL::Dashboard, at: "/graphql/dashboard", schema: #{schema_name.inspect}
+            end
+
+            RUBY
+          end
+
+          gem("google-protobuf")
+
+        end
+      end
+    end
+  end
+end

data/lib/generators/graphql/templates/create_graphql_detailed_traces.erb

@@ -0,0 +1,10 @@
+class CreateGraphqlDetailedTraces < ActiveRecord::Migration[<%= ActiveRecord::Migration.current_version %>]
+  def change
+    create_table :graphql_detailed_traces, force: true do |t|
+      t.bigint :begin_ms, null: false
+      t.float :duration_ms, null: false
+      t.binary :trace_data, null: false
+      t.string :operation_name, null: false
+    end
+  end
+end

data/lib/graphql/dashboard/application_controller.rb

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+require "action_controller"
+
+module Graphql
+  class Dashboard < Rails::Engine
+    class ApplicationController < ActionController::Base
+      protect_from_forgery with: :exception
+      prepend_view_path(File.expand_path("../views", __FILE__))
+
+      content_security_policy do |policy|
+        policy.default_src(:self) if policy.default_src(*policy.default_src).blank?
+        policy.connect_src(:self) if policy.connect_src(*policy.connect_src).blank?
+        policy.base_uri(:none) if policy.base_uri(*policy.base_uri).blank?
+        policy.font_src(:self) if policy.font_src(*policy.font_src).blank?
+        policy.img_src(:self, :data) if policy.img_src(*policy.img_src).blank?
+        policy.object_src(:none) if policy.object_src(*policy.object_src).blank?
+        policy.script_src(:self) if policy.script_src(*policy.script_src).blank?
+        policy.style_src(:self) if policy.style_src(*policy.style_src).blank?
+        policy.form_action(:self) if policy.form_action(*policy.form_action).blank?
+        policy.frame_ancestors(:none) if policy.frame_ancestors(*policy.frame_ancestors).blank?
+      end
+
+      def schema_class
+        @schema_class ||= begin
+          schema_param = request.query_parameters["schema"] || params[:schema]
+          case schema_param
+          when Class
+            schema_param
+          when String
+            schema_param.constantize
+          else
+            raise "Missing `params[:schema]`, please provide a class or string to `mount GraphQL::Dashboard, schema: ...`"
+          end
+        end
+      end
+      helper_method :schema_class
+    end
+  end
+end
+
+ActiveSupport.run_load_hooks(:graphql_dashboard_application_controller, GraphQL::Dashboard::ApplicationController)

data/lib/graphql/dashboard/landings_controller.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+module Graphql
+  class Dashboard < Rails::Engine
+    class LandingsController < ApplicationController
+      def show
+      end
+    end
+  end
+end

data/lib/graphql/dashboard/statics_controller.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+module Graphql
+  class Dashboard < Rails::Engine
+    class StaticsController < ApplicationController
+      skip_forgery_protection
+      # Use an explicit list of files to avoid any chance of reading other files from disk
+      STATICS = {}
+
+      [
+        "icon.png",
+        "header-icon.png",
+        "charts.min.css",
+        "dashboard.css",
+        "dashboard.js",
+        "bootstrap-5.3.3.min.css",
+        "bootstrap-5.3.3.min.js",
+      ].each do |static_file|
+        STATICS[static_file] = File.expand_path("../statics/#{static_file}", __FILE__)
+      end
+
+      def show
+        expires_in 1.year, public: true
+        if (filepath = STATICS[params[:id]])
+          render file: filepath
+        else
+          head :not_found
+        end
+      end
+    end
+  end
+end

data/lib/graphql/dashboard/subscriptions.rb

@@ -1,4 +1,5 @@
 # frozen_string_literal: true
+require_relative "./installable"
 module Graphql
   class Dashboard < Rails::Engine
     module Subscriptions
@@ -6,7 +7,7 @@ module Graphql
         include Installable
 
         def feature_installed?
-          schema_class.subscriptions.is_a?(GraphQL::Pro::Subscriptions)
+          defined?(GraphQL::Pro::Subscriptions) && schema_class.subscriptions.is_a?(GraphQL::Pro::Subscriptions)
         end
 
         INSTALLABLE_COMPONENT_HEADER_HTML = "GraphQL-Pro Subscriptions aren't installed on this schema yet.".html_safe

data/lib/graphql/dashboard.rb

@@ -35,6 +35,15 @@ module Graphql
   class Dashboard < Rails::Engine
     engine_name "graphql_dashboard"
     isolate_namespace(Graphql::Dashboard)
+
+    autoload :ApplicationController, "graphql/dashboard/application_controller"
+    autoload :LandingsController, "graphql/dashboard/landings_controller"
+    autoload :StaticsController, "graphql/dashboard/statics_controller"
+    autoload :DetailedTraces, "graphql/dashboard/detailed_traces"
+    autoload :Subscriptions, "graphql/dashboard/subscriptions"
+    autoload :OperationStore, "graphql/dashboard/operation_store"
+    autoload :Limiters, "graphql/dashboard/limiters"
+
     routes do
       root "landings#show"
       resources :statics, only: :show, constraints: { id: /[0-9A-Za-z\-.]+/ }
@@ -77,85 +86,11 @@ module Graphql
         resources :subscriptions, only: [:show], constraints: { id: /[a-zA-Z0-9\-]+/ }
         post "/subscriptions/clear_all", to: "subscriptions#clear_all", as: :clear_all
       end
-
-      ApplicationController.include(Dashboard.routes.url_helpers)
-    end
-
-    class ApplicationController < ActionController::Base
-      protect_from_forgery with: :exception
-      prepend_view_path(File.join(__FILE__, "../dashboard/views"))
-
-      content_security_policy do |policy|
-        policy.default_src(:self) if policy.default_src(*policy.default_src).blank?
-        policy.connect_src(:self) if policy.connect_src(*policy.connect_src).blank?
-        policy.base_uri(:none) if policy.base_uri(*policy.base_uri).blank?
-        policy.font_src(:self) if policy.font_src(*policy.font_src).blank?
-        policy.img_src(:self, :data) if policy.img_src(*policy.img_src).blank?
-        policy.object_src(:none) if policy.object_src(*policy.object_src).blank?
-        policy.script_src(:self) if policy.script_src(*policy.script_src).blank?
-        policy.style_src(:self) if policy.style_src(*policy.style_src).blank?
-        policy.form_action(:self) if policy.form_action(*policy.form_action).blank?
-        policy.frame_ancestors(:none) if policy.frame_ancestors(*policy.frame_ancestors).blank?
-      end
-
-      def schema_class
-        @schema_class ||= begin
-          schema_param = request.query_parameters["schema"] || params[:schema]
-          case schema_param
-          when Class
-            schema_param
-          when String
-            schema_param.constantize
-          else
-            raise "Missing `params[:schema]`, please provide a class or string to `mount GraphQL::Dashboard, schema: ...`"
-          end
-        end
-      end
-      helper_method :schema_class
-    end
-
-    class LandingsController < ApplicationController
-      def show
-      end
-    end
-
-    class StaticsController < ApplicationController
-      skip_after_action :verify_same_origin_request
-      # Use an explicit list of files to avoid any chance of reading other files from disk
-      STATICS = {}
-
-      [
-        "icon.png",
-        "header-icon.png",
-        "charts.min.css",
-        "dashboard.css",
-        "dashboard.js",
-        "bootstrap-5.3.3.min.css",
-        "bootstrap-5.3.3.min.js",
-      ].each do |static_file|
-        STATICS[static_file] = File.expand_path("../dashboard/statics/#{static_file}", __FILE__)
-      end
-
-      def show
-        expires_in 1.year, public: true
-        if (filepath = STATICS[params[:id]])
-          render file: filepath
-        else
-          head :not_found
-        end
-      end
     end
   end
 end
 
-require 'graphql/dashboard/detailed_traces'
-require 'graphql/dashboard/limiters'
-require 'graphql/dashboard/operation_store'
-require 'graphql/dashboard/subscriptions'
-
 # Rails expects the engine to be called `Graphql::Dashboard`,
 # but `GraphQL::Dashboard` is consistent with this gem's naming.
 # So define both constants to refer to the same class.
 GraphQL::Dashboard = Graphql::Dashboard
-
-ActiveSupport.run_load_hooks(:graphql_dashboard_application_controller, GraphQL::Dashboard::ApplicationController)

data/lib/graphql/dataloader/null_dataloader.rb

@@ -37,13 +37,17 @@ module GraphQL
       end
 
       def run_isolated
-        new_dl = self.class.new
+        # Reuse this instance because execution code may already have a reference to _this_ `dataloader` inside the given block.
+        prev_lazies_at_depth = @lazies_at_depth
+        @lazies_at_depth = @lazies_at_depth.dup.clear
         res = nil
-        new_dl.append_job {
+        append_job {
           res = yield
         }
-        new_dl.run
+        run
         res
+      ensure
+        @lazies_at_depth = prev_lazies_at_depth
       end
 
       def clear_cache; end

data/lib/graphql/execution/batching/field_compatibility.rb

@@ -0,0 +1,150 @@
+# frozen_string_literal: true
+module GraphQL
+  module Execution
+    module Batching
+      module FieldCompatibility
+        def resolve_all_load_arguments(frs, object_from_id_receiver, arguments, argument_owner, context)
+          arg_defns = context.types.arguments(argument_owner)
+          arg_defns.each do |arg_defn|
+            if arg_defn.loads
+              if arguments.key?(arg_defn.keyword)
+                id = arguments.delete(arg_defn.keyword)
+                if !id.nil?
+                  value = if arg_defn.type.list?
+                    id.map {  |inner_id|
+                      object_from_id_receiver.load_and_authorize_application_object(arg_defn, inner_id, context)
+                    }
+                  else
+                    object_from_id_receiver.load_and_authorize_application_object(arg_defn, id, context)
+                  end
+
+                  if frs.runner.resolves_lazies
+                    value = frs.sync(value)
+                  end
+                  if value.is_a?(GraphQL::Error)
+                    value.path = frs.path
+                    return value
+                  end
+                else
+                  value = nil
+                end
+                arguments[arg_defn.keyword] = value
+              end
+            elsif (input_type = arg_defn.type.unwrap).kind.input_object? &&
+                (value = arguments[arg_defn.keyword]) # TODO lists
+              resolve_all_load_arguments(frs, object_from_id_receiver, value, input_type, context)
+            end
+          end
+          nil
+        end
+
+        def resolve_batch(frs, objects, context, kwargs)
+          if @batch_mode && !:direct_send.equal?(@batch_mode)
+            return super
+          end
+
+          if !@resolver_class
+            maybe_err = resolve_all_load_arguments(frs, self, kwargs, self, context)
+            if maybe_err
+              return maybe_err
+            end
+          end
+          if extras.include?(:lookahead)
+            if kwargs.frozen?
+              kwargs = kwargs.dup
+            end
+            kwargs[:lookahead] = Execution::Lookahead.new(
+              query: context.query,
+              ast_nodes: frs.ast_nodes || Array(frs.ast_node),
+              field: self,
+            )
+          end
+
+          if extras.include?(:ast_node)
+            if kwargs.frozen?
+              kwargs = kwargs.dup
+            end
+            kwargs[:ast_node] = frs.ast_node
+          end
+
+          if @owner.method_defined?(@resolver_method)
+            results = []
+            frs.selections_step.graphql_objects.each_with_index do |obj_inst, idx|
+              if frs.object_is_authorized[idx]
+                if dynamic_introspection
+                  obj_inst = @owner.wrap(obj_inst, context)
+                end
+                results << with_extensions(obj_inst, kwargs, context) do |obj, ruby_kwargs|
+                  if ruby_kwargs.empty?
+                    obj.public_send(@resolver_method)
+                  else
+                    obj.public_send(@resolver_method, **ruby_kwargs)
+                  end
+                end
+              end
+            end
+            results
+          elsif @resolver_class
+            objects.map do |o|
+              resolver_inst_kwargs = kwargs.dup
+              resolver_inst = @resolver_class.new(object: o, context: context, field: self)
+              maybe_err = resolve_all_load_arguments(frs, resolver_inst, resolver_inst_kwargs, self, context)
+              if maybe_err
+                next maybe_err
+              end
+              resolver_inst_kwargs = if @resolver_class < Schema::HasSingleInputArgument
+                resolver_inst_kwargs[:input]
+              else
+                resolver_inst_kwargs
+              end
+              with_extensions(o, resolver_inst_kwargs, context) do |obj, ruby_kwargs|
+                resolver_inst.object = obj
+                resolver_inst.prepared_arguments = ruby_kwargs
+                is_authed, new_return_value = resolver_inst.authorized?(**ruby_kwargs)
+                if frs.runner.resolves_lazies && frs.runner.schema.lazy?(is_authed)
+                  is_authed, new_return_value = frs.runner.schema.sync_lazy(is_authed)
+                end
+                if is_authed
+                  resolver_inst.call_resolve(ruby_kwargs)
+                else
+                  new_return_value
+                end
+              end
+            rescue RuntimeError => err
+              err
+            rescue StandardError => stderr
+              begin
+                context.query.handle_or_reraise(stderr)
+              rescue GraphQL::ExecutionError => ex_err
+                ex_err
+              end
+            end
+          elsif objects.first.is_a?(Hash)
+            objects.map { |o| o[method_sym] || o[graphql_name] }
+          elsif objects.first.is_a?(Interpreter::RawValue)
+            objects
+          else
+            # need to use connection extension if present, and extensions expect object type instances
+            if extensions.empty?
+              objects.map { |o| o.public_send(@method_sym)}
+            else
+              results = []
+              frs.selections_step.graphql_objects.each_with_index do |obj_inst, idx|
+                if frs.object_is_authorized[idx]
+                  results << with_extensions(obj_inst, EmptyObjects::EMPTY_HASH, context) do |obj, arguments|
+                    if arguments.empty?
+                      obj.object.public_send(@method_sym)
+                    else
+                      obj.object.public_send(@method_sym, **arguments)
+                    end
+                  end
+                end
+              end
+              results
+            end
+          end
+        end
+      end
+    end
+  end
+end