graphql 1.9.17 → 1.11.7

data/lib/graphql/internal_representation/visit.rb

@@ -23,11 +23,11 @@ module GraphQL
 
       # Traverse a node in a rewritten query tree,
       # visiting the node itself and each of its typed children.
-      def each_node(node)
+      def each_node(node, &block)
         yield(node)
         node.typed_children.each do |obj_type, children|
           children.each do |name, node|
-            each_node(node) { |n| yield(n) }
+            each_node(node, &block)
           end
         end
       end

data/lib/graphql/introspection/base_object.rb

@@ -2,15 +2,12 @@
 module GraphQL
   module Introspection
     class BaseObject < GraphQL::Schema::Object
+      introspection(true)
+
       def self.field(*args, **kwargs, &block)
         kwargs[:introspection] = true
         super(*args, **kwargs, &block)
       end
-
-      def self.inherited(child_class)
-        child_class.introspection(true)
-        super
-      end
     end
   end
 end

data/lib/graphql/introspection/directive_type.rb

@@ -9,7 +9,7 @@ module GraphQL
                   "in ways field arguments will not suffice, such as conditionally including or "\
                   "skipping a field. Directives provide this by describing additional information "\
                     "to the executor."
-      field :name, String, null: false
+      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

data/lib/graphql/introspection/entry_points.rb

@@ -10,23 +10,23 @@ module GraphQL
       def __schema
         # Apply wrapping manually since this field isn't wrapped by instrumentation
         schema = @context.query.schema
-        schema_type = schema.introspection_system.schema_type
-        schema_type.metadata[:type_class].authorized_new(schema, @context)
+        schema_type = schema.introspection_system.types["__Schema"]
+        schema_type.type_class.authorized_new(schema, @context)
       end
 
       def __type(name:)
         return unless context.warden.reachable_type?(name)
-
         type = context.warden.get_type(name)
-        if type && context.interpreter?
-          type = type.metadata[:type_class] || raise("Invariant: interpreter requires class-based type for #{name}")
+
+        if type && context.interpreter? && !type.is_a?(Module)
+          type = type.type_class || raise("Invariant: interpreter requires class-based type for #{name}")
         end
 
         # The interpreter provides this wrapping, other execution doesnt, so support both.
         if type && !context.interpreter?
           # Apply wrapping manually since this field isn't wrapped by instrumentation
-          type_type = context.schema.introspection_system.type_type
-          type = type_type.metadata[:type_class].authorized_new(type, context)
+          type_type = context.schema.introspection_system.types["__Type"]
+          type = type_type.type_class.authorized_new(type, context)
         end
         type
       end

data/lib/graphql/introspection/field_type.rb

@@ -7,7 +7,9 @@ module GraphQL
                   "a name, potentially a list of arguments, and a return type."
       field :name, String, null: false
       field :description, String, null: true
-      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 :type, GraphQL::Schema::LateBoundType.new("__Type"), null: false
       field :is_deprecated, Boolean, null: false
       field :deprecation_reason, String, null: true
@@ -16,8 +18,10 @@ module GraphQL
         !!@object.deprecation_reason
       end
 
-      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/input_value_type.rb

@@ -10,6 +10,12 @@ module GraphQL
       field :description, String, null: true
       field :type, GraphQL::Schema::LateBoundType.new("__Type"), null: false
       field :default_value, String, "A GraphQL-formatted string representing the default value for this input value.", null: true
+      field :is_deprecated, Boolean, null: false
+      field :deprecation_reason, String, null: true
+
+      def is_deprecated
+        !!@object.deprecation_reason
+      end
 
       def default_value
         if @object.default_value?
@@ -18,20 +24,38 @@ module GraphQL
             'null'
           else
             coerced_default_value = @object.type.coerce_result(value, @context)
-            if @object.type.unwrap.is_a?(GraphQL::EnumType)
-              if @object.type.list? 
-                "[#{coerced_default_value.join(", ")}]"
-              else
-                coerced_default_value
-              end
-            else
-              GraphQL::Language.serialize(coerced_default_value)
-            end
+            serialize_default_value(coerced_default_value, @object.type)
           end
         else
           nil
         end
       end
+
+
+      private
+
+      # Recursively serialize, taking care not to add quotes to enum values
+      def serialize_default_value(value, type)
+        if value.nil?
+          'null'
+        elsif type.kind.list?
+          inner_type = type.of_type
+          "[" + value.map { |v| serialize_default_value(v, inner_type) }.join(", ") + "]"
+        elsif type.kind.non_null?
+          serialize_default_value(value, type.of_type)
+        elsif type.kind.enum?
+          value
+        elsif type.kind.input_object?
+          "{" +
+            value.map do |k, v|
+              arg_defn = type.arguments[k]
+              "#{k}: #{serialize_default_value(v, arg_defn.type)}"
+            end.join(", ") +
+            "}"
+        else
+          GraphQL::Language.serialize(value)
+        end
+      end
     end
   end
 end

data/lib/graphql/introspection/introspection_query.rb

@@ -1,93 +1,7 @@
 # frozen_string_literal: true
-# The introspection query to end all introspection queries, copied from
-# https://github.com/graphql/graphql-js/blob/master/src/utilities/introspectionQuery.js
-GraphQL::Introspection::INTROSPECTION_QUERY = "
-query IntrospectionQuery {
-  __schema {
-    queryType { name }
-    mutationType { name }
-    subscriptionType { name }
-    types {
-      ...FullType
-    }
-    directives {
-      name
-      description
-      locations
-      args {
-        ...InputValue
-      }
-    }
-  }
-}
-fragment FullType on __Type {
-  kind
-  name
-  description
-  fields(includeDeprecated: true) {
-    name
-    description
-    args {
-      ...InputValue
-    }
-    type {
-      ...TypeRef
-    }
-    isDeprecated
-    deprecationReason
-  }
-  inputFields {
-    ...InputValue
-  }
-  interfaces {
-    ...TypeRef
-  }
-  enumValues(includeDeprecated: true) {
-    name
-    description
-    isDeprecated
-    deprecationReason
-  }
-  possibleTypes {
-    ...TypeRef
-  }
-}
-fragment InputValue on __InputValue {
-  name
-  description
-  type { ...TypeRef }
-  defaultValue
-}
-fragment TypeRef on __Type {
-  kind
-  name
-  ofType {
-    kind
-    name
-    ofType {
-      kind
-      name
-      ofType {
-        kind
-        name
-        ofType {
-          kind
-          name
-          ofType {
-            kind
-            name
-            ofType {
-              kind
-              name
-              ofType {
-                kind
-                name
-              }
-            }
-          }
-        }
-      }
-    }
-  }
-}
-"
+
+# This query is used by graphql-client so don't add the includeDeprecated
+# argument for inputFields since the server may not support it. Two stage
+# introspection queries will be required to handle this in clients.
+GraphQL::Introspection::INTROSPECTION_QUERY = GraphQL::Introspection.query
+

data/lib/graphql/introspection/schema_type.rb

@@ -9,18 +9,13 @@ module GraphQL
                   "query, mutation, and subscription operations."
 
       field :types, [GraphQL::Schema::LateBoundType.new("__Type")], "A list of all types supported by this server.", null: false
-      field :queryType, GraphQL::Schema::LateBoundType.new("__Type"), "The type that query operations will be rooted at.", null: false
-      field :mutationType, GraphQL::Schema::LateBoundType.new("__Type"), "If this server supports mutation, the type that mutation operations will be rooted at.", null: true
-      field :subscriptionType, GraphQL::Schema::LateBoundType.new("__Type"), "If this server support subscription, the type that subscription operations will be rooted at.", null: true
+      field :query_type, GraphQL::Schema::LateBoundType.new("__Type"), "The type that query operations will be rooted at.", null: false
+      field :mutation_type, GraphQL::Schema::LateBoundType.new("__Type"), "If this server supports mutation, the type that mutation operations will be rooted at.", null: true
+      field :subscription_type, GraphQL::Schema::LateBoundType.new("__Type"), "If this server support subscription, the type that subscription operations will be rooted at.", null: true
       field :directives, [GraphQL::Schema::LateBoundType.new("__Directive")], "A list of all directives supported by this server.", null: false
 
       def types
-        types = @context.warden.reachable_types.sort_by(&:graphql_name)
-        if context.interpreter?
-          types.map { |t| t.metadata[:type_class] || raise("Invariant: can't introspect non-class-based type: #{t}") }
-        else
-          types
-        end
+        @context.warden.reachable_types.sort_by(&:graphql_name)
       end
 
       def query_type

data/lib/graphql/introspection/type_type.rb

@@ -22,7 +22,9 @@ module GraphQL
       field :enum_values, [GraphQL::Schema::LateBoundType.new("__EnumValue")], null: true do
         argument :include_deprecated, Boolean, required: false, default_value: false
       end
-      field :input_fields, [GraphQL::Schema::LateBoundType.new("__InputValue")], null: true
+      field :input_fields, [GraphQL::Schema::LateBoundType.new("__InputValue")], null: true  do
+        argument :include_deprecated, Boolean, required: false, default_value: false
+      end
       field :of_type, GraphQL::Schema::LateBoundType.new("__Type"), null: true
 
       def name
@@ -37,7 +39,7 @@ module GraphQL
         if !@object.kind.enum?
           nil
         else
-          enum_values = @context.warden.enum_values(@object.graphql_definition)
+          enum_values = @context.warden.enum_values(@object)
 
           if !include_deprecated
             enum_values = enum_values.select {|f| !f.deprecation_reason }
@@ -49,15 +51,17 @@ module GraphQL
 
       def interfaces
         if @object.kind == GraphQL::TypeKinds::OBJECT
-          @context.warden.interfaces(@object.graphql_definition)
+          @context.warden.interfaces(@object)
         else
           nil
         end
       end
 
-      def input_fields
+      def input_fields(include_deprecated:)
         if @object.kind.input_object?
-          @context.warden.arguments(@object.graphql_definition)
+          args = @context.warden.arguments(@object)
+          args = args.reject(&:deprecation_reason) unless include_deprecated
+          args
         else
           nil
         end
@@ -65,7 +69,7 @@ module GraphQL
 
       def possible_types
         if @object.kind.abstract?
-          @context.warden.possible_types(@object.graphql_definition)
+          @context.warden.possible_types(@object).sort_by(&:graphql_name)
         else
           nil
         end
@@ -75,7 +79,7 @@ module GraphQL
         if !@object.kind.fields?
           nil
         else
-          fields = @context.warden.fields(@object.graphql_definition)
+          fields = @context.warden.fields(@object)
           if !include_deprecated
             fields = fields.select {|f| !f.deprecation_reason }
           end

data/lib/graphql/introspection.rb

@@ -1,6 +1,102 @@
 # frozen_string_literal: true
 module GraphQL
   module Introspection
+    def self.query(include_deprecated_args: false)
+      # The introspection query to end all introspection queries, copied from
+      # https://github.com/graphql/graphql-js/blob/master/src/utilities/introspectionQuery.js
+      <<-QUERY
+query IntrospectionQuery {
+  __schema {
+    queryType { name }
+    mutationType { name }
+    subscriptionType { name }
+    types {
+      ...FullType
+    }
+    directives {
+      name
+      description
+      locations
+      args {
+        ...InputValue
+      }
+    }
+  }
+}
+fragment FullType on __Type {
+  kind
+  name
+  description
+  fields(includeDeprecated: true) {
+    name
+    description
+    args#{include_deprecated_args ? '(includeDeprecated: true)' : ''} {
+      ...InputValue
+    }
+    type {
+      ...TypeRef
+    }
+    isDeprecated
+    deprecationReason
+  }
+  inputFields#{include_deprecated_args ? '(includeDeprecated: true)' : ''} {
+    ...InputValue
+  }
+  interfaces {
+    ...TypeRef
+  }
+  enumValues(includeDeprecated: true) {
+    name
+    description
+    isDeprecated
+    deprecationReason
+  }
+  possibleTypes {
+    ...TypeRef
+  }
+}
+fragment InputValue on __InputValue {
+  name
+  description
+  type { ...TypeRef }
+  defaultValue
+  #{include_deprecated_args ? 'isDeprecated' : ''}
+  #{include_deprecated_args ? 'deprecationReason' : ''}
+}
+fragment TypeRef on __Type {
+  kind
+  name
+  ofType {
+    kind
+    name
+    ofType {
+      kind
+      name
+      ofType {
+        kind
+        name
+        ofType {
+          kind
+          name
+          ofType {
+            kind
+            name
+            ofType {
+              kind
+              name
+              ofType {
+                kind
+                name
+              }
+            }
+          }
+        }
+      }
+    }
+  }
+}
+      QUERY
+    end
   end
 end
 

data/lib/graphql/invalid_null_error.rb

@@ -28,5 +28,23 @@ module GraphQL
     def parent_error?
       false
     end
+
+    class << self
+      attr_accessor :parent_class
+
+      def subclass_for(parent_class)
+        subclass = Class.new(self)
+        subclass.parent_class = parent_class
+        subclass
+      end
+
+      def inspect
+        if (name.nil? || parent_class.name.nil?) && parent_class.respond_to?(:mutation) && (mutation = parent_class.mutation)
+          "#{mutation.inspect}::#{parent_class.graphql_name}::InvalidNullError"
+        else
+          super
+        end
+      end
+    end
   end
 end

data/lib/graphql/language/block_string.rb

@@ -2,10 +2,21 @@
 module GraphQL
   module Language
     module BlockString
+      if !String.method_defined?(:match?)
+        using GraphQL::StringMatchBackport
+      end
+
       # Remove leading and trailing whitespace from a block string.
       # See "Block Strings" in https://github.com/facebook/graphql/blob/master/spec/Section%202%20--%20Language.md
       def self.trim_whitespace(str)
-        lines = str.split("\n")
+        # Early return for the most common cases:
+        if str == ""
+          return ""
+        elsif !(has_newline = str.include?("\n")) && !(str.start_with?(" "))
+          return str
+        end
+
+        lines = has_newline ? str.split("\n") : [str]
         common_indent = nil
 
         # find the common whitespace
@@ -14,19 +25,27 @@ module GraphQL
             next
           end
           line_length = line.size
-          line_indent = line[/\A */].size
+          line_indent = if line.match?(/\A  [^ ]/)
+            2
+          elsif line.match?(/\A    [^ ]/)
+            4
+          elsif line.match?(/\A[^ ]/)
+            0
+          else
+            line[/\A */].size
+          end
           if line_indent < line_length && (common_indent.nil? || line_indent < common_indent)
             common_indent = line_indent
           end
         end
 
         # Remove the common whitespace
-        if common_indent
+        if common_indent && common_indent > 0
           lines.each_with_index do |line, idx|
             if idx == 0
               next
             else
-              line[0, common_indent] = ""
+              line.slice!(0, common_indent)
             end
           end
         end
@@ -40,7 +59,7 @@ module GraphQL
         end
 
         # Rebuild the string
-        lines.join("\n")
+        lines.size > 1 ? lines.join("\n") : (lines.first || "")
       end
 
       def self.print(str, indent: '')

data/lib/graphql/language/definition_slice.rb

@@ -7,23 +7,34 @@ module GraphQL
       def slice(document, name)
         definitions = {}
         document.definitions.each { |d| definitions[d.name] = d }
-        names = find_definition_dependencies(definitions, name)
+        names = Set.new
+        DependencyVisitor.find_definition_dependencies(definitions, name, names)
         definitions = document.definitions.select { |d| names.include?(d.name) }
         Nodes::Document.new(definitions: definitions)
       end
 
       private
 
-      def find_definition_dependencies(definitions, name)
-        names = Set.new([name])
-        visitor = Visitor.new(definitions[name])
-        visitor[Nodes::FragmentSpread] << ->(node, parent) {
-          if fragment = definitions[node.name]
-            names.merge(find_definition_dependencies(definitions, fragment.name))
+      class DependencyVisitor < GraphQL::Language::Visitor
+        def initialize(doc, definitions, names)
+          @names = names
+          @definitions = definitions
+          super(doc)
+        end
+
+        def on_fragment_spread(node, parent)
+          if fragment = @definitions[node.name]
+            self.class.find_definition_dependencies(@definitions, fragment.name, @names)
           end
-        }
-        visitor.visit
-        names
+          super
+        end
+
+        def self.find_definition_dependencies(definitions, name, names)
+          names.add(name)
+          visitor = self.new(definitions[name], definitions, names)
+          visitor.visit
+          nil
+        end
       end
     end
   end