graphql 2.0.32 → 2.5.22

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: c86c6f3920de2d67a9d8b23a2783ec33f15b70571236db184ca9a9e6b459b80b
-  data.tar.gz: 6f4659f46b99da5c6065ba7084b899253958bdb5627b65f469262898cb38205c
+  metadata.gz: 453860aab49f87d8b8771b00cc50b34a4567e7c80d7ce15b95c1b4fa82b23286
+  data.tar.gz: f33d534cbbccfcfb89ba8e6f553ea17d71199ca3fc898ab75c5f3ace08aba820
 SHA512:
-  metadata.gz: 02bf27d69ec35ecdad618ed18a7731fe7d66cd1b5105fcc7625e7b68f534b31e7e5b6f458ba1efe22b5f6e9e6d819cc696e7cdeba6e80bbfa3259691d9ede441
-  data.tar.gz: 5b91453bbc8e01a72bcfbe5cef21e7f65704ff1976d945c01291e48667a4a1f36e35f690048ba2a029d5c9f019cfa9c72fa46b2f851b422117de48a4722152ec
+  metadata.gz: 3c2c8b87e60b9312ce5fb3848cb9a8112b6d050b6ee9c31eee5720932a2cf754f97f6f7bef273b491199aaa46c7551348e07294270585e79a1e35d176126bdfb
+  data.tar.gz: b679a8434d195d513f97963b2fe70b296cb2106ceda4ae2b7c756d1127d8ee4c56f2e3106b4a01c609498904622ada5d569f489bf97a13f8627e7b6a6a1d83fd

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/install/mutation_root_generator.rb

@@ -9,7 +9,7 @@ module Graphql
       class MutationRootGenerator < Rails::Generators::Base
         include Core
 
-        desc "Create mutation base type, mutation root tipe, and adds the latter to the schema"
+        desc "Create mutation base type, mutation root type, and adds the latter to the schema"
         source_root File.expand_path('../templates', __FILE__)
 
         class_option :schema,
@@ -31,4 +31,4 @@ module Graphql
       end
     end
   end
-end 
+end 

data/lib/generators/graphql/install/templates/base_mutation.erb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 <% module_namespacing_when_supported do -%>
 module Mutations
   class BaseMutation < GraphQL::Schema::RelayClassicMutation

data/lib/generators/graphql/install/templates/mutation_type.erb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 <% module_namespacing_when_supported do -%>
 module Types
   class MutationType < Types::BaseObject

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,
@@ -105,6 +117,9 @@ module Graphql
           template("#{base_type}.erb", "#{options[:directory]}/types/#{base_type}.rb")
         end
 
+        # All resolvers are defined as living in their own module, including this class.
+        template("base_resolver.erb", "#{options[:directory]}/resolvers/base_resolver.rb")
+
         # Note: You can't have a schema without the query type, otherwise introspection breaks
         template("query_type.erb", "#{options[:directory]}/types/query_type.rb")
         insert_root_type('query', 'QueryType')
@@ -177,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/generators/graphql/orm_mutations_base.rb

@@ -18,7 +18,7 @@ module Graphql
       class_option :orm, banner: "NAME", type: :string, required: true,
                          desc: "ORM to generate the controller for"
 
-      class_option 'namespaced_types',
+      class_option :namespaced_types,
         type: :boolean,
         required: false,
         default: false,

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

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 <% module_namespacing_when_supported do -%>
 module Types
   class BaseArgument < GraphQL::Schema::Argument

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

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 <% module_namespacing_when_supported do -%>
 module Types
   class BaseConnection < Types::BaseObject

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

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 <% module_namespacing_when_supported do -%>
 module Types
   class BaseEdge < Types::BaseObject

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

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 <% module_namespacing_when_supported do -%>
 module Types
   class BaseEnum < GraphQL::Schema::Enum

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

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 <% module_namespacing_when_supported do -%>
 module Types
   class BaseField < GraphQL::Schema::Field

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

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 <% module_namespacing_when_supported do -%>
 module Types
   class BaseInputObject < GraphQL::Schema::InputObject

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

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 <% module_namespacing_when_supported do -%>
 module Types
   module BaseInterface

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

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 <% module_namespacing_when_supported do -%>
 module Types
   class BaseObject < GraphQL::Schema::Object

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

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+<% module_namespacing_when_supported do -%>
+module Resolvers
+  class BaseResolver < GraphQL::Schema::Resolver
+  end
+end
+<% end -%>

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

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 <% module_namespacing_when_supported do -%>
 module Types
   class BaseScalar < GraphQL::Schema::Scalar

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

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 <% module_namespacing_when_supported do -%>
 module Types
   class BaseUnion < GraphQL::Schema::Union

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/generators/graphql/templates/graphql_controller.erb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 <% module_namespacing_when_supported do -%>
 class GraphqlController < ApplicationController
   # If accessing from outside this domain, nullify the session

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

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 <% module_namespacing_when_supported do -%>
 module Loaders
   class <%= class_name %> < GraphQL::Batch::Loader

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

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 <% module_namespacing_when_supported do -%>
 module Mutations
   class <%= class_name %> < BaseMutation

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

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 <% module_namespacing_when_supported do -%>
 module Types
   module NodeType

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

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 <% module_namespacing_when_supported do -%>
 module Types
   class QueryType < Types::BaseObject

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

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 <% module_namespacing_when_supported do -%>
 class <%= schema_name %> < GraphQL::Schema
   query(Types::QueryType)
@@ -24,6 +26,9 @@ class <%= schema_name %> < GraphQL::Schema
     raise(GraphQL::RequiredImplementationMissingError)
   end
 
+  # Limit the size of incoming queries:
+  max_query_string_tokens(5000)
+
   # Stop validating when it encounters this many errors:
   validate_max_errors(100)
 end

data/lib/generators/graphql/type_generator.rb

@@ -11,7 +11,7 @@ module Graphql
     class TypeGeneratorBase < Rails::Generators::NamedBase
       include Core
 
-      class_option 'namespaced_types',
+      class_option :namespaced_types,
         type: :boolean,
         required: false,
         default: false,

data/lib/graphql/analysis/analyzer.rb

@@ -0,0 +1,90 @@
+# frozen_string_literal: true
+module GraphQL
+  module Analysis
+    # Query analyzer for query ASTs. Query analyzers respond to visitor style methods
+    # but are prefixed by `enter` and `leave`.
+    #
+    # When an analyzer is initialized with a Multiplex, you can always get the current query from
+    # `visitor.query` in the visit methods.
+    #
+    # @param [GraphQL::Query, GraphQL::Execution::Multiplex] The query or multiplex to analyze
+    class Analyzer
+      def initialize(subject)
+        @subject = subject
+
+        if subject.is_a?(GraphQL::Query)
+          @query = subject
+          @multiplex = nil
+        else
+          @multiplex = subject
+          @query = nil
+        end
+      end
+
+      # Analyzer hook to decide at analysis time whether a query should
+      # be analyzed or not.
+      # @return [Boolean] If the query should be analyzed or not
+      def analyze?
+        true
+      end
+
+      # Analyzer hook to decide at analysis time whether analysis
+      # requires a visitor pass; can be disabled for precomputed results.
+      # @return [Boolean] If analysis requires visitation or not
+      def visit?
+        true
+      end
+
+      # The result for this analyzer. Returning {GraphQL::AnalysisError} results
+      # in a query error.
+      # @return [Any] The analyzer result
+      def result
+        raise GraphQL::RequiredImplementationMissingError
+      end
+
+      # rubocop:disable Development/NoEvalCop This eval takes static inputs at load-time
+      class << self
+        private
+
+        def build_visitor_hooks(member_name)
+          class_eval(<<-EOS, __FILE__, __LINE__ + 1)
+            def on_enter_#{member_name}(node, parent, visitor)
+            end
+
+            def on_leave_#{member_name}(node, parent, visitor)
+            end
+          EOS
+        end
+      end
+
+      build_visitor_hooks :argument
+      build_visitor_hooks :directive
+      build_visitor_hooks :document
+      build_visitor_hooks :enum
+      build_visitor_hooks :field
+      build_visitor_hooks :fragment_spread
+      build_visitor_hooks :inline_fragment
+      build_visitor_hooks :input_object
+      build_visitor_hooks :list_type
+      build_visitor_hooks :non_null_type
+      build_visitor_hooks :null_value
+      build_visitor_hooks :operation_definition
+      build_visitor_hooks :type_name
+      build_visitor_hooks :variable_definition
+      build_visitor_hooks :variable_identifier
+      build_visitor_hooks :abstract_node
+      # rubocop:enable Development/NoEvalCop
+      protected
+
+      # @return [GraphQL::Query, GraphQL::Execution::Multiplex] Whatever this analyzer is analyzing
+      attr_reader :subject
+
+      # @return [GraphQL::Query, nil] `nil` if this analyzer is visiting a multiplex
+      #  (When this is `nil`, use `visitor.query` inside visit methods to get the current query)
+      attr_reader :query
+
+      # @return [GraphQL::Execution::Multiplex, nil] `nil` if this analyzer is visiting a query
+      attr_reader :multiplex
+    end
+  end
+end

data/lib/graphql/analysis/field_usage.rb

@@ -0,0 +1,82 @@
+# frozen_string_literal: true
+module GraphQL
+  module Analysis
+    class FieldUsage < Analyzer
+      def initialize(query)
+        super
+        @used_fields = Set.new
+        @used_deprecated_fields = Set.new
+        @used_deprecated_arguments = Set.new
+        @used_deprecated_enum_values = Set.new
+      end
+
+      def on_leave_field(node, parent, visitor)
+        field_defn = visitor.field_definition
+        field = "#{visitor.parent_type_definition.graphql_name}.#{field_defn.graphql_name}"
+        @used_fields << field
+        @used_deprecated_fields << field if field_defn.deprecation_reason
+        arguments = visitor.query.arguments_for(node, field_defn)
+        # If there was an error when preparing this argument object,
+        # then this might be an error or something:
+        if arguments.respond_to?(:argument_values)
+          extract_deprecated_arguments(arguments.argument_values)
+        end
+      end
+
+      def result
+        {
+          used_fields: @used_fields.to_a,
+          used_deprecated_fields: @used_deprecated_fields.to_a,
+          used_deprecated_arguments: @used_deprecated_arguments.to_a,
+          used_deprecated_enum_values: @used_deprecated_enum_values.to_a,
+        }
+      end
+
+      private
+
+      def extract_deprecated_arguments(argument_values)
+        argument_values.each_pair do |_argument_name, argument|
+          if argument.definition.deprecation_reason
+            @used_deprecated_arguments << argument.definition.path
+          end
+
+          arg_val = argument.value
+
+          next if arg_val.nil?
+
+          argument_type = argument.definition.type
+          if argument_type.non_null?
+            argument_type = argument_type.of_type
+          end
+
+          if argument_type.kind.input_object?
+            extract_deprecated_arguments(argument.original_value.arguments.argument_values) # rubocop:disable Development/ContextIsPassedCop -- runtime args instance
+          elsif argument_type.kind.enum?
+            extract_deprecated_enum_value(argument_type, arg_val)
+          elsif argument_type.list?
+            inner_type = argument_type.unwrap
+            case inner_type.kind
+            when TypeKinds::INPUT_OBJECT
+              argument.original_value.each do |value|
+                extract_deprecated_arguments(value.arguments.argument_values) # rubocop:disable Development/ContextIsPassedCop -- runtime args instance
+              end
+            when TypeKinds::ENUM
+              arg_val.each do |value|
+                extract_deprecated_enum_value(inner_type, value)
+              end
+            else
+              # Not a kind of input that we track
+            end
+          end
+        end
+      end
+
+      def extract_deprecated_enum_value(enum_type, value)
+        enum_value = @query.types.enum_values(enum_type).find { |ev| ev.value == value }
+        if enum_value&.deprecation_reason
+          @used_deprecated_enum_values << enum_value.path
+        end
+      end
+    end
+  end
+end

data/lib/graphql/analysis/max_query_complexity.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+module GraphQL
+  module Analysis
+    # Used under the hood to implement complexity validation,
+    # see {Schema#max_complexity} and {Query#max_complexity}
+    class MaxQueryComplexity < QueryComplexity
+      def result
+        return if subject.max_complexity.nil?
+
+        total_complexity = max_possible_complexity
+
+        if total_complexity > subject.max_complexity
+          GraphQL::AnalysisError.new("Query has complexity of #{total_complexity}, which exceeds max complexity of #{subject.max_complexity}")
+        else
+          nil
+        end
+      end
+    end
+  end
+end

data/lib/graphql/analysis/max_query_depth.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+module GraphQL
+  module Analysis
+    class MaxQueryDepth < QueryDepth
+      def result
+        configured_max_depth = if query
+          query.max_depth
+        else
+          multiplex.schema.max_depth
+        end
+
+        if configured_max_depth && @max_depth > configured_max_depth
+          GraphQL::AnalysisError.new("Query has depth of #{@max_depth}, which exceeds max depth of #{configured_max_depth}")
+        else
+          nil
+        end
+      end
+    end
+  end
+end