graphql 2.0.27 → 2.2.5

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

data/lib/graphql/schema/field.rb

@@ -138,7 +138,7 @@ module GraphQL
             # As a last ditch, try to force loading the return type:
             type.unwrap.name
           end
-          @connection = return_type_name.end_with?("Connection")
+          @connection = return_type_name.end_with?("Connection") && return_type_name != "Connection"
         else
           @connection
         end
@@ -218,8 +218,8 @@ module GraphQL
       # @param ast_node [Language::Nodes::FieldDefinition, nil] If this schema was parsed from definition, this AST node defined the field
       # @param method_conflict_warning [Boolean] If false, skip the warning if this field's method conflicts with a built-in method
       # @param validates [Array<Hash>] Configurations for validating this field
-      # @fallback_value [Object] A fallback value if the method is not defined
-      def initialize(type: nil, name: nil, owner: nil, null: nil, description: NOT_CONFIGURED, deprecation_reason: nil, method: nil, hash_key: nil, dig: nil, resolver_method: nil, connection: nil, max_page_size: NOT_CONFIGURED, default_page_size: NOT_CONFIGURED, scope: nil, introspection: false, camelize: true, trace: nil, complexity: nil, ast_node: nil, extras: EMPTY_ARRAY, extensions: EMPTY_ARRAY, connection_extension: self.class.connection_extension, resolver_class: nil, subscription_scope: nil, relay_node_field: false, relay_nodes_field: false, method_conflict_warning: true, broadcastable: NOT_CONFIGURED, arguments: EMPTY_HASH, directives: EMPTY_HASH, validates: EMPTY_ARRAY, fallback_value: NOT_CONFIGURED, &definition_block)
+      # @param fallback_value [Object] A fallback value if the method is not defined
+      def initialize(type: nil, name: nil, owner: nil, null: nil, description: NOT_CONFIGURED, deprecation_reason: nil, method: nil, hash_key: nil, dig: nil, resolver_method: nil, connection: nil, max_page_size: NOT_CONFIGURED, default_page_size: NOT_CONFIGURED, scope: nil, introspection: false, camelize: true, trace: nil, complexity: nil, ast_node: nil, extras: EMPTY_ARRAY, extensions: EMPTY_ARRAY, connection_extension: self.class.connection_extension, resolver_class: nil, subscription_scope: nil, relay_node_field: false, relay_nodes_field: false, method_conflict_warning: true, broadcastable: NOT_CONFIGURED, arguments: EMPTY_HASH, directives: EMPTY_HASH, validates: EMPTY_ARRAY, fallback_value: NOT_CONFIGURED, dynamic_introspection: false, &definition_block)
         if name.nil?
           raise ArgumentError, "missing first `name` argument or keyword `name:`"
         end
@@ -267,6 +267,7 @@ module GraphQL
         @method_sym = method_name.to_sym
         @resolver_method = (resolver_method || name_s).to_sym
         @complexity = complexity
+        @dynamic_introspection = dynamic_introspection
         @return_type_expr = type
         @return_type_null = if !null.nil?
           null
@@ -351,6 +352,8 @@ module GraphQL
         @call_after_define = true
       end
 
+      attr_accessor :dynamic_introspection
+
       # If true, subscription updates with this field can be shared between viewers
       # @return [Boolean, nil]
       # @see GraphQL::Subscriptions::BroadcastAnalyzer
@@ -659,7 +662,7 @@ module GraphQL
         method_to_call = nil
         method_args = nil
 
-        Schema::Validator.validate!(validators, application_object, query_ctx, args)
+        @own_validators && Schema::Validator.validate!(validators, application_object, query_ctx, args)
 
         query_ctx.query.after_lazy(self.authorized?(application_object, args, query_ctx)) do |is_authorized|
           if is_authorized
@@ -701,7 +704,7 @@ module GraphQL
                   inner_object.dig(*@dig_keys)
                 elsif inner_object.key?(@method_sym)
                   inner_object[@method_sym]
-                elsif inner_object.key?(@method_str)
+                elsif inner_object.key?(@method_str) || !inner_object.default_proc.nil?
                   inner_object[@method_str]
                 elsif @fallback_value != NOT_CONFIGURED
                   @fallback_value