graphql 2.0.28 → 2.2.11

data/lib/graphql/query/context.rb

@@ -1,4 +1,6 @@
 # frozen_string_literal: true
+require "graphql/query/context/scoped_context"
+
 module GraphQL
   class Query
     # Expose some query-specific info to field resolve functions.
@@ -90,104 +92,6 @@ module GraphQL
         @scoped_context = ScopedContext.new(self)
       end
 
-      class ScopedContext
-        NO_PATH = GraphQL::EmptyObjects::EMPTY_ARRAY
-        NO_CONTEXT = GraphQL::EmptyObjects::EMPTY_HASH
-
-        def initialize(query_context)
-          @query_context = query_context
-          @scoped_contexts = nil
-          @all_keys = nil
-        end
-
-        def merged_context
-          if @scoped_contexts.nil?
-            NO_CONTEXT
-          else
-            merged_ctx = {}
-            each_present_path_ctx do |path_ctx|
-              merged_ctx = path_ctx.merge(merged_ctx)
-            end
-            merged_ctx
-          end
-        end
-
-        def merge!(hash)
-          @all_keys ||= Set.new
-          @all_keys.merge(hash.keys)
-          ctx = @scoped_contexts ||= {}
-          current_path.each do |path_part|
-            ctx = ctx[path_part] ||= { parent: ctx }
-          end
-          this_scoped_ctx = ctx[:scoped_context] ||= {}
-          this_scoped_ctx.merge!(hash)
-        end
-
-        def key?(key)
-          if @all_keys && @all_keys.include?(key)
-            each_present_path_ctx do |path_ctx|
-              if path_ctx.key?(key)
-                return true
-              end
-            end
-          end
-          false
-        end
-
-        def [](key)
-          each_present_path_ctx do |path_ctx|
-            if path_ctx.key?(key)
-              return path_ctx[key]
-            end
-          end
-          nil
-        end
-
-        def current_path
-          @query_context.current_path || NO_PATH
-        end
-
-        def dig(key, *other_keys)
-          each_present_path_ctx do |path_ctx|
-            if path_ctx.key?(key)
-              found_value = path_ctx[key]
-              if other_keys.any?
-                return found_value.dig(*other_keys)
-              else
-                return found_value
-              end
-            end
-          end
-          nil
-        end
-
-        private
-
-        # Start at the current location,
-        # but look up the tree for previously-assigned scoped values
-        def each_present_path_ctx
-          ctx = @scoped_contexts
-          if ctx.nil?
-            # no-op
-          else
-            current_path.each do |path_part|
-              if ctx.key?(path_part)
-                ctx = ctx[path_part]
-              else
-                break
-              end
-            end
-
-            while ctx
-              if (scoped_ctx = ctx[:scoped_context])
-                yield(scoped_ctx)
-              end
-              ctx = ctx[:parent]
-            end
-          end
-        end
-      end
-
       # @return [Hash] A hash that will be added verbatim to the result hash, as `"extensions" => { ... }`
       def response_extensions
         namespace(:__query_result_extensions__)
@@ -333,6 +237,10 @@ module GraphQL
         @storage.key?(ns)
       end
 
+      def logger
+        @query && @query.logger
+      end
+
       def inspect
         "#<Query::Context ...>"
       end
@@ -345,6 +253,36 @@ module GraphQL
         scoped_merge!(key => value)
         nil
       end
+
+      # Use this when you need to do a scoped set _inside_ a lazy-loaded (or batch-loaded)
+      # block of code.
+      #
+      # @example using scoped context inside a promise
+      #   scoped_ctx = context.scoped
+      #   SomeBatchLoader.load(...).then do |thing|
+      #     # use a scoped_ctx which was created _before_ dataloading:
+      #     scoped_ctx.set!(:thing, thing)
+      #   end
+      # @return [Context::Scoped]
+      def scoped
+        Scoped.new(@scoped_context, current_path)
+      end
+
+      class Scoped
+        def initialize(scoped_context, path)
+          @path = path
+          @scoped_context = scoped_context
+        end
+
+        def merge!(hash)
+          @scoped_context.merge!(hash, at: @path)
+        end
+
+        def set!(key, value)
+          @scoped_context.merge!({ key => value }, at: @path)
+          nil
+        end
+      end
     end
   end
 end

data/lib/graphql/query/null_context.rb

@@ -1,8 +1,11 @@
 # frozen_string_literal: true
+require "graphql/query/context"
 module GraphQL
   class Query
     # This object can be `ctx` in places where there is no query
-    class NullContext
+    class NullContext < Context
+      include Singleton
+
       class NullQuery
         def after_lazy(value)
           yield(value)
@@ -27,16 +30,6 @@ module GraphQL
       def interpreter?
         true
       end
-
-      class << self
-        extend Forwardable
-
-        def instance
-          @instance ||= self.new
-        end
-
-        def_delegators :instance, :query, :warden, :schema, :interpreter?, :dataloader, :[], :fetch, :dig, :key?
-      end
     end
   end
 end

data/lib/graphql/query/validation_pipeline.rb

@@ -14,7 +14,7 @@ module GraphQL
     #
     # @api private
     class ValidationPipeline
-      attr_reader :max_depth, :max_complexity
+      attr_reader :max_depth, :max_complexity, :validate_timeout_remaining
 
       def initialize(query:, parse_error:, operation_name_error:, max_depth:, max_complexity:)
         @validation_errors = []
@@ -71,7 +71,7 @@ module GraphQL
           validator = @query.static_validator || @schema.static_validator
           validation_result = validator.validate(@query, validate: @query.validate, timeout: @schema.validate_timeout, max_errors: @schema.validate_max_errors)
           @validation_errors.concat(validation_result[:errors])
-
+          @validate_timeout_remaining = validation_result[:remaining_timeout]
           if @validation_errors.empty?
             @validation_errors.concat(@query.variables.errors)
           end

data/lib/graphql/query/variables.rb

@@ -26,7 +26,7 @@ module GraphQL
           # - Then, fall back to the default value from the query string
           # If it's still nil, raise an error if it's required.
           variable_type = schema.type_from_ast(ast_variable.type, context: ctx)
-          if variable_type.nil?
+          if variable_type.nil? || !variable_type.unwrap.kind.input?
             # Pass -- it will get handled by a validator
           else
             variable_name = ast_variable.name
@@ -80,12 +80,12 @@ module GraphQL
         else
           val
         end
-      end    
+      end
 
       def add_max_errors_reached_message
         message = "Too many errors processing variables, max validation error limit reached. Execution aborted"
         validation_result = GraphQL::Query::InputValidationResult.from_problem(message)
-        errors << GraphQL::Query::VariableValidationError.new(nil, nil, nil, validation_result, msg: message) 
+        errors << GraphQL::Query::VariableValidationError.new(nil, nil, nil, validation_result, msg: message)
       end
     end
   end

data/lib/graphql/query.rb

@@ -95,15 +95,10 @@ module GraphQL
     # @param root_value [Object] the object used to resolve fields on the root type
     # @param max_depth [Numeric] the maximum number of nested selections allowed for this query (falls back to schema-level value)
     # @param max_complexity [Numeric] the maximum field complexity for this query (falls back to schema-level value)
-    # @param except [<#call(schema_member, context)>] If provided, objects will be hidden from the schema when `.call(schema_member, context)` returns truthy
-    # @param only [<#call(schema_member, context)>] If provided, objects will be hidden from the schema when `.call(schema_member, context)` returns false
-    def initialize(schema, query_string = nil, query: nil, document: nil, context: nil, variables: nil, validate: true, static_validator: nil, subscription_topic: nil, operation_name: nil, root_value: nil, max_depth: schema.max_depth, max_complexity: schema.max_complexity, except: nil, only: nil, warden: nil)
+    def initialize(schema, query_string = nil, query: nil, document: nil, context: nil, variables: nil, validate: true, static_validator: nil, subscription_topic: nil, operation_name: nil, root_value: nil, max_depth: schema.max_depth, max_complexity: schema.max_complexity, warden: nil)
       # Even if `variables: nil` is passed, use an empty hash for simpler logic
       variables ||= {}
       @schema = schema
-      if only || except
-        merge_filters(except: except, only: only)
-      end
       @context = schema.context_class.new(query: self, object: root_value, values: context)
       @warden = warden
       @subscription_topic = subscription_topic
@@ -120,8 +115,6 @@ module GraphQL
         if schema.trace_class <= GraphQL::Tracing::CallLegacyTracers
           context_tracers += [GraphQL::Backtrace::Tracer]
           @tracers << GraphQL::Backtrace::Tracer
-        elsif !(current_trace.class <= GraphQL::Backtrace::Trace)
-          raise "Invariant: `backtrace: true` should have provided a trace class with Backtrace mixed in, but it didnt. (Found: #{current_trace.class.ancestors}). This is a bug in GraphQL-Ruby, please report it on GitHub."
         end
       end
 
@@ -129,7 +122,6 @@ module GraphQL
         raise ArgumentError, "context[:tracers] are not supported without `trace_with(GraphQL::Tracing::CallLegacyTracers)` in the schema configuration, please add it."
       end
 
-
       @analysis_errors = []
       if variables.is_a?(String)
         raise ArgumentError, "Query variables should be a Hash, not a String. Try JSON.parse to prepare variables."
@@ -168,6 +160,14 @@ module GraphQL
 
       @result_values = nil
       @executed = false
+
+      @logger = if context && context[:logger] == false
+        Logger.new(IO::NULL)
+      elsif context && (l = context[:logger])
+        l
+      else
+        schema.default_logger
+      end
     end
 
     # If a document was provided to `GraphQL::Schema#execute` instead of the raw query string, we will need to get it from the document
@@ -317,7 +317,7 @@ module GraphQL
     end
 
     def_delegators :validation_pipeline, :validation_errors,
-                   :analyzers, :ast_analyzers, :max_depth, :max_complexity
+                   :analyzers, :ast_analyzers, :max_depth, :max_complexity, :validate_timeout_remaining
 
     attr_accessor :analysis_errors
     def valid?
@@ -354,17 +354,6 @@ module GraphQL
       with_prepared_ast { @query }
     end
 
-    # @return [void]
-    def merge_filters(only: nil, except: nil)
-      if @prepared_ast
-        raise "Can't add filters after preparing the query"
-      else
-        @filter ||= @schema.default_filter
-        @filter = @filter.merge(only: only, except: except)
-      end
-      nil
-    end
-
     def subscription?
       with_prepared_ast { @subscription }
     end
@@ -386,6 +375,8 @@ module GraphQL
       end
     end
 
+    attr_reader :logger
+
     private
 
     def find_operation(operations, operation_name)
@@ -400,7 +391,7 @@ module GraphQL
 
     def prepare_ast
       @prepared_ast = true
-      @warden ||= @schema.warden_class.new(@filter, schema: @schema, context: @context)
+      @warden ||= @schema.warden_class.new(schema: @schema, context: @context)
       parse_error = nil
       @document ||= begin
         if query_string

data/lib/graphql/railtie.rb

@@ -1,12 +1,15 @@
 # frozen_string_literal: true
+
 module GraphQL
   class Railtie < Rails::Railtie
-    config.before_configuration do
-      # Bootsnap compile cache has similar expiration properties,
-      # so we assume that if the user has bootsnap setup it's ok
-      # to piggy back on it.
-      if ::Object.const_defined?("Bootsnap::CompileCache::ISeq") && Bootsnap::CompileCache::ISeq.cache_dir
-        Language::Parser.cache ||= Language::Cache.new(Pathname.new(Bootsnap::CompileCache::ISeq.cache_dir).join('graphql'))
+    config.graphql = ActiveSupport::OrderedOptions.new
+    config.graphql.parser_cache = false
+
+    initializer("graphql.cache") do |app|
+      if config.graphql.parser_cache
+        Language::Parser.cache ||= Language::Cache.new(
+          app.root.join("tmp/cache/graphql")
+        )
       end
     end
   end

data/lib/graphql/rake_task.rb

@@ -9,8 +9,7 @@ module GraphQL
   # By default, schemas are looked up by name as constants using `schema_name:`.
   # You can provide a `load_schema` function to return your schema another way.
   #
-  # `load_context:`, `only:` and `except:` are supported so that
-  # you can keep an eye on how filters affect your schema.
+  # Use `load_context:` and `visible?` to dump schemas under certain visibility constraints.
   #
   # @example Dump a Schema to .graphql + .json files
   #   require "graphql/rake_task"
@@ -36,8 +35,6 @@ module GraphQL
       schema_name: nil,
       load_schema: ->(task) { Object.const_get(task.schema_name) },
       load_context: ->(task) { {} },
-      only: nil,
-      except: nil,
       directory: ".",
       idl_outfile: "schema.graphql",
       json_outfile: "schema.json",
@@ -68,12 +65,6 @@ module GraphQL
     # @return [<#call(task)>] A callable for loading the query context
     attr_accessor :load_context
 
-    # @return [<#call(member, ctx)>, nil] A filter for this task
-    attr_accessor :only
-
-    # @return [<#call(member, ctx)>, nil] A filter for this task
-    attr_accessor :except
-
     # @return [String] target for IDL task
     attr_accessor :idl_outfile
 
@@ -117,10 +108,10 @@ module GraphQL
           include_is_repeatable: include_is_repeatable,
           include_specified_by_url: include_specified_by_url,
           include_schema_description: include_schema_description,
-          only: @only, except: @except, context: context
+          context: context
         )
       when :to_definition
-        schema.to_definition(only: @only, except: @except, context: context)
+        schema.to_definition(context: context)
       else
         raise ArgumentError, "Unexpected schema dump method: #{method_name.inspect}"
       end

data/lib/graphql/schema/argument.rb

@@ -221,8 +221,13 @@ module GraphQL
             #
             # This will have to be called later, when the runtime object _is_ available.
             value
-          else
+          elsif obj.respond_to?(@prepare)
             obj.public_send(@prepare, value)
+          elsif owner.respond_to?(@prepare)
+            owner.public_send(@prepare, value, context || obj.context)
+          else
+            raise "Invalid prepare for #{@owner.name}.name: #{@prepare.inspect}. "\
+              "Could not find prepare method #{@prepare} on #{obj.class} or #{owner}."
           end
         elsif @prepare.respond_to?(:call)
           @prepare.call(value, context || obj.context)

data/lib/graphql/schema/base_64_encoder.rb

@@ -1,18 +1,16 @@
 # frozen_string_literal: true
-
-require 'graphql/schema/base_64_bp'
-
+require "base64"
 module GraphQL
   class Schema
     # @api private
     module Base64Encoder
       def self.encode(unencoded_text, nonce: false)
-        Base64Bp.urlsafe_encode64(unencoded_text, padding: false)
+        Base64.urlsafe_encode64(unencoded_text, padding: false)
       end
 
       def self.decode(encoded_text, nonce: false)
         # urlsafe_decode64 is for forward compatibility
-        Base64Bp.urlsafe_decode64(encoded_text)
+        Base64.urlsafe_decode64(encoded_text)
       rescue ArgumentError
         raise GraphQL::ExecutionError, "Invalid input: #{encoded_text.inspect}"
       end

data/lib/graphql/schema/build_from_definition.rb

@@ -432,14 +432,12 @@ module GraphQL
           builder = self
 
           field_definitions.each do |field_definition|
-            type_name = resolve_type_name(field_definition.type)
             resolve_method_name = -"resolve_field_#{field_definition.name}"
             schema_field_defn = owner.field(
               field_definition.name,
               description: field_definition.description,
               type: type_resolver.call(field_definition.type),
               null: true,
-              connection: type_name.end_with?("Connection"),
               connection_extension: nil,
               deprecation_reason: build_deprecation_reason(field_definition.directives),
               ast_node: field_definition,
@@ -487,15 +485,6 @@ module GraphQL
           }
           resolve_type_proc
         end
-
-        def resolve_type_name(type)
-          case type
-          when GraphQL::Language::Nodes::TypeName
-            return type.name
-          else
-            resolve_type_name(type.of_type)
-          end
-        end
       end
 
       private_constant :Builder

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

@@ -6,6 +6,18 @@ module GraphQL
         description "Requires that exactly one field must be supplied and that field must not be `null`."
         locations(GraphQL::Schema::Directive::INPUT_OBJECT)
         default_directive true
+
+        def initialize(...)
+          super
+
+          owner.extend(IsOneOf)
+        end
+
+        module IsOneOf
+          def one_of?
+            true
+          end
+        end
       end
     end
   end

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

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+module GraphQL
+  class Schema
+    class Directive < GraphQL::Schema::Member
+      class SpecifiedBy < GraphQL::Schema::Directive
+        description "Exposes a URL that specifies the behavior of this scalar."
+        locations(GraphQL::Schema::Directive::SCALAR)
+        default_directive true
+
+        argument :url, String, description: "The URL that specifies the behavior of this scalar."
+      end
+    end
+  end
+end

data/lib/graphql/schema/directive.rb

@@ -119,7 +119,7 @@ module GraphQL
         # - lazy resolution
         # Probably, those won't be needed here, since these are configuration arguments,
         # not runtime arguments.
-        @arguments = self.class.coerce_arguments(nil, arguments, Query::NullContext)
+        @arguments = self.class.coerce_arguments(nil, arguments, Query::NullContext.instance)
       end
 
       def graphql_name

data/lib/graphql/schema/enum.rb

@@ -14,7 +14,7 @@ module GraphQL
     #   #   ONIONS
     #   #   PEPPERS
     #   # }
-    #   class PizzaTopping < GraphQL::Enum
+    #   class PizzaTopping < GraphQL::Schema::Enum
     #     value :MUSHROOMS
     #     value :ONIONS
     #     value :PEPPERS
@@ -68,7 +68,7 @@ module GraphQL
         end
 
         # @return [Array<GraphQL::Schema::EnumValue>] Possible values of this enum
-        def enum_values(context = GraphQL::Query::NullContext)
+        def enum_values(context = GraphQL::Query::NullContext.instance)
           inherited_values = superclass.respond_to?(:enum_values) ? superclass.enum_values(context) : nil
           visible_values = []
           warden = Warden.from_context(context)
@@ -110,7 +110,7 @@ module GraphQL
         end
 
         # @return [Hash<String => GraphQL::Schema::EnumValue>] Possible values of this enum, keyed by name.
-        def values(context = GraphQL::Query::NullContext)
+        def values(context = GraphQL::Query::NullContext.instance)
           enum_values(context).each_with_object({}) { |val, obj| obj[val.graphql_name] = val }
         end
 

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

@@ -54,23 +54,9 @@ module GraphQL
                 value.edge_class = custom_t
               end
               value
-            elsif context.schema.new_connections?
+            else
               context.namespace(:connections)[:all_wrappers] ||= context.schema.connections.all_wrappers
               context.schema.connections.wrap(field, object.object, value, original_arguments, context)
-            else
-              if object.is_a?(GraphQL::Schema::Object)
-                object = object.object
-              end
-              connection_class = GraphQL::Relay::BaseConnection.connection_for_nodes(value)
-              connection_class.new(
-                value,
-                original_arguments,
-                field: field,
-                max_page_size: field.max_page_size,
-                default_page_size: field.default_page_size,
-                parent: object,
-                context: context,
-              )
             end
           end
         end

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

@@ -10,7 +10,14 @@ module GraphQL
           else
             ret_type = @field.type.unwrap
             if ret_type.respond_to?(:scope_items)
-              ret_type.scope_items(value, context)
+              scoped_items = ret_type.scope_items(value, context)
+              if !scoped_items.equal?(value) && !ret_type.reauthorize_scoped_objects
+                if (current_runtime_state = Thread.current[:__graphql_runtime_info]) &&
+                    (query_runtime_state = current_runtime_state[context.query])
+                  query_runtime_state.was_authorized_by_scope_items = true
+                end
+              end
+              scoped_items
             else
               value
             end