graphql 2.0.31 → 2.6.1

data/lib/graphql/schema/build_from_definition.rb

@@ -7,15 +7,21 @@ module GraphQL
       class << self
         # @see {Schema.from_definition}
         def from_definition(schema_superclass, definition_string, parser: GraphQL.default_parser, **kwargs)
+          if defined?(parser::SchemaParser)
+            parser = parser::SchemaParser
+          end
           from_document(schema_superclass, parser.parse(definition_string), **kwargs)
         end
 
         def from_definition_path(schema_superclass, definition_path, parser: GraphQL.default_parser, **kwargs)
+          if defined?(parser::SchemaParser)
+            parser = parser::SchemaParser
+          end
           from_document(schema_superclass, parser.parse_file(definition_path), **kwargs)
         end
 
-        def from_document(schema_superclass, document, default_resolve:, using: {}, relay: false)
-          Builder.build(schema_superclass, document, default_resolve: default_resolve || {}, relay: relay, using: using)
+        def from_document(schema_superclass, document, default_resolve:, using: {}, base_types: {}, relay: false)
+          Builder.build(schema_superclass, document, default_resolve: default_resolve || {}, relay: relay, using: using, base_types: base_types)
         end
       end
 
@@ -24,9 +30,18 @@ module GraphQL
         include GraphQL::EmptyObjects
         extend self
 
-        def build(schema_superclass, document, default_resolve:, using: {}, relay:)
+        def build(schema_superclass, document, default_resolve:, using: {}, base_types: {}, relay:)
           raise InvalidDocumentError.new('Must provide a document ast.') if !document || !document.is_a?(GraphQL::Language::Nodes::Document)
 
+          base_types = {
+            object: GraphQL::Schema::Object,
+            interface: GraphQL::Schema::Interface,
+            union: GraphQL::Schema::Union,
+            scalar: GraphQL::Schema::Scalar,
+            enum: GraphQL::Schema::Enum,
+            input_object: GraphQL::Schema::InputObject,
+          }.merge!(base_types)
+
           if default_resolve.is_a?(Hash)
             default_resolve = ResolveMap.new(default_resolve)
           end
@@ -47,7 +62,7 @@ module GraphQL
             types[type_name] ||= begin
               defn = document.definitions.find { |d| d.respond_to?(:name) && d.name == type_name }
               if defn
-                build_definition_from_node(defn, directive_type_resolver, default_resolve)
+                build_definition_from_node(defn, directive_type_resolver, default_resolve, base_types)
               elsif (built_in_defn = GraphQL::Schema::BUILT_IN_TYPES[type_name])
                 built_in_defn
               else
@@ -71,14 +86,30 @@ module GraphQL
             case definition
             when GraphQL::Language::Nodes::SchemaDefinition, GraphQL::Language::Nodes::DirectiveDefinition
               nil # already handled
-            when GraphQL::Language::Nodes::SchemaExtension
+            when GraphQL::Language::Nodes::SchemaExtension,
+              GraphQL::Language::Nodes::ScalarTypeExtension,
+              GraphQL::Language::Nodes::ObjectTypeExtension,
+              GraphQL::Language::Nodes::InterfaceTypeExtension,
+              GraphQL::Language::Nodes::UnionTypeExtension,
+              GraphQL::Language::Nodes::EnumTypeExtension,
+              GraphQL::Language::Nodes::InputObjectTypeExtension
               schema_extensions ||= []
               schema_extensions << definition
             else
               # It's possible that this was already loaded by the directives
               prev_type = types[definition.name]
               if prev_type.nil? || prev_type.is_a?(Schema::LateBoundType)
-                types[definition.name] = build_definition_from_node(definition, type_resolver, default_resolve)
+                if definition.is_a?(GraphQL::Language::Nodes::ObjectTypeDefinition) || definition.is_a?(Language::Nodes::InterfaceTypeDefinition)
+                  interface_names = definition.interfaces.map(&:name)
+                  transitive_names = interface_names.map { |n| document.definitions.find { |d| d.respond_to?(:name) && d.name == n }&.interfaces&.map(&:name) }
+                  transitive_names.flatten!
+                  transitive_names.compact!
+                  if !(missing_transitive_interfaces = transitive_names - interface_names).empty?
+                    raise GraphQL::Schema::InvalidDocumentError, "type #{definition.name} is missing one or more transitive interface names: #{missing_transitive_interfaces.join(", ")}. Add them to the type's `implements` list and try again."
+                  end
+                end
+
+                types[definition.name] = build_definition_from_node(definition, type_resolver, default_resolve, base_types)
               end
             end
           end
@@ -118,12 +149,43 @@ module GraphQL
 
           raise InvalidDocumentError.new('Must provide schema definition with query type or a type named Query.') unless query_root_type
 
+          schema_extensions&.each do |ext|
+            next if ext.is_a?(GraphQL::Language::Nodes::SchemaExtension)
+
+            built_type = types[ext.name]
+
+            case ext
+            when GraphQL::Language::Nodes::ScalarTypeExtension
+              build_directives(built_type, ext, type_resolver)
+            when GraphQL::Language::Nodes::ObjectTypeExtension
+              build_directives(built_type, ext, type_resolver)
+              build_fields(built_type, ext.fields, type_resolver, default_resolve: true)
+              build_interfaces(built_type, ext.interfaces, type_resolver)
+            when GraphQL::Language::Nodes::InterfaceTypeExtension
+              build_directives(built_type, ext, type_resolver)
+              build_fields(built_type, ext.fields, type_resolver, default_resolve: nil)
+              build_interfaces(built_type, ext.interfaces, type_resolver)
+            when GraphQL::Language::Nodes::UnionTypeExtension
+              build_directives(built_type, ext, type_resolver)
+              built_type.possible_types(*ext.types.map { |type_name| type_resolver.call(type_name) })
+            when GraphQL::Language::Nodes::EnumTypeExtension
+              build_directives(built_type, ext, type_resolver)
+              build_values(built_type, ext.values, type_resolver)
+            when GraphQL::Language::Nodes::InputObjectTypeExtension
+              build_directives(built_type, ext, type_resolver)
+              build_arguments(built_type, ext.fields, type_resolver)
+            end
+          end
+
           builder = self
 
+          found_types = types.values
+          object_types = found_types.select { |t| t.respond_to?(:kind) && t.kind.object? }
           schema_class = Class.new(schema_superclass) do
             begin
               # Add these first so that there's some chance of resolving late-bound types
-              orphan_types types.values
+              add_type_and_traverse(found_types, root: false)
+              orphan_types(object_types)
               query query_root_type
               mutation mutation_root_type
               subscription subscription_root_type
@@ -133,6 +195,16 @@ module GraphQL
               raise InvalidDocumentError, "Type \"#{type_name}\" not found in document.", err_backtrace
             end
 
+            object_types.each do |t|
+              t.interfaces.each do |int_t|
+                if int_t.is_a?(LateBoundType)
+                  int_t = types[int_t.graphql_name]
+                  t.implements(int_t)
+                end
+                int_t.orphan_types(t)
+              end
+            end
+
             if default_resolve.respond_to?(:resolve_type)
               def self.resolve_type(*args)
                 self.definition_default_resolve.resolve_type(*args)
@@ -173,11 +245,12 @@ module GraphQL
 
             def self.inherited(child_class)
               child_class.definition_default_resolve = self.definition_default_resolve
+              super
             end
           end
 
-          if schema_extensions
-            schema_extensions.each do |ext|
+          schema_extensions&.each do |ext|
+            if ext.is_a?(GraphQL::Language::Nodes::SchemaExtension)
               build_directives(schema_class, ext, type_resolver)
             end
           end
@@ -189,20 +262,22 @@ module GraphQL
           raise(GraphQL::RequiredImplementationMissingError, "Generated Schema cannot use Interface or Union types for execution. Implement resolve_type on your resolver.")
         }
 
-        def build_definition_from_node(definition, type_resolver, default_resolve)
+        def build_definition_from_node(definition, type_resolver, default_resolve, base_types)
           case definition
           when GraphQL::Language::Nodes::EnumTypeDefinition
-            build_enum_type(definition, type_resolver)
+            build_enum_type(definition, type_resolver, base_types[:enum])
           when GraphQL::Language::Nodes::ObjectTypeDefinition
-            build_object_type(definition, type_resolver)
+            build_object_type(definition, type_resolver, base_types[:object])
           when GraphQL::Language::Nodes::InterfaceTypeDefinition
-            build_interface_type(definition, type_resolver)
+            build_interface_type(definition, type_resolver, base_types[:interface])
           when GraphQL::Language::Nodes::UnionTypeDefinition
-            build_union_type(definition, type_resolver)
+            build_union_type(definition, type_resolver, base_types[:union])
           when GraphQL::Language::Nodes::ScalarTypeDefinition
-            build_scalar_type(definition, type_resolver, default_resolve: default_resolve)
+            build_scalar_type(definition, type_resolver, base_types[:scalar], default_resolve: default_resolve)
           when GraphQL::Language::Nodes::InputObjectTypeDefinition
-            build_input_object_type(definition, type_resolver)
+            build_input_object_type(definition, type_resolver, base_types[:input_object])
+          when GraphQL::Language::Nodes::DirectiveDefinition
+            build_directive(definition, type_resolver)
           end
         end
 
@@ -268,22 +343,26 @@ module GraphQL
           end
         end
 
-        def build_enum_type(enum_type_definition, type_resolver)
+        def build_enum_type(enum_type_definition, type_resolver, base_type)
           builder = self
-          Class.new(GraphQL::Schema::Enum) do
+          Class.new(base_type) do
             graphql_name(enum_type_definition.name)
             builder.build_directives(self, enum_type_definition, type_resolver)
             description(enum_type_definition.description)
             ast_node(enum_type_definition)
-            enum_type_definition.values.each do |enum_value_definition|
-              value(enum_value_definition.name,
-                value: enum_value_definition.name,
-                deprecation_reason: builder.build_deprecation_reason(enum_value_definition.directives),
-                description: enum_value_definition.description,
-                directives: builder.prepare_directives(enum_value_definition, type_resolver),
-                ast_node: enum_value_definition,
-              )
-            end
+            builder.build_values(self, enum_type_definition.values, type_resolver)
+          end
+        end
+
+        def build_values(type_class, enum_value_definitions, type_resolver)
+          enum_value_definitions.each do |enum_value_definition|
+            type_class.value(enum_value_definition.name,
+              value: enum_value_definition.name,
+              deprecation_reason: build_deprecation_reason(enum_value_definition.directives),
+              description: enum_value_definition.description,
+              directives: prepare_directives(enum_value_definition, type_resolver),
+              ast_node: enum_value_definition,
+            )
           end
         end
 
@@ -297,9 +376,9 @@ module GraphQL
           reason.value
         end
 
-        def build_scalar_type(scalar_type_definition, type_resolver, default_resolve:)
+        def build_scalar_type(scalar_type_definition, type_resolver, base_type, default_resolve:)
           builder = self
-          Class.new(GraphQL::Schema::Scalar) do
+          Class.new(base_type) do
             graphql_name(scalar_type_definition.name)
             description(scalar_type_definition.description)
             ast_node(scalar_type_definition)
@@ -320,9 +399,9 @@ module GraphQL
           end
         end
 
-        def build_union_type(union_type_definition, type_resolver)
+        def build_union_type(union_type_definition, type_resolver, base_type)
           builder = self
-          Class.new(GraphQL::Schema::Union) do
+          Class.new(base_type) do
             graphql_name(union_type_definition.name)
             description(union_type_definition.description)
             possible_types(*union_type_definition.types.map { |type_name| type_resolver.call(type_name) })
@@ -331,27 +410,28 @@ module GraphQL
           end
         end
 
-        def build_object_type(object_type_definition, type_resolver)
+        def build_object_type(object_type_definition, type_resolver, base_type)
           builder = self
 
-          Class.new(GraphQL::Schema::Object) do
+          Class.new(base_type) do
             graphql_name(object_type_definition.name)
             description(object_type_definition.description)
             ast_node(object_type_definition)
             builder.build_directives(self, object_type_definition, type_resolver)
-
-            object_type_definition.interfaces.each do |interface_name|
-              interface_defn = type_resolver.call(interface_name)
-              implements(interface_defn)
-            end
-
+            builder.build_interfaces(self, object_type_definition.interfaces, type_resolver)
             builder.build_fields(self, object_type_definition.fields, type_resolver, default_resolve: true)
           end
         end
 
-        def build_input_object_type(input_object_type_definition, type_resolver)
+        def build_interfaces(type_class, interface_names, type_resolver)
+          interface_names.each do |interface_name|
+            type_class.implements(type_resolver.call(interface_name))
+          end
+        end
+
+        def build_input_object_type(input_object_type_definition, type_resolver, base_type)
           builder = self
-          Class.new(GraphQL::Schema::InputObject) do
+          Class.new(base_type) do
             graphql_name(input_object_type_definition.name)
             description(input_object_type_definition.description)
             ast_node(input_object_type_definition)
@@ -411,16 +491,13 @@ module GraphQL
           end
         end
 
-        def build_interface_type(interface_type_definition, type_resolver)
+        def build_interface_type(interface_type_definition, type_resolver, base_type)
           builder = self
           Module.new do
-            include GraphQL::Schema::Interface
+            include base_type
             graphql_name(interface_type_definition.name)
             description(interface_type_definition.description)
-            interface_type_definition.interfaces.each do |interface_name|
-              interface_defn = type_resolver.call(interface_name)
-              implements(interface_defn)
-            end
+            builder.build_interfaces(self, interface_type_definition.interfaces, type_resolver)
             ast_node(interface_type_definition)
             builder.build_directives(self, interface_type_definition, type_resolver)
 
@@ -432,14 +509,12 @@ module GraphQL
           builder = self
 
           field_definitions.each do |field_definition|
-            type_name = resolve_type_name(field_definition.type)
             resolve_method_name = -"resolve_field_#{field_definition.name}"
             schema_field_defn = owner.field(
               field_definition.name,
               description: field_definition.description,
               type: type_resolver.call(field_definition.type),
               null: true,
-              connection: type_name.end_with?("Connection"),
               connection_extension: nil,
               deprecation_reason: build_deprecation_reason(field_definition.directives),
               ast_node: field_definition,
@@ -447,23 +522,31 @@ module GraphQL
               camelize: false,
               directives: prepare_directives(field_definition, type_resolver),
               resolver_method: resolve_method_name,
+              resolve_batch: resolve_method_name,
             )
 
             builder.build_arguments(schema_field_defn, field_definition.arguments, type_resolver)
 
             # Don't do this for interfaces
             if default_resolve
-              owner.class_eval <<-RUBY, __FILE__, __LINE__
-                # frozen_string_literal: true
-                def #{resolve_method_name}(**args)
-                  field_instance = self.class.get_field("#{field_definition.name}")
-                  context.schema.definition_default_resolve.call(self.class, field_instance, object, args, context)
-                end
-              RUBY
+              define_field_resolve_method(owner, resolve_method_name, field_definition.name)
             end
           end
         end
 
+        def define_field_resolve_method(owner, method_name, field_name)
+          owner.define_method(method_name) { |**args|
+            field_instance = context.types.field(owner, field_name)
+            context.schema.definition_default_resolve.call(self.class, field_instance, object, args, context)
+          }
+          owner.define_singleton_method(method_name) { |objects, context, **args|
+            field_instance = context.types.field(owner, field_name)
+            objects.map do |object|
+              context.schema.definition_default_resolve.call(self, field_instance, object, args, context)
+            end
+          }
+        end
+
         def build_resolve_type(lookup_hash, directives, missing_type_handler)
           resolve_type_proc = nil
           resolve_type_proc = ->(ast_node) {
@@ -480,22 +563,13 @@ module GraphQL
             when GraphQL::Language::Nodes::ListType
               resolve_type_proc.call(ast_node.of_type).to_list_type
             when String
-              directives[ast_node]
+              directives[ast_node] ||= missing_type_handler.call(ast_node)
             else
               raise "Unexpected ast_node: #{ast_node.inspect}"
             end
           }
           resolve_type_proc
         end
-
-        def resolve_type_name(type)
-          case type
-          when GraphQL::Language::Nodes::TypeName
-            return type.name
-          else
-            resolve_type_name(type.of_type)
-          end
-        end
       end
 
       private_constant :Builder

data/lib/graphql/schema/directive/flagged.rb

@@ -7,7 +7,7 @@ module GraphQL
       # In this case, the server hides types and fields _entirely_, unless the current context has certain `:flags` present.
       class Flagged < GraphQL::Schema::Directive
         def initialize(target, **options)
-          if target.is_a?(Module) && !target.ancestors.include?(VisibleByFlag)
+          if target.is_a?(Module)
             # This is type class of some kind, `include` will put this module
             # in between the type class itself and its super class, so `super` will work fine
             target.include(VisibleByFlag)
@@ -37,6 +37,8 @@ module GraphQL
 
         argument :by, [String], "Flags to check for this schema member"
 
+        repeatable(true)
+
         module VisibleByFlag
           def self.included(schema_class)
             schema_class.extend(self)
@@ -45,7 +47,7 @@ module GraphQL
           def visible?(context)
             if dir = self.directives.find { |d| d.is_a?(Flagged) }
               relevant_flags = (f = context[:flags]) && dir.arguments[:by] & f # rubocop:disable Development/ContextIsPassedCop -- definition-related
-              relevant_flags && relevant_flags.any? && super
+              relevant_flags && !relevant_flags.empty? && super
             else
               super
             end

data/lib/graphql/schema/directive/one_of.rb

@@ -6,6 +6,18 @@ module GraphQL
         description "Requires that exactly one field must be supplied and that field must not be `null`."
         locations(GraphQL::Schema::Directive::INPUT_OBJECT)
         default_directive true
+
+        def initialize(...)
+          super
+
+          owner.extend(IsOneOf)
+        end
+
+        module IsOneOf
+          def one_of?
+            true
+          end
+        end
       end
     end
   end

data/lib/graphql/schema/directive/specified_by.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+module GraphQL
+  class Schema
+    class Directive < GraphQL::Schema::Member
+      class SpecifiedBy < GraphQL::Schema::Directive
+        description "Exposes a URL that specifies the behavior of this scalar."
+        locations(GraphQL::Schema::Directive::SCALAR)
+        default_directive true
+
+        argument :url, String, description: "The URL that specifies the behavior of this scalar."
+      end
+    end
+  end
+end

data/lib/graphql/schema/directive.rb

@@ -9,6 +9,7 @@ module GraphQL
     class Directive < GraphQL::Schema::Member
       extend GraphQL::Schema::Member::HasArguments
       extend GraphQL::Schema::Member::HasArguments::HasDirectiveArguments
+      extend GraphQL::Schema::Member::HasValidators
 
       class << self
         # Directives aren't types, they don't have kinds.
@@ -29,18 +30,26 @@ module GraphQL
         end
 
         def locations(*new_locations)
-          if new_locations.any?
+          if !new_locations.empty?
+            is_runtime = false
             new_locations.each do |new_loc|
-              if !LOCATIONS.include?(new_loc.to_sym)
+              loc_sym = new_loc.to_sym
+              if !LOCATIONS.include?(loc_sym)
                 raise ArgumentError, "#{self} (#{self.graphql_name}) has an invalid directive location: `locations #{new_loc}` "
               end
+              is_runtime ||= RUNTIME_LOCATIONS.include?(loc_sym)
             end
             @locations = new_locations
+            @is_runtime = is_runtime
           else
             @locations ||= (superclass.respond_to?(:locations) ? superclass.locations : [])
           end
         end
 
+        def runtime?
+          @is_runtime
+        end
+
         def default_directive(new_default_directive = nil)
           if new_default_directive != nil
             @default_directive = new_default_directive
@@ -75,6 +84,10 @@ module GraphQL
           yield
         end
 
+        def validate!(arguments, context)
+          Schema::Validator.validate!(validators, self, context, arguments)
+        end
+
         def on_field?
           locations.include?(FIELD)
         end
@@ -99,8 +112,12 @@ module GraphQL
 
         def inherited(subclass)
           super
-          subclass.class_eval do
+          parent_class = self
+          subclass.class_exec do
             @default_graphql_name ||= nil
+            @locations = parent_class.locations
+            @is_runtime = parent_class.runtime?
+            @repeatable = false
           end
         end
       end
@@ -111,6 +128,9 @@ module GraphQL
       # @return [GraphQL::Interpreter::Arguments]
       attr_reader :arguments
 
+      class InvalidArgumentError < GraphQL::Error
+      end
+
       def initialize(owner, **arguments)
         @owner = owner
         assert_valid_owner
@@ -119,7 +139,49 @@ module GraphQL
         # - lazy resolution
         # Probably, those won't be needed here, since these are configuration arguments,
         # not runtime arguments.
-        @arguments = self.class.coerce_arguments(nil, arguments, Query::NullContext)
+        context = Query::NullContext.instance
+        self.class.all_argument_definitions.each do |arg_defn|
+          keyword = arg_defn.keyword
+          arg_type = arg_defn.type
+          if arguments.key?(keyword)
+            value = arguments[keyword]
+            # This is a Ruby-land value; convert it to graphql for validation
+            graphql_value = begin
+              coerce_value = value
+              if arg_type.list? && (!coerce_value.nil?) && (!coerce_value.is_a?(Array))
+                # When validating inputs, GraphQL accepts a single item
+                # and implicitly converts it to a one-item list.
+                # However, we're using result coercion here to go from Ruby value
+                # to GraphQL value, so it doesn't have that feature.
+                # Keep the GraphQL-type behavior but implement it manually:
+                wrap_type = arg_type
+                while wrap_type.list?
+                  if wrap_type.non_null?
+                    wrap_type = wrap_type.of_type
+                  end
+                  wrap_type = wrap_type.of_type
+                  coerce_value = [coerce_value]
+                end
+              end
+              arg_type.coerce_isolated_result(coerce_value)
+            rescue GraphQL::Schema::Enum::UnresolvedValueError
+              # Let validation handle this
+              value
+            end
+          else
+            value = graphql_value = nil
+          end
+
+          result = arg_type.validate_input(graphql_value, context)
+          if !result.valid?
+            raise InvalidArgumentError, "@#{graphql_name}.#{arg_defn.graphql_name} on #{owner.path} is invalid (#{value.inspect}): #{result.problems.first["explanation"]}"
+          end
+        end
+        self.class.validate!(arguments, context)
+        @arguments = self.class.coerce_arguments(nil, arguments, context)
+        if @arguments.is_a?(GraphQL::ExecutionError)
+          raise @arguments
+        end
       end
 
       def graphql_name
@@ -127,13 +189,16 @@ module GraphQL
       end
 
       LOCATIONS = [
-        QUERY =                  :QUERY,
-        MUTATION =               :MUTATION,
-        SUBSCRIPTION =           :SUBSCRIPTION,
-        FIELD =                  :FIELD,
-        FRAGMENT_DEFINITION =    :FRAGMENT_DEFINITION,
-        FRAGMENT_SPREAD =        :FRAGMENT_SPREAD,
-        INLINE_FRAGMENT =        :INLINE_FRAGMENT,
+        *(RUNTIME_LOCATIONS = [
+          QUERY =                  :QUERY,
+          MUTATION =               :MUTATION,
+          SUBSCRIPTION =           :SUBSCRIPTION,
+          FIELD =                  :FIELD,
+          FRAGMENT_DEFINITION =    :FRAGMENT_DEFINITION,
+          FRAGMENT_SPREAD =        :FRAGMENT_SPREAD,
+          INLINE_FRAGMENT =        :INLINE_FRAGMENT,
+          VARIABLE_DEFINITION =    :VARIABLE_DEFINITION,
+        ]),
         SCHEMA =                 :SCHEMA,
         SCALAR =                 :SCALAR,
         OBJECT =                 :OBJECT,
@@ -145,7 +210,6 @@ module GraphQL
         ENUM_VALUE =             :ENUM_VALUE,
         INPUT_OBJECT =           :INPUT_OBJECT,
         INPUT_FIELD_DEFINITION = :INPUT_FIELD_DEFINITION,
-        VARIABLE_DEFINITION =    :VARIABLE_DEFINITION,
       ]
 
       DEFAULT_DEPRECATION_REASON = 'No longer supported'
@@ -188,6 +252,8 @@ module GraphQL
             assert_has_location(SCALAR)
           elsif @owner < GraphQL::Schema
             assert_has_location(SCHEMA)
+          elsif @owner < GraphQL::Schema::Resolver
+            assert_has_location(FIELD_DEFINITION)
           else
             raise "Unexpected directive owner class: #{@owner}"
           end