graphql 2.2.17 → 2.5.16

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