graphql 1.9.17 → 2.0.21

data/lib/graphql/schema/introspection_system.rb

@@ -2,44 +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
+        @custom_namespace = if @class_based
+          schema.introspection || @built_in_namespace
+        else
+          schema.introspection_namespace || @built_in_namespace
+        end
+
+        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
+          if schema.disable_introspection_entry_points?
             {}
           else
-            get_fields_from_class(class_sym: :EntryPoints)
+            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
         @dynamic_fields = get_fields_from_class(class_sym: :DynamicFields)
       end
 
-      def object_types
-        [
-          @schema_type,
-          @type_type,
-          @field_type,
-          @directive_type,
-          @enum_value_type,
-          @input_value_type,
-          @type_kind_enum,
-          @directive_location_enum,
-        ]
-      end
-
       def entry_points
         @entry_point_fields.values
       end
@@ -56,25 +58,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

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

data/lib/graphql/schema/loader.rb

@@ -5,37 +5,50 @@ module GraphQL
     # to make a schema. This schema is missing some important details like
     # `resolve` functions, but it does include the full type system,
     # so you can use it to validate queries.
+    #
+    # @see GraphQL::Schema.from_introspection for a public API
     module Loader
       extend self
 
       # Create schema with the result of an introspection query.
       # @param introspection_result [Hash] A response from {GraphQL::Introspection::INTROSPECTION_QUERY}
-      # @return [GraphQL::Schema] the schema described by `input`
-      # @deprecated Use {GraphQL::Schema.from_introspection} instead
+      # @return [Class] the schema described by `input`
       def load(introspection_result)
         schema = introspection_result.fetch("data").fetch("__schema")
 
         types = {}
-        type_resolver = ->(type) { -> { resolve_type(types, type) } }
+        type_resolver = ->(type) { resolve_type(types, type) }
 
         schema.fetch("types").each do |type|
           next if type.fetch("name").start_with?("__")
           type_object = define_type(type, type_resolver)
-          types[type_object.name] = type_object
+          types[type["name"]] = type_object
         end
 
-        kargs = { orphan_types: types.values, resolve_type: NullResolveType }
-        [:query, :mutation, :subscription].each do |root|
-          type = schema["#{root}Type"]
-          kargs[root] = types.fetch(type.fetch("name")) if type
+        directives = []
+        schema.fetch("directives", []).each do |directive|
+          next if GraphQL::Schema.default_directives.include?(directive.fetch("name"))
+          directives << define_directive(directive, type_resolver)
         end
 
-        Schema.define(**kargs, raise_definition_error: true)
-      end
+        Class.new(GraphQL::Schema) do
+          orphan_types(types.values)
+          directives(directives)
+          description(schema["description"])
+
+          def self.resolve_type(*)
+            raise(GraphQL::RequiredImplementationMissingError, "This schema was loaded from string, so it can't resolve types for objects")
+          end
 
-      NullResolveType = ->(type, obj, ctx) {
-        raise(GraphQL::RequiredImplementationMissingError, "This schema was loaded from string, so it can't resolve types for objects")
-      }
+          [:query, :mutation, :subscription].each do |root|
+            type = schema["#{root}Type"]
+            if type
+              type_defn = types.fetch(type.fetch("name"))
+              self.public_send(root, type_defn)
+            end
+          end
+        end
+      end
 
       NullScalarCoerce = ->(val, _ctx) { val }
 
@@ -45,11 +58,17 @@ module GraphQL
         def resolve_type(types, type)
           case kind = type.fetch("kind")
           when "ENUM", "INTERFACE", "INPUT_OBJECT", "OBJECT", "SCALAR", "UNION"
-            types.fetch(type.fetch("name"))
+            type_name = type.fetch("name")
+            type = types[type_name] || Schema::BUILT_IN_TYPES[type_name]
+            if type.nil?
+              GraphQL::Schema::LateBoundType.new(type_name)
+            else
+              type
+            end
           when "LIST"
-            ListType.new(of_type: resolve_type(types, type.fetch("ofType")))
+            Schema::List.new(resolve_type(types, type.fetch("ofType")))
           when "NON_NULL"
-            NonNullType.new(of_type: resolve_type(types, type.fetch("ofType")))
+            Schema::NonNull.new(resolve_type(types, type.fetch("ofType")))
           else
             fail GraphQL::RequiredImplementationMissingError, "#{kind} not implemented"
           end
@@ -77,103 +96,132 @@ module GraphQL
         end
 
         def define_type(type, type_resolver)
+          loader = self
           case type.fetch("kind")
           when "ENUM"
-            EnumType.define(
-              name: type["name"],
-              description: type["description"],
-              values: type["enumValues"].map { |enum|
-                EnumType::EnumValue.define(
-                  name: enum["name"],
-                  description: enum["description"],
-                  deprecation_reason: enum["deprecationReason"],
-                  value: enum["name"]
+            Class.new(GraphQL::Schema::Enum) do
+              graphql_name(type["name"])
+              description(type["description"])
+              type["enumValues"].each do |enum_value|
+                value(
+                  enum_value["name"],
+                  description: enum_value["description"],
+                  deprecation_reason: enum_value["deprecationReason"],
                 )
-              })
+              end
+            end
           when "INTERFACE"
-            InterfaceType.define(
-              name: type["name"],
-              description: type["description"],
-              fields: Hash[(type["fields"] || []).map { |field|
-                [field["name"], define_type(field.merge("kind" => "FIELD"), type_resolver)]
-              }]
-            )
+            Module.new do
+              include GraphQL::Schema::Interface
+              graphql_name(type["name"])
+              description(type["description"])
+              loader.build_fields(self, type["fields"] || [], type_resolver)
+            end
           when "INPUT_OBJECT"
-            InputObjectType.define(
-              name: type["name"],
-              description: type["description"],
-              arguments: Hash[type["inputFields"].map { |arg|
-                [arg["name"], define_type(arg.merge("kind" => "ARGUMENT"), type_resolver)]
-              }]
-            )
+            Class.new(GraphQL::Schema::InputObject) do
+              graphql_name(type["name"])
+              description(type["description"])
+              loader.build_arguments(self, type["inputFields"], type_resolver)
+            end
           when "OBJECT"
-            ObjectType.define(
-              name: type["name"],
-              description: type["description"],
-              interfaces: (type["interfaces"] || []).map { |interface|
-                type_resolver.call(interface)
-              },
-              fields: Hash[type["fields"].map { |field|
-                [field["name"], define_type(field.merge("kind" => "FIELD"), type_resolver)]
-              }]
-            )
-          when "FIELD"
-            GraphQL::Field.define(
-              name: type["name"],
-              type: type_resolver.call(type["type"]),
-              description: type["description"],
-              arguments: Hash[type["args"].map { |arg|
-                [arg["name"], define_type(arg.merge("kind" => "ARGUMENT"), type_resolver)]
-              }]
-            )
-          when "ARGUMENT"
-            kwargs = {}
-            if type["defaultValue"]
-              kwargs[:default_value] = begin
-                default_value_str = type["defaultValue"]
-
-                dummy_query_str = "query getStuff($var: InputObj = #{default_value_str}) { __typename }"
-
-                # Returns a `GraphQL::Language::Nodes::Document`:
-                dummy_query_ast = GraphQL.parse(dummy_query_str)
-
-                # Reach into the AST for the default value:
-                input_value_ast = dummy_query_ast.definitions.first.variables.first.default_value
-
-                extract_default_value(default_value_str, input_value_ast)
+            Class.new(GraphQL::Schema::Object) do
+              graphql_name(type["name"])
+              description(type["description"])
+              if type["interfaces"]
+                type["interfaces"].each do |interface_type|
+                  implements(type_resolver.call(interface_type))
+                end
               end
+              loader.build_fields(self, type["fields"], type_resolver)
             end
-
-            GraphQL::Argument.define(
-              name: type["name"],
-              type: type_resolver.call(type["type"]),
-              description: type["description"],
-              method_access: false,
-              **kwargs
-            )
           when "SCALAR"
             type_name = type.fetch("name")
-            if GraphQL::Schema::BUILT_IN_TYPES[type_name]
-              GraphQL::Schema::BUILT_IN_TYPES[type_name]
+            if (builtin = GraphQL::Schema::BUILT_IN_TYPES[type_name])
+              builtin
             else
-              ScalarType.define(
-                name: type["name"],
-                description: type["description"],
-                coerce: NullScalarCoerce,
-              )
+              Class.new(GraphQL::Schema::Scalar) do
+                graphql_name(type["name"])
+                description(type["description"])
+                specified_by_url(type["specifiedByURL"])
+              end
             end
           when "UNION"
-            UnionType.define(
-              name: type["name"],
-              description: type["description"],
-              possible_types: type["possibleTypes"].map { |possible_type|
-                type_resolver.call(possible_type)
-              }
-            )
+            Class.new(GraphQL::Schema::Union) do
+              graphql_name(type["name"])
+              description(type["description"])
+              possible_types(*(type["possibleTypes"].map { |pt| type_resolver.call(pt) }))
+            end
           else
             fail GraphQL::RequiredImplementationMissingError, "#{type["kind"]} not implemented"
           end
         end
+
+        def define_directive(directive, type_resolver)
+          loader = self
+          Class.new(GraphQL::Schema::Directive) do
+            graphql_name(directive["name"])
+            description(directive["description"])
+            locations(*directive["locations"].map(&:to_sym))
+            repeatable(directive["isRepeatable"])
+            loader.build_arguments(self, directive["args"], type_resolver)
+          end
+        end
+
+        public
+
+        def build_fields(type_defn, fields, type_resolver)
+          loader = self
+          fields.each do |field_hash|
+            unwrapped_field_hash = field_hash
+            while (of_type = unwrapped_field_hash["ofType"])
+              unwrapped_field_hash = of_type
+            end
+            type_name = unwrapped_field_hash["name"]
+
+            type_defn.field(
+              field_hash["name"],
+              type: type_resolver.call(field_hash["type"]),
+              description: field_hash["description"],
+              deprecation_reason: field_hash["deprecationReason"],
+              null: true,
+              camelize: false,
+              connection_extension: nil,
+              connection: type_name.end_with?("Connection"),
+            ) do
+              if field_hash["args"].any?
+                loader.build_arguments(self, field_hash["args"], type_resolver)
+              end
+            end
+          end
+        end
+
+        def build_arguments(arg_owner, args, type_resolver)
+          args.each do |arg|
+            kwargs = {
+              type: type_resolver.call(arg["type"]),
+              description: arg["description"],
+              deprecation_reason: arg["deprecationReason"],
+              required: false,
+              camelize: false,
+            }
+
+            if arg["defaultValue"]
+              default_value_str = arg["defaultValue"]
+
+              dummy_query_str = "query getStuff($var: InputObj = #{default_value_str}) { __typename }"
+
+              # Returns a `GraphQL::Language::Nodes::Document`:
+              dummy_query_ast = GraphQL.parse(dummy_query_str)
+
+              # Reach into the AST for the default value:
+              input_value_ast = dummy_query_ast.definitions.first.variables.first.default_value
+
+              kwargs[:default_value] = extract_default_value(default_value_str, input_value_ast)
+            end
+
+            arg_owner.argument(arg["name"], **kwargs)
+          end
+        end
       end
     end
   end