graphql 1.7.6 → 1.8.0

data/lib/graphql/schema/traversal.rb

@@ -25,36 +25,100 @@ module GraphQL
             Schema::BUILT_IN_INSTRUMENTERS +
             schema.instrumenters[:field_after_built_ins]
 
+        # These fields have types specified by _name_,
+        # So we need to inspect the schema and find those types,
+        # then update their references.
+        @late_bound_fields = []
         @type_map = {}
         @instrumented_field_map = Hash.new { |h, k| h[k] = {} }
         @type_reference_map = Hash.new { |h, k| h[k] = [] }
         @union_memberships = Hash.new { |h, k| h[k] = [] }
-        visit(schema, nil)
+        visit(schema, schema, nil)
+        resolve_late_bound_fields
       end
 
       private
 
-      def visit(member, context_description)
+      # A brute-force appraoch to late binding.
+      # Just keep trying the whole list, hoping that they
+      # eventually all resolve.
+      # This could be replaced with proper dependency tracking.
+      def resolve_late_bound_fields
+        # This is a bit tricky, with the writes going to internal state.
+        prev_late_bound_fields = @late_bound_fields
+        # Things might get added here during `visit...`
+        # or they might be added manually if we can't find them by hand
+        @late_bound_fields = []
+        prev_late_bound_fields.each do |(owner_type, field_defn, dynamic_field)|
+          if @type_map.key?(field_defn.type.unwrap.name)
+            late_bound_return_type = field_defn.type
+            resolved_type = @type_map.fetch(late_bound_return_type.unwrap.name)
+            wrapped_resolved_type = rewrap_resolved_type(late_bound_return_type, resolved_type)
+            # Update the field definition in place? :thinking_face:
+            field_defn.type = wrapped_resolved_type
+            visit_field_on_type(@schema, owner_type, field_defn, dynamic_field: dynamic_field)
+          else
+            @late_bound_fields << [owner_type, field_defn, dynamic_field]
+          end
+        end
+
+        if @late_bound_fields.any?
+          # If we visited each field and failed to resolve _any_,
+          # then we're stuck.
+          if @late_bound_fields == prev_late_bound_fields
+            type_names = prev_late_bound_fields.map { |f| f[1] }.map(&:type).map(&:unwrap).map(&:name).uniq
+            raise <<-ERR
+Some late-bound types couldn't be resolved:
+
+- #{type_names}
+- Found __* types: #{@type_map.keys.select { |k| k.start_with?("__") }}
+            ERR
+          else
+            resolve_late_bound_fields
+          end
+        end
+      end
+
+      # The late-bound type may be wrapped with list or non-null types.
+      # Apply the same wrapping to the resolve type and
+      # return the maybe-wrapped type
+      def rewrap_resolved_type(late_bound_type, resolved_inner_type)
+        case late_bound_type
+        when GraphQL::NonNullType
+          rewrap_resolved_type(late_bound_type.of_type, resolved_inner_type).to_non_null_type
+        when GraphQL::ListType
+          rewrap_resolved_type(late_bound_type.of_type, resolved_inner_type).to_list_type
+        when GraphQL::Schema::LateBoundType
+          resolved_inner_type
+        else
+          raise "Unexpected late_bound_type: #{late_bound_type.inspect} (#{late_bound_type.class})"
+        end
+      end
+
+      def visit(schema, member, context_description)
         case member
         when GraphQL::Schema
-          member.directives.each { |name, directive| visit(directive, "Directive #{name}") }
+          member.directives.each { |name, directive| visit(schema, directive, "Directive #{name}") }
           # Find the starting points, then visit them
           visit_roots = [member.query, member.mutation, member.subscription]
           if @introspection
-            visit_roots << GraphQL::Introspection::SchemaType
+            introspection_types = schema.introspection_system.object_types
+            visit_roots.concat(introspection_types)
             if member.query
-              # Visit this so that arguments class is preconstructed
-              # Skip validation since it begins with __
-              visit_field_on_type(member.query, GraphQL::Introspection::TypeByNameField, dynamic_field: true)
+              member.introspection_system.entry_points.each do |introspection_field|
+                # Visit this so that arguments class is preconstructed
+                # Skip validation since it begins with "__"
+                visit_field_on_type(schema, member.query, introspection_field, dynamic_field: true)
+              end
             end
           end
           visit_roots.concat(member.orphan_types)
           visit_roots.compact!
-          visit_roots.each { |t| visit(t, t.name) }
+          visit_roots.each { |t| visit(schema, t, t.name) }
         when GraphQL::Directive
           member.arguments.each do |name, argument|
             @type_reference_map[argument.type.unwrap.to_s] << argument
-            visit(argument.type, "Directive argument #{member.name}.#{name}")
+            visit(schema, argument.type, "Directive argument #{member.name}.#{name}")
           end
           # Construct arguments class here, which is later used to generate GraphQL::Query::Arguments
           # to be passed to a resolver proc
@@ -68,28 +132,40 @@ module GraphQL
             @type_map[type_defn.name] = type_defn
             case type_defn
             when GraphQL::ObjectType
-              type_defn.interfaces.each { |i| visit(i, "Interface on #{type_defn.name}") }
-              visit_fields(type_defn)
+              type_defn.interfaces.each { |i| visit(schema, i, "Interface on #{type_defn.name}") }
+              visit_fields(schema, type_defn)
             when GraphQL::InterfaceType
-              visit_fields(type_defn)
+              visit_fields(schema, type_defn)
+              type_defn.orphan_types.each do |t|
+                visit(schema, t, "Orphan type for #{type_defn.name}")
+              end
             when GraphQL::UnionType
               type_defn.possible_types.each do |t|
                 @union_memberships[t.name] << type_defn
-                visit(t, "Possible type for #{type_defn.name}")
+                visit(schema, t, "Possible type for #{type_defn.name}")
               end
             when GraphQL::InputObjectType
               type_defn.arguments.each do |name, arg|
                 @type_reference_map[arg.type.unwrap.to_s] << arg
-                visit(arg.type, "Input field #{type_defn.name}.#{name}")
+                visit(schema, arg.type, "Input field #{type_defn.name}.#{name}")
               end
 
               # Construct arguments class here, which is later used to generate GraphQL::Query::Arguments
               # to be passed to a resolver proc
-              GraphQL::Query::Arguments.construct_arguments_class(type_defn)
+              if type_defn.arguments_class.nil?
+                GraphQL::Query::Arguments.construct_arguments_class(type_defn)
+              end
             end
           elsif !prev_type.equal?(type_defn)
             # If the previous entry in the map isn't the same object we just found, raise.
-            raise("Duplicate type definition found for name '#{type_defn.name}'")
+            raise("Duplicate type definition found for name '#{type_defn.name}' (#{prev_type.metadata[:type_class]}, #{type_defn.metadata[:type_class]}})")
+          end
+        when Class
+          if member.respond_to?(:graphql_definition)
+            graphql_member = member.graphql_definition
+            visit(schema, graphql_member, context_description)
+          else
+            raise GraphQL::Schema::InvalidTypeError.new("Unexpected traversal member: #{member} (#{member.class.name})")
           end
         else
           message = "Unexpected schema traversal member: #{member} (#{member.class.name})"
@@ -97,13 +173,18 @@ module GraphQL
         end
       end
 
-      def visit_fields(type_defn)
+      def visit_fields(schema, type_defn)
         type_defn.all_fields.each do |field_defn|
-          visit_field_on_type(type_defn, field_defn)
+          visit_field_on_type(schema, type_defn, field_defn)
         end
       end
 
-      def visit_field_on_type(type_defn, field_defn, dynamic_field: false)
+      def visit_field_on_type(schema, type_defn, field_defn, dynamic_field: false)
+        base_return_type = field_defn.type.unwrap
+        if base_return_type.is_a?(GraphQL::Schema::LateBoundType)
+          @late_bound_fields << [type_defn, field_defn, dynamic_field]
+          return
+        end
         if dynamic_field
           # Don't apply instrumentation to dynamic fields since they're shared constants
           instrumented_field_defn = field_defn
@@ -114,11 +195,10 @@ module GraphQL
           @instrumented_field_map[type_defn.name][instrumented_field_defn.name] = instrumented_field_defn
         end
         @type_reference_map[instrumented_field_defn.type.unwrap.name] << instrumented_field_defn
-        visit(instrumented_field_defn.type, "Field #{type_defn.name}.#{instrumented_field_defn.name}'s return type")
-
+        visit(schema, instrumented_field_defn.type, "Field #{type_defn.name}.#{instrumented_field_defn.name}'s return type")
         instrumented_field_defn.arguments.each do |name, arg|
           @type_reference_map[arg.type.unwrap.to_s] << arg
-          visit(arg.type, "Argument #{name} on #{type_defn.name}.#{instrumented_field_defn.name}")
+          visit(schema, arg.type, "Argument #{name} on #{type_defn.name}.#{instrumented_field_defn.name}")
         end
 
         # Construct arguments class here, which is later used to generate GraphQL::Query::Arguments

data/lib/graphql/schema/union.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+module GraphQL
+  class Schema
+    class Union < GraphQL::Schema::Member
+      extend GraphQL::Schema::Member::AcceptsDefinition
+
+      class << self
+        def possible_types(*types)
+          if types.any?
+            @possible_types = types
+          else
+            all_possible_types = @possible_types || []
+            all_possible_types += super if defined?(super)
+            all_possible_types.uniq
+          end
+        end
+
+        def to_graphql
+          type_defn = GraphQL::UnionType.new
+          type_defn.name = graphql_name
+          type_defn.description = description
+          type_defn.possible_types = possible_types
+          if respond_to?(:resolve_type)
+            type_defn.resolve_type = method(:resolve_type)
+          end
+          type_defn.metadata[:type_class] = self
+          type_defn
+        end
+
+        def kind
+          GraphQL::TypeKinds::UNION
+        end
+      end
+    end
+  end
+end

data/lib/graphql/schema/validation.rb

@@ -24,7 +24,8 @@ module GraphQL
         # @param allowed_classes [Class] Classes which the return value may be an instance of
         # @return [Proc] A proc which will validate the input by calling `property_name` and asserting it is an instance of one of `allowed_classes`
         def self.assert_property(property_name, *allowed_classes)
-          allowed_classes_message = allowed_classes.map(&:name).join(" or ")
+          # Hide LateBoundType from user-facing errors
+          allowed_classes_message = allowed_classes.map(&:name).reject {|n| n.include?("LateBoundType") }.join(" or ")
           ->(obj) {
             property_value = obj.public_send(property_name)
             is_valid_value = allowed_classes.any? { |allowed_class| property_value.is_a?(allowed_class) }
@@ -240,7 +241,7 @@ module GraphQL
           Rules::RESERVED_NAME,
           Rules::DESCRIPTION_IS_STRING_OR_NIL,
           Rules.assert_property(:deprecation_reason, String, NilClass),
-          Rules.assert_property(:type, GraphQL::BaseType),
+          Rules.assert_property(:type, GraphQL::BaseType, GraphQL::Schema::LateBoundType),
           Rules.assert_property(:property, Symbol, NilClass),
           Rules::ARGUMENTS_ARE_STRING_TO_ARGUMENT,
           Rules::ARGUMENTS_ARE_VALID,