graphql 1.12.8 → 1.12.14

data/lib/graphql/execution/lazy.rb

@@ -48,7 +48,11 @@ module GraphQL
           end
         end
 
-        if @value.is_a?(StandardError)
+        # `SKIP` was made into a subclass of `GraphQL::Error` to improve runtime performance
+        # (fewer clauses in a hot `case` block), but now it requires special handling here.
+        # I think it's still worth it for the performance win, but if the number of special
+        # cases grows, then maybe it's worth rethinking somehow.
+        if @value.is_a?(StandardError) && @value != GraphQL::Execution::Execute::SKIP
           raise @value
         else
           @value

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/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/query.rb

@@ -270,7 +270,7 @@ module GraphQL
     # @return [String, nil] Returns nil if the query is invalid.
     def sanitized_query_string(inline_variables: true)
       with_prepared_ast {
-        GraphQL::Language::SanitizedPrinter.new(self, inline_variables: inline_variables).sanitized_query_string
+        schema.sanitized_printer.new(self, inline_variables: inline_variables).sanitized_query_string
       }
     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/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
@@ -712,6 +696,7 @@ module GraphQL
     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, :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,
@@ -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)
@@ -1582,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
@@ -1633,6 +1631,14 @@ module GraphQL
         find_inherited_value(:multiplex_analyzers, EMPTY_ARRAY) + own_multiplex_analyzers
       end
 
+      def sanitized_printer(new_sanitized_printer = nil)
+        if new_sanitized_printer
+          @own_sanitized_printer = new_sanitized_printer
+        else
+          @own_sanitized_printer || GraphQL::Language::SanitizedPrinter
+        end
+      end
+
       # Execute a query on itself.
       # @see {Query#initialize} for arguments.
       # @return [Hash] query result, ready to be serialized as JSON
@@ -1709,6 +1715,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)
@@ -1774,202 +1804,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

data/lib/graphql/schema/addition.rb

@@ -0,0 +1,238 @@
+# frozen_string_literal: true
+
+module GraphQL
+  class Schema
+    class Addition
+      attr_reader :directives, :possible_types, :types, :union_memberships, :references, :arguments_with_default_values
+
+      def initialize(schema:, own_types:, new_types:)
+        @schema = schema
+        @own_types = own_types
+        @directives = Set.new
+        @possible_types = {}
+        @types = {}
+        @union_memberships = {}
+        @references = Hash.new { |h, k| h[k] = [] }
+        @arguments_with_default_values = []
+        add_type_and_traverse(new_types)
+      end
+
+      private
+
+      def references_to(thing, from:)
+        @references[thing] << from
+      end
+
+      def get_type(name)
+        @types[name] || @schema.get_type(name)
+      end
+
+      # Lookup using `own_types` here because it's ok to override
+      # inherited types by name
+      def get_local_type(name)
+        @types[name] || @own_types[name]
+      end
+
+      def add_directives_from(owner)
+        dirs = owner.directives.map(&:class)
+        @directives.merge(dirs)
+        add_type_and_traverse(dirs)
+      end
+
+      def add_type_and_traverse(new_types)
+        late_types = []
+        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.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)
+            @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 = @possible_types[int.graphql_name] ||= []
+              if !pt.include?(owner)
+                pt << owner
+              end
+            end
+          end
+
+        when nil
+          # It's a root type
+          @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 = @union_memberships[type.graphql_name] ||= []
+          um << owner
+        end
+
+        if (prev_type = get_local_type(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
+          @directives << type
+          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])
+            if arg.default_value?
+              @arguments_with_default_values << arg
+            end
+          end
+        else
+          @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])
+                if arg.default_value?
+                  @arguments_with_default_values << arg
+                end
+              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])
+              if arg.default_value?
+                @arguments_with_default_values << arg
+              end
+            end
+          end
+          if type.kind.union?
+            @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?
+            @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 = @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
+    end
+  end
+end