graphql 1.9.21 → 2.0.16

data/lib/graphql/schema/object.rb

@@ -1,10 +1,12 @@
 # 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 +14,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,12 +48,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 = context.query.with_error_handling do
+          trace_payload = { context: context, type: self, object: object, path: context[:current_path] }
+
+          maybe_lazy_auth_val = context.query.trace("authorized", trace_payload) do
             begin
               authorized?(object, context)
             rescue GraphQL::UnauthorizedError => err
               context.schema.unauthorized_object(err)
+            rescue StandardError => err
+              context.query.handle_or_reraise(err)
+            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|
@@ -57,13 +84,9 @@ module GraphQL
                 else
                   nil
                 end
-              # rescue GraphQL::ExecutionError => err
-              #   err
               end
             end
           end
-        # rescue GraphQL::ExecutionError => err
-        #   err
         end
       end
 
@@ -73,61 +96,16 @@ 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
+        # 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 const_missing(name)
+          if name == :InvalidNullError
+            custom_err_class = GraphQL::InvalidNullError.subclass_for(self)
+            const_set(:InvalidNullError, custom_err_class)
+            custom_err_class
+          else
+            super
           end
-          own_interfaces.concat(new_interfaces)
-        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
-          all_fields = super
-          interfaces.each do |int|
-            if int.is_a?(GraphQL::InterfaceType)
-              int_f = {}
-              int.fields.each do |name, legacy_field|
-                int_f[name] = field_class.from_options(name, field: legacy_field)
-              end
-              all_fields = int_f.merge(all_fields)
-            end
-          end
-          all_fields
-        end
-
-        # @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.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
-          end
-
-          obj_type.metadata[:type_class] = self
-
-          obj_type
         end
 
         def kind

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,20 +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") do
-          field :throwaway_field, types.String
+        query_root = Class.new(GraphQL::Schema::Object) do
+          graphql_name "Root"
+          field :throwaway_field, String
         end
-        schema = GraphQL::Schema.define(query: query_root)
+        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
@@ -87,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)
@@ -95,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,32 +22,26 @@ 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)
 
       # Override {GraphQL::Schema::Resolver#resolve_with_support} to
       # delete `client_mutation_id` from the kwargs.
       def resolve_with_support(**inputs)
-        # Without the interpreter, the inputs are unwrapped by an instrumenter.
-        # 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
-          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
+        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
-        else
-          input = inputs
         end
 
         if input
@@ -66,21 +60,66 @@ module GraphQL
           super()
         end
 
-        # Again, this is done by an instrumenter when using non-interpreter execution.
-        if context.interpreter?
-          context.schema.after_lazy(return_value) do |return_hash|
-            # It might be an error
-            if return_hash.is_a?(Hash)
-              return_hash[:client_mutation_id] = client_mutation_id
-            end
-            return_hash
+        context.schema.after_lazy(return_value) do |return_hash|
+          # It might be an error
+          if return_hash.is_a?(Hash)
+            return_hash[:client_mutation_id] = client_mutation_id
           end
-        else
-          return_value
+          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})
@@ -100,33 +139,41 @@ module GraphQL
           @input_type ||= generate_input_type
         end
 
-        # Extend {Schema::Mutation.field_options} to add the `input` argument
-        def field_options
-          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
-        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 = arguments
-          mutation_name = graphql_name
+          mutation_args = all_argument_definitions
           mutation_class = self
           Class.new(input_object_class) do
-            graphql_name("#{mutation_name}Input")
-            description("Autogenerated input type of #{mutation_name}")
+            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)
-            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

@@ -20,14 +20,26 @@ module GraphQL
           @payload_type ||= generate_payload_type
         end
 
-        alias :type :payload_type
+        def type(new_type = nil, null: nil)
+          if new_type
+            payload_type(new_type)
+            if !null.nil?
+              self.null(null)
+            end
+          else
+            super()
+          end
+        end
+
         alias :type_expr :payload_type
 
         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_value(:field_class, GraphQL::Schema::Field)
+            find_inherited_value(:field_class, GraphQL::Schema::Field)
           end
         end
 
@@ -36,12 +48,39 @@ 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
+
+          pt.add_field(field_defn, method_conflict_warning: false)
+          field_defn
+        end
+
         private
 
         # Build a subclass of {.object_class} based on `self`.
@@ -49,14 +88,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|
+            description("Autogenerated return type of #{resolver_name}.")
+            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