graphql 1.7.14 → 1.8.0.pre1

data/lib/graphql/field.rb

@@ -102,7 +102,7 @@ module GraphQL
   # @example Calculating the complexity of a list field
   #   field :items, types[ItemType] do
   #     argument :limit, !types.Int
-  #     # Multiply the child complexity by the possible items on the list
+  #     # Mulitply the child complexity by the possible items on the list
   #     complexity ->(ctx, args, child_complexity) { child_complexity * args[:limit] }
   #   end
   #
@@ -130,8 +130,6 @@ module GraphQL
       :relay_node_field,
       :relay_nodes_field,
       :subscription_scope,
-      :trace,
-      :introspection,
       argument: GraphQL::Define::AssignArgument
 
     ensure_defined(
@@ -139,8 +137,7 @@ module GraphQL
       :mutation, :arguments, :complexity, :function,
       :resolve, :resolve=, :lazy_resolve, :lazy_resolve=, :lazy_resolve_proc, :resolve_proc,
       :type, :type=, :name=, :property=, :hash_key=,
-      :relay_node_field, :relay_nodes_field, :edges?, :edge_class, :subscription_scope,
-      :introspection?
+      :relay_node_field, :relay_nodes_field, :edges?, :edge_class, :subscription_scope
     )
 
     # @return [Boolean] True if this is the Relay find-by-id field
@@ -185,16 +182,10 @@ module GraphQL
     attr_accessor :arguments_class
 
     attr_writer :connection
-    attr_writer :introspection
 
     # @return [nil, String] Prefix for subscription names from this field
     attr_accessor :subscription_scope
 
-    # @return [Boolean] True if this field should be traced. By default, fields are only traced if they are not a ScalarType or EnumType.
-    attr_accessor :trace
-
-    attr_accessor :ast_node
-
     # @return [Boolean]
     def connection?
       @connection
@@ -221,20 +212,14 @@ module GraphQL
       @connection = false
       @connection_max_page_size = nil
       @edge_class = nil
-      @trace = nil
-      @introspection = false
     end
 
     def initialize_copy(other)
+      ensure_defined
       super
       @arguments = other.arguments.dup
     end
 
-    # @return [Boolean] Is this field a predefined introspection field?
-    def introspection?
-      @introspection
-    end
-
     # Get a value for this field
     # @example resolving a field value
     #   field.resolve(obj, args, ctx)
@@ -290,8 +275,8 @@ module GraphQL
       "<Field name:#{name || "not-named"} desc:#{description} resolve:#{resolve_proc}>"
     end
 
-    # If {#resolve} returned an object which should be handled lazily,
-    # this method will be called later to force the object to return its value.
+    # If {#resolve} returned and object which should be handled lazily,
+    # this method will be called later force the object to return its value.
     # @param obj [Object] The {#resolve}-provided object, registered with {Schema#lazy_resolve}
     # @param args [GraphQL::Query::Arguments] Arguments to this field
     # @param ctx [GraphQL::Query::Context] Context for this field

data/lib/graphql/function.rb

@@ -97,6 +97,18 @@ module GraphQL
         end
       end
 
+      def build_field(function)
+        GraphQL::Field.define(
+          arguments: function.arguments,
+          complexity: function.complexity,
+          type: function.type,
+          resolve: function,
+          description: function.description,
+          function: function,
+          deprecation_reason: function.deprecation_reason,
+        )
+      end
+
       # Class-level reader/writer which is inherited
       # @api private
       def self.inherited_value(name)

data/lib/graphql/input_object_type.rb

@@ -84,7 +84,6 @@ module GraphQL
 
     def coerce_non_null_input(value, ctx)
       input_values = {}
-      defaults_used = Set.new
 
       arguments.each do |input_key, input_field_defn|
         field_value = value[input_key]
@@ -94,11 +93,10 @@ module GraphQL
           input_values[input_key] = input_field_defn.prepare(coerced_value, ctx)
         elsif input_field_defn.default_value?
           input_values[input_key] = input_field_defn.default_value
-          defaults_used << input_key
         end
       end
 
-      arguments_class.new(input_values, defaults_used)
+      arguments_class.new(input_values, context: ctx)
     end
 
     # @api private

data/lib/graphql/internal_representation/node.rb

@@ -4,12 +4,6 @@ module GraphQL
     class Node
       # @api private
       DEFAULT_TYPED_CHILDREN = Proc.new { |h, k| h[k] = {} }
-
-      # A specialized, reusable object for leaf nodes.
-      NO_TYPED_CHILDREN = Hash.new({}.freeze)
-      def NO_TYPED_CHILDREN.dup; self; end;
-      NO_TYPED_CHILDREN.freeze
-
       # @return [String] the name this node has in the response
       attr_reader :name
 
@@ -22,9 +16,9 @@ module GraphQL
       # This value is derived from {#scoped_children} after the rewrite is finished.
       # @return [Hash<GraphQL::ObjectType, Hash<String => Node>>]
       def typed_children
-        @typed_children ||= begin
+        @typed_childen ||= begin
+          new_tc = Hash.new(&DEFAULT_TYPED_CHILDREN)
           if @scoped_children.any?
-            new_tc = Hash.new(&DEFAULT_TYPED_CHILDREN)
             all_object_types = Set.new
             scoped_children.each_key { |t| all_object_types.merge(@query.possible_types(t)) }
             # Remove any scoped children which don't follow this return type
@@ -33,11 +27,8 @@ module GraphQL
             all_object_types.each do |t|
               new_tc[t] = get_typed_children(t)
             end
-            new_tc
-          else
-            NO_TYPED_CHILDREN
           end
-
+          new_tc
         end
       end
 
@@ -134,20 +125,17 @@ module GraphQL
           @ast_nodes |= new_parent.ast_nodes
           @definitions |= new_parent.definitions
         end
-        new_sc = new_parent.scoped_children
-        if new_sc.any?
-          scope ||= Scope.new(@query, @return_type.unwrap)
-          new_sc.each do |obj_type, new_fields|
-            inner_scope = scope.enter(obj_type)
-            inner_scope.each do |scoped_type|
-              prev_fields = @scoped_children[scoped_type]
-              new_fields.each do |name, new_node|
-                prev_node = prev_fields[name]
-                if prev_node
-                  prev_node.deep_merge_node(new_node)
-                else
-                  prev_fields[name] = new_node
-                end
+        scope ||= Scope.new(@query, @return_type.unwrap)
+        new_parent.scoped_children.each do |obj_type, new_fields|
+          inner_scope = scope.enter(obj_type)
+          inner_scope.each do |scoped_type|
+            prev_fields = @scoped_children[scoped_type]
+            new_fields.each do |name, new_node|
+              prev_node = prev_fields[name]
+              if prev_node
+                prev_node.deep_merge_node(new_node)
+              else
+                prev_fields[name] = new_node
               end
             end
           end

data/lib/graphql/internal_representation/visit.rb

@@ -24,9 +24,12 @@ module GraphQL
       # visiting the node itself and each of its typed children.
       def each_node(node)
         yield(node)
-        node.typed_children.each do |obj_type, children|
-          children.each do |name, node|
-            each_node(node) { |n| yield(n) }
+        if node.typed_children.any?
+          visit_block = Proc.new
+          node.typed_children.each do |obj_type, children|
+            children.each do |name, node|
+              each_node(node, &visit_block)
+            end
           end
         end
       end

data/lib/graphql/introspection/arguments_field.rb

@@ -1,7 +1,6 @@
 # frozen_string_literal: true
 GraphQL::Introspection::ArgumentsField = GraphQL::Field.define do
   type !GraphQL::ListType.new(of_type: !GraphQL::Introspection::InputValueType)
-  introspection true
   resolve ->(obj, args, ctx) {
     ctx.warden.arguments(obj)
   }

data/lib/graphql/introspection/enum_values_field.rb

@@ -1,7 +1,6 @@
 # frozen_string_literal: true
 GraphQL::Introspection::EnumValuesField = GraphQL::Field.define do
   type types[!GraphQL::Introspection::EnumValueType]
-  introspection true
   argument :includeDeprecated, types.Boolean, default_value: false
   resolve ->(object, arguments, context) do
     if !object.kind.enum?

data/lib/graphql/introspection/fields_field.rb

@@ -1,7 +1,6 @@
 # frozen_string_literal: true
 GraphQL::Introspection::FieldsField = GraphQL::Field.define do
   type -> { types[!GraphQL::Introspection::FieldType] }
-  introspection true
   argument :includeDeprecated, GraphQL::BOOLEAN_TYPE, default_value: false
   resolve ->(object, arguments, context) {
     return nil if !object.kind.fields?

data/lib/graphql/introspection/input_fields_field.rb

@@ -1,7 +1,6 @@
 # frozen_string_literal: true
 GraphQL::Introspection::InputFieldsField = GraphQL::Field.define do
   name "inputFields"
-  introspection true
   type types[!GraphQL::Introspection::InputValueType]
   resolve ->(target, a, ctx) {
     if target.kind.input_object?

data/lib/graphql/introspection/interfaces_field.rb

@@ -1,7 +1,6 @@
 # frozen_string_literal: true
 GraphQL::Introspection::InterfacesField = GraphQL::Field.define do
   type -> { types[!GraphQL::Introspection::TypeType] }
-  introspection true
   resolve ->(target, a, ctx) {
     if target.kind == GraphQL::TypeKinds::OBJECT
       ctx.warden.interfaces(target)

data/lib/graphql/introspection/of_type_field.rb

@@ -1,7 +1,6 @@
 # frozen_string_literal: true
 GraphQL::Introspection::OfTypeField = GraphQL::Field.define do
   name "ofType"
-  introspection true
   type -> { GraphQL::Introspection::TypeType }
   resolve ->(obj, args, ctx) { obj.kind.wraps? ? obj.of_type : nil }
 end

data/lib/graphql/introspection/possible_types_field.rb

@@ -1,7 +1,6 @@
 # frozen_string_literal: true
 GraphQL::Introspection::PossibleTypesField = GraphQL::Field.define do
   type -> { types[!GraphQL::Introspection::TypeType] }
-  introspection true
   resolve ->(target, args, ctx) {
     if target.kind.resolves?
       ctx.warden.possible_types(target)

data/lib/graphql/introspection/schema_field.rb

@@ -4,7 +4,6 @@ module GraphQL
     SchemaField = GraphQL::Field.define do
       name("__schema")
       description("This GraphQL schema")
-      introspection true
       type(!GraphQL::Introspection::SchemaType)
       resolve ->(o, a, ctx) { ctx.query.schema }
     end

data/lib/graphql/introspection/type_by_name_field.rb

@@ -5,7 +5,6 @@ module GraphQL
       name("__type")
       description("A type in the GraphQL system")
       type(GraphQL::Introspection::TypeType)
-      introspection true
       argument :name, !types.String
       resolve ->(o, args, ctx) {
         ctx.warden.get_type(args["name"])

data/lib/graphql/introspection/typename_field.rb

@@ -5,7 +5,6 @@ module GraphQL
       name "__typename"
       description "The name of this type"
       type -> { !GraphQL::STRING_TYPE }
-      introspection true
       resolve ->(obj, a, ctx) { ctx.irep_node.owner_type }
     end
   end

data/lib/graphql/language.rb

@@ -1,8 +1,5 @@
 # frozen_string_literal: true
-require "graphql/language/block_string"
-require "graphql/language/printer"
 require "graphql/language/definition_slice"
-require "graphql/language/document_from_schema_definition"
 require "graphql/language/generation"
 require "graphql/language/lexer"
 require "graphql/language/nodes"

data/lib/graphql/language/generation.rb

@@ -14,10 +14,189 @@ module GraphQL
       #
       # @param node [GraphQL::Language::Nodes::AbstractNode] an AST node to recursively stringify
       # @param indent [String] Whitespace to add to each printed node
-      # @param printer [GraphQL::Language::Printer] An optional custom printer for printing AST nodes. Defaults to GraphQL::Language::Printer
       # @return [String] Valid GraphQL for `node`
-      def generate(node, indent: "", printer: GraphQL::Language::Printer.new)
-        printer.print(node, indent: indent)
+      def generate(node, indent: "")
+        case node
+        when Nodes::Document
+          node.definitions.map { |d| generate(d) }.join("\n\n")
+        when Nodes::Argument
+          "#{node.name}: #{generate(node.value)}".dup
+        when Nodes::Directive
+          out = "@#{node.name}".dup
+          out << "(#{node.arguments.map { |a| generate(a) }.join(", ")})" if node.arguments.any?
+          out
+        when Nodes::Enum
+          "#{node.name}".dup
+        when Nodes::NullValue
+          "null".dup
+        when Nodes::Field
+          out = "#{indent}".dup
+          out << "#{node.alias}: " if node.alias
+          out << "#{node.name}"
+          out << "(#{node.arguments.map { |a| generate(a) }.join(", ")})" if node.arguments.any?
+          out << generate_directives(node.directives)
+          out << generate_selections(node.selections, indent: indent)
+          out
+        when Nodes::FragmentDefinition
+          out = "#{indent}fragment #{node.name}".dup
+          if node.type
+            out << " on #{generate(node.type)}"
+          end
+          out << generate_directives(node.directives)
+          out << generate_selections(node.selections, indent: indent)
+          out
+        when Nodes::FragmentSpread
+          out = "#{indent}...#{node.name}".dup
+          out << generate_directives(node.directives)
+          out
+        when Nodes::InlineFragment
+          out = "#{indent}...".dup
+          if node.type
+            out << " on #{generate(node.type)}"
+          end
+          out << generate_directives(node.directives)
+          out << generate_selections(node.selections, indent: indent)
+          out
+        when Nodes::InputObject
+          generate(node.to_h)
+        when Nodes::ListType
+          "[#{generate(node.of_type)}]".dup
+        when Nodes::NonNullType
+          "#{generate(node.of_type)}!".dup
+        when Nodes::OperationDefinition
+          out = "#{indent}#{node.operation_type}".dup
+          out << " #{node.name}" if node.name
+          out << "(#{node.variables.map { |v| generate(v) }.join(", ")})" if node.variables.any?
+          out << generate_directives(node.directives)
+          out << generate_selections(node.selections, indent: indent)
+          out
+        when Nodes::TypeName
+          "#{node.name}".dup
+        when Nodes::VariableDefinition
+          out = "$#{node.name}: #{generate(node.type)}".dup
+          out << " = #{generate(node.default_value)}" unless node.default_value.nil?
+          out
+        when Nodes::VariableIdentifier
+          "$#{node.name}".dup
+        when Nodes::SchemaDefinition
+          if (node.query.nil? || node.query == 'Query') &&
+             (node.mutation.nil? || node.mutation == 'Mutation') &&
+             (node.subscription.nil? || node.subscription == 'Subscription')
+            return
+          end
+
+          out = "schema {\n".dup
+          out << "  query: #{node.query}\n" if node.query
+          out << "  mutation: #{node.mutation}\n" if node.mutation
+          out << "  subscription: #{node.subscription}\n" if node.subscription
+          out << "}"
+        when Nodes::ScalarTypeDefinition
+          out = generate_description(node)
+          out << "scalar #{node.name}"
+          out << generate_directives(node.directives)
+        when Nodes::ObjectTypeDefinition
+          out = generate_description(node)
+          out << "type #{node.name}"
+          out << generate_directives(node.directives)
+          out << " implements " << node.interfaces.map(&:name).join(", ") unless node.interfaces.empty?
+          out << generate_field_definitions(node.fields)
+        when Nodes::InputValueDefinition
+          out = "#{node.name}: #{generate(node.type)}".dup
+          out << " = #{generate(node.default_value)}" unless node.default_value.nil?
+          out << generate_directives(node.directives)
+        when Nodes::FieldDefinition
+          out = node.name.dup
+          unless node.arguments.empty?
+            out << "(" << node.arguments.map{ |arg| generate(arg) }.join(", ") << ")"
+          end
+          out << ": #{generate(node.type)}"
+          out << generate_directives(node.directives)
+        when Nodes::InterfaceTypeDefinition
+          out = generate_description(node)
+          out << "interface #{node.name}"
+          out << generate_directives(node.directives)
+          out << generate_field_definitions(node.fields)
+        when Nodes::UnionTypeDefinition
+          out = generate_description(node)
+          out << "union #{node.name}"
+          out << generate_directives(node.directives)
+          out << " = " + node.types.map(&:name).join(" | ")
+        when Nodes::EnumTypeDefinition
+          out = generate_description(node)
+          out << "enum #{node.name}#{generate_directives(node.directives)} {\n"
+          node.values.each.with_index do |value, i|
+            out << generate_description(value, indent: '  ', first_in_block: i == 0)
+            out << generate(value)
+          end
+          out << "}"
+        when Nodes::EnumValueDefinition
+          out = "  #{node.name}".dup
+          out << generate_directives(node.directives)
+          out << "\n"
+        when Nodes::InputObjectTypeDefinition
+          out = generate_description(node)
+          out << "input #{node.name}"
+          out << generate_directives(node.directives)
+          out << " {\n"
+          node.fields.each.with_index do |field, i|
+            out << generate_description(field, indent: '  ', first_in_block: i == 0)
+            out << "  #{generate(field)}\n"
+          end
+          out << "}"
+        when Nodes::DirectiveDefinition
+          out = generate_description(node)
+          out << "directive @#{node.name}"
+          out << "(#{node.arguments.map { |a| generate(a) }.join(", ")})" if node.arguments.any?
+          out << " on #{node.locations.join(' | ')}"
+        when Nodes::AbstractNode
+          node.to_query_string(indent: indent)
+        when FalseClass, Float, Integer, NilClass, String, TrueClass
+          GraphQL::Language.serialize(node)
+        when Array
+          "[#{node.map { |v| generate(v) }.join(", ")}]".dup
+        when Hash
+          "{#{node.map { |k, v| "#{k}: #{generate(v)}" }.join(", ")}}".dup
+        else
+          raise TypeError
+        end
+      end
+
+      private
+
+      def generate_directives(directives)
+        if directives.any?
+          directives.map { |d| " #{generate(d)}" }.join
+        else
+          ""
+        end
+      end
+
+      def generate_selections(selections, indent: "")
+        if selections.any?
+          out = " {\n".dup
+          selections.each do |selection|
+            out << generate(selection, indent: indent + "  ") << "\n"
+          end
+          out << "#{indent}}"
+        else
+          ""
+        end
+      end
+
+      def generate_description(node, indent: '', first_in_block: true)
+        return ''.dup unless node.description
+
+        description = indent != '' && !first_in_block ? "\n".dup : "".dup
+        description << GraphQL::Language::Comments.commentize(node.description, indent: indent)
+      end
+
+      def generate_field_definitions(fields)
+        out = " {\n".dup
+        fields.each.with_index do |field, i|
+          out << generate_description(field, indent: '  ', first_in_block: i == 0)
+          out << "  #{generate(field)}\n"
+        end
+        out << "}"
       end
     end
   end