graphql 1.12.6 → 1.12.11

data/lib/graphql/introspection.rb

@@ -17,7 +17,7 @@ query IntrospectionQuery {
       name
       description
       locations
-      args {
+      args#{include_deprecated_args ? '(includeDeprecated: true)' : ''} {
         ...InputValue
       }
     }

data/lib/graphql/introspection/directive_type.rb

@@ -12,13 +12,17 @@ module GraphQL
       field :name, String, null: false, method: :graphql_name
       field :description, String, null: true
       field :locations, [GraphQL::Schema::LateBoundType.new("__DirectiveLocation")], null: false
-      field :args, [GraphQL::Schema::LateBoundType.new("__InputValue")], null: false
+      field :args, [GraphQL::Schema::LateBoundType.new("__InputValue")], null: false do
+        argument :include_deprecated, Boolean, required: false, default_value: false
+      end
       field :on_operation, Boolean, null: false, deprecation_reason: "Use `locations`.", method: :on_operation?
       field :on_fragment, Boolean, null: false, deprecation_reason: "Use `locations`.", method: :on_fragment?
       field :on_field, Boolean, null: false, deprecation_reason: "Use `locations`.", method: :on_field?
 
-      def args
-        @context.warden.arguments(@object)
+      def args(include_deprecated:)
+        args = @context.warden.arguments(@object)
+        args = args.reject(&:deprecation_reason) unless include_deprecated
+        args
       end
     end
   end

data/lib/graphql/introspection/schema_type.rb

@@ -31,7 +31,7 @@ module GraphQL
       end
 
       def directives
-        context.schema.directives.values
+        @context.warden.directives
       end
 
       private

data/lib/graphql/pagination/active_record_relation_connection.rb

@@ -5,6 +5,13 @@ module GraphQL
   module Pagination
     # Customizes `RelationConnection` to work with `ActiveRecord::Relation`s.
     class ActiveRecordRelationConnection < Pagination::RelationConnection
+      private
+
+      def relation_larger_than(relation, size)
+        initial_offset = relation.offset_value || 0
+        relation.offset(initial_offset + size).exists?
+      end
+
       def relation_count(relation)
         int_or_hash = if relation.respond_to?(:unscope)
           relation.unscope(:order).count(:all)

data/lib/graphql/pagination/connections.rb

@@ -79,7 +79,7 @@ module GraphQL
           context: context,
           parent: parent,
           field: field,
-          max_page_size: field.max_page_size || context.schema.default_max_page_size,
+          max_page_size: field.has_max_page_size? ? field.max_page_size : context.schema.default_max_page_size,
           first: arguments[:first],
           after: arguments[:after],
           last: arguments[:last],

data/lib/graphql/pagination/relation_connection.rb

@@ -35,7 +35,7 @@ module GraphQL
             if @nodes && @nodes.count < first
               false
             else
-              relation_count(set_limit(sliced_nodes, first + 1)) == first + 1
+              relation_larger_than(sliced_nodes, first)
             end
           else
             false
@@ -53,6 +53,13 @@ module GraphQL
 
       private
 
+      # @param relation [Object] A database query object
+      # @param size [Integer] The value against which we check the relation size
+      # @return [Boolean] True if the number of items in this relation is larger than `size`
+      def relation_larger_than(relation, size)
+        relation_count(set_limit(relation, size + 1)) == size + 1
+      end
+
       # @param relation [Object] A database query object
       # @return [Integer, nil] The offset value, or nil if there isn't one
       def relation_offset(relation)

data/lib/graphql/query.rb

@@ -195,9 +195,7 @@ module GraphQL
     # @return [Hash] A GraphQL response, with `"data"` and/or `"errors"` keys
     def result
       if !@executed
-        with_prepared_ast {
-          Execution::Multiplex.run_queries(@schema, [self], context: @context)
-        }
+        Execution::Multiplex.run_queries(@schema, [self], context: @context)
       end
       @result ||= Query::Result.new(query: self, values: @result_values)
     end

data/lib/graphql/query/null_context.rb

@@ -9,10 +9,16 @@ module GraphQL
         def visible_type?(t); true; end
       end
 
+      class NullQuery
+        def with_error_handling
+          yield
+        end
+      end
+
       attr_reader :schema, :query, :warden, :dataloader
 
       def initialize
-        @query = nil
+        @query = NullQuery.new
         @dataloader = GraphQL::Dataloader::NullDataloader.new
         @schema = GraphQL::Schema.new
         @warden = NullWarden.new(

data/lib/graphql/query/validation_pipeline.rb

@@ -36,7 +36,7 @@ module GraphQL
         @valid
       end
 
-      # @return [Array<GraphQL::StaticValidation::Error >] Static validation errors for the query string
+      # @return [Array<GraphQL::StaticValidation::Error, GraphQL::Query::VariableValidationError>] Static validation errors for the query string
       def validation_errors
         ensure_has_validated
         @validation_errors

data/lib/graphql/rake_task.rb

@@ -98,6 +98,9 @@ module GraphQL
       result = schema.public_send(method_name, only: @only, except: @except, context: context)
       dir = File.dirname(file)
       FileUtils.mkdir_p(dir)
+      if !result.end_with?("\n")
+        result += "\n"
+      end
       File.write(file, result)
     end
 

data/lib/graphql/schema.rb

@@ -1,4 +1,5 @@
 # frozen_string_literal: true
+require "graphql/schema/addition"
 require "graphql/schema/base_64_encoder"
 require "graphql/schema/catchall_middleware"
 require "graphql/schema/default_parse_error"
@@ -355,23 +356,6 @@ module GraphQL
     # For forwards-compatibility with Schema classes
     alias :graphql_definition :itself
 
-    # Validate a query string according to this schema.
-    # @param string_or_document [String, GraphQL::Language::Nodes::Document]
-    # @return [Array<GraphQL::StaticValidation::Error >]
-    def validate(string_or_document, rules: nil, context: nil)
-      doc = if string_or_document.is_a?(String)
-        GraphQL.parse(string_or_document)
-      else
-        string_or_document
-      end
-      query = GraphQL::Query.new(self, document: doc, context: context)
-      validator_opts = { schema: self }
-      rules && (validator_opts[:rules] = rules)
-      validator = GraphQL::StaticValidation::Validator.new(**validator_opts)
-      res = validator.validate(query, timeout: validate_timeout)
-      res[:errors]
-    end
-
     def deprecated_define(**kwargs, &block)
       super
       ensure_defined
@@ -711,7 +695,8 @@ 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, :rescues
+    def_delegators :_schema_class, :error_handler
+    def_delegators :_schema_class, :validate
 
 
     # Given this schema member, find the class-based definition object
@@ -861,7 +846,6 @@ module GraphQL
       def_delegators :graphql_definition,
         # Execution
         :execution_strategy_for_operation,
-        :validate,
         # Configuration
         :metadata, :redefine,
         :id_from_object_proc, :object_from_id_proc,
@@ -989,7 +973,7 @@ module GraphQL
           schema_defn.lazy_methods.set(lazy_class, value_method)
         end
 
-        rescues.each do |err_class, handler|
+        error_handler.each_rescue do |err_class, handler|
           schema_defn.rescue_from(err_class, &handler)
         end
 
@@ -1293,6 +1277,23 @@ module GraphQL
         end
       end
 
+      # Validate a query string according to this schema.
+      # @param string_or_document [String, GraphQL::Language::Nodes::Document]
+      # @return [Array<GraphQL::StaticValidation::Error >]
+      def validate(string_or_document, rules: nil, context: nil)
+        doc = if string_or_document.is_a?(String)
+          GraphQL.parse(string_or_document)
+        else
+          string_or_document
+        end
+        query = GraphQL::Query.new(self, document: doc, context: context)
+        validator_opts = { schema: self }
+        rules && (validator_opts[:rules] = rules)
+        validator = GraphQL::StaticValidation::Validator.new(**validator_opts)
+        res = validator.validate(query, timeout: validate_timeout)
+        res[:errors]
+      end
+
       attr_writer :max_complexity
 
       def max_complexity(max_complexity = nil)
@@ -1424,7 +1425,7 @@ module GraphQL
 
       def rescue_from(*err_classes, &handler_block)
         err_classes.each do |err_class|
-          own_rescues[err_class] = handler_block
+          error_handler.rescue_from(err_class, handler_block)
         end
       end
 
@@ -1468,10 +1469,6 @@ module GraphQL
         super
       end
 
-      def rescues
-        find_inherited_value(:rescues, EMPTY_HASH).merge(own_rescues)
-      end
-
       def object_from_id(node_id, ctx)
         raise GraphQL::RequiredImplementationMissingError, "#{self.name}.object_from_id(node_id, ctx) must be implemented to load by ID (tried to load from id `#{node_id}`)"
       end
@@ -1548,15 +1545,10 @@ module GraphQL
       def parse_error(parse_err, ctx)
         ctx.errors.push(parse_err)
       end
-      attr_writer :error_handler
 
-      # @return [GraphQL::Execution::Errors, Class<GraphQL::Execution::Errors::NullErrorHandler>]
+      # @return [GraphQL::Execution::Errors]
       def error_handler
-        if defined?(@error_handler)
-          @error_handler
-        else
-          find_inherited_value(:error_handler, GraphQL::Execution::Errors::NullErrorHandler)
-        end
+        @error_handler ||= GraphQL::Execution::Errors.new(self)
       end
 
       def lazy_resolve(lazy_class, value_method)
@@ -1591,10 +1583,7 @@ module GraphQL
       # @param new_directive [Class]
       # @return void
       def directive(new_directive)
-        own_directives[new_directive.graphql_name] ||= begin
-          add_type_and_traverse(new_directive, root: false)
-          new_directive
-        end
+        add_type_and_traverse(new_directive, root: false)
       end
 
       def default_directives
@@ -1718,6 +1707,30 @@ module GraphQL
 
       private
 
+      # @param t [Module, Array<Module>]
+      # @return [void]
+      def add_type_and_traverse(t, root:)
+        if root
+          @root_types ||= []
+          @root_types << t
+        end
+        new_types = Array(t)
+        addition = Schema::Addition.new(schema: self, own_types: own_types, new_types: new_types)
+        own_types.merge!(addition.types)
+        own_possible_types.merge!(addition.possible_types) { |key, old_val, new_val| old_val + new_val }
+        own_union_memberships.merge!(addition.union_memberships)
+
+        addition.references.each { |thing, pointers|
+          pointers.each { |pointer| references_to(thing, from: pointer) }
+        }
+
+        addition.directives.each { |dir_class| own_directives[dir_class.graphql_name] = dir_class }
+
+        addition.arguments_with_default_values.each do |arg|
+          arg.validate_default_value
+        end
+      end
+
       def lazy_methods
         if !defined?(@lazy_methods)
           if inherited_map = find_inherited_value(:lazy_methods)
@@ -1744,10 +1757,6 @@ module GraphQL
         @own_plugins ||= []
       end
 
-      def own_rescues
-        @own_rescues ||= {}
-      end
-
       def own_orphan_types
         @own_orphan_types ||= []
       end
@@ -1787,202 +1796,6 @@ module GraphQL
       def own_multiplex_analyzers
         @own_multiplex_analyzers ||= []
       end
-
-      # @param t [Module, Array<Module>]
-      # @return [void]
-      def add_type_and_traverse(t, root:)
-        if root
-          @root_types ||= []
-          @root_types << t
-        end
-        late_types = []
-        new_types = Array(t)
-        new_types.each { |t| add_type(t, owner: nil, late_types: late_types, path: [t.graphql_name]) }
-        missed_late_types = 0
-        while (late_type_vals = late_types.shift)
-          type_owner, lt = late_type_vals
-          if lt.is_a?(String)
-            type = Member::BuildType.constantize(lt)
-            # Reset the counter, since we might succeed next go-round
-            missed_late_types = 0
-            update_type_owner(type_owner, type)
-            add_type(type, owner: type_owner, late_types: late_types, path: [type.graphql_name])
-          elsif lt.is_a?(LateBoundType)
-            if (type = get_type(lt.graphql_name))
-              # Reset the counter, since we might succeed next go-round
-              missed_late_types = 0
-              update_type_owner(type_owner, type)
-              add_type(type, owner: type_owner, late_types: late_types, path: [type.graphql_name])
-            else
-              missed_late_types += 1
-              # Add it back to the list, maybe we'll be able to resolve it later.
-              late_types << [type_owner, lt]
-              if missed_late_types == late_types.size
-                # We've looked at all of them and haven't resolved one.
-                raise UnresolvedLateBoundTypeError.new(type: lt)
-              else
-                # Try the next one
-              end
-            end
-          else
-            raise ArgumentError, "Unexpected late type: #{lt.inspect}"
-          end
-        end
-        nil
-      end
-
-      def update_type_owner(owner, type)
-        case owner
-        when Class
-          if owner.kind.union?
-            # It's a union with possible_types
-            # Replace the item by class name
-            owner.assign_type_membership_object_type(type)
-            own_possible_types[owner.graphql_name] = owner.possible_types
-          elsif type.kind.interface? && owner.kind.object?
-            new_interfaces = []
-            owner.interfaces.each do |int_t|
-              if int_t.is_a?(String) && int_t == type.graphql_name
-                new_interfaces << type
-              elsif int_t.is_a?(LateBoundType) && int_t.graphql_name == type.graphql_name
-                new_interfaces << type
-              else
-                # Don't re-add proper interface definitions,
-                # they were probably already added, maybe with options.
-              end
-            end
-            owner.implements(*new_interfaces)
-            new_interfaces.each do |int|
-              pt = own_possible_types[int.graphql_name] ||= []
-              if !pt.include?(owner)
-                pt << owner
-              end
-            end
-          end
-
-        when nil
-          # It's a root type
-          own_types[type.graphql_name] = type
-        when GraphQL::Schema::Field, GraphQL::Schema::Argument
-          orig_type = owner.type
-          # Apply list/non-null wrapper as needed
-          if orig_type.respond_to?(:of_type)
-            transforms = []
-            while (orig_type.respond_to?(:of_type))
-              if orig_type.kind.non_null?
-                transforms << :to_non_null_type
-              elsif orig_type.kind.list?
-                transforms << :to_list_type
-              else
-                raise "Invariant: :of_type isn't non-null or list"
-              end
-              orig_type = orig_type.of_type
-            end
-            transforms.reverse_each { |t| type = type.public_send(t) }
-          end
-          owner.type = type
-        else
-          raise "Unexpected update: #{owner.inspect} #{type.inspect}"
-        end
-      end
-
-      def add_type(type, owner:, late_types:, path:)
-        if type.respond_to?(:metadata) && type.metadata.is_a?(Hash)
-          type_class = type.metadata[:type_class]
-          if type_class.nil?
-            raise ArgumentError, "Can't add legacy type: #{type} (#{type.class})"
-          else
-            type = type_class
-          end
-        elsif type.is_a?(String) || type.is_a?(GraphQL::Schema::LateBoundType)
-          late_types << [owner, type]
-          return
-        end
-
-        if owner.is_a?(Class) && owner < GraphQL::Schema::Union
-          um = own_union_memberships[type.graphql_name] ||= []
-          um << owner
-        end
-
-        if (prev_type = own_types[type.graphql_name])
-          if prev_type != type
-            raise DuplicateTypeNamesError.new(
-              type_name: type.graphql_name,
-              first_definition: prev_type,
-              second_definition: type,
-              path: path,
-            )
-          else
-            # This type was already added
-          end
-        elsif type.is_a?(Class) && type < GraphQL::Schema::Directive
-          type.arguments.each do |name, arg|
-            arg_type = arg.type.unwrap
-            references_to(arg_type, from: arg)
-            add_type(arg_type, owner: arg, late_types: late_types, path: path + [name])
-          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])
-              end
-            end
-          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])
-            end
-          end
-          if type.kind.union?
-            own_possible_types[type.graphql_name] = type.possible_types
-            type.possible_types.each do |t|
-              add_type(t, owner: type, late_types: late_types, path: path + ["possible_types"])
-            end
-          end
-          if type.kind.interface?
-            type.orphan_types.each do |t|
-              add_type(t, owner: type, late_types: late_types, path: path + ["orphan_types"])
-            end
-          end
-          if type.kind.object?
-            own_possible_types[type.graphql_name] = [type]
-            type.interface_type_memberships.each do |interface_type_membership|
-              case interface_type_membership
-              when Schema::TypeMembership
-                interface_type = interface_type_membership.abstract_type
-                # We can get these now; we'll have to get late-bound types later
-                if interface_type.is_a?(Module)
-                  implementers = own_possible_types[interface_type.graphql_name] ||= []
-                  implementers << type
-                end
-              when String, Schema::LateBoundType
-                interface_type = interface_type_membership
-              else
-                raise ArgumentError, "Invariant: unexpected type membership for #{type.graphql_name}: #{interface_type_membership.class} (#{interface_type_membership.inspect})"
-              end
-              add_type(interface_type, owner: type, late_types: late_types, path: path + ["implements"])
-            end
-          end
-        end
-      end
-
-      def add_directives_from(owner)
-        owner.directives.each { |dir| directive(dir.class) }
-      end
     end
 
     def dataloader_class
@@ -1990,7 +1803,6 @@ module GraphQL
     end
 
     # Install these here so that subclasses will also install it.
-    use(GraphQL::Execution::Errors)
     use(GraphQL::Pagination::Connections)
 
     protected