graphql 1.8.0 → 1.12.12

data/lib/graphql/schema/non_null.rb

@@ -2,20 +2,21 @@
 
 module GraphQL
   class Schema
+    # Represents a non null type in the schema.
     # Wraps a {Schema::Member} when it is required.
     # @see {Schema::Member::TypeSystemHelpers#to_non_null_type}
-    class NonNull
-      include GraphQL::Schema::Member::CachedGraphQLDefinition
-      include GraphQL::Schema::Member::TypeSystemHelpers
-      attr_reader :of_type
-      def initialize(of_type)
-        @of_type = of_type
-      end
+    class NonNull < GraphQL::Schema::Wrapper
+      include Schema::Member::ValidatesInput
 
       def to_graphql
         @of_type.graphql_definition.to_non_null_type
       end
 
+       # @return [GraphQL::TypeKinds::NON_NULL]
+      def kind
+        GraphQL::TypeKinds::NON_NULL
+      end
+
       # @return [true]
       def non_null?
         true
@@ -26,12 +27,40 @@ module GraphQL
         @of_type.list?
       end
 
-      def kind
-        GraphQL::TypeKinds::NON_NULL
+      def to_type_signature
+        "#{@of_type.to_type_signature}!"
+      end
+
+      def inspect
+        "#<#{self.class.name} @of_type=#{@of_type.inspect}>"
+      end
+
+      def validate_input(value, ctx)
+        if value.nil?
+          result = GraphQL::Query::InputValidationResult.new
+          result.add_problem("Expected value to not be null")
+          result
+        else
+          of_type.validate_input(value, ctx)
+        end
+      end
+
+      # This is for introspection, where it's expected the name will be `null`
+      def graphql_name
+        nil
+      end
+
+      def coerce_input(value, ctx)
+        of_type.coerce_input(value, ctx)
+      end
+
+      def coerce_result(value, ctx)
+        of_type.coerce_result(value, ctx)
       end
 
-      def unwrap
-        @of_type.unwrap
+      # This is for implementing introspection
+      def description
+        nil
       end
     end
   end

data/lib/graphql/schema/object.rb

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 
+require "graphql/query/null_context"
+
 module GraphQL
   class Schema
     class Object < GraphQL::Schema::Member
@@ -12,36 +14,170 @@ 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
+        protected :new
+
+        # Make a new instance of this type _if_ the auth check passes,
+        # otherwise, raise an error.
+        #
+        # Probably only the framework should call this method.
+        #
+        # This might return a {GraphQL::Execution::Lazy} if the user-provided `.authorized?`
+        # hook returns some lazy value (like a Promise).
+        #
+        # The reason that the auth check is in this wrapper method instead of {.new} is because
+        # of how it might return a Promise. It would be weird if `.new` returned a promise;
+        # It would be a headache to try to maintain Promise-y state inside a {Schema::Object}
+        # instance. So, hopefully this wrapper method will do the job.
+        #
+        # @param object [Object] The thing wrapped by this object
+        # @param context [GraphQL::Query::Context]
+        # @return [GraphQL::Schema::Object, GraphQL::Execution::Lazy]
+        # @raise [GraphQL::UnauthorizedError] if the user-provided hook returns `false`
+        def authorized_new(object, context)
+          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|
+            if is_authorized
+              self.new(object, context)
+            else
+              # It failed the authorization check, so go to the schema's authorized object hook
+              err = GraphQL::UnauthorizedError.new(object: object, type: self, context: context)
+              # If a new value was returned, wrap that instead of the original value
+              begin
+                new_obj = context.schema.unauthorized_object(err)
+                if new_obj
+                  self.new(new_obj, context)
+                else
+                  nil
+                end
+              end
+            end
+          end
+        end
+      end
+
       def initialize(object, context)
         @object = object
         @context = context
       end
 
       class << self
-        def implements(*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 implements(*new_interfaces, **options)
+          new_memberships = []
           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
+
+              new_memberships << int.type_membership_class.new(int, self, **options)
+
               # Include the methods here,
               # `.fields` will use the inheritance chain
               # to find inherited fields
               include(int)
+            elsif int.is_a?(GraphQL::InterfaceType)
+              new_memberships << int.type_membership_class.new(int, self, **options)
+            elsif int.is_a?(String) || int.is_a?(GraphQL::Schema::LateBoundType)
+              if options.any?
+                raise ArgumentError, "`implements(...)` doesn't support options with late-loaded types yet. Remove #{options} and open an issue to request this feature."
+              end
+              new_memberships << int
+            else
+              raise ArgumentError, "Unexpected interface definition (expected module): #{int} (#{int.class})"
             end
           end
-          own_interfaces.concat(new_interfaces)
+
+          # Remove any interfaces which are being replaced (late-bound types are updated in place this way)
+          own_interface_type_memberships.reject! { |old_i_m|
+            old_int_type = old_i_m.respond_to?(:abstract_type) ? old_i_m.abstract_type : old_i_m
+            old_name = Schema::Member::BuildType.to_type_name(old_int_type)
+
+            new_memberships.any? { |new_i_m|
+              new_int_type = new_i_m.respond_to?(:abstract_type) ? new_i_m.abstract_type : new_i_m
+              new_name = Schema::Member::BuildType.to_type_name(new_int_type)
+
+              new_name == old_name
+            }
+          }
+          own_interface_type_memberships.concat(new_memberships)
         end
 
-        def interfaces
-          own_interfaces + (superclass <= GraphQL::Schema::Object ? superclass.interfaces : [])
+        def own_interface_type_memberships
+          @own_interface_type_memberships ||= []
         end
 
-        def own_interfaces
-          @own_interfaces ||= []
+        def interface_type_memberships
+          own_interface_type_memberships + (superclass.respond_to?(:interface_type_memberships) ? superclass.interface_type_memberships : [])
         end
 
-        # Include legacy-style interfaces, too
+        # param context [Query::Context] If omitted, skip filtering.
+        def interfaces(context = GraphQL::Query::NullContext)
+          visible_interfaces = []
+          unfiltered = context == GraphQL::Query::NullContext
+          own_interface_type_memberships.each do |type_membership|
+            # During initialization, `type_memberships` can hold late-bound types
+            case type_membership
+            when String, Schema::LateBoundType
+              visible_interfaces << type_membership
+            when Schema::TypeMembership
+              if unfiltered || type_membership.visible?(context)
+                visible_interfaces << type_membership.abstract_type
+              end
+            else
+              raise "Invariant: Unexpected type_membership #{type_membership.class}: #{type_membership.inspect}"
+            end
+          end
+          visible_interfaces + (superclass <= GraphQL::Schema::Object ? superclass.interfaces(context) : [])
+        end
+
+        # @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
           all_fields = super
           interfaces.each do |int|
+            # Include legacy-style interfaces, too
             if int.is_a?(GraphQL::InterfaceType)
               int_f = {}
               int.fields.each do |name, legacy_field|
@@ -58,10 +194,10 @@ module 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
-
+          obj_type.ast_node = ast_node
           fields.each do |field_name, field_inst|
             field_defn = field_inst.to_graphql
             obj_type.fields[field_defn.name] = field_defn

data/lib/graphql/schema/possible_types.rb

@@ -14,24 +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, 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}"
+          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

@@ -54,18 +54,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, null: true
+        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
@@ -89,24 +91,10 @@ module GraphQL
       end
 
       def print_type(type)
-        node = @document_from_schema.build_object_type_node(type)
+        node = @document_from_schema.build_type_definition_node(type)
         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

@@ -1,4 +1,5 @@
 # frozen_string_literal: true
+require "graphql/types/string"
 
 module GraphQL
   class Schema
@@ -25,15 +26,59 @@ module GraphQL
       # Relay classic default:
       null(true)
 
-      # Override {GraphQL::Schema::Mutation#resolve_mutation} to
+      # Override {GraphQL::Schema::Resolver#resolve_with_support} to
       # delete `client_mutation_id` from the kwargs.
-      def resolve_mutation(kwargs)
-        # This is handled by Relay::Mutation::Resolve, a bit hacky, but here we are.
-        kwargs.delete(:client_mutation_id)
-        resolve(**kwargs)
-      end
+      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
+          end
+        else
+          input = inputs
+        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 = {}
+        end
+
+        return_value = if input_kwargs.any?
+          super(**input_kwargs)
+        else
+          super()
+        end
 
-      resolve_method(:resolve_mutation)
+        # 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
+          end
+        else
+          return_value
+        end
+      end
 
       class << self
         # The base class for generated input object types
@@ -60,7 +105,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
 
@@ -77,7 +122,9 @@ module GraphQL
             graphql_name("#{mutation_name}Input")
             description("Autogenerated input type of #{mutation_name}")
             mutation(mutation_class)
-            own_arguments.merge!(mutation_args)
+            mutation_args.each do |_name, arg|
+              add_argument(arg)
+            end
             argument :client_mutation_id, String, "A unique identifier for the client performing the mutation.", required: false
           end
         end

data/lib/graphql/schema/rescue_middleware.rb

@@ -43,8 +43,13 @@ module GraphQL
       def attempt_rescue(err)
         rescue_table.each { |klass, handler|
           if klass.is_a?(Class) && err.is_a?(klass) && handler
-            message = handler.call(err)
-            return GraphQL::ExecutionError.new(message)
+            result = handler.call(err)
+            case result
+            when String
+              return GraphQL::ExecutionError.new(result)
+            when GraphQL::ExecutionError
+              return result
+            end
           end
         }
 

data/lib/graphql/schema/resolver/has_payload_type.rb

@@ -0,0 +1,71 @@
+# frozen_string_literal: true
+
+module GraphQL
+  class Schema
+    class Resolver
+      # Adds `field(...)` helper to resolvers so that they can
+      # generate payload types.
+      #
+      # Or, an already-defined one can be attached with `payload_type(...)`.
+      module HasPayloadType
+        # Call this method to get the derived return type of the mutation,
+        # or use it as a configuration method to assign a return type
+        # instead of generating one.
+        # @param new_payload_type [Class, nil] If a type definition class is provided, it will be used as the return type of the mutation field
+        # @return [Class] The object type which this mutation returns.
+        def payload_type(new_payload_type = nil)
+          if new_payload_type
+            @payload_type = new_payload_type
+          end
+          @payload_type ||= generate_payload_type
+        end
+
+        alias :type :payload_type
+        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
+            find_inherited_value(:field_class, GraphQL::Schema::Field)
+          end
+        end
+
+        # An object class to use for deriving return types
+        # @param new_class [Class, nil] Defaults to {GraphQL::Schema::Object}
+        # @return [Class]
+        def object_class(new_class = nil)
+          if new_class
+            @object_class = new_class
+          else
+            @object_class || find_inherited_value(:object_class, GraphQL::Schema::Object)
+          end
+        end
+
+        NO_INTERFACES = [].freeze
+
+        private
+
+        # Build a subclass of {.object_class} based on `self`.
+        # This value will be cached as `{.payload_type}`.
+        # Override this hook to customize return type generation.
+        def generate_payload_type
+          resolver_name = graphql_name
+          resolver_fields = fields
+          Class.new(object_class) do
+            graphql_name("#{resolver_name}Payload")
+            description("Autogenerated return type of #{resolver_name}")
+            resolver_fields.each do |name, f|
+              # Reattach the already-defined field here
+              # (The field's `.owner` will still point to the mutation, not the object type, I think)
+              # 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
+      end
+    end
+  end
+end