graphql 2.0.27 → 2.2.6

data/lib/graphql/schema/has_single_input_argument.rb

@@ -0,0 +1,156 @@
+# frozen_string_literal: true
+
+module GraphQL
+  class Schema
+    module HasSingleInputArgument
+      def resolve_with_support(**inputs)
+        if inputs[:input].is_a?(InputObject)
+          input = inputs[:input].to_kwargs
+        else
+          input = inputs[:input]
+        end
+
+        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
+        else
+          # Relay Classic Mutations with no `argument`s
+          # don't require `input:`
+          input_kwargs = {}
+        end
+
+        if input_kwargs.any?
+          super(**input_kwargs)
+        else
+          super()
+        end
+      end
+
+      def self.included(base)
+        base.extend(ClassMethods)
+      end
+
+      module ClassMethods
+        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.instance)
+          dummy.arguments(context)
+        end
+
+        def get_field_argument(name, context = GraphQL::Query::NullContext.instance)
+          dummy.get_argument(name, context)
+        end
+
+        def own_field_arguments
+          dummy.own_arguments
+        end
+
+        def any_field_arguments?
+          dummy.any_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
+          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/input_object.rb

@@ -79,7 +79,7 @@ module GraphQL
       end
 
       def self.one_of?
-        directives.any? { |d| d.is_a?(GraphQL::Schema::Directive::OneOf) }
+        false # Re-defined when `OneOf` is added
       end
 
       def unwrap_value(value)
@@ -145,7 +145,7 @@ module GraphQL
         end
 
         # @api private
-        INVALID_OBJECT_MESSAGE = "Expected %{object} to be a key-value object responding to `to_h` or `to_unsafe_h`."
+        INVALID_OBJECT_MESSAGE = "Expected %{object} to be a key-value object."
 
         def validate_non_null_input(input, ctx, max_errors: nil)
           warden = ctx.warden

data/lib/graphql/schema/interface.rb

@@ -20,6 +20,15 @@ module GraphQL
         # - Added as class methods to this interface
         # - Added as class methods to all child interfaces
         def definition_methods(&block)
+          # Use an instance variable to tell whether it's been included previously or not;
+          # You can't use constant detection because constants are brought into scope
+          # by `include`, which has already happened at this point.
+          if !defined?(@_definition_methods)
+            defn_methods_module = Module.new
+            @_definition_methods = defn_methods_module
+            const_set(:DefinitionMethods, defn_methods_module)
+            extend(self::DefinitionMethods)
+          end
           self::DefinitionMethods.module_eval(&block)
         end
 
@@ -47,20 +56,11 @@ module GraphQL
 
             child_class.type_membership_class(self.type_membership_class)
             child_class.ancestors.reverse_each do |ancestor|
-              if ancestor.const_defined?(:DefinitionMethods)
+              if ancestor.const_defined?(:DefinitionMethods) && ancestor != child_class
                 child_class.extend(ancestor::DefinitionMethods)
               end
             end
 
-            # Use an instance variable to tell whether it's been included previously or not;
-            # You can't use constant detection because constants are brought into scope
-            # by `include`, which has already happened at this point.
-            if !child_class.instance_variable_defined?(:@_definition_methods)
-              defn_methods_module = Module.new
-              child_class.instance_variable_set(:@_definition_methods, defn_methods_module)
-              child_class.const_set(:DefinitionMethods, defn_methods_module)
-              child_class.extend(child_class::DefinitionMethods)
-            end
             child_class.introspection(introspection)
             child_class.description(description)
             # If interfaces are mixed into each other, only define this class once

data/lib/graphql/schema/introspection_system.rb

@@ -39,7 +39,9 @@ module GraphQL
             entry_point_fields.delete('__type') if schema.disable_type_introspection_entry_point?
             entry_point_fields
           end
+        @entry_point_fields.each { |k, v| v.dynamic_introspection = true }
         @dynamic_fields = get_fields_from_class(class_sym: :DynamicFields)
+        @dynamic_fields.each { |k, v| v.dynamic_introspection = true }
       end
 
       def entry_points

data/lib/graphql/schema/loader.rb

@@ -176,7 +176,6 @@ module GraphQL
             while (of_type = unwrapped_field_hash["ofType"])
               unwrapped_field_hash = of_type
             end
-            type_name = unwrapped_field_hash["name"]
 
             type_defn.field(
               field_hash["name"],
@@ -186,7 +185,6 @@ module GraphQL
               null: true,
               camelize: false,
               connection_extension: nil,
-              connection: type_name.end_with?("Connection"),
             ) do
               if field_hash["args"].any?
                 loader.build_arguments(self, field_hash["args"], type_resolver)

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

@@ -102,7 +102,8 @@ module GraphQL
         def default_graphql_name
           @default_graphql_name ||= begin
             raise GraphQL::RequiredImplementationMissingError, 'Anonymous class should declare a `graphql_name`' if name.nil?
-            -name.split("::").last.sub(/Type\Z/, "")
+            g_name = -name.split("::").last
+            g_name.end_with?("Type") ? g_name.sub(/Type\Z/, "") : g_name
           end
         end
 

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

@@ -109,7 +109,7 @@ module GraphQL
         end
 
         # @return [Hash<String => GraphQL::Schema::Argument] Arguments defined on this thing, keyed by name. Includes inherited definitions
-        def arguments(context = GraphQL::Query::NullContext)
+        def arguments(context = GraphQL::Query::NullContext.instance)
           if own_arguments.any?
             own_arguments_that_apply = {}
             own_arguments.each do |name, args_entry|
@@ -122,6 +122,10 @@ module GraphQL
           own_arguments_that_apply || own_arguments
         end
 
+        def any_arguments?
+          own_arguments.any?
+        end
+
         module ClassConfigured
           def inherited(child_class)
             super
@@ -129,7 +133,7 @@ module GraphQL
           end
 
           module InheritedArguments
-            def arguments(context = GraphQL::Query::NullContext)
+            def arguments(context = GraphQL::Query::NullContext.instance)
               own_arguments = super
               inherited_arguments = superclass.arguments(context)
 
@@ -145,6 +149,10 @@ module GraphQL
               end
             end
 
+            def any_arguments?
+              super || superclass.any_arguments?
+            end
+
             def all_argument_definitions
               all_defns = {}
               ancestors.reverse_each do |ancestor|
@@ -158,7 +166,7 @@ module GraphQL
             end
 
 
-            def get_argument(argument_name, context = GraphQL::Query::NullContext)
+            def get_argument(argument_name, context = GraphQL::Query::NullContext.instance)
               warden = Warden.from_context(context)
               for ancestor in ancestors
                 if ancestor.respond_to?(:own_arguments) &&
@@ -173,9 +181,9 @@ module GraphQL
         end
 
         module FieldConfigured
-          def arguments(context = GraphQL::Query::NullContext)
+          def arguments(context = GraphQL::Query::NullContext.instance)
             own_arguments = super
-            if defined?(@resolver_class) && @resolver_class
+            if @resolver_class
               inherited_arguments = @resolver_class.field_arguments(context)
               if own_arguments.any?
                 if inherited_arguments.any?
@@ -191,8 +199,12 @@ module GraphQL
             end
           end
 
+          def any_arguments?
+            super || (@resolver_class && @resolver_class.any_field_arguments?)
+          end
+
           def all_argument_definitions
-            if defined?(@resolver_class) && @resolver_class
+            if @resolver_class
               all_defns = {}
               @resolver_class.all_field_argument_definitions.each do |arg_defn|
                 key = arg_defn.graphql_name
@@ -224,7 +236,7 @@ module GraphQL
         end
 
         # @return [GraphQL::Schema::Argument, nil] Argument defined on this thing, fetched by name.
-        def get_argument(argument_name, context = GraphQL::Query::NullContext)
+        def get_argument(argument_name, context = GraphQL::Query::NullContext.instance)
           warden = Warden.from_context(context)
           if (arg_config = own_arguments[argument_name]) && (visible_arg = Warden.visible_entry?(:visible_argument?, arg_config, context, warden))
             visible_arg
@@ -367,41 +379,52 @@ module GraphQL
           def authorize_application_object(argument, id, context, loaded_application_object)
             context.query.after_lazy(loaded_application_object) do |application_object|
               if application_object.nil?
-                err = GraphQL::LoadApplicationObjectFailedError.new(argument: argument, id: id, object: application_object)
-                load_application_object_failed(err)
+                err = GraphQL::LoadApplicationObjectFailedError.new(context: context, argument: argument, id: id, object: application_object)
+                application_object = load_application_object_failed(err)
               end
               # Double-check that the located object is actually of this type
               # (Don't want to allow arbitrary access to objects this way)
-              maybe_lazy_resolve_type = context.schema.resolve_type(argument.loads, application_object, context)
-              context.query.after_lazy(maybe_lazy_resolve_type) do |resolve_type_result|
-                if resolve_type_result.is_a?(Array) && resolve_type_result.size == 2
-                  application_object_type, application_object = resolve_type_result
-                else
-                  application_object_type = resolve_type_result
-                  # application_object is already assigned
-                end
-                possible_object_types = context.warden.possible_types(argument.loads)
-                if !possible_object_types.include?(application_object_type)
-                  err = GraphQL::LoadApplicationObjectFailedError.new(argument: argument, id: id, object: application_object)
-                  load_application_object_failed(err)
-                else
-                  # This object was loaded successfully
-                  # and resolved to the right type,
-                  # now apply the `.authorized?` class method if there is one
-                  context.query.after_lazy(application_object_type.authorized?(application_object, context)) do |authed|
-                    if authed
-                      application_object
-                    else
-                      err = GraphQL::UnauthorizedError.new(
-                        object: application_object,
-                        type: application_object_type,
-                        context: context,
-                      )
-                      if self.respond_to?(:unauthorized_object)
-                        err.set_backtrace(caller)
-                        unauthorized_object(err)
+              if application_object.nil?
+                nil
+              else
+                maybe_lazy_resolve_type = context.schema.resolve_type(argument.loads, application_object, context)
+                context.query.after_lazy(maybe_lazy_resolve_type) do |resolve_type_result|
+                  if resolve_type_result.is_a?(Array) && resolve_type_result.size == 2
+                    application_object_type, application_object = resolve_type_result
+                  else
+                    application_object_type = resolve_type_result
+                    # application_object is already assigned
+                  end
+
+                  if !(
+                      context.warden.possible_types(argument.loads).include?(application_object_type) ||
+                      context.warden.loadable?(argument.loads, context)
+                    )
+                    err = GraphQL::LoadApplicationObjectFailedError.new(context: context, argument: argument, id: id, object: application_object)
+                    application_object = load_application_object_failed(err)
+                  end
+
+                  if application_object.nil?
+                    nil
+                  else
+                    # This object was loaded successfully
+                    # and resolved to the right type,
+                    # now apply the `.authorized?` class method if there is one
+                    context.query.after_lazy(application_object_type.authorized?(application_object, context)) do |authed|
+                      if authed
+                        application_object
                       else
-                        raise err
+                        err = GraphQL::UnauthorizedError.new(
+                          object: application_object,
+                          type: application_object_type,
+                          context: context,
+                        )
+                        if self.respond_to?(:unauthorized_object)
+                          err.set_backtrace(caller)
+                          unauthorized_object(err)
+                        else
+                          raise err
+                        end
                       end
                     end
                   end

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

@@ -97,7 +97,7 @@ module GraphQL
         end
 
         module InterfaceMethods
-          def get_field(field_name, context = GraphQL::Query::NullContext)
+          def get_field(field_name, context = GraphQL::Query::NullContext.instance)
             warden = Warden.from_context(context)
             for ancestor in ancestors
               if ancestor.respond_to?(:own_fields) &&
@@ -110,7 +110,7 @@ module GraphQL
           end
 
           # @return [Hash<String => GraphQL::Schema::Field>] Fields on this object, keyed by name, including inherited fields
-          def fields(context = GraphQL::Query::NullContext)
+          def fields(context = GraphQL::Query::NullContext.instance)
             warden = Warden.from_context(context)
             # Local overrides take precedence over inherited fields
             visible_fields = {}
@@ -130,22 +130,25 @@ module GraphQL
         end
 
         module ObjectMethods
-          def get_field(field_name, context = GraphQL::Query::NullContext)
+          def get_field(field_name, context = GraphQL::Query::NullContext.instance)
             # Objects need to check that the interface implementation is visible, too
             warden = Warden.from_context(context)
-            for ancestor in ancestors
+            ancs = ancestors
+            i = 0
+            while (ancestor = ancs[i])
               if ancestor.respond_to?(:own_fields) &&
                   visible_interface_implementation?(ancestor, context, warden) &&
                   (f_entry = ancestor.own_fields[field_name]) &&
                   (f = Warden.visible_entry?(:visible_field?, f_entry, context, warden))
                 return f
               end
+              i += 1
             end
             nil
           end
 
           # @return [Hash<String => GraphQL::Schema::Field>] Fields on this object, keyed by name, including inherited fields
-          def fields(context = GraphQL::Query::NullContext)
+          def fields(context = GraphQL::Query::NullContext.instance)
             # Objects need to check that the interface implementation is visible, too
             warden = Warden.from_context(context)
             # Local overrides take precedence over inherited fields

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

@@ -70,11 +70,20 @@ module GraphQL
           end
 
           module InheritedInterfaces
-            def interfaces(context = GraphQL::Query::NullContext)
+            def interfaces(context = GraphQL::Query::NullContext.instance)
               visible_interfaces = super
-              visible_interfaces.concat(superclass.interfaces(context))
-              visible_interfaces.uniq!
-              visible_interfaces
+              inherited_interfaces = superclass.interfaces(context)
+              if visible_interfaces.any?
+                if inherited_interfaces.any?
+                  visible_interfaces.concat(inherited_interfaces)
+                  visible_interfaces.uniq!
+                end
+                visible_interfaces
+              elsif inherited_interfaces.any?
+                inherited_interfaces
+              else
+                EmptyObjects::EMPTY_ARRAY
+              end
             end
 
             def interface_type_memberships
@@ -90,25 +99,30 @@ module GraphQL
         end
 
         # param context [Query::Context] If omitted, skip filtering.
-        def interfaces(context = GraphQL::Query::NullContext)
+        def interfaces(context = GraphQL::Query::NullContext.instance)
           warden = Warden.from_context(context)
-          visible_interfaces = []
+          visible_interfaces = nil
           own_interface_type_memberships.each do |type_membership|
             case type_membership
             when Schema::TypeMembership
               if warden.visible_type_membership?(type_membership, context)
+                visible_interfaces ||= []
                 visible_interfaces << type_membership.abstract_type
               end
             when String, Schema::LateBoundType
               # During initialization, `type_memberships` can hold late-bound types
+              visible_interfaces ||= []
               visible_interfaces << type_membership
             else
               raise "Invariant: Unexpected type_membership #{type_membership.class}: #{type_membership.inspect}"
             end
           end
-          visible_interfaces.uniq!
-
-          visible_interfaces
+          if visible_interfaces
+            visible_interfaces.uniq!
+            visible_interfaces
+          else
+            EmptyObjects::EMPTY_ARRAY
+          end
         end
 
         private

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