graphql 1.9.5 → 1.13.19

data/lib/graphql/schema/object.rb

@@ -1,10 +1,13 @@
 # frozen_string_literal: true
 
+require "graphql/query/null_context"
+
 module GraphQL
   class Schema
     class Object < GraphQL::Schema::Member
       extend GraphQL::Schema::Member::AcceptsDefinition
       extend GraphQL::Schema::Member::HasFields
+      extend GraphQL::Schema::Member::HasInterfaces
 
       # @return [Object] the application object this type is wrapping
       attr_reader :object
@@ -12,6 +15,17 @@ module GraphQL
       # @return [GraphQL::Query::Context] the context instance for this query
       attr_reader :context
 
+      # @return [GraphQL::Dataloader]
+      def dataloader
+        context.dataloader
+      end
+
+      # Call this in a field method to return a value that should be returned to the client
+      # without any further handling by GraphQL.
+      def raw_value(obj)
+        GraphQL::Execution::Interpreter::RawValue.new(obj)
+      end
+
       class << self
         # This is protected so that we can be sure callers use the public method, {.authorized_new}
         # @see authorized_new to make instances
@@ -35,10 +49,26 @@ module GraphQL
         # @return [GraphQL::Schema::Object, GraphQL::Execution::Lazy]
         # @raise [GraphQL::UnauthorizedError] if the user-provided hook returns `false`
         def authorized_new(object, context)
-          auth_val = begin
-            authorized?(object, context)
-          rescue GraphQL::UnauthorizedError => err
-            context.schema.unauthorized_object(err)
+          trace_payload = { context: context, type: self, object: object, path: context[:current_path] }
+
+          maybe_lazy_auth_val = context.query.trace("authorized", trace_payload) do
+            context.query.with_error_handling do
+              begin
+                authorized?(object, context)
+              rescue GraphQL::UnauthorizedError => err
+                context.schema.unauthorized_object(err)
+              end
+            end
+          end
+
+          auth_val = if context.schema.lazy?(maybe_lazy_auth_val)
+            GraphQL::Execution::Lazy.new do
+              context.query.trace("authorized_lazy", trace_payload) do
+                context.schema.sync_lazy(maybe_lazy_auth_val)
+              end
+            end
+          else
+            maybe_lazy_auth_val
           end
 
           context.schema.after_lazy(auth_val) do |is_authorized|
@@ -55,13 +85,9 @@ module GraphQL
                 else
                   nil
                 end
-              # rescue GraphQL::ExecutionError => err
-              #   err
               end
             end
           end
-        # rescue GraphQL::ExecutionError => err
-        #   err
         end
       end
 
@@ -71,37 +97,23 @@ module GraphQL
       end
 
       class << self
-        def implements(*new_interfaces)
-          new_interfaces.each do |int|
-            if int.is_a?(Module)
-              unless int.include?(GraphQL::Schema::Interface)
-                raise "#{int} cannot be implemented since it's not a GraphQL Interface. Use `include` for plain Ruby modules."
-              end
-
-              # Include the methods here,
-              # `.fields` will use the inheritance chain
-              # to find inherited fields
-              include(int)
-            end
-          end
-          own_interfaces.concat(new_interfaces)
+        # Set up a type-specific invalid null error to use when this object's non-null fields wrongly return `nil`.
+        # It should help with debugging and bug tracker integrations.
+        def inherited(child_class)
+          child_class.const_set(:InvalidNullError, GraphQL::InvalidNullError.subclass_for(child_class))
+          super
         end
 
-        def interfaces
-          own_interfaces + (superclass <= GraphQL::Schema::Object ? superclass.interfaces : [])
-        end
-
-        def own_interfaces
-          @own_interfaces ||= []
-        end
-
-        # Include legacy-style interfaces, too
-        def fields
+        # @return [Hash<String => GraphQL::Schema::Field>] All of this object's fields, indexed by name
+        # @see get_field A faster way to find one field by name ({#fields} merges hashes of inherited fields; {#get_field} just looks up one field.)
+        def fields(context = GraphQL::Query::NullContext)
           all_fields = super
+          # This adds fields from legacy-style interfaces only.
+          # Multi-fields are not supported here.
           interfaces.each do |int|
             if int.is_a?(GraphQL::InterfaceType)
               int_f = {}
-              int.fields.each do |name, legacy_field|
+              int.fields.each do |name, legacy_field| # rubocop:disable Development/ContextIsPassedCop -- legacy-related
                 int_f[name] = field_class.from_options(name, field: legacy_field)
               end
               all_fields = int_f.merge(all_fields)
@@ -110,17 +122,20 @@ module GraphQL
           all_fields
         end
 
+        prepend Schema::Member::CachedGraphQLDefinition::DeprecatedToGraphQL
+
         # @return [GraphQL::ObjectType]
         def to_graphql
           obj_type = GraphQL::ObjectType.new
           obj_type.name = graphql_name
           obj_type.description = description
-          obj_type.interfaces = interfaces
+          obj_type.structural_interface_type_memberships = interface_type_memberships
           obj_type.introspection = introspection
           obj_type.mutation = mutation
-          fields.each do |field_name, field_inst|
-            field_defn = field_inst.to_graphql
-            obj_type.fields[field_defn.name] = field_defn
+          obj_type.ast_node = ast_node
+          fields.each do |field_name, field_inst| # rubocop:disable Development/ContextIsPassedCop -- legacy-related
+            field_defn = field_inst.to_graphql(silence_deprecation_warning: true)
+            obj_type.fields[field_defn.name] = field_defn # rubocop:disable Development/ContextIsPassedCop -- legacy-related
           end
 
           obj_type.metadata[:type_class] = self

data/lib/graphql/schema/possible_types.rb

@@ -14,26 +14,31 @@ module GraphQL
     class PossibleTypes
       def initialize(schema)
         @object_types = schema.types.values.select { |type| type.kind.object? }
-
-        @interface_implementers = Hash.new do |hash, key|
-          hash[key] = @object_types.select { |type| type.interfaces.include?(key) }.sort_by(&:name)
+        @interface_implementers = Hash.new do |h1, ctx|
+          h1[ctx] = Hash.new do |h2, int_type|
+            h2[int_type] = @object_types.select { |type| type.interfaces(ctx).include?(int_type) }.sort_by(&:name)
+          end
         end
       end
 
-      def possible_types(type_defn)
+      def possible_types(type_defn, ctx)
         case type_defn
         when Module
-          possible_types(type_defn.graphql_definition)
+          possible_types(type_defn.graphql_definition, ctx)
         when GraphQL::UnionType
-          type_defn.possible_types
+          type_defn.possible_types(ctx)
         when GraphQL::InterfaceType
-          @interface_implementers[type_defn]
+          interface_implementers(ctx, type_defn)
         when GraphQL::BaseType
           [type_defn]
         else
           raise "Unexpected possible_types object: #{type_defn.inspect}"
         end
       end
+
+      def interface_implementers(ctx, type_defn)
+        @interface_implementers[ctx][type_defn]
+      end
     end
   end
 end

data/lib/graphql/schema/printer.rb

@@ -4,37 +4,32 @@ module GraphQL
     # Used to convert your {GraphQL::Schema} to a GraphQL schema string
     #
     # @example print your schema to standard output (via helper)
-    #   MySchema = GraphQL::Schema.define(query: QueryType)
     #   puts GraphQL::Schema::Printer.print_schema(MySchema)
     #
     # @example print your schema to standard output
-    #   MySchema = GraphQL::Schema.define(query: QueryType)
     #   puts GraphQL::Schema::Printer.new(MySchema).print_schema
     #
     # @example print a single type to standard output
-    #   query_root = GraphQL::ObjectType.define do
-    #     name "Query"
+    #   class Types::Query < GraphQL::Schema::Object
     #     description "The query root of this schema"
     #
-    #     field :post do
-    #       type post_type
-    #       resolve ->(obj, args, ctx) { Post.find(args["id"]) }
-    #     end
+    #     field :post, Types::Post, null: true
     #   end
     #
-    #   post_type = GraphQL::ObjectType.define do
-    #     name "Post"
+    #   class Types::Post < GraphQL::Schema::Object
     #     description "A blog post"
     #
-    #     field :id, !types.ID
-    #     field :title, !types.String
-    #     field :body, !types.String
+    #     field :id, ID, null: false
+    #     field :title, String, null: false
+    #     field :body, String, null: false
     #   end
     #
-    #   MySchema = GraphQL::Schema.define(query: query_root)
+    #   class MySchema < GraphQL::Schema
+    #     query(Types::Query)
+    #   end
     #
     #   printer = GraphQL::Schema::Printer.new(MySchema)
-    #   puts printer.print_type(post_type)
+    #   puts printer.print_type(Types::Post)
     #
     class Printer < GraphQL::Language::Printer
       attr_reader :schema, :warden
@@ -54,18 +49,20 @@ module GraphQL
         )
 
         @document = @document_from_schema.document
-
         @schema = schema
       end
 
       # Return the GraphQL schema string for the introspection type system
       def self.print_introspection_schema
-        query_root = ObjectType.define(name: "Root")
-        schema = GraphQL::Schema.define(query: query_root)
+        query_root = Class.new(GraphQL::Schema::Object) do
+          graphql_name "Root"
+          field :throwaway_field, String
+        end
+        schema = Class.new(GraphQL::Schema) { query(query_root) }
 
         introspection_schema_ast = GraphQL::Language::DocumentFromSchemaDefinition.new(
           schema,
-          except: ->(member, _) { member.name == "Root" },
+          except: ->(member, _) { member.graphql_name == "Root" },
           include_introspection_types: true,
           include_built_in_directives: true,
         ).document
@@ -85,7 +82,7 @@ module GraphQL
 
       # Return a GraphQL schema string for the defined types in the schema
       def print_schema
-        print(@document)
+        print(@document) + "\n"
       end
 
       def print_type(type)
@@ -93,20 +90,6 @@ module GraphQL
         print(node)
       end
 
-      def print_directive(directive)
-        if directive.name == "deprecated"
-          reason = directive.arguments.find { |arg| arg.name == "reason" }
-
-          if reason.value == GraphQL::Directive::DEFAULT_DEPRECATION_REASON
-            "@deprecated"
-          else
-            "@deprecated(reason: #{reason.value.to_s.inspect})"
-          end
-        else
-          super
-        end
-      end
-
       class IntrospectionPrinter < GraphQL::Language::Printer
         def print_schema_definition(schema)
           "schema {\n  query: Root\n}"

data/lib/graphql/schema/relay_classic_mutation.rb

@@ -22,7 +22,7 @@ module GraphQL
     #
     class RelayClassicMutation < GraphQL::Schema::Mutation
       # The payload should always include this field
-      field(:client_mutation_id, String, "A unique identifier for the client performing the mutation.", null: true)
+      field(:client_mutation_id, String, "A unique identifier for the client performing the mutation.")
       # Relay classic default:
       null(true)
 
@@ -33,10 +33,18 @@ module GraphQL
         # But when using the interpreter, no instrumenters are applied.
         if context.interpreter?
           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
-          self.class.extras.each do |ext|
-            input[ext] = inputs[ext]
+          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
         else
           input = inputs
@@ -53,7 +61,7 @@ module GraphQL
         end
 
         return_value = if input_kwargs.any?
-          super(input_kwargs)
+          super(**input_kwargs)
         else
           super()
         end
@@ -73,6 +81,31 @@ module GraphQL
       end
 
       class << self
+
+        # Also apply this argument to the input type:
+        def argument(*args, **kwargs, &block)
+          it = input_type # make sure any inherited arguments are already added to it
+          arg = super
+
+          # 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})
@@ -97,7 +130,7 @@ module GraphQL
           sig = super
           # Arguments were added at the root, but they should be nested
           sig[:arguments].clear
-          sig[:arguments][:input] = { type: input_type, required: true }
+          sig[:arguments][:input] = { type: input_type, required: true, description: "Parameters for #{graphql_name}" }
           sig
         end
 
@@ -107,18 +140,29 @@ module GraphQL
         # To customize how input objects are generated, override this method
         # @return [Class] a subclass of {.input_object_class}
         def generate_input_type
-          mutation_args = arguments
+          mutation_args = all_argument_definitions
           mutation_name = graphql_name
           mutation_class = self
           Class.new(input_object_class) do
             graphql_name("#{mutation_name}Input")
             description("Autogenerated input type of #{mutation_name}")
             mutation(mutation_class)
-            own_arguments.merge!(mutation_args)
+            # 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/has_payload_type.rb

@@ -26,8 +26,10 @@ module GraphQL
         def field_class(new_class = nil)
           if new_class
             @field_class = new_class
+          elsif defined?(@field_class) && @field_class
+            @field_class
           else
-            @field_class || find_inherited_method(:field_class, GraphQL::Schema::Field)
+            find_inherited_value(:field_class, GraphQL::Schema::Field)
           end
         end
 
@@ -36,9 +38,37 @@ module GraphQL
         # @return [Class]
         def object_class(new_class = nil)
           if new_class
+            if defined?(@payload_type)
+              raise "Can't configure `object_class(...)` after the payload type has already been initialized. Move this configuration higher up the class definition."
+            end
             @object_class = new_class
+          else
+            @object_class || find_inherited_value(:object_class, GraphQL::Schema::Object)
+          end
+        end
+
+        NO_INTERFACES = [].freeze
+
+        def field(*args, **kwargs, &block)
+          pt = payload_type # make sure it's initialized with any inherited fields
+          field_defn = super
+
+          # Remove any inherited fields to avoid false conflicts at runtime
+          prev_fields = pt.own_fields[field_defn.graphql_name]
+          case prev_fields
+          when GraphQL::Schema::Field
+            if prev_fields.owner != self
+              pt.own_fields.delete(field_defn.graphql_name)
+            end
+          when Array
+            prev_fields.reject! { |f| f.owner != self }
+            if prev_fields.empty?
+              pt.own_fields.delete(field_defn.graphql_name)
+            end
           end
-          @object_class || (superclass.respond_to?(:object_class) ? superclass.object_class : GraphQL::Schema::Object)
+
+          pt.add_field(field_defn, method_conflict_warning: false)
+          field_defn
         end
 
         private
@@ -48,14 +78,15 @@ module GraphQL
         # Override this hook to customize return type generation.
         def generate_payload_type
           resolver_name = graphql_name
-          resolver_fields = fields
+          resolver_fields = all_field_definitions
           Class.new(object_class) do
             graphql_name("#{resolver_name}Payload")
             description("Autogenerated return type of #{resolver_name}")
-            resolver_fields.each do |name, f|
+            resolver_fields.each do |f|
               # Reattach the already-defined field here
               # (The field's `.owner` will still point to the mutation, not the object type, I think)
-              add_field(f)
+              # Don't re-warn about a method conflict. Since this type is generated, it should be fixed in the resolver instead.
+              add_field(f, method_conflict_warning: false)
             end
           end
         end