graphql 2.0.30 → 2.3.6

data/lib/graphql/schema/member/scoped.rb

@@ -15,6 +15,25 @@ module GraphQL
         def scope_items(items, context)
           items
         end
+
+        def reauthorize_scoped_objects(new_value = nil)
+          if new_value.nil?
+            if @reauthorize_scoped_objects != nil
+              @reauthorize_scoped_objects
+            else
+              find_inherited_value(:reauthorize_scoped_objects, true)
+            end
+          else
+            @reauthorize_scoped_objects = new_value
+          end
+        end
+
+        def inherited(subclass)
+          super
+          subclass.class_eval do
+            @reauthorize_scoped_objects = nil
+          end
+        end
       end
     end
   end

data/lib/graphql/schema/member/type_system_helpers.rb

@@ -4,12 +4,11 @@ module GraphQL
   class Schema
     class Member
       module TypeSystemHelpers
-        def initialize(*args, &block)
+        def initialize(...)
           super
           @to_non_null_type ||= nil
           @to_list_type ||= nil
         end
-        ruby2_keywords :initialize if respond_to?(:ruby2_keywords, true)
 
         # @return [Schema::NonNull] Make a non-null-type representation of this type
         def to_non_null_type

data/lib/graphql/schema/member/validates_input.rb

@@ -17,15 +17,15 @@ module GraphQL
         end
 
         def valid_isolated_input?(v)
-          valid_input?(v, GraphQL::Query::NullContext)
+          valid_input?(v, GraphQL::Query::NullContext.instance)
         end
 
         def coerce_isolated_input(v)
-          coerce_input(v, GraphQL::Query::NullContext)
+          coerce_input(v, GraphQL::Query::NullContext.instance)
         end
 
         def coerce_isolated_result(v)
-          coerce_result(v, GraphQL::Query::NullContext)
+          coerce_result(v, GraphQL::Query::NullContext.instance)
         end
       end
     end

data/lib/graphql/schema/mutation.rb

@@ -62,6 +62,13 @@ module GraphQL
       extend GraphQL::Schema::Member::HasFields
       extend GraphQL::Schema::Resolver::HasPayloadType
 
+      # @api private
+      def call_resolve(_args_hash)
+        # Clear any cached values from `loads` or authorization:
+        dataloader.clear_cache
+        super
+      end
+
       class << self
         def visible?(context)
           true

data/lib/graphql/schema/object.rb

@@ -30,6 +30,10 @@ module GraphQL
         # @see authorized_new to make instances
         protected :new
 
+        def wrap_scoped(object, context)
+          scoped_new(object, context)
+        end
+
         # This is called by the runtime to return an object to call methods on.
         def wrap(object, context)
           authorized_new(object, context)
@@ -91,6 +95,10 @@ module GraphQL
             end
           end
         end
+
+        def scoped_new(object, context)
+          self.new(object, context)
+        end
       end
 
       def initialize(object, context)

data/lib/graphql/schema/printer.rb

@@ -36,15 +36,11 @@ module GraphQL
 
       # @param schema [GraphQL::Schema]
       # @param context [Hash]
-      # @param only [<#call(member, ctx)>]
-      # @param except [<#call(member, ctx)>]
       # @param introspection [Boolean] Should include the introspection types in the string?
-      def initialize(schema, context: nil, only: nil, except: nil, introspection: false)
+      def initialize(schema, context: nil, introspection: false)
         @document_from_schema = GraphQL::Language::DocumentFromSchemaDefinition.new(
           schema,
           context: context,
-          only: only,
-          except: except,
           include_introspection_types: introspection,
         )
 
@@ -61,7 +57,12 @@ module GraphQL
             false
           end
         end
-        schema = Class.new(GraphQL::Schema) { query(query_root) }
+        schema = Class.new(GraphQL::Schema) {
+          query(query_root)
+          def self.visible?(member, _ctx)
+            member.graphql_name != "Root"
+          end
+        }
 
         introspection_schema_ast = GraphQL::Language::DocumentFromSchemaDefinition.new(
           schema,
@@ -94,7 +95,7 @@ module GraphQL
 
       class IntrospectionPrinter < GraphQL::Language::Printer
         def print_schema_definition(schema)
-          "schema {\n  query: Root\n}"
+          print_string("schema {\n  query: Root\n}")
         end
       end
     end

data/lib/graphql/schema/relay_classic_mutation.rb

@@ -21,6 +21,10 @@ module GraphQL
     # @see {GraphQL::Schema::Mutation} for an example, it's basically the same.
     #
     class RelayClassicMutation < GraphQL::Schema::Mutation
+      include GraphQL::Schema::HasSingleInputArgument
+
+      argument :client_mutation_id, String, "A unique identifier for the client performing the mutation.", required: false
+
       # The payload should always include this field
       field(:client_mutation_id, String, "A unique identifier for the client performing the mutation.")
       # Relay classic default:
@@ -31,34 +35,14 @@ module GraphQL
       def resolve_with_support(**inputs)
         input = inputs[:input].to_kwargs
 
-        new_extras = field ? field.extras : []
-        all_extras = self.class.extras + new_extras
-
-        # Transfer these from the top-level hash to the
-        # shortcutted `input:` object
-        all_extras.each do |ext|
-          # It's possible that the `extra` was not passed along by this point,
-          # don't re-add it if it wasn't given here.
-          if inputs.key?(ext)
-            input[ext] = inputs[ext]
-          end
-        end
-
         if input
           # This is handled by Relay::Mutation::Resolve, a bit hacky, but here we are.
           input_kwargs = input.to_h
           client_mutation_id = input_kwargs.delete(:client_mutation_id)
-        else
-          # Relay Classic Mutations with no `argument`s
-          # don't require `input:`
-          input_kwargs = {}
+          inputs[:input] = input_kwargs
         end
 
-        return_value = if input_kwargs.any?
-          super(**input_kwargs)
-        else
-          super()
-        end
+        return_value = super(**inputs)
 
         context.query.after_lazy(return_value) do |return_hash|
           # It might be an error
@@ -68,112 +52,6 @@ module GraphQL
           return_hash
         end
       end
-
-      class << self
-        def dummy
-          @dummy ||= begin
-            d = Class.new(GraphQL::Schema::Resolver)
-            d.argument_class(self.argument_class)
-            # TODO make this lazier?
-            d.argument(:input, input_type, description: "Parameters for #{self.graphql_name}")
-            d
-          end
-        end
-
-        def field_arguments(context = GraphQL::Query::NullContext)
-          dummy.arguments(context)
-        end
-
-        def get_field_argument(name, context = GraphQL::Query::NullContext)
-          dummy.get_argument(name, context)
-        end
-
-        def own_field_arguments
-          dummy.own_arguments
-        end
-
-        def all_field_argument_definitions
-          dummy.all_argument_definitions
-        end
-
-        # Also apply this argument to the input type:
-        def argument(*args, own_argument: false, **kwargs, &block)
-          it = input_type # make sure any inherited arguments are already added to it
-          arg = super(*args, **kwargs, &block)
-
-          # This definition might be overriding something inherited;
-          # if it is, remove the inherited definition so it's not confused at runtime as having multiple definitions
-          prev_args = it.own_arguments[arg.graphql_name]
-          case prev_args
-          when GraphQL::Schema::Argument
-            if prev_args.owner != self
-              it.own_arguments.delete(arg.graphql_name)
-            end
-          when Array
-            prev_args.reject! { |a| a.owner != self }
-            if prev_args.empty?
-              it.own_arguments.delete(arg.graphql_name)
-            end
-          end
-
-          it.add_argument(arg)
-          arg
-        end
-
-        # The base class for generated input object types
-        # @param new_class [Class] The base class to use for generating input object definitions
-        # @return [Class] The base class for this mutation's generated input object (default is {GraphQL::Schema::InputObject})
-        def input_object_class(new_class = nil)
-          if new_class
-            @input_object_class = new_class
-          end
-          @input_object_class || (superclass.respond_to?(:input_object_class) ? superclass.input_object_class : GraphQL::Schema::InputObject)
-        end
-
-        # @param new_input_type [Class, nil] If provided, it configures this mutation to accept `new_input_type` instead of generating an input type
-        # @return [Class] The generated {Schema::InputObject} class for this mutation's `input`
-        def input_type(new_input_type = nil)
-          if new_input_type
-            @input_type = new_input_type
-          end
-          @input_type ||= generate_input_type
-        end
-
-        private
-
-        # Generate the input type for the `input:` argument
-        # To customize how input objects are generated, override this method
-        # @return [Class] a subclass of {.input_object_class}
-        def generate_input_type
-          mutation_args = all_argument_definitions
-          mutation_class = self
-          Class.new(input_object_class) do
-            class << self
-              def default_graphql_name
-                "#{self.mutation.graphql_name}Input"
-              end
-
-              def description(new_desc = nil)
-                super || "Autogenerated input type of #{self.mutation.graphql_name}"
-              end
-            end
-            mutation(mutation_class)
-            # these might be inherited:
-            mutation_args.each do |arg|
-              add_argument(arg)
-            end
-            argument :client_mutation_id, String, "A unique identifier for the client performing the mutation.", required: false
-          end
-        end
-      end
-
-      private
-
-      def authorize_arguments(args, values)
-        # remove the `input` wrapper to match values
-        input_args = args["input"].type.unwrap.arguments(context)
-        super(input_args, values)
-      end
     end
   end
 end

data/lib/graphql/schema/resolver.rb

@@ -25,6 +25,7 @@ module GraphQL
       extend GraphQL::Schema::Member::HasValidators
       include Schema::Member::HasPath
       extend Schema::Member::HasPath
+      extend Schema::Member::HasDirectives
 
       # @param object [Object] The application object that this field is being resolved on
       # @param context [GraphQL::Query::Context]
@@ -103,11 +104,7 @@ module GraphQL
                   end
                 elsif authorized_val
                   # Finally, all the hooks have passed, so resolve it
-                  if loaded_args.any?
-                    public_send(self.class.resolve_method, **loaded_args)
-                  else
-                    public_send(self.class.resolve_method)
-                  end
+                  call_resolve(loaded_args)
                 else
                   raise GraphQL::UnauthorizedFieldError.new(context: context, object: object, type: field.owner, field: field)
                 end
@@ -117,6 +114,15 @@ module GraphQL
         end
       end
 
+      # @api private {GraphQL::Schema::Mutation} uses this to clear the dataloader cache
+      def call_resolve(args_hash)
+        if args_hash.any?
+          public_send(self.class.resolve_method, **args_hash)
+        else
+          public_send(self.class.resolve_method)
+        end
+      end
+
       # Do the work. Everything happens here.
       # @return [Object] An object corresponding to the return type
       def resolve(**args)
@@ -166,11 +172,15 @@ module GraphQL
         args.each_value do |argument|
           arg_keyword = argument.keyword
           if inputs.key?(arg_keyword) && !(arg_value = inputs[arg_keyword]).nil? && (arg_value != argument.default_value)
-            arg_auth, err = argument.authorized?(self, arg_value, context)
-            if !arg_auth
-              return arg_auth, err
-            else
-              true
+            auth_result = argument.authorized?(self, arg_value, context)
+            if auth_result.is_a?(Array)
+              # only return this second value if the application returned a second value
+              arg_auth, err = auth_result
+              if !arg_auth
+                return arg_auth, err
+              end
+            elsif auth_result == false
+              return auth_result
             end
           else
             true
@@ -205,16 +215,20 @@ module GraphQL
         end
       end
 
-      def get_argument(name, context = GraphQL::Query::NullContext)
+      def get_argument(name, context = GraphQL::Query::NullContext.instance)
         self.class.get_argument(name, context)
       end
 
       class << self
-        def field_arguments(context = GraphQL::Query::NullContext)
+        def field_arguments(context = GraphQL::Query::NullContext.instance)
           arguments(context)
         end
 
-        def get_field_argument(name, context = GraphQL::Query::NullContext)
+        def any_field_arguments?
+          any_arguments?
+        end
+
+        def get_field_argument(name, context = GraphQL::Query::NullContext.instance)
           get_argument(name, context)
         end
 

data/lib/graphql/schema/scalar.rb

@@ -19,9 +19,9 @@ module GraphQL
 
         def specified_by_url(new_url = nil)
           if new_url
-            @specified_by_url = new_url
-          elsif defined?(@specified_by_url)
-            @specified_by_url
+            directive(GraphQL::Schema::Directive::SpecifiedBy, url: new_url)
+          elsif (directive = directives.find { |dir| dir.graphql_name == "specifiedBy" })
+            directive.arguments[:url] # rubocop:disable Development/ContextIsPassedCop
           elsif superclass.respond_to?(:specified_by_url)
             superclass.specified_by_url
           else

data/lib/graphql/schema/subscription.rb

@@ -28,14 +28,19 @@ module GraphQL
       def resolve_with_support(**args)
         result = nil
         unsubscribed = true
-        catch :graphql_subscription_unsubscribed do
+        unsubscribed_result = catch :graphql_subscription_unsubscribed do
           result = super
           unsubscribed = false
         end
 
 
         if unsubscribed
-          context.skip
+          if unsubscribed_result
+            context.namespace(:subscriptions)[:final_update] = true
+            unsubscribed_result
+          else
+            context.skip
+          end
         else
           result
         end
@@ -94,9 +99,11 @@ module GraphQL
       end
 
       # Call this to halt execution and remove this subscription from the system
-      def unsubscribe
+      # @param update_value [Object] if present, deliver this update before unsubscribing
+      # @return [void]
+      def unsubscribe(update_value = nil)
         context.namespace(:subscriptions)[:unsubscribed] = true
-        throw :graphql_subscription_unsubscribed
+        throw :graphql_subscription_unsubscribed, update_value
       end
 
       READING_SCOPE = ::Object.new

data/lib/graphql/schema/union.rb

@@ -10,7 +10,7 @@ module GraphQL
           super
         end
 
-        def possible_types(*types, context: GraphQL::Query::NullContext, **options)
+        def possible_types(*types, context: GraphQL::Query::NullContext.instance, **options)
           if types.any?
             types.each do |t|
               assert_valid_union_member(t)

data/lib/graphql/schema/unique_within_type.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
-require 'graphql/schema/base_64_bp'
+require "base64"
 
 module GraphQL
   class Schema