graphql 1.9.0 → 2.1.1

data/lib/graphql/schema/interface.rb

@@ -4,14 +4,17 @@ module GraphQL
     module Interface
       include GraphQL::Schema::Member::GraphQLTypeNames
       module DefinitionMethods
-        include GraphQL::Schema::Member::CachedGraphQLDefinition
-        include GraphQL::Relay::TypeExtensions
         include GraphQL::Schema::Member::BaseDSLMethods
+        # ConfigurationExtension's responsibilities are in `def included` below
         include GraphQL::Schema::Member::TypeSystemHelpers
         include GraphQL::Schema::Member::HasFields
         include GraphQL::Schema::Member::HasPath
         include GraphQL::Schema::Member::RelayShortcuts
         include GraphQL::Schema::Member::Scoped
+        include GraphQL::Schema::Member::HasAstNode
+        include GraphQL::Schema::Member::HasUnresolvedTypeError
+        include GraphQL::Schema::Member::HasDirectives
+        include GraphQL::Schema::Member::HasInterfaces
 
         # Methods defined in this block will be:
         # - Added as class methods to this interface
@@ -20,24 +23,17 @@ module GraphQL
           self::DefinitionMethods.module_eval(&block)
         end
 
-        # The interface is visible if any of its possible types are visible
+        # @see {Schema::Warden} hides interfaces without visible implementations
         def visible?(context)
-          context.schema.possible_types(self).each do |type|
-            if context.schema.visible?(type, context)
-              return true
-            end
-          end
-          false
+          true
         end
 
-        # The interface is accessible if any of its possible types are accessible
-        def accessible?(context)
-          context.schema.possible_types(self).each do |type|
-            if context.schema.accessible?(type, context)
-              return true
-            end
+        def type_membership_class(membership_class = nil)
+          if membership_class
+            @type_membership_class = membership_class
+          else
+            @type_membership_class || find_inherited_value(:type_membership_class, GraphQL::Schema::TypeMembership)
           end
-          false
         end
 
         # Here's the tricky part. Make sure behavior keeps making its way down the inheritance chain.
@@ -49,9 +45,11 @@ module GraphQL
             # We need this before we can call `own_interfaces`
             child_class.extend(Schema::Interface::DefinitionMethods)
 
-            child_class.own_interfaces << self
-            child_class.interfaces.reverse_each do |interface_defn|
-              child_class.extend(interface_defn::DefinitionMethods)
+            child_class.type_membership_class(self.type_membership_class)
+            child_class.ancestors.reverse_each do |ancestor|
+              if ancestor.const_defined?(:DefinitionMethods)
+                child_class.extend(ancestor::DefinitionMethods)
+              end
             end
 
             # Use an instance variable to tell whether it's been included previously or not;
@@ -63,9 +61,15 @@ module GraphQL
               child_class.const_set(:DefinitionMethods, defn_methods_module)
               child_class.extend(child_class::DefinitionMethods)
             end
+            child_class.introspection(introspection)
+            child_class.description(description)
+            # If interfaces are mixed into each other, only define this class once
+            if !child_class.const_defined?(:UnresolvedTypeError, false)
+              add_unresolved_type_error(child_class)
+            end
           elsif child_class < GraphQL::Schema::Object
             # This is being included into an object type, make sure it's using `implements(...)`
-            backtrace_line = caller(0, 10).find { |line| line.include?("schema/object.rb") && line.include?("in `implements'")}
+            backtrace_line = caller(0, 10).find { |line| line.include?("schema/member/has_interfaces.rb") && line.include?("in `implements'")}
             if !backtrace_line
               raise "Attach interfaces using `implements(#{self})`, not `include(#{self})`"
             end
@@ -84,40 +88,11 @@ module GraphQL
           end
         end
 
-        def to_graphql
-          type_defn = GraphQL::InterfaceType.new
-          type_defn.name = graphql_name
-          type_defn.description = description
-          type_defn.orphan_types = orphan_types
-          fields.each do |field_name, field_inst|
-            field_defn = field_inst.graphql_definition
-            type_defn.fields[field_defn.name] = field_defn
-          end
-          type_defn.metadata[:type_class] = self
-          if respond_to?(:resolve_type)
-            type_defn.resolve_type = method(:resolve_type)
-          end
-          type_defn
-        end
-
         def kind
           GraphQL::TypeKinds::INTERFACE
         end
-
-        protected
-
-        def own_interfaces
-          @own_interfaces ||= []
-        end
-
-        def interfaces
-          own_interfaces + (own_interfaces.map { |i| i.own_interfaces }).flatten
-        end
       end
 
-      # Extend this _after_ `DefinitionMethods` is defined, so it will be used
-      extend GraphQL::Schema::Member::AcceptsDefinition
-
       extend DefinitionMethods
 
       def unwrap

data/lib/graphql/schema/introspection_system.rb

@@ -2,37 +2,46 @@
 module GraphQL
   class Schema
     class IntrospectionSystem
-      attr_reader :schema_type, :type_type, :typename_field
+      attr_reader :types, :possible_types
 
       def initialize(schema)
         @schema = schema
+        @class_based = !!@schema.is_a?(Class)
         @built_in_namespace = GraphQL::Introspection
-        @custom_namespace = schema.introspection_namespace || @built_in_namespace
-
-        # Use to-graphql to avoid sharing with any previous instantiations
-        @schema_type = load_constant(:SchemaType).to_graphql
-        @type_type = load_constant(:TypeType).to_graphql
-        @field_type = load_constant(:FieldType).to_graphql
-        @directive_type = load_constant(:DirectiveType).to_graphql
-        @enum_value_type = load_constant(:EnumValueType).to_graphql
-        @input_value_type = load_constant(:InputValueType).to_graphql
-        @type_kind_enum = load_constant(:TypeKindEnum).to_graphql
-        @directive_location_enum = load_constant(:DirectiveLocationEnum).to_graphql
-        @entry_point_fields = get_fields_from_class(class_sym: :EntryPoints)
-        @dynamic_fields = get_fields_from_class(class_sym: :DynamicFields)
-      end
+        @custom_namespace = if @class_based
+          schema.introspection || @built_in_namespace
+        else
+          schema.introspection_namespace || @built_in_namespace
+        end
 
-      def object_types
-        [
-          @schema_type,
-          @type_type,
-          @field_type,
-          @directive_type,
-          @enum_value_type,
-          @input_value_type,
-          @type_kind_enum,
-          @directive_location_enum,
+        type_defns = [
+          load_constant(:SchemaType),
+          load_constant(:TypeType),
+          load_constant(:FieldType),
+          load_constant(:DirectiveType),
+          load_constant(:EnumValueType),
+          load_constant(:InputValueType),
+          load_constant(:TypeKindEnum),
+          load_constant(:DirectiveLocationEnum)
         ]
+        @types = {}
+        @possible_types = {}
+        type_defns.each do |t|
+          @types[t.graphql_name] = t
+          @possible_types[t.graphql_name] = [t]
+        end
+        @entry_point_fields =
+          if schema.disable_introspection_entry_points?
+            {}
+          else
+            entry_point_fields = get_fields_from_class(class_sym: :EntryPoints)
+            entry_point_fields.delete('__schema') if schema.disable_schema_introspection_entry_point?
+            entry_point_fields.delete('__type') if schema.disable_type_introspection_entry_point?
+            entry_point_fields
+          end
+        @entry_point_fields.each { |k, v| v.dynamic_introspection = true }
+        @dynamic_fields = get_fields_from_class(class_sym: :DynamicFields)
+        @dynamic_fields.each { |k, v| v.dynamic_introspection = true }
       end
 
       def entry_points
@@ -51,25 +60,89 @@ module GraphQL
         @dynamic_fields[name]
       end
 
+      # The introspection system is prepared with a bunch of LateBoundTypes.
+      # Replace those with the objects that they refer to, since LateBoundTypes
+      # aren't handled at runtime.
+      #
+      # @api private
+      # @return void
+      def resolve_late_bindings
+        @types.each do |name, t|
+          if t.kind.fields?
+            t.fields.each do |_name, field_defn|
+              field_defn.type = resolve_late_binding(field_defn.type)
+            end
+          end
+        end
+
+        @entry_point_fields.each do |name, f|
+          f.type = resolve_late_binding(f.type)
+        end
+
+        @dynamic_fields.each do |name, f|
+          f.type = resolve_late_binding(f.type)
+        end
+        nil
+      end
+
       private
 
+      def resolve_late_binding(late_bound_type)
+        case late_bound_type
+        when GraphQL::Schema::LateBoundType
+          @schema.get_type(late_bound_type.name)
+        when GraphQL::Schema::List
+          resolve_late_binding(late_bound_type.of_type).to_list_type
+        when GraphQL::Schema::NonNull
+          resolve_late_binding(late_bound_type.of_type).to_non_null_type
+        when Module
+          # It's a normal type -- no change required
+          late_bound_type
+        else
+          raise "Invariant: unexpected type: #{late_bound_type} (#{late_bound_type.class})"
+        end
+      end
+
       def load_constant(class_name)
-        @custom_namespace.const_get(class_name)
+        const = @custom_namespace.const_get(class_name)
+        dup_type_class(const)
       rescue NameError
         # Dup the built-in so that the cached fields aren't shared
-        @built_in_namespace.const_get(class_name)
+        dup_type_class(@built_in_namespace.const_get(class_name))
       end
 
       def get_fields_from_class(class_sym:)
-        object_class = load_constant(class_sym)
-        object_type_defn = object_class.to_graphql
-        extracted_field_defns = {}
-        object_type_defn.all_fields.each do |field_defn|
-          inner_resolve = field_defn.resolve_proc
-          resolve_with_instantiate = PerFieldProxyResolve.new(object_class: object_class, inner_resolve: inner_resolve)
-          extracted_field_defns[field_defn.name] = field_defn.redefine(resolve: resolve_with_instantiate)
+        object_type_defn = load_constant(class_sym)
+
+        if object_type_defn.is_a?(Module)
+          object_type_defn.fields
+        else
+          extracted_field_defns = {}
+          object_class = object_type_defn.metadata[:type_class]
+          object_type_defn.all_fields.each do |field_defn|
+            inner_resolve = field_defn.resolve_proc
+            resolve_with_instantiate = PerFieldProxyResolve.new(object_class: object_class, inner_resolve: inner_resolve)
+            extracted_field_defns[field_defn.name] = field_defn.redefine(resolve: resolve_with_instantiate)
+          end
+          extracted_field_defns
+        end
+      end
+
+      # This is probably not 100% robust -- but it has to be good enough to avoid modifying the built-in introspection types
+      def dup_type_class(type_class)
+        type_name = type_class.graphql_name
+        Class.new(type_class) do
+          # This won't be inherited like other things will
+          graphql_name(type_name)
+
+          if type_class.kind.fields?
+            type_class.fields.each do |_name, field_defn|
+              dup_field = field_defn.dup
+              dup_field.owner = self
+              add_field(dup_field)
+            end
+          end
         end
-        extracted_field_defns
       end
 
       class PerFieldProxyResolve
@@ -84,7 +157,7 @@ module GraphQL
           if obj.is_a?(GraphQL::Schema::Object)
             obj = obj.object
           end
-          wrapped_object = @object_class.authorized_new(obj, query_ctx)
+          wrapped_object = @object_class.wrap(obj, query_ctx)
           @inner_resolve.call(wrapped_object, args, ctx)
         end
       end

data/lib/graphql/schema/late_bound_type.rb

@@ -6,8 +6,11 @@ module GraphQL
     # @api Private
     class LateBoundType
       attr_reader :name
+      alias :graphql_name :name
       def initialize(local_name)
         @name = local_name
+        @to_non_null_type = nil
+        @to_list_type = nil
       end
 
       def unwrap
@@ -15,17 +18,21 @@ module GraphQL
       end
 
       def to_non_null_type
-        GraphQL::NonNullType.new(of_type: self)
+        @to_non_null_type ||= GraphQL::Schema::NonNull.new(self)
       end
 
       def to_list_type
-        GraphQL::ListType.new(of_type: self)
+        @to_list_type ||= GraphQL::Schema::List.new(self)
       end
 
       def inspect
         "#<LateBoundType @name=#{name}>"
       end
 
+      def non_null?
+        false
+      end
+
       alias :to_s :inspect
     end
   end

data/lib/graphql/schema/list.rb

@@ -6,9 +6,7 @@ module GraphQL
     # Wraps a {Schema::Member} as a list type.
     # @see {Schema::Member::TypeSystemHelpers#to_list_type}
     class List < GraphQL::Schema::Wrapper
-      def to_graphql
-        @of_type.graphql_definition.to_list_type
-      end
+      include Schema::Member::ValidatesInput
 
       # @return [GraphQL::TypeKinds::LIST]
       def kind
@@ -23,6 +21,66 @@ module GraphQL
       def to_type_signature
         "[#{@of_type.to_type_signature}]"
       end
+
+      # This is for introspection, where it's expected the name will be `null`
+      def graphql_name
+        nil
+      end
+
+      # Also for implementing introspection
+      def description
+        nil
+      end
+
+      def coerce_result(value, ctx)
+        value.map { |i| i.nil? ? nil : of_type.coerce_result(i, ctx) }
+      end
+
+      def coerce_input(value, ctx)
+        if value.nil?
+          nil
+        else
+          coerced = ensure_array(value).map { |item| item.nil? ? item : of_type.coerce_input(item, ctx) }
+          ctx.schema.after_any_lazies(coerced, &:itself)
+        end
+      end
+
+      def validate_non_null_input(value, ctx, max_errors: nil)
+        result = GraphQL::Query::InputValidationResult.new
+        ensure_array(value).each_with_index do |item, index|
+          item_result = of_type.validate_input(item, ctx)
+          unless item_result.valid?
+            if max_errors
+              if max_errors == 0
+                add_max_errros_reached_message(result)
+                break
+              end
+
+              max_errors -= 1
+            end
+
+            result.merge_result!(index, item_result)
+          end
+        end
+        result.valid? ? nil : result
+      end
+
+      private
+
+      def ensure_array(value)
+        # `Array({ a: 1 })` makes `[[:a, 1]]`, so do it manually
+        if value.is_a?(Array)
+          value
+        else
+          [value]
+        end
+      end
+
+      def add_max_errros_reached_message(result)
+        message = "Too many errors processing list variable, max validation error limit reached. Execution aborted"
+        item_result = GraphQL::Query::InputValidationResult.from_problem(message)
+        result.merge_result!(nil, item_result)
+      end
     end
   end
 end