graphql 1.11.8 → 1.12.0

data/lib/graphql/relay/type_extensions.rb

@@ -12,6 +12,7 @@ module GraphQL
       # Define a custom connection type for this object type
       # @return [GraphQL::ObjectType]
       def define_connection(**kwargs, &block)
+        warn ".connection_type and .define_connection will be removed from GraphQL-Ruby 2.0, use class-based type definitions instead: https://graphql-ruby.org/schema/class_based_api.html"
         GraphQL::Relay::ConnectionType.create_type(self, **kwargs, &block)
       end
 
@@ -23,6 +24,7 @@ module GraphQL
       # Define a custom edge type for this object type
       # @return [GraphQL::ObjectType]
       def define_edge(**kwargs, &block)
+        warn ".edge_type and .define_edge will be removed from GraphQL-Ruby 2.0, use class-based type definitions instead: https://graphql-ruby.org/schema/class_based_api.html"
         GraphQL::Relay::EdgeType.create_type(self, **kwargs, &block)
       end
     end

data/lib/graphql/scalar_type.rb

@@ -2,6 +2,8 @@
 module GraphQL
   # @api deprecated
   class ScalarType < GraphQL::BaseType
+    extend Define::InstanceDefinable::DeprecatedDefine
+
     accepts_definitions :coerce, :coerce_input, :coerce_result
     ensure_defined :coerce_non_null_input, :coerce_result
 

data/lib/graphql/schema.rb

@@ -21,6 +21,7 @@ require "graphql/schema/validation"
 require "graphql/schema/warden"
 require "graphql/schema/build_from_definition"
 
+require "graphql/schema/validator"
 require "graphql/schema/member"
 require "graphql/schema/wrapper"
 require "graphql/schema/list"
@@ -40,6 +41,7 @@ require "graphql/schema/directive/deprecated"
 require "graphql/schema/directive/include"
 require "graphql/schema/directive/skip"
 require "graphql/schema/directive/feature"
+require "graphql/schema/directive/flagged"
 require "graphql/schema/directive/transform"
 require "graphql/schema/type_membership"
 
@@ -80,6 +82,7 @@ module GraphQL
     extend GraphQL::Schema::Member::AcceptsDefinition
     extend GraphQL::Schema::Member::HasAstNode
     include GraphQL::Define::InstanceDefinable
+    extend GraphQL::Define::InstanceDefinable::DeprecatedDefine
     extend GraphQL::Schema::FindInheritedValue
 
     class DuplicateTypeNamesError < GraphQL::Error
@@ -281,11 +284,11 @@ module GraphQL
       @lazy_methods = GraphQL::Execution::Lazy::LazyMethodMap.new
       @lazy_methods.set(GraphQL::Execution::Lazy, :value)
       @cursor_encoder = Base64Encoder
-      # Default to the built-in execution strategy:
+      # For schema instances, default to legacy runtime modules
       @analysis_engine = GraphQL::Analysis
-      @query_execution_strategy = self.class.default_execution_strategy
-      @mutation_execution_strategy = self.class.default_execution_strategy
-      @subscription_execution_strategy = self.class.default_execution_strategy
+      @query_execution_strategy = GraphQL::Execution::Execute
+      @mutation_execution_strategy = GraphQL::Execution::Execute
+      @subscription_execution_strategy = GraphQL::Execution::Execute
       @default_mask = GraphQL::Schema::NullMask
       @rebuilding_artifacts = false
       @context_class = GraphQL::Query::Context
@@ -300,12 +303,11 @@ module GraphQL
 
     # @return [Boolean] True if using the new {GraphQL::Execution::Interpreter}
     def interpreter?
-      @interpreter
+      query_execution_strategy == GraphQL::Execution::Interpreter &&
+        mutation_execution_strategy == GraphQL::Execution::Interpreter &&
+        subscription_execution_strategy == GraphQL::Execution::Interpreter
     end
 
-    # @api private
-    attr_writer :interpreter
-
     def inspect
       "#<#{self.class.name} ...>"
     end
@@ -370,7 +372,7 @@ module GraphQL
       res[:errors]
     end
 
-    def define(**kwargs, &block)
+    def deprecated_define(**kwargs, &block)
       super
       ensure_defined
       # Assert that all necessary configs are present:
@@ -709,7 +711,7 @@ module GraphQL
     alias :_schema_class :class
     def_delegators :_schema_class, :unauthorized_object, :unauthorized_field, :inaccessible_fields
     def_delegators :_schema_class, :directive
-    def_delegators :_schema_class, :error_handler
+    def_delegators :_schema_class, :error_handler, :rescues
 
 
     # Given this schema member, find the class-based definition object
@@ -787,9 +789,8 @@ module GraphQL
     # @param default_resolve [<#call(type, field, obj, args, ctx)>] A callable for handling field resolution
     # @param parser [Object] An object for handling definition string parsing (must respond to `parse`)
     # @param using [Hash] Plugins to attach to the created schema with `use(key, value)`
-    # @param interpreter [Boolean] If false, the legacy {Execution::Execute} runtime will be used
     # @return [Class] the schema described by `document`
-    def self.from_definition(definition_or_path, default_resolve: nil, interpreter: true, parser: GraphQL.default_parser, using: {})
+    def self.from_definition(definition_or_path, default_resolve: nil, parser: GraphQL.default_parser, using: {})
       # If the file ends in `.graphql`, treat it like a filepath
       if definition_or_path.end_with?(".graphql")
         GraphQL::Schema::BuildFromDefinition.from_definition_path(
@@ -797,7 +798,6 @@ module GraphQL
           default_resolve: default_resolve,
           parser: parser,
           using: using,
-          interpreter: interpreter,
         )
       else
         GraphQL::Schema::BuildFromDefinition.from_definition(
@@ -805,7 +805,6 @@ module GraphQL
           default_resolve: default_resolve,
           parser: parser,
           using: using,
-          interpreter: interpreter,
         )
       end
     end
@@ -1119,15 +1118,14 @@ module GraphQL
             type.possible_types(context: context)
           else
             stored_possible_types = own_possible_types[type.graphql_name]
-            visible_possible_types = if stored_possible_types && type.kind.interface?
-              stored_possible_types.select do |possible_type|
-                # Use `.graphql_name` comparison to match legacy vs class-based types.
-                # When we don't need to support legacy `.define` types, use `.include?(type)` instead.
-                possible_type.interfaces(context).any? { |interface| interface.graphql_name == type.graphql_name }
-              end
-            else
-              stored_possible_types
-            end
+            visible_possible_types = stored_possible_types.select do |possible_type|
+              next true unless type.kind.interface?
+              next true unless possible_type.kind.object?
+
+              # Use `.graphql_name` comparison to match legacy vs class-based types.
+              # When we don't need to support legacy `.define` types, use `.include?(type)` instead.
+              possible_type.interfaces(context).any? { |interface| interface.graphql_name == type.graphql_name }
+            end if stored_possible_types
             visible_possible_types ||
               introspection_system.possible_types[type.graphql_name] ||
               (
@@ -1158,6 +1156,14 @@ module GraphQL
         end
       end
 
+      # @api private
+      # @see GraphQL::Dataloader
+      def dataloader_class
+        @dataloader_class || GraphQL::Dataloader::NullDataloader
+      end
+
+      attr_writer :dataloader_class
+
       def references_to(to_type = nil, from: nil)
         @own_references_to ||= Hash.new { |h, k| h[k] = [] }
         if to_type
@@ -1301,7 +1307,7 @@ module GraphQL
       attr_writer :analysis_engine
 
       def analysis_engine
-        @analysis_engine || find_inherited_value(:analysis_engine, GraphQL::Analysis)
+        @analysis_engine || find_inherited_value(:analysis_engine, self.default_analysis_engine)
       end
 
       def using_ast_analysis?
@@ -1309,11 +1315,9 @@ module GraphQL
       end
 
       def interpreter?
-        if defined?(@interpreter)
-          @interpreter
-        else
-          find_inherited_value(:interpreter?, false)
-        end
+        query_execution_strategy == GraphQL::Execution::Interpreter &&
+          mutation_execution_strategy == GraphQL::Execution::Interpreter &&
+          subscription_execution_strategy == GraphQL::Execution::Interpreter
       end
 
       attr_writer :interpreter
@@ -1397,7 +1401,15 @@ module GraphQL
         if superclass <= GraphQL::Schema
           superclass.default_execution_strategy
         else
-          @default_execution_strategy ||= GraphQL::Execution::Execute
+          @default_execution_strategy ||= GraphQL::Execution::Interpreter
+        end
+      end
+
+      def default_analysis_engine
+        if superclass <= GraphQL::Schema
+          superclass.default_analysis_engine
+        else
+          @default_analysis_engine ||= GraphQL::Analysis::AST
         end
       end
 
@@ -1551,6 +1563,10 @@ module GraphQL
       end
 
       def instrument(instrument_step, instrumenter, options = {})
+        if instrument_step == :field
+          warn "Field instrumentation (#{instrumenter.inspect}) will be removed in GraphQL-Ruby 2.0, please upgrade to field extensions: https://graphql-ruby.org/type_definitions/field_extensions.html"
+        end
+
         step = if instrument_step == :field && options[:after_built_ins]
           :field_after_built_ins
         else
@@ -1572,9 +1588,12 @@ module GraphQL
 
       # Attach a single directive to this schema
       # @param new_directive [Class]
+      # @return void
       def directive(new_directive)
-        add_type_and_traverse(new_directive, root: false)
-        own_directives[new_directive.graphql_name] = new_directive
+        own_directives[new_directive.graphql_name] ||= begin
+          add_type_and_traverse(new_directive, root: false)
+          new_directive
+        end
       end
 
       def default_directives
@@ -1606,6 +1625,7 @@ module GraphQL
 
       def middleware(new_middleware = nil)
         if new_middleware
+          warn "Middleware will be removed in GraphQL-Ruby 2.0, please upgrade to Field Extensions: https://graphql-ruby.org/type_definitions/field_extensions.html"
           own_middleware << new_middleware
         else
           # TODO make sure this is cached when running a query
@@ -1705,6 +1725,7 @@ module GraphQL
           else
             @lazy_methods = GraphQL::Execution::Lazy::LazyMethodMap.new
             @lazy_methods.set(GraphQL::Execution::Lazy, :value)
+            @lazy_methods.set(GraphQL::Dataloader::Request, :load)
           end
         end
         @lazy_methods
@@ -1901,13 +1922,16 @@ module GraphQL
           end
         else
           own_types[type.graphql_name] = type
+          add_directives_from(type)
           if type.kind.fields?
             type.fields.each do |name, field|
               field_type = field.type.unwrap
               references_to(field_type, from: field)
               field_path = path + [name]
               add_type(field_type, owner: field, late_types: late_types, path: field_path)
+              add_directives_from(field)
               field.arguments.each do |arg_name, arg|
+                add_directives_from(arg)
                 arg_type = arg.type.unwrap
                 references_to(arg_type, from: arg)
                 add_type(arg_type, owner: arg, late_types: late_types, path: field_path + [arg_name])
@@ -1916,6 +1940,7 @@ module GraphQL
           end
           if type.kind.input_object?
             type.arguments.each do |arg_name, arg|
+              add_directives_from(arg)
               arg_type = arg.type.unwrap
               references_to(arg_type, from: arg)
               add_type(arg_type, owner: arg, late_types: late_types, path: path + [arg_name])
@@ -1953,8 +1978,20 @@ module GraphQL
           end
         end
       end
+
+      def add_directives_from(owner)
+        owner.directives.each { |dir| directive(dir.class) }
+      end
     end
 
+    def dataloader_class
+      self.class.dataloader_class
+    end
+
+    # Install these here so that subclasses will also install it.
+    use(GraphQL::Execution::Errors)
+    use(GraphQL::Pagination::Connections)
+
     protected
 
     def rescues?

data/lib/graphql/schema/argument.rb

@@ -10,6 +10,10 @@ module GraphQL
       include GraphQL::Schema::Member::AcceptsDefinition
       include GraphQL::Schema::Member::HasPath
       include GraphQL::Schema::Member::HasAstNode
+      include GraphQL::Schema::Member::HasDirectives
+      include GraphQL::Schema::Member::HasDeprecationReason
+      include GraphQL::Schema::Member::HasValidators
+      include GraphQL::Schema::FindInheritedValue::EmptyObjects
 
       NO_DEFAULT = :__no_default__
 
@@ -45,8 +49,10 @@ module GraphQL
       # @param camelize [Boolean] if true, the name will be camelized when building the schema
       # @param from_resolver [Boolean] if true, a Resolver class defined this argument
       # @param method_access [Boolean] If false, don't build method access on legacy {Query::Arguments} instances.
+      # @param directives [Hash{Class => Hash}]
       # @param deprecation_reason [String]
-      def initialize(arg_name = nil, type_expr = nil, desc = nil, required:, type: nil, name: nil, loads: nil, description: nil, ast_node: nil, default_value: NO_DEFAULT, as: nil, from_resolver: false, camelize: true, prepare: nil, method_access: true, owner:, deprecation_reason: nil, &definition_block)
+      # @param validates [Hash, nil] Options for building validators, if any should be applied
+      def initialize(arg_name = nil, type_expr = nil, desc = nil, required:, type: nil, name: nil, loads: nil, description: nil, ast_node: nil, default_value: NO_DEFAULT, as: nil, from_resolver: false, camelize: true, prepare: nil, method_access: true, owner:, validates: nil, directives: nil, deprecation_reason: nil, &definition_block)
         arg_name ||= name
         @name = -(camelize ? Member::BuildType.camelize(arg_name.to_s) : arg_name.to_s)
         @type_expr = type_expr || type
@@ -63,6 +69,14 @@ module GraphQL
         @method_access = method_access
         self.deprecation_reason = deprecation_reason
 
+        if directives
+          directives.each do |dir_class, dir_options|
+            directive(dir_class, **dir_options)
+          end
+        end
+
+        self.validates(validates)
+
         if definition_block
           if definition_block.arity == 1
             instance_exec(self, &definition_block)
@@ -94,14 +108,16 @@ module GraphQL
       # @return [String] Deprecation reason for this argument
       def deprecation_reason(text = nil)
         if text
-          validate_deprecated_or_optional(null: @null, deprecation_reason: text)
-          @deprecation_reason = text
+          self.deprecation_reason = text
         else
-          @deprecation_reason
+          super()
         end
       end
 
-      alias_method :deprecation_reason=, :deprecation_reason
+      def deprecation_reason=(new_reason)
+        validate_deprecated_or_optional(null: @null, deprecation_reason: new_reason)
+        super
+      end
 
       def visible?(context)
         true
@@ -157,8 +173,8 @@ module GraphQL
         if NO_DEFAULT != @default_value
           argument.default_value = @default_value
         end
-        if @deprecation_reason
-          argument.deprecation_reason = @deprecation_reason
+        if self.deprecation_reason
+          argument.deprecation_reason = self.deprecation_reason
         end
         argument
       end
@@ -199,6 +215,8 @@ module GraphQL
           value = value.prepare
         end
 
+        Schema::Validator.validate!(validators, obj, context, value)
+
         if @prepare.nil?
           value
         elsif @prepare.is_a?(String) || @prepare.is_a?(Symbol)

data/lib/graphql/schema/build_from_definition.rb

@@ -3,6 +3,7 @@ require "graphql/schema/build_from_definition/resolve_map"
 
 module GraphQL
   class Schema
+    # TODO Populate `.directive(...)` from here
     module BuildFromDefinition
       if !String.method_defined?(:-@)
         using GraphQL::StringDedupBackport
@@ -18,8 +19,8 @@ module GraphQL
           from_document(parser.parse_file(definition_path), **kwargs)
         end
 
-        def from_document(document, default_resolve:, using: {}, relay: false, interpreter: true)
-          Builder.build(document, default_resolve: default_resolve || {}, relay: relay, using: using, interpreter: interpreter)
+        def from_document(document, default_resolve:, using: {}, relay: false)
+          Builder.build(document, default_resolve: default_resolve || {}, relay: relay, using: using)
         end
       end
 
@@ -27,7 +28,7 @@ module GraphQL
       module Builder
         extend self
 
-        def build(document, default_resolve:, using: {}, interpreter: true, relay:)
+        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)
@@ -41,45 +42,43 @@ module GraphQL
           schema_definition = schema_defns.first
           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(GraphQL::Schema::BUILT_IN_TYPES, directives, ->(type_name) {
+            types[type_name] ||= begin
+              defn = document.definitions.find { |d| d.respond_to?(:name) && d.name == type_name }
+              build_definition_from_node(defn, directive_type_resolver, default_resolve)
+            end
+          })
 
           document.definitions.each do |definition|
-            case definition
-            when GraphQL::Language::Nodes::SchemaDefinition
-              nil # already handled
-            when GraphQL::Language::Nodes::EnumTypeDefinition
-              types[definition.name] = build_enum_type(definition, type_resolver)
-            when GraphQL::Language::Nodes::ObjectTypeDefinition
-              types[definition.name] = build_object_type(definition, type_resolver)
-            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)
+            if definition.is_a?(GraphQL::Language::Nodes::DirectiveDefinition)
+              directives[definition.name] = build_directive(definition, directive_type_resolver)
             end
           end
 
-          # At this point, if types named by the built in types are _late-bound_ types,
-          # that means they were referenced in the schema but not defined in the schema.
-          # That's supported for built-in types. (Eg, you can use `String` without defining it.)
-          # In that case, insert the concrete type definition now.
-          #
-          # However, if the type in `types` is a _concrete_ type definition, that means that
-          # the document contained an explicit definition of the scalar type.
-          # Don't override it in this case.
-          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
+          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, GraphQL::Language::Nodes::DirectiveDefinition
+              nil # already handled
+            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
@@ -133,11 +132,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)
@@ -169,10 +163,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|
@@ -180,6 +249,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
@@ -202,6 +272,7 @@ module GraphQL
             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)
               # Put these method definitions in another method to avoid retaining `type_resolve`
@@ -219,11 +290,13 @@ module GraphQL
         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
 
@@ -234,6 +307,7 @@ module GraphQL
             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)
@@ -250,6 +324,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
@@ -290,6 +365,7 @@ module GraphQL
               ast_node: argument_defn,
               camelize: false,
               method_access: false,
+              directives: prepare_directives(argument_defn, type_resolver),
               **default_value_kwargs
             )
           end
@@ -313,6 +389,7 @@ module GraphQL
             graphql_name(interface_type_definition.name)
             description(interface_type_definition.description)
             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
@@ -335,6 +412,7 @@ module GraphQL
               ast_node: field_definition,
               method_conflict_warning: false,
               camelize: false,
+              directives: prepare_directives(field_definition, type_resolver),
               resolver_method: resolve_method_name,
             )
 
@@ -353,18 +431,28 @@ module GraphQL
           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)