graphql 2.4.5 → 2.5.21

data/lib/graphql/backtrace.rb

@@ -1,9 +1,6 @@
 # frozen_string_literal: true
-require "graphql/backtrace/inspect_result"
 require "graphql/backtrace/table"
 require "graphql/backtrace/traced_error"
-require "graphql/backtrace/tracer"
-require "graphql/backtrace/trace"
 module GraphQL
   # Wrap unhandled errors with {TracedError}.
   #
@@ -24,7 +21,7 @@ module GraphQL
     def_delegators :to_a, :each, :[]
 
     def self.use(schema_defn)
-      schema_defn.trace_with(self::Trace)
+      schema_defn.using_backtrace = true
     end
 
     def initialize(context, value: nil)
@@ -40,20 +37,5 @@ module GraphQL
     def to_a
       @table.to_backtrace
     end
-
-    # Used for internal bookkeeping
-    # @api private
-    class Frame
-      attr_reader :path, :query, :ast_node, :object, :field, :arguments, :parent_frame
-      def initialize(path:, query:, ast_node:, object:, field:, arguments:, parent_frame:)
-        @path = path
-        @query = query
-        @ast_node = ast_node
-        @field = field
-        @object = object
-        @arguments = arguments
-        @parent_frame = parent_frame
-      end
-    end
   end
 end

data/lib/graphql/current.rb

@@ -22,7 +22,7 @@ module GraphQL
   #   ]
   #
   module Current
-    # @return [String, nil] Comma-joined operation names for the currently-running {Multiplex}. `nil` if all operations are anonymous.
+    # @return [String, nil] Comma-joined operation names for the currently-running {Execution::Multiplex}. `nil` if all operations are anonymous.
     def self.operation_name
       if (m = Fiber[:__graphql_current_multiplex])
         m.context[:__graphql_current_operation_name] ||= begin
@@ -48,5 +48,10 @@ module GraphQL
     def self.dataloader_source_class
       Fiber[:__graphql_current_dataloader_source]&.class
     end
+
+    # @return [GraphQL::Dataloader::Source, nil] The currently-running source, if there is one
+    def self.dataloader_source
+      Fiber[:__graphql_current_dataloader_source]
+    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/detailed_traces.rb

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+require_relative "./installable"
+module Graphql
+  class Dashboard < Rails::Engine
+    module DetailedTraces
+      class TracesController < Graphql::Dashboard::ApplicationController
+        include Installable
+
+        def index
+          @last = params[:last]&.to_i || 50
+          @before = params[:before]&.to_i
+          @traces = schema_class.detailed_trace.traces(last: @last, before: @before)
+        end
+
+        def show
+          trace = schema_class.detailed_trace.find_trace(params[:id].to_i)
+          send_data(trace.trace_data)
+        end
+
+        def destroy
+          schema_class.detailed_trace.delete_trace(params[:id])
+          flash[:success] = "Trace deleted."
+          head :no_content
+        end
+
+        def delete_all
+          schema_class.detailed_trace.delete_all_traces
+          flash[:success] = "Deleted all traces."
+          head :no_content
+        end
+
+        private
+
+        def feature_installed?
+          !!schema_class.detailed_trace
+        end
+
+        INSTALLABLE_COMPONENT_HEADER_HTML = "Detailed traces aren't installed yet."
+        INSTALLABLE_COMPONENT_MESSAGE_HTML = <<~HTML.html_safe
+          GraphQL-Ruby can instrument production traffic and save tracing artifacts here for later review.
+          <br>
+          Read more in <a href="https://graphql-ruby.org/queries/tracing#detailed-traces">the detailed tracing docs</a>.
+        HTML
+      end
+    end
+  end
+end

data/lib/graphql/dashboard/installable.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+module Graphql
+  class Dashboard < Rails::Engine
+    module Installable
+      def self.included(child_module)
+        child_module.before_action(:check_installed)
+      end
+
+      def feature_installed?
+        raise "Implement #{self.class}#feature_installed? to check whether this should render `not_installed` or not."
+      end
+
+      def check_installed
+        if !feature_installed?
+          @component_header_html = self.class::INSTALLABLE_COMPONENT_HEADER_HTML
+          @component_message_html = self.class::INSTALLABLE_COMPONENT_MESSAGE_HTML
+          render "graphql/dashboard/not_installed"
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,93 @@
+# frozen_string_literal: true
+require_relative "./installable"
+module Graphql
+  class Dashboard < Rails::Engine
+    module Limiters
+      class LimitersController < Dashboard::ApplicationController
+        include Installable
+        FALLBACK_CSP_NONCE_GENERATOR = ->(_req) { SecureRandom.hex(32) }
+
+        def show
+          name = params[:name]
+          @title = case name
+          when "runtime"
+            "Runtime Limiter"
+          when "active_operations"
+            "Active Operation Limiter"
+          when "mutations"
+            "Mutation Limiter"
+          else
+            raise ArgumentError, "Unknown limiter name: #{name}"
+          end
+
+          limiter = limiter_for(name)
+          if limiter.nil?
+            @install_path = "http://graphql-ruby.org/limiters/#{name}"
+          else
+            @chart_mode = params[:chart] || "day"
+            @current_soft = limiter.soft_limit_enabled?
+            @histogram = limiter.dashboard_histogram(@chart_mode)
+
+            # These configs may have already been defined by the application; provide overrides here if not.
+            request.content_security_policy_nonce_generator ||= FALLBACK_CSP_NONCE_GENERATOR
+            nonce_dirs = request.content_security_policy_nonce_directives || []
+            if !nonce_dirs.include?("style-src")
+              nonce_dirs += ["style-src"]
+              request.content_security_policy_nonce_directives = nonce_dirs
+            end
+            @csp_nonce = request.content_security_policy_nonce
+          end
+        end
+
+        def update
+          name = params[:name]
+          limiter = limiter_for(name)
+          if limiter
+            limiter.toggle_soft_limit
+            flash[:success] = if limiter.soft_limit_enabled?
+              "Enabled soft limiting -- over-limit traffic will be logged but not rejected."
+            else
+              "Disabled soft limiting -- over-limit traffic will be rejected."
+            end
+          else
+            flash[:warning] = "No limiter configured for #{name.inspect}"
+          end
+
+          redirect_to graphql_dashboard.limiters_limiter_path(name, chart: params[:chart])
+        end
+
+        private
+
+        def limiter_for(name)
+          case name
+          when "runtime"
+            schema_class.enterprise_runtime_limiter
+          when "active_operations"
+            schema_class.enterprise_active_operation_limiter
+          when "mutations"
+            schema_class.enterprise_mutation_limiter
+          else
+            raise ArgumentError, "Unknown limiter: #{name}"
+          end
+        end
+
+        def feature_installed?
+          defined?(GraphQL::Enterprise::Limiter) &&
+            (
+              schema_class.enterprise_active_operation_limiter ||
+              schema_class.enterprise_runtime_limiter ||
+              (schema_class.respond_to?(:enterprise_mutation_limiter) && schema_class.enterprise_mutation_limiter)
+            )
+        end
+
+
+        INSTALLABLE_COMPONENT_HEADER_HTML = "Rate limiters aren't installed on this schema yet."
+        INSTALLABLE_COMPONENT_MESSAGE_HTML = <<-HTML.html_safe
+          Check out the docs to get started with GraphQL-Enterprise's
+          <a href="https://graphql-ruby.org/limiters/runtime.html">runtime limiter</a> or
+          <a href="https://graphql-ruby.org/limiters/active_operations.html">active operation limiter</a>.
+        HTML
+      end
+    end
+  end
+end

data/lib/graphql/dashboard/operation_store.rb

@@ -0,0 +1,199 @@
+# frozen_string_literal: true
+require_relative "./installable"
+module Graphql
+  class Dashboard < Rails::Engine
+    module OperationStore
+      class BaseController < Dashboard::ApplicationController
+        include Installable
+
+        private
+
+        def feature_installed?
+          schema_class.respond_to?(:operation_store) && schema_class.operation_store.is_a?(GraphQL::Pro::OperationStore)
+        end
+
+        INSTALLABLE_COMPONENT_HEADER_HTML = "<code>OperationStore</code> isn't installed for this schema yet.".html_safe
+        INSTALLABLE_COMPONENT_MESSAGE_HTML = <<-HTML.html_safe
+          Learn more about improving performance and security with stored operations
+          in the <a href="https://graphql-ruby.org/operation_store/overview.html"><code>OperationStore</code> docs</a>.
+        HTML
+      end
+
+      class ClientsController < BaseController
+        def index
+          @order_by = params[:order_by] || "name"
+          @order_dir = params[:order_dir].presence || "asc"
+          clients_page = schema_class.operation_store.all_clients(
+            page: params[:page]&.to_i || 1,
+            per_page: params[:per_page]&.to_i || 25,
+            order_by: @order_by,
+            order_dir: @order_dir,
+          )
+
+          @clients_page = clients_page
+        end
+
+        def new
+          @client = init_client(secret: SecureRandom.hex(32))
+        end
+
+        def create
+          client_params = params.require(:client).permit(:name, :secret)
+          schema_class.operation_store.upsert_client(client_params[:name], client_params[:secret])
+          flash[:success] = "Created #{client_params[:name].inspect}"
+          redirect_to graphql_dashboard.operation_store_clients_path
+        end
+
+        def edit
+          @client = schema_class.operation_store.get_client(params[:name])
+        end
+
+        def update
+          client_name = params[:name]
+          client_secret = params.require(:client).permit(:secret)[:secret]
+          schema_class.operation_store.upsert_client(client_name, client_secret)
+          flash[:success] = "Updated #{client_name.inspect}"
+          redirect_to graphql_dashboard.operation_store_clients_path
+        end
+
+        def destroy
+          client_name = params[:name]
+          schema_class.operation_store.delete_client(client_name)
+          flash[:success] = "Deleted #{client_name.inspect}"
+          redirect_to graphql_dashboard.operation_store_clients_path
+        end
+
+        private
+
+        def init_client(name: nil, secret: nil)
+          GraphQL::Pro::OperationStore::ClientRecord.new(
+            name: name,
+            secret: secret,
+            created_at: nil,
+            operations_count: 0,
+            archived_operations_count: 0,
+            last_synced_at: nil,
+            last_used_at: nil,
+          )
+        end
+      end
+
+      class OperationsController < BaseController
+        def index
+          @client_operations = client_name = params[:client_name]
+          per_page = params[:per_page]&.to_i || 25
+          page = params[:page]&.to_i || 1
+          @is_archived = params[:archived_status] == :archived
+          order_by = params[:order_by] || "name"
+          order_dir = params[:order_dir]&.to_sym || :asc
+          if @client_operations
+            @operations_page = schema_class.operation_store.get_client_operations_by_client(
+              client_name,
+              page: page,
+              per_page: per_page,
+              is_archived: @is_archived,
+              order_by: order_by,
+              order_dir: order_dir,
+            )
+            opposite_archive_mode_count = schema_class.operation_store.get_client_operations_by_client(
+              client_name,
+              page: 1,
+              per_page: 1,
+              is_archived: !@is_archived,
+              order_by: order_by,
+              order_dir: order_dir,
+            ).total_count
+          else
+            @operations_page = schema_class.operation_store.all_operations(
+              page: page,
+              per_page: per_page,
+              is_archived: @is_archived,
+              order_by: order_by,
+              order_dir: order_dir,
+            )
+            opposite_archive_mode_count = schema_class.operation_store.all_operations(
+              page: 1,
+              per_page: 1,
+              is_archived: !@is_archived,
+              order_by: order_by,
+              order_dir: order_dir,
+            ).total_count
+          end
+
+          if @is_archived
+            @archived_operations_count = @operations_page.total_count
+            @unarchived_operations_count = opposite_archive_mode_count
+          else
+            @archived_operations_count = opposite_archive_mode_count
+            @unarchived_operations_count = @operations_page.total_count
+          end
+        end
+
+        def show
+          digest = params[:digest]
+          @operation = schema_class.operation_store.get_operation_by_digest(digest)
+          if @operation
+            # Parse & re-format the query
+            document = GraphQL.parse(@operation.body)
+            @graphql_source = document.to_query_string
+
+            @client_operations = schema_class.operation_store.get_client_operations_by_digest(digest)
+            @entries = schema_class.operation_store.get_index_entries_by_digest(digest)
+          end
+        end
+
+        def update
+          is_archived = case params[:modification]
+          when :archive
+            true
+          when :unarchive
+            false
+          else
+            raise ArgumentError, "Unexpected modification: #{params[:modification].inspect}"
+          end
+
+          if (client_name = params[:client_name])
+            operation_aliases = params[:operation_aliases]
+            schema_class.operation_store.archive_client_operations(
+              client_name: client_name,
+              operation_aliases: operation_aliases,
+              is_archived: is_archived
+            )
+            flash[:success] = "#{is_archived ? "Archived" : "Activated"} #{operation_aliases.size} #{"operation".pluralize(operation_aliases.size)}"
+          else
+            digests = params[:digests]
+            schema_class.operation_store.archive_operations(
+              digests: digests,
+              is_archived: is_archived
+            )
+            flash[:success] = "#{is_archived ? "Archived" : "Activated"} #{digests.size} #{"operation".pluralize(digests.size)}"
+          end
+          head :no_content
+        end
+      end
+
+      class IndexEntriesController < BaseController
+        def index
+          @search_term = if request.params["q"] && request.params["q"].length > 0
+            request.params["q"]
+          else
+            nil
+          end
+
+          @index_entries_page = schema_class.operation_store.all_index_entries(
+            search_term: @search_term,
+            page: params[:page]&.to_i || 1,
+            per_page: params[:per_page]&.to_i || 25,
+          )
+        end
+
+        def show
+          name = params[:name]
+          @entry = schema_class.operation_store.index.get_entry(name)
+          @chain = schema_class.operation_store.index.index_entry_chain(name)
+          @operations = schema_class.operation_store.get_operations_by_index_entry(name)
+        end
+      end
+    end
+  end
+end