graphql 1.10.1 → 1.13.0

data/lib/graphql/schema/build_from_definition.rb

@@ -5,23 +5,17 @@ module GraphQL
   class Schema
     module BuildFromDefinition
       class << self
-        def from_definition(definition_string, default_resolve:, using: {}, interpreter: true, parser: DefaultParser)
-          document = parser.parse(definition_string)
-          Builder.build(document, default_resolve: default_resolve, using: using, interpreter: interpreter)
+        # @see {Schema.from_definition}
+        def from_definition(definition_string, parser: GraphQL.default_parser, **kwargs)
+          from_document(parser.parse(definition_string), **kwargs)
         end
-      end
 
-      # @api private
-      DefaultParser = GraphQL::Language::Parser
+        def from_definition_path(definition_path, parser: GraphQL.default_parser, **kwargs)
+          from_document(parser.parse_file(definition_path), **kwargs)
+        end
 
-      # @api private
-      module DefaultResolve
-        def self.call(type, field, obj, args, ctx)
-          if field.arguments.any?
-            obj.public_send(field.name, args, ctx)
-          else
-            obj.public_send(field.name)
-          end
+        def from_document(document, default_resolve:, using: {}, relay: false)
+          Builder.build(document, default_resolve: default_resolve || {}, relay: relay, using: using)
         end
       end
 
@@ -29,7 +23,7 @@ module GraphQL
       module Builder
         extend self
 
-        def build(document, default_resolve: DefaultResolve, using: {}, interpreter: true)
+        def build(document, default_resolve:, using: {}, relay:)
           raise InvalidDocumentError.new('Must provide a document ast.') if !document || !document.is_a?(GraphQL::Language::Nodes::Document)
 
           if default_resolve.is_a?(Hash)
@@ -42,34 +36,50 @@ module GraphQL
           end
           schema_definition = schema_defns.first
           types = {}
-          types.merge!(GraphQL::Schema::BUILT_IN_TYPES)
           directives = {}
-          type_resolver = ->(type) { resolve_type(types, type)  }
+          type_resolver = build_resolve_type(types, directives, ->(type_name) { types[type_name] ||= Schema::LateBoundType.new(type_name)})
+          # Make a different type resolver because we need to coerce directive arguments
+          # _while_ building the schema.
+          # It will dig for a type if it encounters a custom type. This could be a problem if there are cycles.
+          directive_type_resolver = nil
+          directive_type_resolver = build_resolve_type(types, directives, ->(type_name) {
+            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)
+              elsif (built_in_defn = GraphQL::Schema::BUILT_IN_TYPES[type_name])
+                built_in_defn
+              else
+                raise "No definition for #{type_name.inspect} found in schema document or built-in types. Add a definition for it or remove it."
+              end
+            end
+          })
+
+          document.definitions.each do |definition|
+            if definition.is_a?(GraphQL::Language::Nodes::DirectiveDefinition)
+              directives[definition.name] = build_directive(definition, directive_type_resolver)
+            end
+          end
+
+          directives = GraphQL::Schema.default_directives.merge(directives)
+
+          # In case any directives referenced built-in types for their arguments:
+          replace_late_bound_types_with_built_in(types)
 
           document.definitions.each do |definition|
             case definition
-            when GraphQL::Language::Nodes::SchemaDefinition
+            when GraphQL::Language::Nodes::SchemaDefinition, GraphQL::Language::Nodes::DirectiveDefinition
               nil # already handled
-            when GraphQL::Language::Nodes::EnumTypeDefinition
-              types[definition.name] = build_enum_type(definition, type_resolver)
-            when GraphQL::Language::Nodes::ObjectTypeDefinition
-              is_subscription_root = (definition.name == "Subscription" && (schema_definition.nil? || schema_definition.subscription.nil?)) || (schema_definition && (definition.name == schema_definition.subscription))
-              should_extend_subscription_root = is_subscription_root && interpreter
-              types[definition.name] = build_object_type(definition, type_resolver, default_resolve: default_resolve, extend_subscription_root: should_extend_subscription_root)
-            when GraphQL::Language::Nodes::InterfaceTypeDefinition
-              types[definition.name] = build_interface_type(definition, type_resolver)
-            when GraphQL::Language::Nodes::UnionTypeDefinition
-              types[definition.name] = build_union_type(definition, type_resolver)
-            when GraphQL::Language::Nodes::ScalarTypeDefinition
-              types[definition.name] = build_scalar_type(definition, type_resolver, default_resolve: default_resolve)
-            when GraphQL::Language::Nodes::InputObjectTypeDefinition
-              types[definition.name] = build_input_object_type(definition, type_resolver)
-            when GraphQL::Language::Nodes::DirectiveDefinition
-              directives[definition.name] = build_directive(definition, type_resolver)
+            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)
+              end
             end
           end
 
-          directives = GraphQL::Schema.default_directives.merge(directives)
+          replace_late_bound_types_with_built_in(types)
 
           if schema_definition
             if schema_definition.query
@@ -108,11 +118,11 @@ module GraphQL
             end
 
             if default_resolve.respond_to?(:resolve_type)
-              define_singleton_method(:resolve_type) do |*args|
-                default_resolve.resolve_type(*args)
+              def self.resolve_type(*args)
+                self.definition_default_resolve.resolve_type(*args)
               end
             else
-              define_singleton_method(:resolve_type) do |*args|
+              def self.resolve_type(*args)
                 NullResolveType.call(*args)
               end
             end
@@ -123,11 +133,6 @@ module GraphQL
               ast_node(schema_definition)
             end
 
-            if interpreter
-              use GraphQL::Execution::Interpreter
-              use GraphQL::Analysis::AST
-            end
-
             using.each do |plugin, options|
               if options
                 use(plugin, **options)
@@ -135,6 +140,23 @@ module GraphQL
                 use(plugin)
               end
             end
+
+            # Empty `orphan_types` -- this will make unreachable types ... unreachable.
+            own_orphan_types.clear
+
+            class << self
+              attr_accessor :definition_default_resolve
+            end
+
+            self.definition_default_resolve = default_resolve
+
+            def definition_default_resolve
+              self.class.definition_default_resolve
+            end
+
+            def self.inherited(child_class)
+              child_class.definition_default_resolve = self.definition_default_resolve
+            end
           end
         end
 
@@ -142,10 +164,85 @@ 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)
+          case definition
+          when GraphQL::Language::Nodes::EnumTypeDefinition
+            build_enum_type(definition, type_resolver)
+          when GraphQL::Language::Nodes::ObjectTypeDefinition
+            build_object_type(definition, type_resolver)
+          when GraphQL::Language::Nodes::InterfaceTypeDefinition
+            build_interface_type(definition, type_resolver)
+          when GraphQL::Language::Nodes::UnionTypeDefinition
+            build_union_type(definition, type_resolver)
+          when GraphQL::Language::Nodes::ScalarTypeDefinition
+            build_scalar_type(definition, type_resolver, default_resolve: default_resolve)
+          when GraphQL::Language::Nodes::InputObjectTypeDefinition
+            build_input_object_type(definition, type_resolver)
+          end
+        end
+
+        # Modify `types`, replacing any late-bound references to built-in types
+        # with their actual definitions.
+        #
+        # (Schema definitions are allowed to reference those built-ins without redefining them.)
+        # @return void
+        def replace_late_bound_types_with_built_in(types)
+          GraphQL::Schema::BUILT_IN_TYPES.each do |scalar_name, built_in_scalar|
+            existing_type = types[scalar_name]
+            if existing_type.is_a?(GraphQL::Schema::LateBoundType)
+              types[scalar_name] = built_in_scalar
+            end
+          end
+        end
+
+        def build_directives(definition, ast_node, type_resolver)
+          dirs = prepare_directives(ast_node, type_resolver)
+          dirs.each do |dir_class, options|
+            definition.directive(dir_class, **options)
+          end
+        end
+
+        def prepare_directives(ast_node, type_resolver)
+          dirs = {}
+          ast_node.directives.each do |dir_node|
+            if dir_node.name == "deprecated"
+              # This is handled using `deprecation_reason`
+              next
+            else
+              dir_class = type_resolver.call(dir_node.name)
+              if dir_class.nil?
+                raise ArgumentError, "No definition for @#{dir_node.name} on #{ast_node.name} at #{ast_node.line}:#{ast_node.col}"
+              end
+              options = args_to_kwargs(dir_class, dir_node)
+              dirs[dir_class] = options
+            end
+          end
+          dirs
+        end
+
+        def args_to_kwargs(arg_owner, node)
+          if node.respond_to?(:arguments)
+            kwargs = {}
+            node.arguments.each do |arg_node|
+              arg_defn = arg_owner.get_argument(arg_node.name)
+              kwargs[arg_defn.keyword] = args_to_kwargs(arg_defn.type.unwrap, arg_node.value)
+            end
+            kwargs
+          elsif node.is_a?(Array)
+            node.map { |n| args_to_kwargs(arg_owner, n) }
+          elsif node.is_a?(Language::Nodes::Enum)
+            node.name
+          else
+            # scalar
+            node
+          end
+        end
+
         def build_enum_type(enum_type_definition, type_resolver)
           builder = self
           Class.new(GraphQL::Schema::Enum) 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|
@@ -153,6 +250,7 @@ module GraphQL
                 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
@@ -170,53 +268,54 @@ module GraphQL
         end
 
         def build_scalar_type(scalar_type_definition, type_resolver, default_resolve:)
+          builder = self
           Class.new(GraphQL::Schema::Scalar) do
             graphql_name(scalar_type_definition.name)
             description(scalar_type_definition.description)
             ast_node(scalar_type_definition)
+            builder.build_directives(self, scalar_type_definition, type_resolver)
 
             if default_resolve.respond_to?(:coerce_input)
-              define_singleton_method(:coerce_input) do |val, ctx|
-                default_resolve.coerce_input(self, val, ctx)
-              end
-
-              define_singleton_method(:coerce_result) do |val, ctx|
-                default_resolve.coerce_result(self, val, ctx)
-              end
+              # Put these method definitions in another method to avoid retaining `type_resolve`
+              # from this method's bindiing
+              builder.build_scalar_type_coerce_method(self, :coerce_input, default_resolve)
+              builder.build_scalar_type_coerce_method(self, :coerce_result, default_resolve)
             end
           end
         end
 
+        def build_scalar_type_coerce_method(scalar_class, method_name, default_definition_resolve)
+          scalar_class.define_singleton_method(method_name) do |val, ctx|
+            default_definition_resolve.public_send(method_name, self, val, ctx)
+          end
+        end
+
         def build_union_type(union_type_definition, type_resolver)
+          builder = self
           Class.new(GraphQL::Schema::Union) 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) })
             ast_node(union_type_definition)
+            builder.build_directives(self, union_type_definition, type_resolver)
           end
         end
 
-        def build_object_type(object_type_definition, type_resolver, default_resolve:, extend_subscription_root:)
+        def build_object_type(object_type_definition, type_resolver)
           builder = self
-          type_def = nil
-          typed_resolve_fn = ->(field, obj, args, ctx) { default_resolve.call(type_def, field, obj, args, ctx) }
 
           Class.new(GraphQL::Schema::Object) do
-            type_def = self
             graphql_name(object_type_definition.name)
             description(object_type_definition.description)
             ast_node(object_type_definition)
-            if extend_subscription_root
-              # This has to come before `field ...` configurations since it modifies them
-              extend Subscriptions::SubscriptionRoot
-            end
+            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_fields(self, object_type_definition.fields, type_resolver, default_resolve: typed_resolve_fn)
+            builder.build_fields(self, object_type_definition.fields, type_resolver, default_resolve: true)
           end
         end
 
@@ -226,6 +325,7 @@ module GraphQL
             graphql_name(input_object_type_definition.name)
             description(input_object_type_definition.description)
             ast_node(input_object_type_definition)
+            builder.build_directives(self, input_object_type_definition, type_resolver)
             builder.build_arguments(self, input_object_type_definition.fields, type_resolver)
           end
         end
@@ -245,13 +345,16 @@ module GraphQL
           end
         end
 
+        NO_DEFAULT_VALUE = {}.freeze
+
         def build_arguments(type_class, arguments, type_resolver)
           builder = self
 
           arguments.each do |argument_defn|
-            default_value_kwargs = {}
-            if !argument_defn.default_value.nil?
-              default_value_kwargs[:default_value] = builder.build_default_value(argument_defn.default_value)
+            default_value_kwargs = if !argument_defn.default_value.nil?
+              { default_value: builder.build_default_value(argument_defn.default_value) }
+            else
+              NO_DEFAULT_VALUE
             end
 
             type_class.argument(
@@ -259,9 +362,11 @@ module GraphQL
               type: type_resolver.call(argument_defn.type),
               required: false,
               description: argument_defn.description,
+              deprecation_reason: builder.build_deprecation_reason(argument_defn.directives),
               ast_node: argument_defn,
               camelize: false,
               method_access: false,
+              directives: prepare_directives(argument_defn, type_resolver),
               **default_value_kwargs
             )
           end
@@ -284,7 +389,13 @@ module GraphQL
             include GraphQL::Schema::Interface
             graphql_name(interface_type_definition.name)
             description(interface_type_definition.description)
+            interface_type_definition.interfaces.each do |interface_name|
+              "Implements: #{interface_type_definition} -> #{interface_name}"
+              interface_defn = type_resolver.call(interface_name)
+              implements(interface_defn)
+            end
             ast_node(interface_type_definition)
+            builder.build_directives(self, interface_type_definition, type_resolver)
 
             builder.build_fields(self, interface_type_definition.fields, type_resolver, default_resolve: nil)
           end
@@ -293,45 +404,61 @@ module GraphQL
         def build_fields(owner, field_definitions, type_resolver, default_resolve:)
           builder = self
 
-          field_definitions.map do |field_definition|
+          field_definitions.each do |field_definition|
             type_name = resolve_type_name(field_definition.type)
-
-            owner.field(
+            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,
               method_conflict_warning: false,
               camelize: false,
-            ) do
-              builder.build_arguments(self, field_definition.arguments, type_resolver)
-
-              # Don't do this for interfaces
-              if default_resolve
-                # TODO fragile hack. formalize this API?
-                define_singleton_method :resolve_field_method do |obj, args, ctx|
-                  default_resolve.call(self, obj.object, args, ctx)
+              directives: prepare_directives(field_definition, type_resolver),
+              resolver_method: 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
-              end
+              RUBY
             end
           end
         end
 
-        def resolve_type(types, ast_node)
-          case ast_node
-          when GraphQL::Language::Nodes::TypeName
-            type_name = ast_node.name
-            types[type_name] ||= GraphQL::Schema::LateBoundType.new(type_name)
-          when GraphQL::Language::Nodes::NonNullType
-            resolve_type(types, ast_node.of_type).to_non_null_type
-          when GraphQL::Language::Nodes::ListType
-            resolve_type(types, ast_node.of_type).to_list_type
-          else
-            raise "Unexpected ast_node: #{ast_node.inspect}"
-          end
+        def build_resolve_type(lookup_hash, directives, missing_type_handler)
+          resolve_type_proc = nil
+          resolve_type_proc = ->(ast_node) {
+            case ast_node
+            when GraphQL::Language::Nodes::TypeName
+              type_name = ast_node.name
+              if lookup_hash.key?(type_name)
+                lookup_hash[type_name]
+              else
+                missing_type_handler.call(type_name)
+              end
+            when GraphQL::Language::Nodes::NonNullType
+              resolve_type_proc.call(ast_node.of_type).to_non_null_type
+            when GraphQL::Language::Nodes::ListType
+              resolve_type_proc.call(ast_node.of_type).to_list_type
+            when String
+              directives[ast_node]
+            else
+              raise "Unexpected ast_node: #{ast_node.inspect}"
+            end
+          }
+          resolve_type_proc
         end
 
         def resolve_type_name(type)

data/lib/graphql/schema/default_type_error.rb

@@ -8,6 +8,8 @@ module GraphQL
           ctx.errors << type_error
         when GraphQL::UnresolvedTypeError, GraphQL::StringEncodingError, GraphQL::IntegerEncodingError
           raise type_error
+        when GraphQL::IntegerDecodingError
+          nil
         end
       end
     end

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

@@ -4,7 +4,7 @@ module GraphQL
     class Directive < GraphQL::Schema::Member
       class Deprecated < GraphQL::Schema::Directive
         description "Marks an element of a GraphQL schema as no longer supported."
-        locations(GraphQL::Schema::Directive::FIELD_DEFINITION, GraphQL::Schema::Directive::ENUM_VALUE)
+        locations(GraphQL::Schema::Directive::FIELD_DEFINITION, GraphQL::Schema::Directive::ENUM_VALUE, GraphQL::Schema::Directive::ARGUMENT_DEFINITION, GraphQL::Schema::Directive::INPUT_FIELD_DEFINITION)
 
         reason_description = "Explains why this element was deprecated, usually also including a "\
         "suggestion for how to access supported similar data. Formatted "\

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

@@ -42,7 +42,7 @@ module GraphQL
           GraphQL::Schema::Directive::INLINE_FRAGMENT
         )
 
-        argument :flag, String, required: true,
+        argument :flag, String,
           description: "The name of the feature to check before continuing"
 
         # Implement the Directive API

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

@@ -0,0 +1,57 @@
+# frozen_string_literal: true
+module GraphQL
+  class Schema
+    class Directive < GraphQL::Schema::Member
+      # This is _similar_ to {Directive::Feature}, except it's prescribed by the server, not the client.
+      #
+      # 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)
+            # 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)
+          elsif !target.is_a?(VisibleByFlag)
+            # This is an instance of a base class. `include` won't put this in front of the
+            # base class implementation, so we need to `.prepend`.
+            # `#visible?` could probably be moved to a module and then this could use `include` instead.
+            target.class.prepend(VisibleByFlag)
+          end
+          super
+        end
+
+        description "Hides this part of the schema unless the named flag is present in context[:flags]"
+
+        locations(
+          GraphQL::Schema::Directive::FIELD_DEFINITION,
+          GraphQL::Schema::Directive::OBJECT,
+          GraphQL::Schema::Directive::SCALAR,
+          GraphQL::Schema::Directive::ENUM,
+          GraphQL::Schema::Directive::UNION,
+          GraphQL::Schema::Directive::INTERFACE,
+          GraphQL::Schema::Directive::INPUT_OBJECT,
+          GraphQL::Schema::Directive::ENUM_VALUE,
+          GraphQL::Schema::Directive::ARGUMENT_DEFINITION,
+          GraphQL::Schema::Directive::INPUT_FIELD_DEFINITION,
+        )
+
+        argument :by, [String], "Flags to check for this schema member"
+
+        module VisibleByFlag
+          def self.included(schema_class)
+            schema_class.extend(self)
+          end
+
+          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
+            else
+              super
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -11,7 +11,7 @@ module GraphQL
           GraphQL::Schema::Directive::INLINE_FRAGMENT
         )
 
-        argument :if, Boolean, required: true,
+        argument :if, Boolean,
           description: "Included when true."
 
         default_directive true

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

@@ -11,7 +11,7 @@ module GraphQL
           GraphQL::Schema::Directive::INLINE_FRAGMENT
         )
 
-        argument :if, Boolean, required: true,
+        argument :if, Boolean,
           description: "Skipped when true."
 
         default_directive true

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

@@ -24,7 +24,7 @@ module GraphQL
           GraphQL::Schema::Directive::FIELD,
         )
 
-        argument :by, String, required: true,
+        argument :by, String,
           description: "The name of the transform to run if applicable"
 
         TRANSFORMS = [
@@ -39,7 +39,19 @@ module GraphQL
           transform_name = arguments[:by]
           if TRANSFORMS.include?(transform_name) && return_value.respond_to?(transform_name)
             return_value = return_value.public_send(transform_name)
-            context.namespace(:interpreter)[:runtime].write_in_response(path, return_value)
+            response = context.namespace(:interpreter)[:runtime].final_result
+            *keys, last = path
+            keys.each do |key|
+              if response && (response = response[key])
+                next
+              else
+                break
+              end
+            end
+            if response
+              response[last] = return_value
+            end
+            nil
           end
         end
       end